@copilotkit/runtime 1.56.0 → 1.56.1

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

@@ -0,0 +1,195 @@
+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/index.ts

@@ -1267,13 +1267,17 @@ export class BuiltInAgent extends AbstractAgent {
                 break;
               }
               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
+                // Use SDK-provided id, or generate a fresh UUID if the id is falsy,
+                // "0", or matches the non-unique pattern emitted by @ai-sdk/openai-compatible
+                // (e.g. "txt-0", "reasoning-0", "msg-0").
                 const providedId = "id" in part ? part.id : undefined;
-                reasoningMessageId =
-                  providedId && providedId !== "0"
-                    ? (providedId as typeof reasoningMessageId)
-                    : randomUUID();
+                const isNonUniqueId =
+                  !providedId ||
+                  providedId === "0" ||
+                  /^(txt|reasoning|msg)-0$/.test(providedId);
+                reasoningMessageId = isNonUniqueId
+                  ? randomUUID()
+                  : (providedId as typeof reasoningMessageId);
                 const reasoningStartEvent: ReasoningStartEvent = {
                   type: EventType.REASONING_START,
                   messageId: reasoningMessageId,
@@ -1341,12 +1345,16 @@ export class BuiltInAgent extends AbstractAgent {
 
               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
+                // Use randomUUID() if part.id is falsy, "0", or matches the non-unique
+                // pattern emitted by @ai-sdk/openai-compatible (e.g. "txt-0", "msg-0").
                 const providedId = "id" in part ? part.id : undefined;
-                messageId =
-                  providedId && providedId !== "0"
-                    ? (providedId as typeof messageId)
-                    : randomUUID();
+                const isNonUniqueTextId =
+                  !providedId ||
+                  providedId === "0" ||
+                  /^(txt|reasoning|msg)-0$/.test(providedId);
+                messageId = isNonUniqueTextId
+                  ? randomUUID()
+                  : (providedId as typeof messageId);
                 break;
               }
 

package/src/lib/integrations/node-http/__tests__/request-duck-type.test.ts

@@ -0,0 +1,66 @@
+import { describe, it, expect } from "vitest";
+
+/**
+ * Test for #2986: instanceof Request fails with @hono/node-server polyfill
+ *
+ * When Hono polyfills the Request class, `instanceof Request` fails because
+ * the polyfilled Request has a different prototype. We need duck-type checking.
+ */
+
+// Simulates a polyfilled Request object that does NOT pass instanceof Request
+function createPolyfillRequest(url: string, method: string = "GET"): object {
+  return {
+    url,
+    method,
+    headers: new Headers({ "content-type": "application/json" }),
+    body: null,
+    clone: () => createPolyfillRequest(url, method),
+  };
+}
+
+// This is the duck-type check that should replace instanceof
+function isRequestLike(obj: unknown): obj is Request {
+  return (
+    typeof obj === "object" &&
+    obj !== null &&
+    "url" in obj &&
+    "method" in obj &&
+    "headers" in obj &&
+    typeof (obj as any).url === "string" &&
+    typeof (obj as any).method === "string"
+  );
+}
+
+describe("Request duck-type detection (#2986)", () => {
+  it("should detect a native Request object", () => {
+    const req = new Request("http://localhost:3000/api/copilotkit", {
+      method: "POST",
+    });
+    expect(isRequestLike(req)).toBe(true);
+    expect(req instanceof Request).toBe(true);
+  });
+
+  it("should detect a polyfilled Request object that fails instanceof", () => {
+    const polyfilled = createPolyfillRequest(
+      "http://localhost:3000/api/copilotkit",
+      "POST",
+    );
+
+    // instanceof fails for polyfilled objects
+    expect(polyfilled instanceof Request).toBe(false);
+
+    // But duck-type check succeeds
+    expect(isRequestLike(polyfilled)).toBe(true);
+  });
+
+  it("should NOT match null or undefined", () => {
+    expect(isRequestLike(null)).toBe(false);
+    expect(isRequestLike(undefined)).toBe(false);
+  });
+
+  it("should NOT match an object missing required properties", () => {
+    expect(isRequestLike({ url: "http://test.com" })).toBe(false);
+    expect(isRequestLike({ method: "GET" })).toBe(false);
+    expect(isRequestLike({})).toBe(false);
+  });
+});

package/src/lib/integrations/node-http/index.ts

@@ -158,11 +158,25 @@ export function copilotRuntimeNodeHttpEndpoint(
     }
   };
 
