fix(plugins): dispatch cached tools by runtime name (#78716)

zanni098 · web-flow · commit 3adbbe7c34b5 · 2026-05-08T12:44:01.000+05:30
Fix cached descriptor-backed plugin tool dispatch for unnamed factories sharing manifest contracts. Thanks @zanni098!
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -327,6 +327,7 @@ Docs: https://docs.openclaw.ai
 - Plugins/update: keep installed official npm and ClawHub plugins such as Codex, Discord, WhatsApp, and diagnostics plugins synced during host updates even when disabled or previously exact-pinned, while preserving third-party plugin pins. Thanks @vincentkoc.
 - Doctor/status: warn when `OPENCLAW_GATEWAY_TOKEN` would shadow a different active `gateway.auth.token` source for local CLI commands, while avoiding false positives when config points at the same env token. Fixes #74271. Thanks @yelog.
 - Gateway/HTTP: avoid loading managed outgoing-image media handlers for unrelated requests, so disabled OpenAI-compatible routes return 404 without waiting on lazy media sidecars. Thanks @vincentkoc.
+- Plugins: dispatch cached descriptor-backed tools by the resolved runtime tool name for unnamed factories, fixing multi-tool plugins whose shared manifest contracts exposed sibling tools but failed at execution. Fixes #78671. Thanks @zanni098.
 - Gateway/OpenAI-compatible: send the assistant role SSE chunk as soon as streaming chat-completion headers are accepted, so cold agent setup cannot leave `/v1/chat/completions` clients with a bodyless 200 response until their idle timeout fires.
 - Agents/media: avoid direct generated-media completion fallback while the announce-agent run is still pending, so async video and music completions do not duplicate raw media messages. (#77754)
 - WebChat/Codex media: stage Codex app-server generated local images into managed media before Gateway display, so Codex-home image paths no longer hit `LocalMediaAccessError` while keeping Codex home out of the display allowlist. Thanks @frankekn.
diff --git a/src/plugins/tools.optional.test.ts b/src/plugins/tools.optional.test.ts
@@ -1724,6 +1724,91 @@ describe("resolvePluginTools optional tools", () => {
     expect(factory).toHaveBeenCalledTimes(2);
   });
 
+  it("executes the matching cached plugin tool when unnamed factories share declared names", async () => {
+    const alphaFactory = vi.fn(() => ({
+      ...makeTool("implicit_alpha"),
+      async execute() {
+        return { content: [{ type: "text", text: "implicit-alpha-ok" }] };
+      },
+    }));
+    const betaFactory = vi.fn(() => ({
+      ...makeTool("implicit_beta"),
+      async execute() {
+        return { content: [{ type: "text", text: "implicit-beta-ok" }] };
+      },
+    }));
+    setRegistry([
+      {
+        pluginId: "implicit-owner",
+        optional: false,
+        source: "/tmp/implicit-owner.js",
+        names: [],
+        declaredNames: ["implicit_alpha", "implicit_beta"],
+        factory: alphaFactory,
+      },
+      {
+        pluginId: "implicit-owner",
+        optional: false,
+        source: "/tmp/implicit-owner.js",
+        names: [],
+        declaredNames: ["implicit_alpha", "implicit_beta"],
+        factory: betaFactory,
+      },
+    ]);
+
+    const first = resolvePluginTools(createResolveToolsParams());
+    const second = resolvePluginTools(createResolveToolsParams());
+    const betaTool = second.find((tool) => tool.name === "implicit_beta");
+
+    expectResolvedToolNames(first, ["implicit_alpha", "implicit_beta"]);
+    expectResolvedToolNames(second, ["implicit_alpha", "implicit_beta"]);
+    await expect(betaTool?.execute("call", {}, undefined)).resolves.toEqual({
+      content: [{ type: "text", text: "implicit-beta-ok" }],
+    });
+    expect(alphaFactory).toHaveBeenCalledTimes(2);
+    expect(betaFactory).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not invoke unrelated named factories before cached unnamed tool fallback", async () => {
+    const namedFactory = vi.fn(() => makeTool("unrelated_tool"));
+    const implicitFactory = vi.fn(() => ({
+      ...makeTool("implicit_tool"),
+      async execute() {
+        return { content: [{ type: "text", text: "implicit-ok" }] };
+      },
+    }));
+    setRegistry([
+      {
+        pluginId: "implicit-owner",
+        optional: false,
+        source: "/tmp/implicit-owner.js",
+        names: ["unrelated_tool"],
+        declaredNames: ["unrelated_tool"],
+        factory: namedFactory,
+      },
+      {
+        pluginId: "implicit-owner",
+        optional: false,
+        source: "/tmp/implicit-owner.js",
+        names: [],
+        declaredNames: ["implicit_tool"],
+        factory: implicitFactory,
+      },
+    ]);
+
+    resolvePluginTools(createResolveToolsParams());
+    const cachedTools = resolvePluginTools(createResolveToolsParams());
+    namedFactory.mockClear();
+    implicitFactory.mockClear();
+
+    const implicitTool = cachedTools.find((tool) => tool.name === "implicit_tool");
+    await expect(implicitTool?.execute("call", {}, undefined)).resolves.toEqual({
+      content: [{ type: "text", text: "implicit-ok" }],
+    });
+    expect(namedFactory).not.toHaveBeenCalled();
+    expect(implicitFactory).toHaveBeenCalledTimes(1);
+  });
+
   it("skips factory-returned tools outside the manifest tool contract", () => {
     const registry = setRegistry([
       {
diff --git a/src/plugins/tools.ts b/src/plugins/tools.ts
@@ -553,26 +553,43 @@ function createCachedDescriptorPluginTool(params: {
         loadOptions,
         onlyPluginIds: [pluginId],
       });
-      const entry = registry?.tools.find(
-        (candidate) =>
-          candidate.pluginId === pluginId &&
-          (candidate.names.length > 0 ? candidate.names : (candidate.declaredNames ?? [])).some(
-            (name) => normalizeToolName(name) === normalizeToolName(toolName),
-          ),
-      );
-      if (!entry) {
+      const candidates = registry?.tools.filter((candidate) => candidate.pluginId === pluginId);
+      if (!candidates || candidates.length === 0) {
         throw new Error(`plugin tool runtime unavailable (${pluginId}): ${toolName}`);
       }
-      const resolved = entry.factory(params.ctx);
-      const listRaw: unknown[] = Array.isArray(resolved) ? resolved : resolved ? [resolved] : [];
-      for (const toolRaw of listRaw) {
-        const malformedReason = describeMalformedPluginTool(toolRaw);
-        if (malformedReason) {
-          throw new Error(`plugin tool is malformed (${pluginId}): ${malformedReason}`);
+      const requestedToolName = normalizeToolName(toolName);
+      const resolveCandidateTool = (
+        candidate: PluginToolRegistration,
+      ): AnyAgentTool | undefined => {
+        const resolved = candidate.factory(params.ctx);
+        const listRaw: unknown[] = Array.isArray(resolved) ? resolved : resolved ? [resolved] : [];
+        for (const toolRaw of listRaw) {
+          const malformedReason = describeMalformedPluginTool(toolRaw);
+          if (malformedReason) {
+            throw new Error(`plugin tool is malformed (${pluginId}): ${malformedReason}`);
+          }
+          const runtimeTool = toolRaw as AnyAgentTool;
+          if (normalizeToolName(runtimeTool.name) === requestedToolName) {
+            return runtimeTool;
+          }
+        }
+        return undefined;
+      };
+      const matchingNamedCandidates = candidates.filter(
+        (candidate) =>
+          candidate.names.length > 0 &&
+          candidate.names.some((name) => normalizeToolName(name) === requestedToolName),
+      );
+      const unnamedCandidates = candidates.filter((candidate) => candidate.names.length === 0);
+      for (const candidate of [...matchingNamedCandidates, ...unnamedCandidates]) {
+        let matchedTool: AnyAgentTool | undefined;
+        try {
+          matchedTool = resolveCandidateTool(candidate);
+        } catch {
+          continue;
         }
-        const runtimeTool = toolRaw as AnyAgentTool;
-        if (normalizeToolName(runtimeTool.name) === normalizeToolName(toolName)) {
-          return runtimeTool.execute(toolCallId, executeParams, signal, onUpdate);
+        if (matchedTool) {
+          return matchedTool.execute(toolCallId, executeParams, signal, onUpdate);
         }
       }
       throw new Error(`plugin tool runtime missing (${pluginId}): ${toolName}`);
