@copilotkit/runtime 1.55.1 → 1.55.2-next.1

package/src/agent/__tests__/converter-tanstack.test.ts

@@ -0,0 +1,314 @@
+import { describe, it, expect } from "vitest";
+import { EventType } from "@ag-ui/client";
+import {
+  createAgent,
+  createDefaultInput,
+  collectEvents,
+  expectLifecycleWrapped,
+  expectEventSequence,
+  eventField,
+  tanstackTextChunk,
+  tanstackToolCallStart,
+  tanstackToolCallArgs,
+  tanstackToolCallEnd,
+} from "./agent-test-helpers";
+
+describe("TanStack AI converter (via Agent)", () => {
+  // -------------------------------------------------------------------------
+  // Text Events
+  // -------------------------------------------------------------------------
+  describe("Text Events", () => {
+    it("TEXT_MESSAGE_CONTENT chunk produces TEXT_MESSAGE_CHUNK with role assistant and correct delta", async () => {
+      const agent = createAgent("tanstack", [tanstackTextChunk("Hello world")]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+
+      const textEvents = events.filter(
+        (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
+      );
+      expect(textEvents).toHaveLength(1);
+
+      expect(eventField<string>(textEvents[0], "role")).toBe("assistant");
+      expect(eventField<string>(textEvents[0], "delta")).toBe("Hello world");
+      expect(eventField<string>(textEvents[0], "messageId")).toBeDefined();
+      expect(typeof eventField<string>(textEvents[0], "messageId")).toBe(
+        "string",
+      );
+      expect(
+        eventField<string>(textEvents[0], "messageId").length,
+      ).toBeGreaterThan(0);
+    });
+
+    it("multiple text chunks share the same messageId", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackTextChunk("Hello "),
+        tanstackTextChunk("world"),
+        tanstackTextChunk("!"),
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+
+      const textEvents = events.filter(
+        (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
+      );
+      expect(textEvents).toHaveLength(3);
+
+      const messageIds = new Set(
+        textEvents.map((e) => eventField<string>(e, "messageId")),
+      );
+      expect(messageIds.size).toBe(1);
+    });
+
+    it("empty stream produces only RUN_STARTED + RUN_FINISHED", async () => {
+      const agent = createAgent("tanstack", []);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectEventSequence(events, [
+        EventType.RUN_STARTED,
+        EventType.RUN_FINISHED,
+      ]);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Tool Call Events
+  // -------------------------------------------------------------------------
+  describe("Tool Call Events", () => {
+    it("full tool call lifecycle produces START, ARGS, END events in order", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackToolCallStart("tc-1", "myTool"),
+        tanstackToolCallArgs("tc-1", '{"key":'),
+        tanstackToolCallArgs("tc-1", '"value"}'),
+        tanstackToolCallEnd("tc-1"),
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+      expectEventSequence(events, [
+        EventType.RUN_STARTED,
+        EventType.TOOL_CALL_START,
+        EventType.TOOL_CALL_ARGS,
+        EventType.TOOL_CALL_ARGS,
+        EventType.TOOL_CALL_END,
+        EventType.RUN_FINISHED,
+      ]);
+
+      expect(eventField<string>(events[1], "toolCallId")).toBe("tc-1");
+      expect(eventField<string>(events[1], "toolCallName")).toBe("myTool");
+
+      expect(eventField<string>(events[2], "toolCallId")).toBe("tc-1");
+      expect(eventField<string>(events[2], "delta")).toBe('{"key":');
+
+      expect(eventField<string>(events[3], "toolCallId")).toBe("tc-1");
+      expect(eventField<string>(events[3], "delta")).toBe('"value"}');
+
+      expect(eventField<string>(events[4], "toolCallId")).toBe("tc-1");
+    });
+
+    it("TOOL_CALL_START sets parentMessageId", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackTextChunk("before"),
+        tanstackToolCallStart("tc-1", "myTool"),
+        tanstackToolCallEnd("tc-1"),
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      const textEvent = events.find(
+        (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
+      )!;
+      const toolStartEvent = events.find(
+        (e) => e.type === EventType.TOOL_CALL_START,
+      )!;
+
+      expect(
+        eventField<string>(toolStartEvent, "parentMessageId"),
+      ).toBeDefined();
+      expect(eventField<string>(toolStartEvent, "parentMessageId")).toBe(
+        eventField<string>(textEvent, "messageId"),
+      );
+    });
+
+    it("multiple tool calls in sequence each get correct events", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackToolCallStart("tc-1", "toolA"),
+        tanstackToolCallArgs("tc-1", '{"a":1}'),
+        tanstackToolCallEnd("tc-1"),
+        tanstackToolCallStart("tc-2", "toolB"),
+        tanstackToolCallArgs("tc-2", '{"b":2}'),
+        tanstackToolCallEnd("tc-2"),
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+      expectEventSequence(events, [
+        EventType.RUN_STARTED,
+        EventType.TOOL_CALL_START,
+        EventType.TOOL_CALL_ARGS,
+        EventType.TOOL_CALL_END,
+        EventType.TOOL_CALL_START,
+        EventType.TOOL_CALL_ARGS,
+        EventType.TOOL_CALL_END,
+        EventType.RUN_FINISHED,
+      ]);
+
+      // Verify first tool call
+      expect(eventField<string>(events[1], "toolCallId")).toBe("tc-1");
+      expect(eventField<string>(events[1], "toolCallName")).toBe("toolA");
+
+      expect(eventField<string>(events[2], "toolCallId")).toBe("tc-1");
+
+      expect(eventField<string>(events[3], "toolCallId")).toBe("tc-1");
+
+      // Verify second tool call
+      expect(eventField<string>(events[4], "toolCallId")).toBe("tc-2");
+      expect(eventField<string>(events[4], "toolCallName")).toBe("toolB");
+
+      expect(eventField<string>(events[5], "toolCallId")).toBe("tc-2");
+
+      expect(eventField<string>(events[6], "toolCallId")).toBe("tc-2");
+    });
+
+    it("tool call with no ARGS chunks produces only START + END", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackToolCallStart("tc-1", "noArgsTool"),
+        tanstackToolCallEnd("tc-1"),
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+      expectEventSequence(events, [
+        EventType.RUN_STARTED,
+        EventType.TOOL_CALL_START,
+        EventType.TOOL_CALL_END,
+        EventType.RUN_FINISHED,
+      ]);
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Tool Call Result Events
+  // -------------------------------------------------------------------------
+  describe("Tool Call Result Events", () => {
+    it("TOOL_CALL_RESULT chunk produces TOOL_CALL_RESULT event with correct content", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackToolCallStart("tc-1", "myTool"),
+        tanstackToolCallArgs("tc-1", '{"key":"value"}'),
+        tanstackToolCallEnd("tc-1"),
+        {
+          type: "TOOL_CALL_RESULT",
+          toolCallId: "tc-1",
+          content: JSON.stringify({ result: "ok" }),
+        },
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+
+      const resultEvents = events.filter(
+        (e) => e.type === EventType.TOOL_CALL_RESULT,
+      );
+      expect(resultEvents).toHaveLength(1);
+      expect(eventField<string>(resultEvents[0], "toolCallId")).toBe("tc-1");
+      expect(eventField<string>(resultEvents[0], "role")).toBe("tool");
+      expect(
+        JSON.parse(eventField<string>(resultEvents[0], "content")),
+      ).toEqual({ result: "ok" });
+    });
+
+    it("TOOL_CALL_RESULT with object content serializes to JSON", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackToolCallStart("tc-2", "myTool"),
+        tanstackToolCallEnd("tc-2"),
+        {
+          type: "TOOL_CALL_RESULT",
+          toolCallId: "tc-2",
+          result: { data: 42 },
+        },
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      const resultEvents = events.filter(
+        (e) => e.type === EventType.TOOL_CALL_RESULT,
+      );
+      expect(resultEvents).toHaveLength(1);
+      expect(
+        JSON.parse(eventField<string>(resultEvents[0], "content")),
+      ).toEqual({ data: 42 });
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Mixed Content
+  // -------------------------------------------------------------------------
+  describe("Mixed Content", () => {
+    it("text interleaved with tool calls produces correct event types and order", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackTextChunk("Let me help. "),
+        tanstackToolCallStart("tc-1", "search"),
+        tanstackToolCallArgs("tc-1", '{"q":"test"}'),
+        tanstackToolCallEnd("tc-1"),
+        tanstackTextChunk("Here are the results."),
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+      expectEventSequence(events, [
+        EventType.RUN_STARTED,
+        EventType.TEXT_MESSAGE_CHUNK,
+        EventType.TOOL_CALL_START,
+        EventType.TOOL_CALL_ARGS,
+        EventType.TOOL_CALL_END,
+        EventType.TEXT_MESSAGE_CHUNK,
+        EventType.RUN_FINISHED,
+      ]);
+
+      // Verify content of text events
+      const textEvents = events.filter(
+        (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
+      );
+      expect(eventField<string>(textEvents[0], "delta")).toBe("Let me help. ");
+      expect(eventField<string>(textEvents[1], "delta")).toBe(
+        "Here are the results.",
+      );
+    });
+  });
+
+  // -------------------------------------------------------------------------
+  // Edge Cases
+  // -------------------------------------------------------------------------
+  describe("Edge Cases", () => {
+    it("unknown chunk types are silently ignored", async () => {
+      const agent = createAgent("tanstack", [
+        tanstackTextChunk("hello"),
+        { type: "SOME_UNKNOWN_TYPE", data: "foo" },
+        { type: "ANOTHER_MYSTERY", value: 42 },
+        tanstackTextChunk(" world"),
+      ]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+      expectEventSequence(events, [
+        EventType.RUN_STARTED,
+        EventType.TEXT_MESSAGE_CHUNK,
+        EventType.TEXT_MESSAGE_CHUNK,
+        EventType.RUN_FINISHED,
+      ]);
+    });
+
+    it("large deltas (100k chars) are passed through", async () => {
+      const largeDelta = "x".repeat(100_000);
+      const agent = createAgent("tanstack", [tanstackTextChunk(largeDelta)]);
+      const events = await collectEvents(agent.run(createDefaultInput()));
+
+      expectLifecycleWrapped(events);
+
+      const textEvent = events.find(
+        (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
+      )!;
+      expect(eventField<string>(textEvent, "delta")).toBe(largeDelta);
+      expect(eventField<string>(textEvent, "delta").length).toBe(100_000);
+    });
+  });
+});

package/src/agent/__tests__/mcp-servers-integration.test.ts

@@ -0,0 +1,373 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { BasicAgent } from "../index";
+import { EventType } from "@ag-ui/client";
+import { streamText } from "ai";
+import { LLMock, MCPMock } from "@copilotkit/aimock";
+import {
+  mockStreamTextResponse,
+  textDelta,
+  finish,
+  collectEvents,
+  toolCall,
+  toolResult,
+} from "./test-helpers";
+
+// Mock the ai module — we don't want real LLM calls
+vi.mock("ai", () => ({
+  streamText: vi.fn(),
+  tool: vi.fn((config) => config),
+  stepCountIs: vi.fn((count: number) => ({ type: "stepCount", count })),
+}));
+
+vi.mock("@ai-sdk/openai", () => ({
+  createOpenAI: vi.fn(() => (modelId: string) => ({
+    modelId,
+    provider: "openai",
+  })),
+}));
+
+// Do NOT mock @ai-sdk/mcp or @modelcontextprotocol/sdk transports —
+// we want real HTTP connections to the MCPMock server.
+
+describe("mcpServers — real MCP server integration", () => {
+  const originalEnv = process.env;
+  let llm: LLMock;
+  let mcpMock: MCPMock;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env = { ...originalEnv };
+    process.env.OPENAI_API_KEY = "test-key";
+  });
+
+  afterEach(async () => {
+    process.env = originalEnv;
+    if (llm) {
+      await llm.stop().catch(() => {});
+    }
+  });
+
+  const baseInput = {
+    threadId: "thread1",
+    runId: "run1",
+    messages: [],
+    tools: [],
+    context: [],
+    state: {},
+  };
+
+  /**
+   * Start an LLMock with an MCPMock mounted at /mcp.
+   * Returns the full MCP endpoint URL.
+   */
+  async function startMcpServer(
+    tools: Array<{ name: string; description?: string }>,
+  ): Promise<{ mcpUrl: string; llm: LLMock; mcpMock: MCPMock }> {
+    const mock = new MCPMock();
+    for (const t of tools) {
+      mock.addTool({
+        name: t.name,
+        description: t.description ?? `${t.name} tool`,
+        inputSchema: {
+          type: "object",
+          properties: { query: { type: "string" } },
+        },
+      });
+      mock.onToolCall(t.name, () => `result from ${t.name}`);
+    }
+
+    const server = new LLMock({ port: 0 });
+    server.mount("/mcp", mock);
+    await server.start();
+
+    return {
+      mcpUrl: `${server.url}/mcp`,
+      llm: server,
+      mcpMock: mock,
+    };
+  }
+
+  it("HTTP transport fetches tools from MCPMock", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Hello"), finish()]) as any,
+    );
+
+    await collectEvents(agent["run"](baseInput));
+
+    const callArgs = vi.mocked(streamText).mock.calls[0][0];
+    expect(callArgs.tools).toHaveProperty("get_weather");
+  });
+
+  it("SSE transport against MCPMock emits RUN_ERROR or completes without crash", async () => {
+    // MCPMock only supports Streamable HTTP, not SSE.
+    // The agent should emit RUN_ERROR when SSE connection fails.
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "sse", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([finish()]) as any,
+    );
+
+    // Collect events manually — the Observable may error after emitting RUN_ERROR
+    const events: any[] = [];
+    try {
+      await new Promise((resolve, reject) => {
+        agent["run"](baseInput).subscribe({
+          next: (event: any) => events.push(event),
+          error: (err: any) => reject(err),
+          complete: () => resolve(events),
+        });
+      });
+      // If it completes without error, that's also acceptable (graceful fallthrough)
+    } catch {
+      // Expected — SSE transport failure should emit RUN_ERROR then error
+    }
+
+    const hasRunError = events.some((e) => e.type === EventType.RUN_ERROR);
+    // Either we got a RUN_ERROR or streamText was never called (connection failed before tools fetch)
+    expect(hasRunError || !vi.mocked(streamText).mock.calls.length).toBe(true);
+  });
+
+  it("tool call round-trip emits TOOL_CALL_START, TOOL_CALL_RESULT, and TEXT_MESSAGE_CHUNK", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([
+        toolCall("tc1", "get_weather", { query: "NYC" }),
+        toolResult("tc1", "get_weather", "Sunny 72F"),
+        textDelta("The weather is sunny."),
+        finish(),
+      ]) as any,
+    );
+
+    const events = await collectEvents(agent["run"](baseInput));
+
+    const types = events.map((e: any) => e.type);
+    expect(types).toContain(EventType.TOOL_CALL_START);
+    expect(types).toContain(EventType.TOOL_CALL_RESULT);
+    expect(types).toContain(EventType.TEXT_MESSAGE_CHUNK);
+
+    // Verify the tool call result content
+    const resultEvent = events.find(
+      (e: any) => e.type === EventType.TOOL_CALL_RESULT,
+    ) as any;
+    expect(resultEvent.toolCallId).toBe("tc1");
+    expect(resultEvent.content).toContain("Sunny 72F");
+  });
+
+  it("MCP clients are cleaned up after completion — second run creates fresh connections", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    // First run
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Run 1"), finish()]) as any,
+    );
+    const events1 = await collectEvents(agent["run"](baseInput));
+    expect(events1.some((e: any) => e.type === EventType.RUN_FINISHED)).toBe(
+      true,
+    );
+
+    // Second run — should succeed with fresh MCP client connections
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Run 2"), finish()]) as any,
+    );
+    const events2 = await collectEvents(agent["run"](baseInput));
+    expect(events2.some((e: any) => e.type === EventType.RUN_FINISHED)).toBe(
+      true,
+    );
+
+    // streamText was called twice (once per run), each time with MCP tools
+    expect(vi.mocked(streamText).mock.calls).toHaveLength(2);
+    expect(vi.mocked(streamText).mock.calls[0][0].tools).toHaveProperty(
+      "get_weather",
+    );
+    expect(vi.mocked(streamText).mock.calls[1][0].tools).toHaveProperty(
+      "get_weather",
+    );
+  });
+
+  it("unreachable MCP server emits RUN_ERROR", async () => {
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: "http://localhost:59999" }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([finish()]) as any,
+    );
+
+    const events: any[] = [];
+    try {
+      await new Promise((resolve, reject) => {
+        agent["run"](baseInput).subscribe({
+          next: (event: any) => events.push(event),
+          error: (err: any) => reject(err),
+          complete: () => resolve(events),
+        });
+      });
+    } catch {
+      // Expected — connection refused should cause an error
+    }
+
+    expect(events.some((e) => e.type === EventType.RUN_ERROR)).toBe(true);
+    // streamText should not have been called since MCP init failed
+    expect(streamText).not.toHaveBeenCalled();
+  });
+
+  it("MCP clients are cleaned up after streamText error — subsequent run still works", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    // First run — streamText throws an error
+    vi.mocked(streamText).mockImplementation(() => {
+      throw new Error("LLM connection failed");
+    });
+
+    const events1: any[] = [];
+    try {
+      await new Promise((resolve, reject) => {
+        agent["run"](baseInput).subscribe({
+          next: (event: any) => events1.push(event),
+          error: (err: any) => reject(err),
+          complete: () => resolve(events1),
+        });
+      });
+    } catch {
+      // Expected — streamText threw
+    }
+
+    // Should have emitted RUN_ERROR
+    expect(events1.some((e) => e.type === EventType.RUN_ERROR)).toBe(true);
+
+    // Second run — streamText works normally, proving MCP cleanup happened
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Recovery"), finish()]) as any,
+    );
+    const events2 = await collectEvents(agent["run"](baseInput));
+    expect(events2.some((e: any) => e.type === EventType.RUN_FINISHED)).toBe(
+      true,
+    );
+
+    // The second run should have MCP tools available
+    const secondCallArgs = vi.mocked(streamText).mock.calls[1][0];
+    expect(secondCallArgs.tools).toHaveProperty("get_weather");
+  });
+
+  it("MCP tool descriptions are passed to streamText tools config", async () => {
+    const result = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result.llm;
+    mcpMock = result.mcpMock;
+
+    const agent = new BasicAgent({
+      model: "openai/gpt-4o",
+      mcpServers: [{ type: "http", url: result.mcpUrl }],
+    });
+
+    vi.mocked(streamText).mockReturnValue(
+      mockStreamTextResponse([textDelta("Hello"), finish()]) as any,
+    );
+
+    await collectEvents(agent["run"](baseInput));
+
+    const callArgs = vi.mocked(streamText).mock.calls[0][0];
+    expect(callArgs.tools).toHaveProperty("get_weather");
+    // The MCP tool should include the description from the MCPMock server
+    expect(callArgs.tools.get_weather.description).toBe("Get the weather");
+  });
+
+  it("multiple MCP servers merge tools from both", async () => {
+    // First server with get_weather
+    const result1 = await startMcpServer([
+      { name: "get_weather", description: "Get the weather" },
+    ]);
+    llm = result1.llm;
+
+    // Second server with search_docs
+    const mock2 = new MCPMock();
+    mock2.addTool({
+      name: "search_docs",
+      description: "Search documentation",
+      inputSchema: {
+        type: "object",
+        properties: { query: { type: "string" } },
+      },
+    });
+    mock2.onToolCall("search_docs", () => "doc results");
+
+    const llm2 = new LLMock({ port: 0 });
+    llm2.mount("/mcp", mock2);
+    await llm2.start();
+
+    try {
+      const agent = new BasicAgent({
+        model: "openai/gpt-4o",
+        mcpServers: [
+          { type: "http", url: result1.mcpUrl },
+          { type: "http", url: `${llm2.url}/mcp` },
+        ],
+      });
+
+      vi.mocked(streamText).mockReturnValue(
+        mockStreamTextResponse([
+          textDelta("Both tools available"),
+          finish(),
+        ]) as any,
+      );
+
+      await collectEvents(agent["run"](baseInput));
+
+      const callArgs = vi.mocked(streamText).mock.calls[0][0];
+      expect(callArgs.tools).toHaveProperty("get_weather");
+      expect(callArgs.tools).toHaveProperty("search_docs");
+    } finally {
+      await llm2.stop().catch(() => {});
+    }
+  });
+});