@tyvm/knowhow 0.0.158 → 0.0.160

package/tests/services/Tools.test.ts

@@ -1,1738 +0,0 @@
-import { ToolsService, ToolContext, ToolCallContext } from "../../src/services/Tools";
-import { Tool, ToolCall } from "../../src/clients/types";
-import { createPatternMatcher } from "../../src/services/types";
-import { AgentService } from "../../src/services/AgentService";
-import { EventService } from "../../src/services/EventService";
-import { AIClient } from "../../src/clients";
-import { PluginService } from "../../src/plugins/plugins";
-
-describe("ToolsService", () => {
-  let toolsService: ToolsService;
-
-  beforeEach(() => {
-    toolsService = new ToolsService();
-  });
-
-  describe("constructor", () => {
-    it("should initialize with empty context when no context is provided", () => {
-      const service = new ToolsService();
-      const context = service.getContext();
-
-      expect(context).toBeDefined();
-      expect(context.Tools).toBe(service);
-      expect(context.Agents).toBeUndefined();
-      expect(context.Events).toBeUndefined();
-      expect(context.Clients).toBeUndefined();
-      expect(context.Plugins).toBeUndefined();
-    });
-
-    it("should initialize with provided context", () => {
-      const mockAgents = {} as AgentService;
-      const mockEvents = {} as EventService;
-      const initialContext: ToolContext = {
-        Agents: mockAgents,
-        Events: mockEvents,
-      };
-
-      const service = new ToolsService(initialContext);
-      const context = service.getContext();
-
-      expect(context.Tools).toBe(service);
-      expect(context.Agents).toBe(mockAgents);
-      expect(context.Events).toBe(mockEvents);
-    });
-  });
-
-  describe("context management", () => {
-    it("should set and get context", () => {
-      const mockContext: ToolContext = {
-        Agents: {} as AgentService,
-        metadata: { test: "value" },
-      };
-
-      toolsService.setContext(mockContext);
-      const context = toolsService.getContext();
-
-      expect(context.Tools).toBe(toolsService);
-      expect(context.Agents).toBe(mockContext.Agents);
-      expect(context.metadata).toEqual({ test: "value" });
-    });
-
-    it("should add context properties", () => {
-      const mockAgents = {} as AgentService;
-
-      toolsService.addContext("Agents", mockAgents);
-      const context = toolsService.getContext();
-
-      expect(context.Agents).toBe(mockAgents);
-      expect(context.Tools).toBe(toolsService);
-    });
-  });
-
-  describe("tool management", () => {
-    const mockTool: Tool = {
-      type: "function",
-      function: {
-        name: "testTool",
-        description: "A test tool",
-        parameters: {
-          type: "object",
-          properties: {
-            input: { type: "string", description: "Test input" },
-          },
-          required: ["input"],
-        },
-      },
-    };
-
-    it("should add a single tool", () => {
-      toolsService.addTool(mockTool);
-
-      expect(toolsService.getTools()).toContain(mockTool);
-      expect(toolsService.getToolNames()).toContain("testTool");
-    });
-
-    it("should add multiple tools", () => {
-      const tool2: Tool = {
-        type: "function",
-        function: {
-          name: "testTool2",
-          description: "Another test tool",
-          parameters: {
-            type: "object",
-            properties: {},
-            required: [],
-          },
-        },
-      };
-
-      toolsService.addTools([mockTool, tool2]);
-
-      expect(toolsService.getTools()).toHaveLength(2);
-      expect(toolsService.getToolNames()).toEqual(["testTool", "testTool2"]);
-    });
-
-    it("should prevent duplicate tool names", () => {
-      toolsService.addTool(mockTool);
-      toolsService.addTools([mockTool]); // Try to add same tool again
-
-      expect(toolsService.getTools()).toHaveLength(1);
-    });
-
-    it("should get tool by name", () => {
-      toolsService.addTool(mockTool);
-
-      const retrievedTool = toolsService.getTool("testTool");
-      expect(retrievedTool).toBe(mockTool);
-
-      const nonExistentTool = toolsService.getTool("nonExistent");
-      expect(nonExistentTool).toBeUndefined();
-    });
-
-    it("should get tools by names", () => {
-      const tool2: Tool = {
-        type: "function",
-        function: {
-          name: "testTool2",
-          description: "Another test tool",
-          parameters: {
-            type: "object",
-            properties: {},
-            required: [],
-          },
-        },
-      };
-
-      toolsService.addTools([mockTool, tool2]);
-
-      const selectedTools = toolsService.getToolsByNames(["testTool"]);
-      expect(selectedTools).toHaveLength(1);
-      expect(selectedTools[0]).toBe(mockTool);
-    });
-  });
-
-  describe("function management", () => {
-    it("should set and get functions", () => {
-      const testFunction = jest.fn().mockReturnValue("test result");
-
-      toolsService.setFunction("testFunc", testFunction);
-      const retrievedFunction = toolsService.getFunction("testFunc");
-
-      expect(retrievedFunction).toBeDefined();
-      expect(typeof retrievedFunction).toBe("function");
-    });
-
-    it("should add multiple functions", () => {
-      const functions = {
-        func1: jest.fn(),
-        func2: jest.fn(),
-      };
-
-      toolsService.addFunctions(functions);
-
-      expect(toolsService.getFunction("func1")).toBeDefined();
-      expect(toolsService.getFunction("func2")).toBeDefined();
-    });
-
-    it("should set multiple functions by names and functions arrays", () => {
-      const func1 = jest.fn();
-      const func2 = jest.fn();
-
-      toolsService.setFunctions(["test1", "test2"], [func1, func2]);
-
-      expect(toolsService.getFunction("test1")).toBeDefined();
-      expect(toolsService.getFunction("test2")).toBeDefined();
-    });
-
-    it("should define tools and functions together", () => {
-      const mockTool: Tool = {
-        type: "function",
-        function: {
-          name: "combinedTool",
-          parameters: {
-            type: "object",
-            properties: {},
-            required: [],
-          },
-        },
-      };
-
-      const mockFunction = jest.fn();
-
-      toolsService.defineTools([mockTool], { combinedTool: mockFunction });
-
-      expect(toolsService.getTool("combinedTool")).toBe(mockTool);
-      expect(toolsService.getFunction("combinedTool")).toBeDefined();
-    });
-  });
-
-  describe("copyToolsFrom", () => {
-    it("should copy tools and functions from another ToolsService", () => {
-      const sourceService = new ToolsService();
-      const mockTool: Tool = {
-        type: "function",
-        function: {
-          name: "sourceTool",
-          parameters: {
-            type: "object",
-            properties: {},
-            required: [],
-          },
-        },
-      };
-      const mockFunction = jest.fn();
-
-      sourceService.addTool(mockTool);
-      sourceService.setFunction("sourceTool", mockFunction);
-
-      toolsService.copyToolsFrom(["sourceTool"], sourceService);
-
-      expect(toolsService.getTool("sourceTool")).toEqual(mockTool);
-      expect(toolsService.getFunction("sourceTool")).toBeDefined();
-    });
-  });
-  describe("callTool", () => {
-    const mockTool: Tool = {
-      type: "function",
-      function: {
-        name: "testTool",
-        description: "A test tool",
-        parameters: {
-          type: "object",
-          properties: {
-            input: { type: "string", description: "Test input" },
-            optional: { type: "string", description: "Optional input" },
-          },
-          required: ["input"],
-        },
-      },
-    };
-
-    const mockToolCall: ToolCall = {
-      id: "call_123",
-      type: "function",
-      function: {
-        name: "testTool",
-        arguments: JSON.stringify({ input: "test value" }),
-      },
-    };
-
-    beforeEach(() => {
-      toolsService.addTool(mockTool);
-      jest.clearAllMocks();
-    });
-
-    it("should successfully call a tool with correct arguments", async () => {
-      const mockFunction = jest.fn().mockResolvedValue("success result");
-      toolsService.setFunction("testTool", mockFunction);
-
-      const result = await toolsService.callTool(mockToolCall);
-
-      // By default (no `usesContext`), tools do NOT receive `_ctx`.
-      expect(mockFunction).toHaveBeenCalledWith(
-        expect.objectContaining({ input: "test value" })
-      );
-      expect(mockFunction.mock.calls[0][0]._ctx).toBeUndefined();
-      expect(result.toolMessages).toHaveLength(1);
-      expect(result.toolMessages[0]).toEqual({
-        tool_call_id: "call_123",
-        role: "tool",
-        name: "testTool",
-        content: "success result",
-      });
-      expect(result.functionResp).toBe("success result");
-    });
-
-    it("should handle positional arguments", async () => {
-      const positionalTool: Tool = {
-        type: "function",
-        function: {
-          name: "positionalTool",
-          parameters: {
-            type: "object",
-            positional: true,
-            properties: {
-              arg1: { type: "string" },
-              arg2: { type: "number" },
-            },
-            required: ["arg1", "arg2"],
-          },
-        },
-      };
-
-      const positionalCall: ToolCall = {
-        id: "call_456",
-        type: "function",
-        function: {
-          name: "positionalTool",
-          arguments: JSON.stringify({ arg1: "hello", arg2: 42 }),
-        },
-      };
-
-      const mockFunction = jest.fn().mockResolvedValue("positional result");
-
-      toolsService.addTool(positionalTool);
-      toolsService.setFunction("positionalTool", mockFunction);
-
-      await toolsService.callTool(positionalCall);
-
-      // By default (no `usesContext`), positional tools receive ONLY their
-      // declared positional args — no trailing `_ctx`.
-      expect(mockFunction).toHaveBeenCalledWith("hello", 42);
-    });
-
-    it("should handle tool not enabled error", async () => {
-      const mockFunction = jest.fn();
-      toolsService.setFunction("testTool", mockFunction);
-
-      const result = await toolsService.callTool(mockToolCall, ["otherTool"]);
-
-      expect(mockFunction).not.toHaveBeenCalled();
-      expect(result.toolMessages[0].name).toBe("error");
-      expect(result.toolMessages[0].content).toContain("not enabled");
-      expect(result.functionResp).toBeUndefined();
-    });
-
-    it("should handle tool definition not found", async () => {
-      const unknownToolCall: ToolCall = {
-        id: "call_unknown",
-        type: "function",
-        function: {
-          name: "unknownTool",
-          arguments: "{}",
-        },
-      };
-
-      const result = await toolsService.callTool(unknownToolCall);
-
-      expect(result.toolMessages[0].name).toBe("error");
-      expect(result.toolMessages[0].content).toContain("not enabled");
-    });
-
-    it("should handle function implementation not found", async () => {
-      // Tool is defined but no function implementation
-      const result = await toolsService.callTool(mockToolCall);
-
-      expect(result.toolMessages[0].name).toBe("error");
-      expect(result.toolMessages[0].content).toContain("not found");
-    });
-
-    it("should handle function execution errors", async () => {
-      const mockFunction = jest
-        .fn()
-        .mockRejectedValue(new Error("Function failed"));
-      toolsService.setFunction("testTool", mockFunction);
-
-      const result = await toolsService.callTool(mockToolCall);
-
-      expect(result.toolMessages[0].name).toBe("error");
-      expect(result.toolMessages[0].content).toContain(
-        "ERROR: Function failed"
-      );
-      expect(result.functionResp).toBeUndefined();
-    });
-
-    it("should handle object responses by converting to JSON", async () => {
-      const mockFunction = jest
-        .fn()
-        .mockResolvedValue({ key: "value", nested: { data: 123 } });
-      toolsService.setFunction("testTool", mockFunction);
-
-      const result = await toolsService.callTool(mockToolCall);
-
-      expect(result.toolMessages[0].content).toBe(
-        JSON.stringify({ key: "value", nested: { data: 123 } }, null, 2)
-      );
-    });
-
-    it("should handle multi_tool_use.parallel special case", async () => {
-      const parallelTool: Tool = {
-        type: "function",
-        function: {
-          name: "multi_tool_use.parallel",
-          parameters: {
-            type: "object",
-            properties: {},
-            required: [],
-          },
-        },
-      };
-
-      const parallelCall: ToolCall = {
-        id: "call_parallel",
-        type: "function",
-        function: {
-          name: "multi_tool_use.parallel",
-          arguments: JSON.stringify([
-            { recipient_name: "tool1.action", parameters: {} },
-            { recipient_name: "tool2.action", parameters: {} },
-          ]),
-        },
-      };
-
-      const mockFunction = jest.fn().mockResolvedValue(["result1", "result2"]);
-
-      toolsService.addTool(parallelTool);
-      toolsService.setFunction("multi_tool_use.parallel", mockFunction);
-
-      const result = await toolsService.callTool(parallelCall);
-
-      expect(result.toolMessages).toHaveLength(2);
-      expect(result.toolMessages[0].tool_call_id).toBe("call_parallel_0");
-      expect(result.toolMessages[1].tool_call_id).toBe("call_parallel_1");
-      expect(result.toolMessages[0].name).toBe("action");
-      expect(result.toolMessages[1].name).toBe("action");
-    });
-
-    it("should handle string arguments that need parsing", async () => {
-      const toolCallWithStringArgs: ToolCall = {
-        id: "call_string",
-        type: "function",
-        function: {
-          name: "testTool",
-          arguments: '{"input": "escaped\\nstring"}',
-        },
-      };
-
-      const mockFunction = jest.fn().mockResolvedValue("success");
-      toolsService.setFunction("testTool", mockFunction);
-
-      await toolsService.callTool(toolCallWithStringArgs);
-
-      expect(mockFunction).toHaveBeenCalledWith(
-        expect.objectContaining({ input: "escaped\nstring" })
-      );
-      // testTool does not opt into context, so no `_ctx` is injected.
-      expect(mockFunction.mock.calls[0][0]._ctx).toBeUndefined();
-    });
-  });
-  describe("Tool Override System", () => {
-    const mockTool: Tool = {
-      type: "function",
-      function: {
-        name: "overridableTool",
-        description: "A tool that can be overridden",
-        parameters: {
-          type: "object",
-          properties: {
-            input: { type: "string" },
-          },
-          required: ["input"],
-        },
-      },
-    };
-
-    beforeEach(() => {
-      toolsService.addTool(mockTool);
-      jest.clearAllMocks();
-    });
-
-    it("should register override with string pattern", () => {
-      const overrideFunction = jest.fn().mockResolvedValue("override result");
-
-      toolsService.registerOverride("overridableTool", overrideFunction);
-
-      expect(() => toolsService.getFunction("overridableTool")).not.toThrow();
-    });
-
-    it("should register override with regex pattern", () => {
-      const overrideFunction = jest.fn().mockResolvedValue("regex override");
-      const pattern = /^overridable/;
-
-      toolsService.registerOverride(pattern, overrideFunction);
-
-      expect(() => toolsService.getFunction("overridableTool")).not.toThrow();
-    });
-
-    it("should execute override function instead of original", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original result");
-      const overrideFunction = jest.fn().mockResolvedValue("override result");
-
-      toolsService.setFunction("overridableTool", originalFunction);
-      toolsService.registerOverride("overridableTool", overrideFunction);
-
-      const toolCall: ToolCall = {
-        id: "call_override",
-        type: "function",
-        function: {
-          name: "overridableTool",
-          arguments: JSON.stringify({ input: "test" }),
-        },
-      };
-
-      const result = await toolsService.callTool(toolCall);
-
-      // overridableTool does not opt into context, so args have no `_ctx`;
-      // the override receives them in an array.
-      expect(overrideFunction).toHaveBeenCalledWith(
-        [expect.objectContaining({ input: "test" })],
-        expect.any(Object)
-      );
-      expect(originalFunction).not.toHaveBeenCalled();
-      expect(result.functionResp).toBe("override result");
-    });
-
-    it("should handle override priority ordering", async () => {
-      const override1 = jest.fn().mockResolvedValue("override1");
-      const override2 = jest.fn().mockResolvedValue("override2");
-
-      // Register with different priorities
-      toolsService.registerOverride("overridableTool", override1, 1);
-      toolsService.registerOverride("overridableTool", override2, 2);
-
-      // Higher priority should be used
-      const func = toolsService.getFunction("overridableTool");
-      // Function should be bound version of override2, test by calling it
-      expect(await func({})).toBe("override2");
-    });
-
-    it("should handle pattern matching with wildcards", async () => {
-      const overrideFunction = jest.fn().mockResolvedValue("wildcard override");
-
-      toolsService.registerOverride("overrid*Tool", overrideFunction);
-
-      const func = toolsService.getFunction("overridableTool");
-      // Function should be bound version of override, test by calling it
-      expect(await func({})).toBe("wildcard override");
-    });
-
-    it("should remove overrides", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const overrideFunction = jest.fn().mockResolvedValue("override");
-
-      toolsService.setFunction("overridableTool", originalFunction);
-      toolsService.registerOverride("overridableTool", overrideFunction);
-
-      // Override should be active
-      const overriddenFunc = toolsService.getFunction("overridableTool");
-      expect(await overriddenFunc({})).toBe("override");
-
-      toolsService.removeOverride("overridableTool");
-
-      // Should return to original
-      const restoredFunc = toolsService.getFunction("overridableTool");
-      expect(await restoredFunc({})).toBe("original");
-    });
-
-    it("should preserve original functions when override is registered", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const overrideFunction = jest.fn().mockResolvedValue("override");
-
-      toolsService.setFunction("overridableTool", originalFunction);
-      toolsService.registerOverride("overridableTool", overrideFunction);
-
-      const originalStored =
-        toolsService.getOriginalFunction("overridableTool");
-      // Original function should still be the same function (not bound)
-      expect(await originalStored!({})).toBe("original");
-    });
-  });
-
-  describe("Tool Wrapper System", () => {
-    const mockTool: Tool = {
-      type: "function",
-      function: {
-        name: "wrappableTool",
-        description: "A tool that can be wrapped",
-        parameters: {
-          type: "object",
-          properties: {
-            input: { type: "string" },
-          },
-          required: ["input"],
-        },
-      },
-    };
-
-    beforeEach(() => {
-      toolsService.addTool(mockTool);
-      jest.clearAllMocks();
-    });
-
-    it("should register wrapper with string pattern", () => {
-      const wrapperFunction = jest
-        .fn()
-        .mockImplementation((originalFn, args) => {
-          return originalFn(args);
-        });
-
-      toolsService.registerWrapper("wrappableTool", wrapperFunction);
-
-      expect(() => toolsService.getFunction("wrappableTool")).not.toThrow();
-    });
-
-    it("should register wrapper with regex pattern", () => {
-      const wrapperFunction = jest
-        .fn()
-        .mockImplementation((originalFn, args) => {
-          return originalFn(args);
-        });
-      const pattern = /^wrappable/;
-
-      toolsService.registerWrapper(pattern, wrapperFunction);
-
-      expect(() => toolsService.getFunction("wrappableTool")).not.toThrow();
-    });
-
-    it("should execute wrapper function with original function", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original result");
-      const wrapperFunction = jest
-        .fn()
-        .mockImplementation(async (originalFn, args, tool) => {
-          // args is now an array of arguments
-          const result = await originalFn(...args);
-          return `wrapped: ${result}`;
-        });
-
-      toolsService.setFunction("wrappableTool", originalFunction);
-      toolsService.registerWrapper("wrappableTool", wrapperFunction);
-
-      const toolCall: ToolCall = {
-        id: "call_wrapper",
-        type: "function",
-        function: {
-          name: "wrappableTool",
-          arguments: JSON.stringify({ input: "test" }),
-        },
-      };
-
-      const result = await toolsService.callTool(toolCall);
-
-      expect(wrapperFunction).toHaveBeenCalled();
-      expect(originalFunction).toHaveBeenCalledWith(
-        expect.objectContaining({ input: "test" })
-      );
-      expect(result.functionResp).toBe("wrapped: original result");
-    });
-
-    it("should handle wrapper priority ordering", () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const wrapper1 = jest.fn().mockImplementation((fn, args) => fn(args));
-      const wrapper2 = jest.fn().mockImplementation((fn, args) => fn(args));
-
-      toolsService.setFunction("wrappableTool", originalFunction);
-      toolsService.registerWrapper("wrappableTool", wrapper1, 1);
-      toolsService.registerWrapper("wrappableTool", wrapper2, 2);
-
-      // Should use higher priority wrapper
-      const func = toolsService.getFunction("wrappableTool");
-      expect(func).not.toBe(originalFunction);
-      expect(func).not.toBe(wrapper1);
-    });
-
-    it("should support multiple wrapper chaining", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-
-      const wrapper1 = jest
-        .fn()
-        .mockImplementation(async (originalFn, args) => {
-          const result = await originalFn(args);
-          return `wrapper1(${result})`;
-        });
-
-      const wrapper2 = jest
-        .fn()
-        .mockImplementation(async (originalFn, args) => {
-          const result = await originalFn(args);
-          return `wrapper2(${result})`;
-        });
-
-      toolsService.setFunction("wrappableTool", originalFunction);
-      toolsService.registerWrapper("wrappableTool", wrapper1, 1);
-      toolsService.registerWrapper("wrappableTool", wrapper2, 2);
-
-      const toolCall: ToolCall = {
-        id: "call_chained",
-        type: "function",
-        function: {
-          name: "wrappableTool",
-          arguments: JSON.stringify({ input: "test" }),
-        },
-      };
-
-      const result = await toolsService.callTool(toolCall);
-
-      expect(result.functionResp).toContain("wrapper1");
-      expect(result.functionResp).toContain("wrapper2");
-      expect(originalFunction).toHaveBeenCalled();
-    });
-
-    it("should remove wrappers", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const wrapperFunction = jest
-        .fn()
-        .mockImplementation((fn, args) => fn(args));
-
-      toolsService.setFunction("wrappableTool", originalFunction);
-      toolsService.registerWrapper("wrappableTool", wrapperFunction);
-
-      // Wrapper should be active
-      expect(toolsService.getFunction("wrappableTool")).not.toBe(
-        originalFunction
-      );
-
-      toolsService.removeWrapper("wrappableTool");
-
-      // Should return to original
-      const restoredFunc = toolsService.getFunction("wrappableTool");
-      expect(await restoredFunc!({})).toBe("original");
-    });
-  });
-  describe("Pattern Matching", () => {
-    it("should match glob patterns with wildcards", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const overrideFunction = jest.fn().mockResolvedValue("override");
-
-      toolsService.setFunction("testTool", originalFunction);
-      toolsService.setFunction("testHelper", originalFunction);
-      toolsService.setFunction("otherTool", originalFunction);
-
-      // Register override with glob pattern
-      toolsService.registerOverride("test*", overrideFunction);
-
-      // Should match tools starting with "test"
-      const testFunc = toolsService.getFunction("testTool");
-      const testHelperFunc = toolsService.getFunction("testHelper");
-      const otherFunc = toolsService.getFunction("otherTool");
-      expect(await testFunc!({})).toBe("override");
-      expect(await testHelperFunc!({})).toBe("override");
-      expect(await otherFunc!({})).toBe("original");
-    });
-
-    it("should match regex patterns", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const overrideFunction = jest.fn().mockResolvedValue("override");
-
-      toolsService.setFunction("tool123", originalFunction);
-      toolsService.setFunction("tool456", originalFunction);
-      toolsService.setFunction("toolABC", originalFunction);
-
-      // Register override with regex pattern for tools ending with numbers
-      toolsService.registerOverride(/tool\d+$/, overrideFunction);
-
-      const tool123Func = toolsService.getFunction("tool123");
-      const tool456Func = toolsService.getFunction("tool456");
-      const toolABCFunc = toolsService.getFunction("toolABC");
-      expect(await tool123Func!({})).toBe("override");
-      expect(await tool456Func!({})).toBe("override");
-      expect(await toolABCFunc!({})).toBe("original");
-    });
-
-    it("should handle complex glob patterns", async () => {
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const overrideFunction = jest.fn().mockResolvedValue("override");
-
-      toolsService.setFunction("api_get_user", originalFunction);
-      toolsService.setFunction("api_post_user", originalFunction);
-      toolsService.setFunction("api_delete_user", originalFunction);
-      toolsService.setFunction("util_format", originalFunction);
-
-      // Match API tools with user operations
-      toolsService.registerOverride("api_*_user", overrideFunction);
-
-      const apiGetFunc = toolsService.getFunction("api_get_user");
-      const apiPostFunc = toolsService.getFunction("api_post_user");
-      const apiDeleteFunc = toolsService.getFunction("api_delete_user");
-
-      expect(await apiGetFunc!({})).toBe("override");
-      expect(await apiPostFunc!({})).toBe("override");
-      expect(await apiDeleteFunc!({})).toBe("override");
-      const utilFormatFunc = toolsService.getFunction("util_format");
-      expect(await utilFormatFunc!({})).toBe("original");
-    });
-
-    it("should test pattern matcher factory function directly", () => {
-      // Test string pattern matcher
-      const stringMatcher = createPatternMatcher("test*");
-      expect(stringMatcher.matches("testTool")).toBe(true);
-      expect(stringMatcher.matches("otherTool")).toBe(false);
-
-      // Test regex pattern matcher
-      const regexMatcher = createPatternMatcher(/^api_/);
-      expect(regexMatcher.matches("api_call")).toBe(true);
-      expect(regexMatcher.matches("util_call")).toBe(false);
-    });
-  });
-
-  describe("Error Handling and Edge Cases", () => {
-    it("should handle malformed tool call arguments", async () => {
-      const mockTool: Tool = {
-        type: "function",
-        function: {
-          name: "testTool",
-          parameters: { type: "object", properties: {}, required: [] },
-        },
-      };
-
-      const malformedCall: ToolCall = {
-        id: "call_malformed",
-        type: "function",
-        function: {
-          name: "testTool",
-          arguments: "invalid json {",
-        },
-      };
-
-      toolsService.addTool(mockTool);
-      toolsService.setFunction(
-        "testTool",
-        jest.fn().mockResolvedValue("result")
-      );
-
-      const result = await toolsService.callTool(malformedCall);
-
-      expect(result.toolMessages[0].name).toBe("error");
-      expect(result.toolMessages[0].content).toContain("JSON");
-    });
-
-    it("should handle tools with no parameters", async () => {
-      const noParamTool: Tool = {
-        type: "function",
-        function: {
-          name: "noParamTool",
-          description: "Tool with no parameters",
-          parameters: {
-            type: "object",
-            properties: {},
-            required: [],
-          },
-        },
-      };
-
-      const noParamCall: ToolCall = {
-        id: "call_no_param",
-        type: "function",
-        function: {
-          name: "noParamTool",
-          arguments: "{}",
-        },
-      };
-
-      const mockFunction = jest.fn().mockResolvedValue("no param result");
-
-      toolsService.addTool(noParamTool);
-      toolsService.setFunction("noParamTool", mockFunction);
-
-      const result = await toolsService.callTool(noParamCall);
-
-      expect(mockFunction).toHaveBeenCalledWith(expect.any(Object));
-      // noParamTool does not opt into context, so no `_ctx` is injected.
-      expect(mockFunction.mock.calls[0][0]._ctx).toBeUndefined();
-      expect(result.functionResp).toBe("no param result");
-    });
-
-    it("should handle tools with complex nested parameter structures", async () => {
-      const complexTool: Tool = {
-        type: "function",
-        function: {
-          name: "complexTool",
-          parameters: {
-            type: "object",
-            properties: {
-              config: {
-                type: "object",
-                properties: {
-                  settings: {
-                    type: "array",
-                    items: {
-                      type: "object",
-                      properties: {
-                        key: { type: "string" },
-                        value: { type: "number" },
-                      },
-                    },
-                  },
-                },
-              },
-            },
-            required: ["config"],
-          },
-        },
-      };
-
-      const complexCall: ToolCall = {
-        id: "call_complex",
-        type: "function",
-        function: {
-          name: "complexTool",
-          arguments: JSON.stringify({
-            config: {
-              settings: [
-                { key: "timeout", value: 5000 },
-                { key: "retries", value: 3 },
-              ],
-            },
-          }),
-        },
-      };
-
-      const mockFunction = jest.fn().mockResolvedValue("complex result");
-
-      toolsService.addTool(complexTool);
-      toolsService.setFunction("complexTool", mockFunction);
-
-      const result = await toolsService.callTool(complexCall);
-
-      expect(mockFunction).toHaveBeenCalledWith(
-        expect.objectContaining({
-        config: {
-          settings: [
-            { key: "timeout", value: 5000 },
-            { key: "retries", value: 3 },
-          ],
-        },
-        })
-      );
-      expect(result.functionResp).toBe("complex result");
-    });
-
-    it("should handle concurrent tool calls", async () => {
-      const concurrentTool: Tool = {
-        type: "function",
-        function: {
-          name: "concurrentTool",
-          parameters: {
-            type: "object",
-            properties: {
-              delay: { type: "number" },
-            },
-            required: ["delay"],
-          },
-        },
-      };
-
-      const mockFunction = jest.fn().mockImplementation(async ({ delay }) => {
-        await new Promise((resolve) => setTimeout(resolve, delay));
-        return `completed after ${delay}ms`;
-      });
-
-      toolsService.addTool(concurrentTool);
-      toolsService.setFunction("concurrentTool", mockFunction);
-
-      const call1: ToolCall = {
-        id: "call_1",
-        type: "function",
-        function: {
-          name: "concurrentTool",
-          arguments: JSON.stringify({ delay: 100 }),
-        },
-      };
-
-      const call2: ToolCall = {
-        id: "call_2",
-        type: "function",
-        function: {
-          name: "concurrentTool",
-          arguments: JSON.stringify({ delay: 50 }),
-        },
-      };
-
-      const [result1, result2] = await Promise.all([
-        toolsService.callTool(call1),
-        toolsService.callTool(call2),
-      ]);
-
-      expect(result1.functionResp).toBe("completed after 100ms");
-      expect(result2.functionResp).toBe("completed after 50ms");
-      expect(mockFunction).toHaveBeenCalledTimes(2);
-    });
-
-    it("should handle undefined and null function responses", async () => {
-      // Test undefined response with separate tool
-      const undefinedTool: Tool = {
-        type: "function",
-        function: {
-          name: "undefinedTool",
-          parameters: { type: "object", properties: {}, required: [] },
-        },
-      };
-
-      const undefinedCall: ToolCall = {
-        id: "call_undefined",
-        type: "function",
-        function: {
-          name: "undefinedTool",
-          arguments: "{}",
-        },
-      };
-
-      toolsService.addTool(undefinedTool);
-      toolsService.setFunction(
-        "undefinedTool",
-        jest.fn().mockResolvedValue(undefined)
-      );
-      let result = await toolsService.callTool(undefinedCall);
-      expect(result.toolMessages[0].content).toBe("undefined");
-
-      // Test null response with separate tool
-      const nullTool: Tool = {
-        type: "function",
-        function: {
-          name: "nullTool",
-          parameters: { type: "object", properties: {}, required: [] },
-        },
-      };
-
-      const nullCall: ToolCall = {
-        id: "call_null",
-        type: "function",
-        function: {
-          name: "nullTool",
-          arguments: "{}",
-        },
-      };
-
-      toolsService.addTool(nullTool);
-      toolsService.setFunction("nullTool", jest.fn().mockResolvedValue(null));
-      result = await toolsService.callTool(nullCall);
-      expect(result.toolMessages[0].content).toBe("null");
-    });
-  });
-
-  describe("Integration Tests", () => {
-    it("should handle complete workflow with override and wrapper", async () => {
-      const baseTool: Tool = {
-        type: "function",
-        function: {
-          name: "workflowTool",
-          parameters: {
-            type: "object",
-            properties: {
-              input: { type: "string" },
-            },
-            required: ["input"],
-          },
-        },
-      };
-
-      const originalFunction = jest.fn().mockResolvedValue("original");
-      const wrapperFunction = jest
-        .fn()
-        .mockImplementation(async (originalFn, args) => {
-          const result = await originalFn(args);
-          return `wrapped: ${result}`;
-        });
-      const overrideFunction = jest.fn().mockResolvedValue("override");
-
-      toolsService.addTool(baseTool);
-      toolsService.setFunction("workflowTool", originalFunction);
-      toolsService.registerWrapper("workflowTool", wrapperFunction);
-      toolsService.registerOverride("workflowTool", overrideFunction);
-
-      const toolCall: ToolCall = {
-        id: "call_workflow",
-        type: "function",
-        function: {
-          name: "workflowTool",
-          arguments: JSON.stringify({ input: "test" }),
-        },
-      };
-
-      const result = await toolsService.callTool(toolCall);
-
-      // Override should take precedence over wrapper
-      expect(overrideFunction).toHaveBeenCalled();
-      expect(wrapperFunction).not.toHaveBeenCalled();
-      expect(originalFunction).not.toHaveBeenCalled();
-      expect(result.functionResp).toBe("override");
-    });
-
-    it("should maintain tool state across multiple operations", () => {
-      const tools: Tool[] = [
-        {
-          type: "function",
-          function: {
-            name: "tool1",
-            parameters: { type: "object", properties: {}, required: [] },
-          },
-        },
-        {
-          type: "function",
-          function: {
-            name: "tool2",
-            parameters: { type: "object", properties: {}, required: [] },
-          },
-        },
-      ];
-
-      toolsService.addTools(tools);
-      expect(toolsService.getToolsByNames(["tool1", "tool2"])).toHaveLength(2);
-
-      toolsService.setFunction("tool1", jest.fn());
-      toolsService.setFunction("tool2", jest.fn());
-
-      expect(toolsService.getFunction("tool1")).toBeDefined();
-      expect(toolsService.getFunction("tool2")).toBeDefined();
-
-      // Copy to new service
-      const newService = new ToolsService();
-      newService.copyToolsFrom(["tool1", "tool2"], toolsService);
-
-      expect(newService.getToolsByNames(["tool1", "tool2"])).toHaveLength(2);
-    });
-
-    describe("Function Binding", () => {
-      let toolsService: ToolsService;
-      let mockContext: ToolContext;
-
-      beforeEach(() => {
-        mockContext = {
-          metadata: { testKey: "testValue" },
-        };
-        toolsService = new ToolsService(mockContext);
-      });
-
-      describe("this binding in tool functions", () => {
-        it("should bind functions so 'this' refers to ToolsService instance", async () => {
-          const testTool: Tool = {
-            type: "function",
-            function: {
-              name: "testThisBinding",
-              description: "Test function that accesses this",
-              parameters: {
-                type: "object",
-                properties: {
-                  message: { type: "string" },
-                },
-              },
-            },
-          };
-
-          function testFunction(this: ToolsService, args: { message: string }) {
-            // This function should have 'this' bound to the ToolsService instance
-            if (!this || typeof this.getContext !== "function") {
-              throw new Error("'this' is not bound to ToolsService instance");
-            }
-            const context = this.getContext();
-            return {
-              message: args.message,
-              contextMetadata: context.metadata,
-              hasThisBinding: true,
-            };
-          }
-
-          toolsService.addTool(testTool);
-          toolsService.setFunction("testThisBinding", testFunction);
-
-          const toolCall: ToolCall = {
-            id: "test-call-1",
-            type: "function",
-            function: {
-              name: "testThisBinding",
-              arguments: JSON.stringify({ message: "test" }),
-            },
-          };
-
-          const result = await toolsService.callTool(toolCall);
-
-          expect(result.functionResp.hasThisBinding).toBe(true);
-          expect(result.functionResp.contextMetadata).toEqual({
-            testKey: "testValue",
-          });
-          expect(result.functionResp.message).toBe("test");
-        });
-
-        it("should allow tool functions to call other tools via this.callTool", async () => {
-          const helperTool: Tool = {
-            type: "function",
-            function: {
-              name: "helperTool",
-              description: "Helper tool",
-              parameters: {
-                type: "object",
-                properties: {
-                  value: { type: "string" },
-                },
-              },
-            },
-          };
-
-          const mainTool: Tool = {
-            type: "function",
-            function: {
-              name: "mainTool",
-              description: "Main tool that calls helper",
-              parameters: {
-                type: "object",
-                properties: {
-                  input: { type: "string" },
-                },
-              },
-            },
-          };
-
-          function helperFunction(args: { value: string }) {
-            return `Helper processed: ${args.value}`;
-          }
-
-          async function mainFunction(
-            this: ToolsService,
-            args: { input: string }
-          ) {
-            if (!this || typeof this.callTool !== "function") {
-              throw new Error("'this' is not bound to ToolsService instance");
-            }
-
-            const helperCall: ToolCall = {
-              id: "helper-call",
-              type: "function",
-              function: {
-                name: "helperTool",
-                arguments: JSON.stringify({ value: args.input }),
-              },
-            };
-
-            const helperResult = await this.callTool(helperCall);
-            return `Main tool result: ${helperResult.functionResp}`;
-          }
-
-          toolsService.addTool(helperTool);
-          toolsService.addTool(mainTool);
-          toolsService.setFunction("helperTool", helperFunction);
-          toolsService.setFunction("mainTool", mainFunction);
-
-          const toolCall: ToolCall = {
-            id: "test-call-2",
-            type: "function",
-            function: {
-              name: "mainTool",
-              arguments: JSON.stringify({ input: "test data" }),
-            },
-          };
-
-          const result = await toolsService.callTool(toolCall);
-
-          expect(result.functionResp).toBe(
-            "Main tool result: Helper processed: test data"
-          );
-        });
-
-        it("should maintain binding through overrides", async () => {
-          const testTool: Tool = {
-            type: "function",
-            function: {
-              name: "bindingTestTool",
-              description: "Test tool for binding with overrides",
-              parameters: {
-                type: "object",
-                properties: {
-                  data: { type: "string" },
-                },
-              },
-            },
-          };
-
-          function originalFunction(
-            this: ToolsService,
-            args: { data: string }
-          ) {
-            if (!this || typeof this.getContext !== "function") {
-              throw new Error(
-                "'this' is not bound to ToolsService instance in original"
-              );
-            }
-            return `Original: ${args.data}`;
-          }
-
-          const overrideFunction = function (
-            this: ToolsService,
-            originalArgs: any[],
-            originalTool: Tool
-          ) {
-            if (!this || typeof this.getContext !== "function") {
-              throw new Error(
-                "'this' is not bound to ToolsService instance in override"
-              );
-            }
-            return `Override: ${originalArgs[0].data}`;
-          };
-
-          toolsService.addTool(testTool);
-          toolsService.setFunction("bindingTestTool", originalFunction);
-          toolsService.registerOverride("bindingTestTool", overrideFunction);
-
-          const toolCall: ToolCall = {
-            id: "test-call-3",
-            type: "function",
-            function: {
-              name: "bindingTestTool",
-              arguments: JSON.stringify({ data: "test" }),
-            },
-          };
-
-          const result = await toolsService.callTool(toolCall);
-
-          expect(result.functionResp).toBe("Override: test");
-        });
-
-        it("should maintain binding through wrappers", async () => {
-          const testTool: Tool = {
-            type: "function",
-            function: {
-              name: "wrapperBindingTest",
-              description: "Test tool for binding with wrappers",
-              parameters: {
-                type: "object",
-                properties: {
-                  value: { type: "string" },
-                },
-              },
-            },
-          };
-
-          function baseFunction(this: ToolsService, args: { value: string }) {
-            if (!this || typeof this.getContext !== "function") {
-              throw new Error(
-                "'this' is not bound to ToolsService instance in base function"
-              );
-            }
-            return `Base: ${args.value}`;
-          }
-
-          const wrapper = (originalFunc: Function, args: any, tool: Tool) => {
-            // The wrapper should preserve the binding, args is now an array
-            // We need to spread the args array when calling the function
-            const result = originalFunc.call(toolsService, ...args);
-            return `Wrapped: ${result}`;
-          };
-
-          toolsService.addTool(testTool);
-          toolsService.setFunction("wrapperBindingTest", baseFunction);
-          toolsService.registerWrapper("wrapperBindingTest", wrapper);
-
-          const toolCall: ToolCall = {
-            id: "test-call-4",
-            type: "function",
-            function: {
-              name: "wrapperBindingTest",
-              arguments: JSON.stringify({ value: "test" }),
-            },
-          };
-
-          const result = await toolsService.callTool(toolCall);
-
-          expect(result.functionResp).toBe("Wrapped: Base: test");
-        });
-      });
-    });
-  });
-
-  describe("endsWith Tool Name Resolution", () => {
-    it("should register tool with complex prefix", () => {
-      const complexTool: Tool = {
-        type: "function",
-        function: {
-          name: "mcp_server_prefix_actualTool",
-          description: "A tool with a complex prefix",
-          parameters: {
-            type: "object",
-            properties: {
-              input: { type: "string", description: "Test input" },
-            },
-            required: ["input"],
-          },
-        },
-      };
-
-      toolsService.addTool(complexTool);
-
-      expect(toolsService.getTools()).toContain(complexTool);
-      expect(toolsService.getToolNames()).toContain("mcp_server_prefix_actualTool");
-    });
-
-    it("should find tool using endsWith matching", () => {
-      const complexTool: Tool = {
-        type: "function",
-        function: {
-          name: "mcp_server_prefix_actualTool",
-          description: "A tool with a complex prefix",
-          parameters: {
-            type: "object",
-            properties: {
-              input: { type: "string", description: "Test input" },
-            },
-            required: ["input"],
-          },
-        },
-      };
-
-      toolsService.addTool(complexTool);
-
-      // Should find tool by partial name (suffix)
-      const foundTool = toolsService.getTool("actualTool");
-      expect(foundTool).toBeDefined();
-      expect(foundTool.function.name).toBe("mcp_server_prefix_actualTool");
-    });
-
-    it("should call tool using partial name with endsWith", async () => {
-      const complexTool: Tool = {
-        type: "function",
-        function: {
-          name: "mcp_server_prefix_testFunction",
-          description: "A tool with a complex prefix",
-          parameters: {
-            type: "object",
-            properties: {
-              message: { type: "string", description: "Test message" },
-            },
-            required: ["message"],
-          },
-        },
-      };
-
-      const testFunction = (args: { message: string }) => {
-        return `Received: ${args.message}`;
-      };
-
-      toolsService.addTool(complexTool);
-      toolsService.setFunction("mcp_server_prefix_testFunction", testFunction);
-
-      const toolCall: ToolCall = {
-        id: "test-endsWith-1",
-        type: "function",
-        function: {
-          name: "testFunction",
-          arguments: JSON.stringify({ message: "Hello" }),
-        },
-      };
-
-      const result = await toolsService.callTool(toolCall, [
-        "mcp_server_prefix_testFunction",
-      ]);
-
-      expect(result.functionResp).toBe("Received: Hello");
-      expect(result.functionName).toBe("testFunction");
-    });
-
-    it("should execute function correctly with endsWith resolution", async () => {
-      const complexTool: Tool = {
-        type: "function",
-        function: {
-          name: "complex_prefix_myTool",
-          description: "Test tool with prefix",
-          parameters: {
-            type: "object",
-            properties: {
-              value: { type: "number", description: "A number" },
-            },
-            required: ["value"],
-          },
-        },
-      };
-
-      const myFunction = (args: { value: number }) => {
-        return args.value * 2;
-      };
-
-      toolsService.addTool(complexTool);
-      toolsService.setFunction("complex_prefix_myTool", myFunction);
-
-      const toolCall: ToolCall = {
-        id: "test-endsWith-2",
-        type: "function",
-        function: {
-          name: "myTool",
-          arguments: JSON.stringify({ value: 5 }),
-        },
-      };
-
-      const result = await toolsService.callTool(toolCall, [
-        "complex_prefix_myTool",
-      ]);
-
-      expect(result.functionResp).toBe(10);
-      expect(result.functionName).toBe("myTool");
-    });
-
-    it("should handle multiple tools with same suffix", () => {
-      const tool1: Tool = {
-        type: "function",
-        function: {
-          name: "prefix_a_sharedTool",
-          description: "First tool",
-          parameters: { type: "object", properties: {} },
-        },
-      };
-
-      const tool2: Tool = {
-        type: "function",
-        function: {
-          name: "prefix_b_sharedTool",
-          description: "Second tool",
-          parameters: { type: "object", properties: {} },
-        },
-      };
-
-      toolsService.addTool(tool1);
-      toolsService.addTool(tool2);
-
-      // getTool should return the first matching tool
-      const foundTool = toolsService.getTool("sharedTool");
-      expect(foundTool).toBeDefined();
-      expect(foundTool.function.name).toMatch(/_sharedTool$/);
-    });
-
-    it("should return first matching tool (no exact match priority)", () => {
-      // The implementation does NOT prioritize exact matches
-      // It returns the first tool that matches either exactly or via endsWith
-      const prefixedTool: Tool = {
-        type: "function",
-        function: {
-          name: "prefix_myTool",
-          description: "Prefixed tool",
-          parameters: { type: "object", properties: {} },
-        },
-      };
-
-      const exactMatchTool: Tool = {
-        type: "function",
-        function: {
-          name: "myTool",
-          description: "Exact match tool",
-          parameters: { type: "object", properties: {} },
-        },
-      };
-
-      // Add prefixed tool first
-      toolsService.addTool(prefixedTool);
-      
-      // When we search for "myTool", it will find prefixedTool first
-      // because "prefix_myTool".endsWith("myTool") is true
-      let foundTool = toolsService.getTool("myTool");
-      expect(foundTool).toBeDefined();
-      expect(foundTool.function.name).toBe("prefix_myTool");
-      
-      // Now add exact match tool
-      toolsService.addTool(exactMatchTool);
-      
-      // It will still find prefixedTool first (first in array)
-      foundTool = toolsService.getTool("myTool");
-      expect(foundTool).toBeDefined();
-      expect(foundTool.function.name).toBe("prefix_myTool");
-    });
-
-    it("should return undefined for non-matching partial name", () => {
-      const tool: Tool = {
-        type: "function",
-        function: {
-          name: "mcp_server_myTool",
-          description: "A tool",
-          parameters: { type: "object", properties: {} },
-        },
-      };
-
-      toolsService.addTool(tool);
-
-      const foundTool = toolsService.getTool("nonExistent");
-      expect(foundTool).toBeUndefined();
-    });
-
-    it("should work with getToolsByNames using endsWith logic for prefix stripping", () => {
-      // Note: getToolsByNames uses endsWith logic for prefix stripping!
-      // It checks if the TOOL name ends with the INPUT name
-      // So to find "mcp_prefix_tool1", you can search with just "tool1"
-      const tool1: Tool = {
-        type: "function",
-        function: { name: "tool1", description: "", parameters: { type: "object", properties: {} } },
-      };
-      const tool2: Tool = {
-        type: "function",
-        function: { name: "tool2", description: "", parameters: { type: "object", properties: {} } },
-      };
-
-      toolsService.addTools([tool1, tool2]);
-
-      const foundTools = toolsService.getToolsByNames(["tool1", "tool2"]);
-      expect(foundTools).toHaveLength(2);
-      expect(foundTools.map(t => t.function.name)).toContain("tool1");
-      expect(foundTools.map(t => t.function.name)).toContain("tool2");
-    });
-  });
-
-  describe("_ctx per-call context threading", () => {
-    const positionalTool: Tool = {
-      type: "function",
-      function: {
-        name: "posCtxTool",
-        parameters: {
-          type: "object",
-          positional: true,
-          usesContext: true,
-          properties: {
-            arg1: { type: "string" },
-          },
-          required: ["arg1"],
-        },
-      },
-    };
-
-    const nonPositionalTool: Tool = {
-      type: "function",
-      function: {
-        name: "nonPosCtxTool",
-        parameters: {
-          type: "object",
-          usesContext: true,
-          properties: {
-            input: { type: "string" },
-          },
-          required: ["input"],
-        },
-      },
-    };
-
-    it("passes _ctx as the last positional argument for positional tools", async () => {
-      const fn = jest.fn().mockResolvedValue("ok");
-      toolsService.addTool(positionalTool);
-      toolsService.setFunction("posCtxTool", fn);
-
-      const caller = { name: "TestAgent" };
-      await toolsService.callTool(
-        {
-          id: "c1",
-          type: "function",
-          function: {
-            name: "posCtxTool",
-            arguments: JSON.stringify({ arg1: "hello" }),
-          },
-        },
-        undefined,
-        { caller, taskId: "task-123" }
-      );
-
-      const callArgs = fn.mock.calls[0];
-      expect(callArgs[0]).toBe("hello");
-      const ctx = callArgs[1] as ToolCallContext;
-      expect(ctx).toBeDefined();
-      expect(ctx.caller).toBe(caller);
-      expect(ctx.taskId).toBe("task-123");
-      expect(ctx.Tools).toBe(toolsService);
-    });
-
-    it("merges _ctx onto the args object for non-positional tools", async () => {
-      const fn = jest.fn().mockResolvedValue("ok");
-      toolsService.addTool(nonPositionalTool);
-      toolsService.setFunction("nonPosCtxTool", fn);
-
-      const caller = { name: "TestAgent" };
-      await toolsService.callTool(
-        {
-          id: "c2",
-          type: "function",
-          function: {
-            name: "nonPosCtxTool",
-            arguments: JSON.stringify({ input: "value" }),
-          },
-        },
-        undefined,
-        { caller, taskId: "task-456" }
-      );
-
-      const argObj = fn.mock.calls[0][0];
-      expect(argObj.input).toBe("value");
-      expect(argObj._ctx).toBeDefined();
-      expect(argObj._ctx.caller).toBe(caller);
-      expect(argObj._ctx.taskId).toBe("task-456");
-      expect(argObj._ctx.Tools).toBe(toolsService);
-    });
-
-    it("still provides a _ctx (with Tools) when no callContext is passed", async () => {
-      const fn = jest.fn().mockResolvedValue("ok");
-      toolsService.addTool(nonPositionalTool);
-      toolsService.setFunction("nonPosCtxTool", fn);
-
-      await toolsService.callTool({
-        id: "c3",
-        type: "function",
-        function: {
-          name: "nonPosCtxTool",
-          arguments: JSON.stringify({ input: "value" }),
-        },
-      });
-
-      const argObj = fn.mock.calls[0][0];
-      expect(argObj._ctx).toBeDefined();
-      expect(argObj._ctx.Tools).toBe(toolsService);
-      expect(argObj._ctx.caller).toBeUndefined();
-    });
-
-    it("does not leak _ctx into the multi_tool_use.parallel extraction", async () => {
-      // The parallel path should extract calls from the ORIGINAL args, not the
-      // _ctx-augmented ones.
-      const parallelTool: Tool = {
-        type: "function",
-        function: {
-          name: "multi_tool_use.parallel",
-          parameters: { type: "object", properties: {} },
-        },
-      };
-      const inner = jest
-        .fn()
-        .mockResolvedValue(["r1", "r2"]);
-      toolsService.addTool(parallelTool);
-      toolsService.setFunction("multi_tool_use.parallel", inner);
-
-      const result = await toolsService.callTool(
-        {
-          id: "c4",
-          type: "function",
-          function: {
-            name: "multi_tool_use.parallel",
-            arguments: JSON.stringify([
-              { recipient_name: "functions.a", parameters: {} },
-              { recipient_name: "functions.b", parameters: {} },
-            ]),
-          },
-        },
-        undefined,
-        { caller: {}, taskId: "t" }
-      );
-
-      // Two tool messages, one per parallel call — proves extraction used the
-      // original array shape rather than an _ctx-wrapped object.
-      expect(result.toolMessages).toHaveLength(2);
-      expect(result.toolMessages[0].name).toBe("a");
-      expect(result.toolMessages[1].name).toBe("b");
-    });
-  });
-});