@copilotkit/runtime 1.57.2 → 1.57.4

package/src/agent/__tests__/zod-regression.test.ts

@@ -1,350 +0,0 @@
-/**
- * Regression tests proving that the agent package's defineTool and
- * convertToolDefinitionsToVercelAITools still work identically with
- * Zod schemas after the Standard Schema migration.
- *
- * Covers:
- * 1. defineTool with complex Zod schemas
- * 2. convertToolDefinitionsToVercelAITools passes Zod schemas directly
- *    (not through JSON Schema conversion — critical behavioral regression)
- * 3. BuiltInAgent with Zod tools still works end-to-end
- * 4. execute callback receives correctly shaped args
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { z } from "zod";
-import {
-  defineTool,
-  convertToolDefinitionsToVercelAITools,
-  BuiltInAgent,
-} from "../index";
-import type { RunAgentInput } from "@ag-ui/client";
-import { streamText } from "ai";
-import { mockStreamTextResponse, finish, collectEvents } from "./test-helpers";
-
-vi.mock("ai", async () => {
-  const actual = await vi.importActual("ai");
-  return {
-    ...actual,
-    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",
-  })),
-}));
-
-describe("defineTool Zod regression", () => {
-  it("complex Zod schema with nested objects, arrays, unions", () => {
-    const tool = defineTool({
-      name: "complexTool",
-      description: "A complex tool",
-      parameters: z.object({
-        query: z.string().describe("Search query"),
-        filters: z
-          .object({
-            category: z.enum(["books", "movies", "music"]).optional(),
-            minRating: z.number().min(0).max(5).optional(),
-            tags: z.array(z.string()).optional(),
-          })
-          .optional(),
-        pagination: z
-          .object({
-            page: z.number().int().positive().default(1),
-            perPage: z.number().int().positive().default(20),
-          })
-          .optional(),
-      }),
-      execute: async (args) => {
-        return { query: args.query };
-      },
-    });
-
-    expect(tool.name).toBe("complexTool");
-    expect(tool.parameters["~standard"].vendor).toBe("zod");
-    expect(tool.parameters["~standard"].version).toBe(1);
-  });
-
-  it("Zod schema with discriminated union", () => {
-    const tool = defineTool({
-      name: "actionTool",
-      description: "An action tool",
-      parameters: z.object({
-        action: z.discriminatedUnion("type", [
-          z.object({ type: z.literal("search"), query: z.string() }),
-          z.object({ type: z.literal("navigate"), url: z.string().url() }),
-          z.object({
-            type: z.literal("execute"),
-            code: z.string(),
-            language: z.enum(["javascript", "python"]),
-          }),
-        ]),
-      }),
-      execute: async (args) => {
-        return { action: args.action.type };
-      },
-    });
-
-    expect(tool.name).toBe("actionTool");
-    expect(tool.parameters["~standard"].vendor).toBe("zod");
-  });
-
-  it("Zod schema with nullable and record fields", () => {
-    const tool = defineTool({
-      name: "flexTool",
-      description: "Flexible tool",
-      parameters: z.object({
-        title: z.string(),
-        description: z.string().nullable(),
-        metadata: z.record(z.string(), z.unknown()).optional(),
-      }),
-      execute: async (args) => {
-        return { title: args.title };
-      },
-    });
-
-    expect(tool.name).toBe("flexTool");
-    expect(tool.parameters["~standard"].vendor).toBe("zod");
-  });
-
-  it("execute callback receives correctly typed args", async () => {
-    const receivedArgs: unknown[] = [];
-
-    const tool = defineTool({
-      name: "argCapture",
-      description: "Captures args",
-      parameters: z.object({
-        city: z.string(),
-        units: z.enum(["celsius", "fahrenheit"]),
-      }),
-      execute: async (args) => {
-        receivedArgs.push(args);
-        return { temp: 22 };
-      },
-    });
-
-    await tool.execute({ city: "Berlin", units: "celsius" });
-
-    expect(receivedArgs).toHaveLength(1);
-    expect(receivedArgs[0]).toEqual({ city: "Berlin", units: "celsius" });
-  });
-});
-
-describe("convertToolDefinitionsToVercelAITools Zod regression", () => {
-  it("Zod schemas are passed directly to AI SDK (not converted via JSON Schema)", () => {
-    const zodSchema = z.object({
-      city: z.string(),
-      units: z.enum(["celsius", "fahrenheit"]).optional(),
-    });
-
-    const tools = [
-      defineTool({
-        name: "weather",
-        description: "Get weather",
-        parameters: zodSchema,
-        execute: async () => ({ temp: 22 }),
-      }),
-    ];
-
-    const aiTools = convertToolDefinitionsToVercelAITools(tools);
-
-    expect(aiTools).toHaveProperty("weather");
-    // The inputSchema should be the original Zod schema (passed directly),
-    // NOT a jsonSchema() wrapper. We verify by checking the Zod-specific
-    // ~standard.vendor property is preserved on the schema.
-    const inputSchema = aiTools.weather.inputSchema;
-    expect(inputSchema).toBeDefined();
-    // For Zod schemas, the AI SDK receives the raw Zod object (which has ~standard.vendor === "zod")
-    // If it went through jsonSchema(), it would lose the ~standard property
-    expect(inputSchema["~standard"]?.vendor).toBe("zod");
-  });
-
-  it("multiple Zod tools all get direct pass-through", () => {
-    const tools = [
-      defineTool({
-        name: "tool1",
-        description: "Tool 1",
-        parameters: z.object({ a: z.string() }),
-        execute: async () => ({}),
-      }),
-      defineTool({
-        name: "tool2",
-        description: "Tool 2",
-        parameters: z.object({ b: z.number(), c: z.boolean().optional() }),
-        execute: async () => ({}),
-      }),
-      defineTool({
-        name: "tool3",
-        description: "Tool 3",
-        parameters: z.object({
-          nested: z.object({ x: z.number(), y: z.number() }),
-        }),
-        execute: async () => ({}),
-      }),
-    ];
-
-    const aiTools = convertToolDefinitionsToVercelAITools(tools);
-
-    for (const name of ["tool1", "tool2", "tool3"]) {
-      expect(aiTools).toHaveProperty(name);
-      expect(aiTools[name].inputSchema["~standard"]?.vendor).toBe("zod");
-      expect(typeof aiTools[name].execute).toBe("function");
-    }
-  });
-
-  it("preserves tool description and execute function", () => {
-    const executeFn = vi.fn().mockResolvedValue({ result: "ok" });
-
-    const tools = [
-      defineTool({
-        name: "myTool",
-        description: "My custom tool description",
-        parameters: z.object({ input: z.string() }),
-        execute: executeFn,
-      }),
-    ];
-
-    const aiTools = convertToolDefinitionsToVercelAITools(tools);
-
-    expect(aiTools.myTool.description).toBe("My custom tool description");
-    expect(aiTools.myTool.execute).toBeDefined();
-  });
-});
-
-describe("BuiltInAgent Zod regression", () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env = { ...originalEnv };
-    process.env.OPENAI_API_KEY = "test-key";
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  it("Zod tools are included in streamText call", async () => {
-    const agent = new BuiltInAgent({
-      model: "openai/gpt-4o",
-      tools: [
-        defineTool({
-          name: "weather",
-          description: "Get weather",
-          parameters: z.object({
-            city: z.string(),
-            units: z.enum(["celsius", "fahrenheit"]).optional(),
-          }),
-          execute: async () => ({ temp: 22 }),
-        }),
-      ],
-    });
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([finish()]) as any,
-    );
-
-    const input: RunAgentInput = {
-      threadId: "thread1",
-      runId: "run1",
-      messages: [],
-      tools: [],
-      context: [],
-      state: {},
-    };
-
-    await collectEvents(agent["run"](input));
-
-    const callArgs = vi.mocked(streamText).mock.calls[0][0];
-    expect(callArgs.tools).toHaveProperty("weather");
-    expect(typeof callArgs.tools?.weather.execute).toBe("function");
-  });
-
-  it("multiple Zod tools coexist with built-in state tools", async () => {
-    const agent = new BuiltInAgent({
-      model: "openai/gpt-4o",
-      tools: [
-        defineTool({
-          name: "search",
-          description: "Search",
-          parameters: z.object({ query: z.string() }),
-          execute: async () => ({}),
-        }),
-        defineTool({
-          name: "calculate",
-          description: "Calculate",
-          parameters: z.object({
-            expression: z.string(),
-            precision: z.number().int().optional(),
-          }),
-          execute: async () => ({}),
-        }),
-      ],
-    });
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([finish()]) as any,
-    );
-
-    const input: RunAgentInput = {
-      threadId: "thread1",
-      runId: "run1",
-      messages: [],
-      tools: [],
-      context: [],
-      state: {},
-    };
-
-    await collectEvents(agent["run"](input));
-
-    const callArgs = vi.mocked(streamText).mock.calls[0][0];
-    // User-defined Zod tools
-    expect(callArgs.tools).toHaveProperty("search");
-    expect(callArgs.tools).toHaveProperty("calculate");
-    // Built-in state tools
-    expect(callArgs.tools).toHaveProperty("AGUISendStateSnapshot");
-    expect(callArgs.tools).toHaveProperty("AGUISendStateDelta");
-  });
-
-  it("Zod tool execute is invocable after conversion", async () => {
-    const executeFn = vi.fn().mockResolvedValue({ temp: 22 });
-
-    const agent = new BuiltInAgent({
-      model: "openai/gpt-4o",
-      tools: [
-        defineTool({
-          name: "weather",
-          description: "Get weather",
-          parameters: z.object({ city: z.string() }),
-          execute: executeFn,
-        }),
-      ],
-    });
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([finish()]) as any,
-    );
-
-    const input: RunAgentInput = {
-      threadId: "thread1",
-      runId: "run1",
-      messages: [],
-      tools: [],
-      context: [],
-      state: {},
-    };
-
-    await collectEvents(agent["run"](input));
-
-    const callArgs = vi.mocked(streamText).mock.calls[0][0];
-    const weatherTool = callArgs.tools?.weather;
-
-    // Invoke the execute function to verify it's wired correctly
-    await weatherTool.execute({ city: "Berlin" });
-    expect(executeFn).toHaveBeenCalledWith({ city: "Berlin" });
-  });
-});

package/src/agent/converters/aisdk.ts

@@ -1,326 +0,0 @@
-import {
-  BaseEvent,
-  EventType,
-  ReasoningEndEvent,
-  ReasoningMessageContentEvent,
-  ReasoningMessageEndEvent,
-  ReasoningMessageStartEvent,
-  ReasoningStartEvent,
-  TextMessageChunkEvent,
-  ToolCallArgsEvent,
-  ToolCallEndEvent,
-  ToolCallStartEvent,
-  ToolCallResultEvent,
-  StateSnapshotEvent,
-  StateDeltaEvent,
-} from "@ag-ui/client";
-import { randomUUID } from "@copilotkit/shared";
-
-/**
- * Converts an AI SDK `fullStream` into AG-UI `BaseEvent` objects.
- *
- * This is a pure converter — it does NOT emit lifecycle events
- * (RUN_STARTED / RUN_FINISHED / RUN_ERROR). The caller (Agent class)
- * is responsible for those.
- *
- * Terminal stream events (finish, error, abort) cause the generator to
- * return so the caller can handle lifecycle appropriately.
- */
-export async function* convertAISDKStream(
-  fullStream: AsyncIterable<unknown>,
-  abortSignal: AbortSignal,
-): AsyncGenerator<BaseEvent> {
-  let messageId = randomUUID();
-  let reasoningMessageId = randomUUID();
-  let isInReasoning = false;
-
-  const toolCallStates = new Map<
-    string,
-    {
-      started: boolean;
-      hasArgsDelta: boolean;
-      ended: boolean;
-      toolName?: string;
-    }
-  >();
-
-  const ensureToolCallState = (toolCallId: string) => {
-    let state = toolCallStates.get(toolCallId);
-    if (!state) {
-      state = { started: false, hasArgsDelta: false, ended: false };
-      toolCallStates.set(toolCallId, state);
-    }
-    return state;
-  };
-
-  /**
-   * Auto-close an open reasoning lifecycle.
-   * Some AI SDK providers (notably @ai-sdk/anthropic) never emit "reasoning-end",
-   * which leaves downstream state machines stuck. This helper emits the
-   * missing REASONING_MESSAGE_END + REASONING_END events so the stream
-   * can transition to text, tool-call, or finish phases.
-   */
-  function* closeReasoningIfOpen(): Generator<BaseEvent> {
-    if (!isInReasoning) return;
-    isInReasoning = false;
-    const reasoningMsgEnd: ReasoningMessageEndEvent = {
-      type: EventType.REASONING_MESSAGE_END,
-      messageId: reasoningMessageId,
-    };
-    yield reasoningMsgEnd;
-    const reasoningEnd: ReasoningEndEvent = {
-      type: EventType.REASONING_END,
-      messageId: reasoningMessageId,
-    };
-    yield reasoningEnd;
-  }
-
-  try {
-    for await (const part of fullStream) {
-      const p = part as Record<string, unknown>;
-
-      // Close any open reasoning lifecycle on every event except
-      // reasoning-delta, which arrives mid-block and must not interrupt it.
-      if (p.type !== "reasoning-delta") {
-        yield* closeReasoningIfOpen();
-      }
-
-      switch (p.type) {
-        case "abort": {
-          // Terminal — let the caller handle lifecycle
-          return;
-        }
-
-        case "reasoning-start": {
-          // Use SDK-provided id, or generate a fresh UUID if id is falsy/"0"
-          // to prevent consecutive reasoning blocks from sharing a messageId
-          const providedId = "id" in p ? p.id : undefined;
-          reasoningMessageId =
-            providedId && providedId !== "0"
-              ? (providedId as string)
-              : randomUUID();
-          const reasoningStartEvent: ReasoningStartEvent = {
-            type: EventType.REASONING_START,
-            messageId: reasoningMessageId,
-          };
-          yield reasoningStartEvent;
-          const reasoningMessageStart: ReasoningMessageStartEvent = {
-            type: EventType.REASONING_MESSAGE_START,
-            messageId: reasoningMessageId,
-            role: "reasoning",
-          };
-          yield reasoningMessageStart;
-          isInReasoning = true;
-          break;
-        }
-
-        case "reasoning-delta": {
-          const delta = (p.text as string) ?? "";
-          if (!delta) break; // skip — @ag-ui/core schema requires delta to be non-empty
-          const reasoningDeltaEvent: ReasoningMessageContentEvent = {
-            type: EventType.REASONING_MESSAGE_CONTENT,
-            messageId: reasoningMessageId,
-            delta,
-          };
-          yield reasoningDeltaEvent;
-          break;
-        }
-
-        case "reasoning-end": {
-          // closeReasoningIfOpen() already called before the switch — no-op here
-          // if the SDK never emits this event (e.g. @ai-sdk/anthropic).
-          break;
-        }
-
-        case "tool-input-start": {
-          const toolCallId = p.id as string;
-          const state = ensureToolCallState(toolCallId);
-          state.toolName = p.toolName as string;
-          if (!state.started) {
-            state.started = true;
-            const startEvent: ToolCallStartEvent = {
-              type: EventType.TOOL_CALL_START,
-              parentMessageId: messageId,
-              toolCallId,
-              toolCallName: p.toolName as string,
-            };
-            yield startEvent;
-          }
-          break;
-        }
-
-        case "tool-input-delta": {
-          const toolCallId = p.id as string;
-          const state = ensureToolCallState(toolCallId);
-          state.hasArgsDelta = true;
-          const argsEvent: ToolCallArgsEvent = {
-            type: EventType.TOOL_CALL_ARGS,
-            toolCallId,
-            delta: p.delta as string,
-          };
-          yield argsEvent;
-          break;
-        }
-
-        case "tool-input-end": {
-          // No direct event – the subsequent "tool-call" part marks completion.
-          break;
-        }
-
-        case "text-start": {
-          // New text message starting - use the SDK-provided id
-          // Use randomUUID() if part.id is falsy or "0" to prevent message merging issues
-          const providedId = "id" in p ? p.id : undefined;
-          messageId =
-            providedId && providedId !== "0"
-              ? (providedId as string)
-              : randomUUID();
-          break;
-        }
-
-        case "text-delta": {
-          // AI SDK text-delta events use 'text' (not 'delta')
-          const textDelta = "text" in p ? (p.text as string) : "";
-          const textEvent: TextMessageChunkEvent = {
-            type: EventType.TEXT_MESSAGE_CHUNK,
-            role: "assistant",
-            messageId,
-            delta: textDelta,
-          };
-          yield textEvent;
-          break;
-        }
-
-        case "tool-call": {
-          const toolCallId = p.toolCallId as string;
-          const state = ensureToolCallState(toolCallId);
-          state.toolName = (p.toolName as string) ?? state.toolName;
-
-          if (!state.started) {
-            state.started = true;
-            const startEvent: ToolCallStartEvent = {
-              type: EventType.TOOL_CALL_START,
-              parentMessageId: messageId,
-              toolCallId,
-              toolCallName: p.toolName as string,
-            };
-            yield startEvent;
-          }
-
-          if (!state.hasArgsDelta && "input" in p && p.input !== undefined) {
-            let serializedInput = "";
-            if (typeof p.input === "string") {
-              serializedInput = p.input;
-            } else {
-              try {
-                serializedInput = JSON.stringify(p.input);
-              } catch {
-                serializedInput = String(p.input);
-              }
-            }
-
-            if (serializedInput.length > 0) {
-              const argsEvent: ToolCallArgsEvent = {
-                type: EventType.TOOL_CALL_ARGS,
-                toolCallId,
-                delta: serializedInput,
-              };
-              yield argsEvent;
-              state.hasArgsDelta = true;
-            }
-          }
-
-          if (!state.ended) {
-            state.ended = true;
-            const endEvent: ToolCallEndEvent = {
-              type: EventType.TOOL_CALL_END,
-              toolCallId,
-            };
-            yield endEvent;
-          }
-          break;
-        }
-
-        case "tool-result": {
-          // AI SDK tool-result uses "output"; older versions used "result" — check both
-          const toolResult =
-            "output" in p ? p.output : "result" in p ? p.result : null;
-          const toolName = "toolName" in p ? (p.toolName as string) : "";
-          toolCallStates.delete(p.toolCallId as string);
-
-          // Check if this is a state update tool
-          if (
-            toolName === "AGUISendStateSnapshot" &&
-            toolResult &&
-            typeof toolResult === "object"
-          ) {
-            const snapshot = (toolResult as Record<string, unknown>).snapshot;
-            if (snapshot !== undefined) {
-              const stateSnapshotEvent: StateSnapshotEvent = {
-                type: EventType.STATE_SNAPSHOT,
-                snapshot,
-              };
-              yield stateSnapshotEvent;
-            }
-          } else if (
-            toolName === "AGUISendStateDelta" &&
-            toolResult &&
-            typeof toolResult === "object"
-          ) {
-            const delta = (toolResult as Record<string, unknown>).delta;
-            if (delta !== undefined) {
-              const stateDeltaEvent: StateDeltaEvent = {
-                type: EventType.STATE_DELTA,
-                delta,
-              };
-              yield stateDeltaEvent;
-            }
-          }
-
-          // Always emit the tool result event for the LLM
-          let serializedResult: string;
-          try {
-            serializedResult = JSON.stringify(toolResult);
-          } catch {
-            serializedResult = `[Unserializable tool result from ${toolName || "unknown tool"}]`;
-          }
-          const resultEvent: ToolCallResultEvent = {
-            type: EventType.TOOL_CALL_RESULT,
-            role: "tool",
-            messageId: randomUUID(),
-            toolCallId: p.toolCallId as string,
-            content: serializedResult,
-          };
-          yield resultEvent;
-          break;
-        }
-
-        case "finish": {
-          // Terminal — let the caller handle lifecycle
-          return;
-        }
-
-        case "error": {
-          if (abortSignal.aborted) {
-            return;
-          }
-          // Re-throw so the caller can emit RUN_ERROR
-          const err = p.error ?? p.message ?? p.cause;
-          if (err instanceof Error) throw err;
-          throw new Error(
-            typeof err === "string"
-              ? err
-              : `AI SDK stream error: ${JSON.stringify(p)}`,
-          );
-        }
-
-        default:
-          // Unknown event types are silently ignored
-          break;
-      }
-    }
-  } finally {
-    // Always close reasoning on exit (normal or exceptional)
-    yield* closeReasoningIfOpen();
-  }
-}

package/src/agent/converters/index.ts

@@ -1,7 +0,0 @@
-export { convertAISDKStream } from "./aisdk";
-export {
-  convertTanStackStream,
-  convertInputToTanStackAI,
-  type TanStackChatMessage,
-  type TanStackInputResult,
-} from "./tanstack";