Fix cached plugin tool dispatch

zanni098 · zanni098 · commit 8040057e9813 · 2026-05-08T05:17:20.000+05:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -284,6 +284,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,66 +553,46 @@ function createCachedDescriptorPluginTool(params: {
         loadOptions,
         onlyPluginIds: [pluginId],
       });
-      const candidates = registry?.tools.filter(
-        (candidate) => candidate.pluginId === pluginId,
-      );
+      const candidates = registry?.tools.filter((candidate) => candidate.pluginId === pluginId);
       if (!candidates || candidates.length === 0) {
         throw new Error(`plugin tool runtime unavailable (${pluginId}): ${toolName}`);
       }
-      // First try named candidates, then fall back to all candidates if no match
-      const namedCandidates = candidates.filter(
-        (candidate) => candidate.names.length > 0,
+      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),
       );
-      // Try named candidates first
+      const unnamedCandidates = candidates.filter((candidate) => candidate.names.length === 0);
       let matchedTool: AnyAgentTool | undefined;
-      for (const candidate of namedCandidates) {
+      for (const candidate of [...matchingNamedCandidates, ...unnamedCandidates]) {
         try {
-          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) === normalizeToolName(toolName)) {
-              matchedTool = runtimeTool;
-              break;
-            }
+          matchedTool = resolveCandidateTool(candidate);
+          if (matchedTool) {
+            break;
           }
-          if (matchedTool) { break; }
         } catch {
           // Continue to next candidate if factory/materialization fails
           continue;
         }
       }
