fix(agents): preserve Symbol-keyed metadata through normalizeToolParameters so re-wrap path recovers source tool (fixes #92973)

zenglingbiao · zenglingbiao · commit aa5b75f43a4d · 2026-06-15T00:12:04.000+08:00
diff --git a/src/agents/agent-tools.before-tool-call.e2e.test.ts b/src/agents/agent-tools.before-tool-call.e2e.test.ts
@@ -28,6 +28,7 @@ import {
   runBeforeToolCallHook,
   wrapToolWithBeforeToolCallHook,
 } from "./agent-tools.before-tool-call.js";
+import { normalizeToolParameters } from "./agent-tools.schema.js";
 import { CRITICAL_THRESHOLD } from "./tool-loop-detection.js";
 import type { AnyAgentTool } from "./tools/common.js";
 import { callGatewayTool } from "./tools/gateway.js";
@@ -418,6 +419,53 @@ describe("before_tool_call loop detection behavior", () => {
     expect(execute).toHaveBeenCalledTimes(1);
   });
 
+  it("re-wraps a normalized already-wrapped tool with the current context (createOpenClawCodingTools path)", async () => {
+    const execute = vi.fn().mockResolvedValue({
+      content: [{ type: "text", text: "ok" }],
+      details: { ok: true },
+    });
+    const params = { path: "/tmp/file" };
+
+    // Step 1: wrap with initial context (shared tool registry)
+    const firstContext = {
+      ...enabledLoopDetectionContext,
+      runId: "initial-run",
+      sessionKey: "initial-session",
+    };
+    const baseTool: AnyAgentTool = { name: "read", execute } as any;
+    const wrappedOnce = wrapToolWithBeforeToolCallHook(
+      { name: "read", execute } as any,
+      firstContext,
+    );
+    expect(isToolWrappedWithBeforeToolCallHook(wrappedOnce)).toBe(true);
+
+    // Step 2: normalize (simulating createOpenClawCodingTools pipeline)
+    // normalizeToolParameters does { ...tool, parameters } which drops
+    // non-enumerable Symbol metadata (BEFORE_TOOL_CALL_SOURCE_TOOL,
+    // BEFORE_TOOL_CALL_HOOK_CONTEXT). After the fix, those Symbols
+    // are preserved via Object.getOwnPropertySymbols.
+    const normalized = normalizeToolParameters(wrappedOnce, {
+      modelProvider: "anthropic",
+    });
+
+    // Step 3: re-wrap with new context (the second half of the pipeline)
+    const newContext = {
+      ...enabledLoopDetectionContext,
+      runId: "new-run",
+      sessionKey: "new-session",
+    };
+    const reWrapped = wrapToolWithBeforeToolCallHook(normalized, newContext);
+
+    // After normalization + re-wrap, the tool should be wrapped with new context
+    expect(isToolWrappedWithBeforeToolCallHook(reWrapped)).toBe(true);
+    // The re-wrapped tool is a fresh wrapper, not the normalized one
+    expect(reWrapped).not.toBe(normalized);
+
+    // Execute: the hook should fire exactly once with the new context
+    await expectUnblockedToolExecution(reWrapped, "call-1", params);
+    expect(execute).toHaveBeenCalledTimes(1);
+  });
+
   it("escalates generic repeat diagnostics from warning to critical", async () => {
     await withToolLoopEvents(async (emitted) => {
       const { tool, params } = createGenericReadRepeatFixture();
diff --git a/src/agents/agent-tools.schema.ts b/src/agents/agent-tools.schema.ts
@@ -82,11 +82,21 @@ export function normalizeToolParameters(
     return tool;
   }
   const parameters = normalizeToolParameterSchema(schema, options);
-  return preserveToolMeta({
+  const result = preserveToolMeta({
     ...tool,
     ...addEmptyObjectArgumentPreparation(tool, parameters),
     parameters,
   });
+  // Preserve Symbol-keyed metadata (e.g. before_tool_call wrapper markers)
+  // that object spread drops when non-enumerable. This ensures already-wrapped
+  // tools retain their source-tool reference and hook context through normalization.
+  for (const sym of Object.getOwnPropertySymbols(tool)) {
+    const desc = Object.getOwnPropertyDescriptor(tool, sym);
+    if (desc) {
+      Object.defineProperty(result, sym, desc);
+    }
+  }
+  return result;
 }
 
 /**
