@copilotkit/runtime 1.57.3 → 1.58.0-canary.thread-id-propagation

package/src/agent/__tests__/provider-id-collision.test.ts

@@ -1,195 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { BuiltInAgent } from "../index";
-import { EventType, type RunAgentInput } from "@ag-ui/client";
-import { streamText } from "ai";
-import {
-  mockStreamTextResponse,
-  textDelta,
-  finish,
-  collectEvents,
-} from "./test-helpers";
-
-// Mock the ai module
-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) => ({
-    specificationVersion: "v3",
-    modelId,
-    provider: "openai",
-  })),
-}));
-
-vi.mock("@ai-sdk/anthropic", () => ({
-  createAnthropic: vi.fn(() => (modelId: string) => ({
-    specificationVersion: "v3",
-    modelId,
-    provider: "anthropic",
-  })),
-}));
-
-vi.mock("@ai-sdk/google", () => ({
-  createGoogleGenerativeAI: vi.fn(() => (modelId: string) => ({
-    specificationVersion: "v3",
-    modelId,
-    provider: "google",
-  })),
-}));
-
-describe("Provider ID collision (#3410, #3623)", () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env = { ...originalEnv };
-    process.env.OPENAI_API_KEY = "test-key";
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  it('should replace text-start providedId "txt-0" with a UUID', async () => {
-    const agent = new BuiltInAgent({ model: "openai:gpt-4o-mini" });
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([
-        { type: "text-start", id: "txt-0" },
-        textDelta("Hello"),
-        finish(),
-      ]) as any,
-    );
-
-    const input: RunAgentInput = {
-      threadId: "thread-1",
-      runId: "run-1",
-      messages: [{ id: "1", role: "user", content: "Hi" }],
-      tools: [],
-      context: [],
-      state: {},
-    };
-
-    const events = await collectEvents(agent["run"](input));
-
-    // Find the TEXT_MESSAGE_CHUNK event and check its messageId
-    const textChunks = events.filter(
-      (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
-    );
-    expect(textChunks.length).toBeGreaterThan(0);
-    const messageId = (textChunks[0] as any).messageId;
-
-    // The messageId should NOT be "txt-0" — it should be a UUID
-    expect(messageId).not.toBe("txt-0");
-    // UUID v4 pattern
-    expect(messageId).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-    );
-  });
-
-  it('should replace reasoning-start providedId "reasoning-0" with a UUID', async () => {
-    const agent = new BuiltInAgent({ model: "openai:gpt-4o-mini" });
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([
-        { type: "reasoning-start", id: "reasoning-0" },
-        { type: "reasoning-delta", text: "Thinking..." },
-        { type: "reasoning-end" },
-        { type: "text-start", id: "txt-0" },
-        textDelta("Answer"),
-        finish(),
-      ]) as any,
-    );
-
-    const input: RunAgentInput = {
-      threadId: "thread-2",
-      runId: "run-2",
-      messages: [{ id: "1", role: "user", content: "Hi" }],
-      tools: [],
-      context: [],
-      state: {},
-    };
-
-    const events = await collectEvents(agent["run"](input));
-
-    // Find REASONING_START event
-    const reasoningStarts = events.filter(
-      (e) => e.type === EventType.REASONING_START,
-    );
-    expect(reasoningStarts.length).toBeGreaterThan(0);
-    const reasoningId = (reasoningStarts[0] as any).messageId;
-
-    // Should NOT be "reasoning-0"
-    expect(reasoningId).not.toBe("reasoning-0");
-    expect(reasoningId).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-    );
-  });
-
-  it('should replace providedId "msg-0" with a UUID', async () => {
-    const agent = new BuiltInAgent({ model: "openai:gpt-4o-mini" });
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([
-        { type: "text-start", id: "msg-0" },
-        textDelta("Hello"),
-        finish(),
-      ]) as any,
-    );
-
-    const input: RunAgentInput = {
-      threadId: "thread-3",
-      runId: "run-3",
-      messages: [{ id: "1", role: "user", content: "Hi" }],
-      tools: [],
-      context: [],
-      state: {},
-    };
-
-    const events = await collectEvents(agent["run"](input));
-
-    const textChunks = events.filter(
-      (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
-    );
-    expect(textChunks.length).toBeGreaterThan(0);
-    const messageId = (textChunks[0] as any).messageId;
-
-    expect(messageId).not.toBe("msg-0");
-    expect(messageId).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
-    );
-  });
-
-  it("should preserve legitimate provider IDs", async () => {
-    const agent = new BuiltInAgent({ model: "openai:gpt-4o-mini" });
-
-    vi.mocked(streamText).mockReturnValue(
-      mockStreamTextResponse([
-        { type: "text-start", id: "custom-msg-id-123" },
-        textDelta("Hello"),
-        finish(),
-      ]) as any,
-    );
-
-    const input: RunAgentInput = {
-      threadId: "thread-4",
-      runId: "run-4",
-      messages: [{ id: "1", role: "user", content: "Hi" }],
-      tools: [],
-      context: [],
-      state: {},
-    };
-
-    const events = await collectEvents(agent["run"](input));
-
-    const textChunks = events.filter(
-      (e) => e.type === EventType.TEXT_MESSAGE_CHUNK,
-    );
-    expect(textChunks.length).toBeGreaterThan(0);
-    // Legitimate IDs should be preserved
-    expect((textChunks[0] as any).messageId).toBe("custom-msg-id-123");
-  });
-});