+  // Duck-type check for Request-like objects (handles polyfilled Request from @hono/node-server)
+  function isRequestLike(obj: unknown): obj is Request {
+    return (
+      obj instanceof Request ||
+      (typeof obj === "object" &&
+        obj !== null &&
+        "url" in obj &&
+        "method" in obj &&
+        "headers" in obj &&
+        typeof (obj as any).url === "string" &&
+        typeof (obj as any).method === "string")
+    );
+  }
+
   return function (
     reqOrRequest: IncomingMessage | Request,
     res?: ServerResponse,
   ): Promise<void> | Promise<Response> | Response {
-    if (reqOrRequest instanceof Request) {
+    if (isRequestLike(reqOrRequest) && !res) {
       return honoApp.fetch(reqOrRequest as Request);
     }
     if (!res) {

package/src/lib/runtime/__tests__/mcp-tools-utils.test.ts

@@ -110,10 +110,14 @@ describe("MCP Tools Utils", () => {
       });
       expect(result[1]).toEqual({
         name: "objectArray",
-        type: "array",
+        type: "object[]",
         description:
           "Array of objects Array of objects with properties: name, value",
         required: false,
+        attributes: [
+          { name: "name", type: "string", description: "", required: false },
+          { name: "value", type: "number", description: "", required: false },
+        ],
       });
     });
 
@@ -147,6 +151,7 @@ describe("MCP Tools Utils", () => {
         type: "string",
         description: "Status value Allowed values: active | inactive | pending",
         required: true,
+        enum: ["active", "inactive", "pending"],
       });
       expect(result[1]).toEqual({
         name: "priority",
@@ -192,6 +197,30 @@ describe("MCP Tools Utils", () => {
         description:
           "User object Object with properties: name, email, preferences",
         required: true,
+        attributes: [
+          { name: "name", type: "string", description: "", required: false },
+          { name: "email", type: "string", description: "", required: false },
+          {
+            name: "preferences",
+            type: "object",
+            description: "Object with properties: theme, notifications",
+            required: false,
+            attributes: [
+              {
+                name: "theme",
+                type: "string",
+                description: "",
+                required: false,
+              },
+              {
+                name: "notifications",
+                type: "boolean",
+                description: "",
+                required: false,
+              },
+            ],
+          },
+        ],
       });
     });
 

package/src/lib/runtime/__tests__/on-after-request.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi } from "vitest";
+import { CopilotRuntime } from "../copilot-runtime";
+
+describe("onAfterRequest middleware (#2124)", () => {
+  it("should pass hookParams to onAfterRequest, not an empty object", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    // Access the internal afterRequestMiddleware function
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+    expect(afterRequestMw).toBeDefined();
+
+    // Simulate calling the middleware with hookParams (as the v2 runtime would)
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      messages: [
+        { id: "msg-1", role: "user", content: "Hi there" },
+        { id: "msg-2", role: "assistant", content: "Hello" },
+        { id: "msg-3", role: "tool", content: "result", toolCallId: "tc-1" },
+      ],
+      threadId: "thread-123",
+      runId: "run-456",
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+
+    // Should NOT be called with an empty object
+    expect(callArg).not.toEqual({});
+
+    // Verify all OnAfterRequestOptions fields are present
+    expect(callArg).toHaveProperty("threadId", "thread-123");
+    expect(callArg).toHaveProperty("runId", "run-456");
+    expect(callArg).toHaveProperty("url", "/api/copilotkit");
+    expect(callArg).toHaveProperty("properties");
+    expect(callArg.properties).toEqual({});
+
+    // Verify message splitting: user messages → inputMessages, others → outputMessages
+    expect(callArg.inputMessages).toHaveLength(1);
+    expect(callArg.inputMessages[0]).toMatchObject({
+      id: "msg-1",
+      role: "user",
+    });
+
+    expect(callArg.outputMessages).toHaveLength(2);
+    expect(callArg.outputMessages[0]).toMatchObject({
+      id: "msg-2",
+      role: "assistant",
+    });
+    expect(callArg.outputMessages[1]).toMatchObject({
+      id: "msg-3",
+      role: "tool",
+    });
+  });
+
+  it("should handle undefined messages gracefully", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      // messages intentionally omitted (undefined)
+      threadId: "thread-789",
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+    expect(callArg.threadId).toBe("thread-789");
+    expect(callArg.inputMessages).toEqual([]);
+    expect(callArg.outputMessages).toEqual([]);
+  });
+
+  it("should default threadId to empty string when undefined", async () => {
+    const onAfterRequest = vi.fn();
+
+    const runtime = new CopilotRuntime({
+      middleware: {
+        onAfterRequest,
+      },
+    });
+
+    const afterRequestMw = runtime.instance.afterRequestMiddleware;
+
+    const fakeHookParams = {
+      runtime: {} as any,
+      response: new Response("test"),
+      path: "/api/copilotkit",
+      messages: [],
+      // threadId intentionally omitted
+    };
+
+    await (afterRequestMw as Function)(fakeHookParams);
+
+    expect(onAfterRequest).toHaveBeenCalledTimes(1);
+
+    const callArg = onAfterRequest.mock.calls[0][0];
+    expect(callArg.threadId).toBe("");
+    expect(callArg.runId).toBeUndefined();
+  });
+});