-      // If no match in named candidates, try unnamed candidates only
-      if (!matchedTool) {
-        const unnamedCandidates = candidates.filter(
-          (candidate) => candidate.names.length === 0,
-        );
-        for (const candidate of unnamedCandidates) {
-          try {
-            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) === normalizeToolName(toolName)) {
-                matchedTool = runtimeTool;
-                break;
-              }
-            }
-            if (matchedTool) { break; }
-          } catch {
-            // Continue to next candidate if factory/materialization fails
-            continue;
-          }
-        }
-      }
       if (matchedTool) {
         // Return outside try blocks to preserve tool execution errors
         return matchedTool.execute(toolCallId, executeParams, signal, onUpdate);
@@ -844,13 +824,13 @@ function resolvePluginToolLoadState(params: {
   env?: NodeJS.ProcessEnv;
 }):
   | {
-    context: ReturnType<typeof resolvePluginRuntimeLoadContext>;
-    env: NodeJS.ProcessEnv;
-    loadOptions: PluginLoadOptions;
-    onlyPluginIds: string[];
-    runtimeOptions: PluginLoadOptions["runtimeOptions"];
-    snapshot: PluginMetadataManifestView;
-  }
+      context: ReturnType<typeof resolvePluginRuntimeLoadContext>;
+      env: NodeJS.ProcessEnv;
+      loadOptions: PluginLoadOptions;
+      onlyPluginIds: string[];
+      runtimeOptions: PluginLoadOptions["runtimeOptions"];
+      snapshot: PluginMetadataManifestView;
+    }
   | undefined {
   const env = params.env ?? process.env;
   const baseConfig = applyTestPluginDefaults(params.context.config ?? {}, env);
@@ -988,7 +968,8 @@ export function resolvePluginTools(params: {
       });
     } catch (error) {
       context.logger.error(
-        `failed to cold-load plugin tool registry for plugin ids [${runtimePluginIds.join(", ")}]: ${error instanceof Error ? error.message : String(error)
+        `failed to cold-load plugin tool registry for plugin ids [${runtimePluginIds.join(", ")}]: ${
+          error instanceof Error ? error.message : String(error)
         }`,
       );
       throw error;
@@ -1057,19 +1038,19 @@ export function resolvePluginTools(params: {
       declaredNames.length > 0 ? declaredNames : (entry.declaredNames ?? []);
     const allowlistNames = manifestPlugin
       ? filterManifestToolNamesForAvailability({
-        plugin: manifestPlugin,
-        toolNames: availabilityNames,
-        config: params.context.runtimeConfig ?? context.config,
-        env,
-        hasAuthForProvider: params.hasAuthForProvider,
-      }).filter(
-        (toolName) =>
-          !denylistBlocksPluginTool({
-            pluginId: entry.pluginId,
-            toolName,
-            denylist,
-          }),
-      )
+          plugin: manifestPlugin,
+          toolNames: availabilityNames,
+          config: params.context.runtimeConfig ?? context.config,
+          env,
+          hasAuthForProvider: params.hasAuthForProvider,
+        }).filter(
+          (toolName) =>
+            !denylistBlocksPluginTool({
+              pluginId: entry.pluginId,
+              toolName,
+              denylist,
+            }),
+        )
       : declaredNames;
     if (manifestPlugin && availabilityNames.length > 0 && allowlistNames.length === 0) {
       continue;
@@ -1115,33 +1096,33 @@ export function resolvePluginTools(params: {
         : undefined;
     const availableList = manifestPlugin
       ? listRaw.filter((tool) => {
-        const toolName = readPluginToolName(tool);
-        const normalizedToolName = normalizeToolName(toolName);
-        if (
-          isManifestToolOptional(manifestPlugin, toolName) &&
-          !isOptionalToolAllowed({
+          const toolName = readPluginToolName(tool);
+          const normalizedToolName = normalizeToolName(toolName);
+          if (
+            isManifestToolOptional(manifestPlugin, toolName) &&
+            !isOptionalToolAllowed({
+              toolName,
+              pluginId: entry.pluginId,
+              allowlist,
+            })
+          ) {
+            return false;
+          }
+          if (
+            selectedManifestToolNames &&
+            manifestContractToolNames?.has(normalizedToolName) &&
+            !selectedManifestToolNames.has(normalizedToolName)
+          ) {
+            return false;
+          }
+          return isManifestToolNameAvailable({
+            plugin: manifestPlugin,
             toolName,
-            pluginId: entry.pluginId,
-            allowlist,
-          })
-        ) {
-          return false;
-        }
-        if (
-          selectedManifestToolNames &&
-          manifestContractToolNames?.has(normalizedToolName) &&
-          !selectedManifestToolNames.has(normalizedToolName)
-        ) {
-          return false;
-        }
-        return isManifestToolNameAvailable({
-          plugin: manifestPlugin,
-          toolName,
-          config: params.context.runtimeConfig ?? context.config,
-          env,
-          hasAuthForProvider: params.hasAuthForProvider,
-        });
-      })
+            config: params.context.runtimeConfig ?? context.config,
+            env,
+            hasAuthForProvider: params.hasAuthForProvider,
+          });
+        })
       : listRaw;
     const policyAvailableList = availableList.filter(
       (tool) =>
@@ -1153,12 +1134,12 @@ export function resolvePluginTools(params: {
     );
     const list = entry.optional
       ? policyAvailableList.filter((tool) =>
-        isOptionalToolAllowed({
-          toolName: readPluginToolName(tool),
-          pluginId: entry.pluginId,
-          allowlist,
-        }),
-      )
+          isOptionalToolAllowed({
+            toolName: readPluginToolName(tool),
+            pluginId: entry.pluginId,
+            allowlist,
+          }),
+        )
       : policyAvailableList;
     if (list.length === 0) {
       continue;
@@ -1182,9 +1163,9 @@ export function resolvePluginTools(params: {
       const tool = toolRaw as AnyAgentTool;
       const undeclared = entry.declaredNames
         ? findUndeclaredPluginToolNames({
-          declaredNames: entry.declaredNames,
-          toolNames: [tool.name],
-        })
+            declaredNames: entry.declaredNames,
+            toolNames: [tool.name],
+          })
         : [];
       if (undeclared.length > 0) {
         const message = `plugin tool is undeclared (${entry.pluginId}): ${undeclared.join(", ")}`;
@@ -1287,8 +1268,3 @@ export function resolvePluginTools(params: {
 
   return tools;
 }
-
-
-
-
-