package/src/agent/__tests__/standard-schema-tools.test.ts

@@ -1,313 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { z } from "zod";
-import * as v from "valibot";
-import { toStandardJsonSchema } from "@valibot/to-json-schema";
-import { type } from "arktype";
-import {
-  defineTool,
-  convertToolDefinitionsToVercelAITools,
-  BuiltInAgent,
-} from "../index";
-import type { RunAgentInput } from "@ag-ui/client";
-import { streamText } from "ai";
-import { mockStreamTextResponse, finish, collectEvents } from "./test-helpers";
-
-// Mock the ai module — keep jsonSchema real for non-Zod path
-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 })),
-  };
-});
-
-// Mock the SDK clients
-vi.mock("@ai-sdk/openai", () => ({
-  createOpenAI: vi.fn(() => (modelId: string) => ({
-    modelId,
-    provider: "openai",
-  })),
-}));
-
-describe("Standard Schema support in agent tools", () => {
-  const originalEnv = process.env;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    process.env = { ...originalEnv };
-    process.env.OPENAI_API_KEY = "test-key";
-  });
-
-  afterEach(() => {
-    process.env = originalEnv;
-  });
-
-  describe("defineTool with different schema libraries", () => {
-    it("accepts a Zod schema (existing behavior)", () => {
-      const tool = defineTool({
-        name: "zodTool",
-        description: "A tool with Zod schema",
-        parameters: z.object({
-          city: z.string(),
-          units: z.enum(["celsius", "fahrenheit"]).optional(),
-        }),
-        execute: async (args) => {
-          return { city: args.city };
-        },
-      });
-
-      expect(tool.name).toBe("zodTool");
-      expect(tool.parameters["~standard"].vendor).toBe("zod");
-    });
-
-    it("accepts a Valibot schema (via toStandardJsonSchema)", () => {
-      const tool = defineTool({
-        name: "valibotTool",
-        description: "A tool with Valibot schema",
-        parameters: toStandardJsonSchema(
-          v.object({
-            query: v.string(),
-            limit: v.optional(v.number()),
-          }),
-        ),
-        execute: async (args) => {
-          return { query: args.query };
-        },
-      });
-
-      expect(tool.name).toBe("valibotTool");
-      expect(tool.parameters["~standard"].vendor).toBe("valibot");
-    });
-
-    it("accepts an ArkType schema", () => {
-      const tool = defineTool({
-        name: "arktypeTool",
-        description: "A tool with ArkType schema",
-        parameters: type({
-          query: "string",
-          limit: "number",
-        }),
-        execute: async (args) => {
-          return { query: args.query };
-        },
-      });
-
-      expect(tool.name).toBe("arktypeTool");
-      expect(tool.parameters["~standard"].vendor).toBe("arktype");
-    });
-  });
-
-  describe("convertToolDefinitionsToVercelAITools", () => {
-    it("converts Zod tool definitions to AI SDK tools (passes Zod directly)", () => {
-      const tools = [
-        defineTool({
-          name: "zodTool",
-          description: "Zod test",
-          parameters: z.object({ name: z.string() }),
-          execute: async () => ({}),
-        }),
-      ];
-
-      const aiTools = convertToolDefinitionsToVercelAITools(tools);
-
-      expect(aiTools).toHaveProperty("zodTool");
-      expect(aiTools.zodTool).toHaveProperty("description", "Zod test");
-      expect(aiTools.zodTool).toHaveProperty("execute");
-      expect(aiTools.zodTool.inputSchema).toBeDefined();
-    });
-
-    it("converts Valibot tool definitions to AI SDK tools", () => {
-      const tools = [
-        defineTool({
-          name: "valibotTool",
-          description: "Valibot test",
-          parameters: toStandardJsonSchema(v.object({ name: v.string() })),
-          execute: async () => ({}),
-        }),
-      ];
-
-      const aiTools = convertToolDefinitionsToVercelAITools(tools);
-
-      expect(aiTools).toHaveProperty("valibotTool");
-      expect(aiTools.valibotTool).toHaveProperty("description", "Valibot test");
-      expect(aiTools.valibotTool).toHaveProperty("execute");
-      expect(aiTools.valibotTool.inputSchema).toBeDefined();
-    });
-
-    it("converts ArkType tool definitions to AI SDK tools", () => {
-      const tools = [
-        defineTool({
-          name: "arktypeTool",
-          description: "ArkType test",
-          parameters: type({ name: "string" }),
-          execute: async () => ({}),
-        }),
-      ];
-
-      const aiTools = convertToolDefinitionsToVercelAITools(tools);
-
-      expect(aiTools).toHaveProperty("arktypeTool");
-      expect(aiTools.arktypeTool).toHaveProperty("description", "ArkType test");
-      expect(aiTools.arktypeTool).toHaveProperty("execute");
-      expect(aiTools.arktypeTool.inputSchema).toBeDefined();
-    });
-
-    it("converts mixed schema types in the same tool set", () => {
-      const tools = [
-        defineTool({
-          name: "zodTool",
-          description: "Zod",
-          parameters: z.object({ a: z.string() }),
-          execute: async () => ({}),
-        }),
-        defineTool({
-          name: "valibotTool",
-          description: "Valibot",
-          parameters: toStandardJsonSchema(v.object({ b: v.string() })),
-          execute: async () => ({}),
-        }),
-        defineTool({
-          name: "arktypeTool",
-          description: "ArkType",
-          parameters: type({ c: "string" }),
-          execute: async () => ({}),
-        }),
-      ];
-
-      const aiTools = convertToolDefinitionsToVercelAITools(tools);
-
-      expect(Object.keys(aiTools)).toEqual([
-        "zodTool",
-        "valibotTool",
-        "arktypeTool",
-      ]);
-      for (const key of Object.keys(aiTools)) {
-        expect(aiTools[key]).toHaveProperty("execute");
-        expect(aiTools[key]).toHaveProperty("inputSchema");
-      }
-    });
-  });
-
-  describe("BuiltInAgent with non-Zod schemas", () => {
-    it("includes Valibot-based config tools alongside input tools", async () => {
-      const executeFn = vi.fn().mockResolvedValue({ result: "ok" });
-
-      const valibotTool = defineTool({
-        name: "searchValibot",
-        description: "Search with Valibot schema",
-        parameters: toStandardJsonSchema(v.object({ query: v.string() })),
-        execute: executeFn,
-      });
-
-      const agent = new BuiltInAgent({
-        model: "openai/gpt-4o",
-        tools: [valibotTool],
-      });
-
-      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("searchValibot");
-      expect(typeof callArgs.tools?.searchValibot.execute).toBe("function");
-    });
-
-    it("includes ArkType-based config tools alongside input tools", async () => {
-      const executeFn = vi.fn().mockResolvedValue({ result: "ok" });
-
-      const arktypeTool = defineTool({
-        name: "searchArktype",
-        description: "Search with ArkType schema",
-        parameters: type({ query: "string" }),
-        execute: executeFn,
-      });
-
-      const agent = new BuiltInAgent({
-        model: "openai/gpt-4o",
-        tools: [arktypeTool],
-      });
-
-      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("searchArktype");
-      expect(typeof callArgs.tools?.searchArktype.execute).toBe("function");
-    });
-
-    it("mixes Zod, Valibot, and ArkType tools in one agent", async () => {
-      const agent = new BuiltInAgent({
-        model: "openai/gpt-4o",
-        tools: [
-          defineTool({
-            name: "zodTool",
-            description: "Zod",
-            parameters: z.object({ a: z.string() }),
-            execute: async () => ({}),
-          }),
-          defineTool({
-            name: "valibotTool",
-            description: "Valibot",
-            parameters: toStandardJsonSchema(v.object({ b: v.string() })),
-            execute: async () => ({}),
-          }),
-          defineTool({
-            name: "arktypeTool",
-            description: "ArkType",
-            parameters: type({ c: "string" }),
-            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];
-      expect(callArgs.tools).toHaveProperty("zodTool");
-      expect(callArgs.tools).toHaveProperty("valibotTool");
-      expect(callArgs.tools).toHaveProperty("arktypeTool");
-      // State tools should also be present
-      expect(callArgs.tools).toHaveProperty("AGUISendStateSnapshot");
-      expect(callArgs.tools).toHaveProperty("AGUISendStateDelta");
-    });
-  });
-});

package/src/agent/__tests__/standard-schema-types.test.ts

@@ -1,158 +0,0 @@
-import { describe, it, expectTypeOf } from "vitest";
-import { z } from "zod";
-import * as v from "valibot";
-import { type } from "arktype";
-import type { StandardSchemaV1 } from "@copilotkit/shared";
-import { defineTool, type ToolDefinition } from "../index";
-
-describe("ToolDefinition type inference", () => {
-  describe("defineTool with Zod", () => {
-    it("infers execute args from Zod schema", () => {
-      const tool = defineTool({
-        name: "weather",
-        description: "Get weather",
-        parameters: z.object({
-          city: z.string(),
-          units: z.enum(["celsius", "fahrenheit"]),
-        }),
-        execute: async (args) => {
-          // args should be fully typed
-          expectTypeOf(args).toEqualTypeOf<{
-            city: string;
-            units: "celsius" | "fahrenheit";
-          }>();
-          return {};
-        },
-      });
-
-      expectTypeOf(tool.name).toBeString();
-      expectTypeOf(tool.description).toBeString();
-      expectTypeOf(tool.parameters).toMatchTypeOf<StandardSchemaV1>();
-    });
-
-    it("infers execute args with optional Zod fields", () => {
-      defineTool({
-        name: "search",
-        description: "Search",
-        parameters: z.object({
-          query: z.string(),
-          limit: z.number().optional(),
-        }),
-        execute: async (args) => {
-          expectTypeOf(args).toEqualTypeOf<{
-            query: string;
-            limit?: number | undefined;
-          }>();
-          return {};
-        },
-      });
-    });
-  });
-
-  describe("defineTool with Valibot", () => {
-    it("infers execute args from Valibot schema", () => {
-      defineTool({
-        name: "search",
-        description: "Search",
-        parameters: v.object({
-          query: v.string(),
-          limit: v.number(),
-        }),
-        execute: async (args) => {
-          expectTypeOf(args).toEqualTypeOf<{
-            query: string;
-            limit: number;
-          }>();
-          return {};
-        },
-      });
-    });
-
-    it("infers execute args with optional Valibot fields", () => {
-      defineTool({
-        name: "search",
-        description: "Search",
-        parameters: v.object({
-          query: v.string(),
-          limit: v.optional(v.number()),
-        }),
-        execute: async (args) => {
-          expectTypeOf(args).toEqualTypeOf<{
-            query: string;
-            limit?: number | undefined;
-          }>();
-          return {};
-        },
-      });
-    });
-  });
-
-  describe("defineTool with ArkType", () => {
-    it("infers execute args from ArkType schema", () => {
-      defineTool({
-        name: "search",
-        description: "Search",
-        parameters: type({
-          query: "string",
-          limit: "number",
-        }),
-        execute: async (args) => {
-          expectTypeOf(args).toEqualTypeOf<{
-            query: string;
-            limit: number;
-          }>();
-          return {};
-        },
-      });
-    });
-
-    it("infers execute args with optional ArkType fields", () => {
-      defineTool({
-        name: "profile",
-        description: "Profile",
-        parameters: type({
-          name: "string",
-          "age?": "number",
-        }),
-        execute: async (args) => {
-          expectTypeOf(args).toEqualTypeOf<{
-            name: string;
-            age?: number;
-          }>();
-          return {};
-        },
-      });
-    });
-  });
-
-  describe("ToolDefinition interface", () => {
-    it("accepts Zod schema as generic parameter", () => {
-      type ZodTool = ToolDefinition<z.ZodObject<{ city: z.ZodString }>>;
-
-      expectTypeOf<ZodTool["execute"]>().toBeFunction();
-      expectTypeOf<Parameters<ZodTool["execute"]>[0]>().toEqualTypeOf<{
-        city: string;
-      }>();
-    });
-
-    it("default generic parameter is StandardSchemaV1", () => {
-      type DefaultTool = ToolDefinition;
-
-      expectTypeOf<
-        DefaultTool["parameters"]
-      >().toMatchTypeOf<StandardSchemaV1>();
-    });
-
-    it("preserves schema type through defineTool return", () => {
-      const schema = z.object({ x: z.number() });
-      const tool = defineTool({
-        name: "t",
-        description: "d",
-        parameters: schema,
-        execute: async () => ({}),
-      });
-
-      expectTypeOf(tool.parameters).toEqualTypeOf<typeof schema>();
-    });
-  });
-});