package/src/lib/runtime/copilot-runtime.ts

@@ -626,9 +626,22 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       params?.afterRequestMiddleware?.(hookParams);
 
       if (params?.middleware?.onAfterRequest) {
-        // TODO: provide old expected params here when available
-        // @ts-expect-error -- missing arguments.
-        params.middleware.onAfterRequest({});
+        const messages = hookParams.messages ?? [];
+        params.middleware.onAfterRequest({
+          threadId: hookParams.threadId ?? "",
+          runId: hookParams.runId,
+          inputMessages: messages.filter(
+            (m): m is typeof m & { role: string } =>
+              "role" in m && m.role === "user",
+          ) as unknown as Message[],
+          outputMessages: messages.filter(
+            (m): m is typeof m & { role: string } =>
+              "role" in m && m.role !== "user",
+          ) as unknown as Message[],
+          // TODO: forward actual properties once the after-request hook has access to the request body
+          properties: {},
+          url: hookParams.path,
+        } satisfies OnAfterRequestOptions);
       }
     };
   }

package/src/lib/runtime/mcp-tools-utils.ts

@@ -85,30 +85,65 @@ export function extractParametersFromSchema(
         }
       }
 
-      // Handle enums
+      // Handle enums — preserve as structured data for Zod conversion
+      let enumValues: string[] | undefined;
       if (paramDef.enum && Array.isArray(paramDef.enum)) {
-        const enumValues = paramDef.enum.join(" | ");
+        enumValues = paramDef.enum.map(String);
+        const enumDisplay = enumValues.join(" | ");
         description =
           description +
           (description ? " " : "") +
-          `Allowed values: ${enumValues}`;
+          `Allowed values: ${enumDisplay}`;
       }
 
-      // Handle objects with properties
+      // Handle objects with properties — recurse to preserve nested structure
+      let attributes: Parameter[] | undefined;
       if (type === "object" && paramDef.properties) {
         const objectProperties = Object.keys(paramDef.properties).join(", ");
         description =
           description +
           (description ? " " : "") +
           `Object with properties: ${objectProperties}`;
+        // Recursively extract nested parameters
+        attributes = extractParametersFromSchema({
+          parameters: {
+            properties: paramDef.properties,
+            required: paramDef.required || [],
+          },
+        });
       }
 
-      parameters.push({
+      // Handle object arrays — recurse into item schema
+      if (type === "array" && paramDef.items?.type === "object" && paramDef.items?.properties) {
+        attributes = extractParametersFromSchema({
+          parameters: {
+            properties: paramDef.items.properties,
+            required: paramDef.items.required || [],
+          },
+        });
+      }
+
+      const param: any = {
         name: paramName,
         type: type,
         description: description,
         required: requiredParams.has(paramName),
-      });
+      };
+
+      // Preserve enum values for string parameters
+      if (type === "string" && enumValues) {
+        param.enum = enumValues;
+      }
+
+      // Preserve nested attributes for object and object[] types
+      if (attributes && attributes.length > 0) {
+        param.attributes = attributes;
+        if (type === "array") {
+          param.type = "object[]";
+        }
+      }
+
+      parameters.push(param);
     }
   }