@copilotkit/runtime 1.56.0 → 1.56.2-canary.pin-to-send

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/agents/langgraph/__tests__/event-source.test.ts

@@ -0,0 +1,256 @@
+import { RemoteLangGraphEventSource } from "../event-source";
+import { LangGraphEventTypes } from "../events";
+
+/**
+ * Access private methods for testing via a helper.
+ * These are pure functions that extract data from LangGraph events.
+ */
+function getSource() {
+  return new RemoteLangGraphEventSource();
+}
+
+// Helper to call private methods. Returns `any` — type safety is traded for
+// access to private implementation details that have no public test surface.
+function callPrivate(
+  source: RemoteLangGraphEventSource,
+  method: string,
+  ...args: any[]
+) {
+  return (source as any)[method](...args);
+}
+
+describe("shouldEmitToolCall", () => {
+  const source = getSource();
+
+  it("returns true when shouldEmitToolCalls is true (boolean)", () => {
+    expect(callPrivate(source, "shouldEmitToolCall", true, "anyTool")).toBe(
+      true,
+    );
+  });
+
+  it("returns false when shouldEmitToolCalls is false (boolean)", () => {
+    expect(callPrivate(source, "shouldEmitToolCall", false, "anyTool")).toBe(
+      false,
+    );
+  });
+
+  it("returns true when tool name matches string", () => {
+    expect(
+      callPrivate(source, "shouldEmitToolCall", "SearchTool", "SearchTool"),
+    ).toBe(true);
+  });
+
+  it("returns false when tool name does not match string", () => {
+    expect(
+      callPrivate(source, "shouldEmitToolCall", "SearchTool", "OtherTool"),
+    ).toBe(false);
+  });
+
+  it("returns true when tool name is in array", () => {
+    expect(
+      callPrivate(
+        source,
+        "shouldEmitToolCall",
+        ["SearchTool", "FetchTool"],
+        "FetchTool",
+      ),
+    ).toBe(true);
+  });
+
+  it("returns false when tool name is not in array", () => {
+    expect(
+      callPrivate(
+        source,
+        "shouldEmitToolCall",
+        ["SearchTool", "FetchTool"],
+        "OtherTool",
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("getCurrentMessageId", () => {
+  const source = getSource();
+
+  it("extracts id from standard kwargs layout", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { kwargs: { id: "msg-std-123" } } },
+    };
+    expect(callPrivate(source, "getCurrentMessageId", event)).toBe(
+      "msg-std-123",
+    );
+  });
+
+  it("extracts id from LangGraph Platform layout (no kwargs)", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { id: "msg-plat-456" } },
+    };
+    expect(callPrivate(source, "getCurrentMessageId", event)).toBe(
+      "msg-plat-456",
+    );
+  });
+
+  it("prefers kwargs layout when both present", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { kwargs: { id: "kwargs-id" }, id: "direct-id" } },
+    };
+    expect(callPrivate(source, "getCurrentMessageId", event)).toBe("kwargs-id");
+  });
+
+  it("returns undefined when neither layout is present", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: {} },
+    };
+    expect(callPrivate(source, "getCurrentMessageId", event)).toBeUndefined();
+  });
+
+  it("handles missing data gracefully", () => {
+    const event = { event: LangGraphEventTypes.OnChatModelStream };
+    expect(callPrivate(source, "getCurrentMessageId", event)).toBeUndefined();
+  });
+});
+
+describe("getCurrentToolCallChunks", () => {
+  const source = getSource();
+
+  it("extracts chunks from standard kwargs layout", () => {
+    const chunks = [{ name: "tool1", args: "{}", id: "tc-1", index: 0 }];
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { kwargs: { tool_call_chunks: chunks } } },
+    };
+    expect(callPrivate(source, "getCurrentToolCallChunks", event)).toEqual(
+      chunks,
+    );
+  });
+
+  it("extracts chunks from LangGraph Platform layout", () => {
+    const chunks = [{ name: "tool2", args: "{}", id: "tc-2", index: 0 }];
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { tool_call_chunks: chunks } },
+    };
+    expect(callPrivate(source, "getCurrentToolCallChunks", event)).toEqual(
+      chunks,
+    );
+  });
+
+  it("returns undefined when no chunks present", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: {} },
+    };
+    expect(
+      callPrivate(source, "getCurrentToolCallChunks", event),
+    ).toBeUndefined();
+  });
+});
+
+describe("getResponseMetadata", () => {
+  const source = getSource();
+
+  it("extracts metadata from standard kwargs layout", () => {
+    const meta = { finish_reason: "stop" };
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { kwargs: { response_metadata: meta } } },
+    };
+    expect(callPrivate(source, "getResponseMetadata", event)).toEqual(meta);
+  });
+
+  it("extracts metadata from LangGraph Platform layout", () => {
+    const meta = { finish_reason: "tool_calls" };
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { response_metadata: meta } },
+    };
+    expect(callPrivate(source, "getResponseMetadata", event)).toEqual(meta);
+  });
+
+  it("returns undefined when no metadata present", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: {} },
+    };
+    expect(callPrivate(source, "getResponseMetadata", event)).toBeUndefined();
+  });
+});
+
+describe("getCurrentContent", () => {
+  const source = getSource();
+
+  it("extracts string content from kwargs layout", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { kwargs: { content: "hello world" } } },
+    };
+    expect(callPrivate(source, "getCurrentContent", event)).toBe("hello world");
+  });
+
+  it("extracts string content from Platform layout", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { content: "platform content" } },
+    };
+    expect(callPrivate(source, "getCurrentContent", event)).toBe(
+      "platform content",
+    );
+  });
+
+  it("extracts text from array content (Anthropic format)", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: {
+        chunk: {
+          kwargs: {
+            content: [{ text: "array text", type: "text", index: 0 }],
+          },
+        },
+      },
+    };
+    expect(callPrivate(source, "getCurrentContent", event)).toBe("array text");
+  });
+
+  it("returns null when no content and no tool call chunks", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { kwargs: {} } },
+    };
+    expect(callPrivate(source, "getCurrentContent", event)).toBeNull();
+  });
+
+  it("falls back to tool_call_chunks args when no content", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: {
+        chunk: {
+          kwargs: {
+            content: "",
+            tool_call_chunks: [{ args: '{"key":"val"}' }],
+          },
+        },
+      },
+    };
+    expect(callPrivate(source, "getCurrentContent", event)).toBe(
+      '{"key":"val"}',
+    );
+  });
+
+  it("handles missing data gracefully", () => {
+    const event = { event: LangGraphEventTypes.OnChatModelStream };
+    expect(callPrivate(source, "getCurrentContent", event)).toBeNull();
+  });
+
+  it("returns empty string when content is empty string", () => {
+    const event = {
+      event: LangGraphEventTypes.OnChatModelStream,
+      data: { chunk: { kwargs: { content: "" } } },
+    };
+    // Empty string is a valid string, so typeof === "string" returns it as-is
+    expect(callPrivate(source, "getCurrentContent", event)).toBe("");
+  });
+});

package/src/graphql/resolvers/__tests__/resolve-message-id.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { resolveMessageId } from "../resolve-message-id";
+
+describe("resolveMessageId (#2118)", () => {
+  it("preserves a provided non-empty id verbatim", () => {
+    expect(resolveMessageId("msg-123")).toBe("msg-123");
+  });
+
+  it.each(["", null, undefined] as const)(
+    "falls back to a generated id when the event id is %p",
+    (input) => {
+      const id = resolveMessageId(input);
+      // randomId() always produces the "ck-<uuid>" shape; the important
+      // contract for #2118 is that the returned value is a non-empty string,
+      // never null/undefined.
+      expect(id).toMatch(/^ck-[0-9a-f-]{36}$/);
+    },
+  );
+
+  it("generates a fresh id on each fallback call", () => {
+    const a = resolveMessageId(undefined);
+    const b = resolveMessageId(undefined);
+    expect(a).not.toBe(b);
+  });
+});

package/src/graphql/resolvers/copilot.resolver.ts

@@ -58,6 +58,7 @@ import {
 } from "../types/converted";
 import telemetry from "../../lib/telemetry-client";
 import { randomId } from "@copilotkit/shared";
+import { resolveMessageId } from "./resolve-message-id";
 import { AgentsResponse } from "../types/agents-response.type";
 import { LangGraphEventTypes } from "../../agents/langgraph/events";
 import {
@@ -488,7 +489,7 @@ export class CopilotResolver {
                   typeof MessageStatusUnion
                 >();
 
-                const messageId = event.messageId;
+                const messageId = resolveMessageId(event.messageId);
                 // push the new message
                 pushMessage({
                   id: messageId,

package/src/graphql/resolvers/resolve-message-id.ts

@@ -0,0 +1,14 @@
+import { randomId } from "@copilotkit/shared";
+
+/**
+ * Resolve the id to use for a streamed TextMessageOutput.
+ *
+ * Upstream events occasionally arrive with `messageId` missing, null, or an
+ * empty string. We fall back to a freshly generated id in those cases so the
+ * resulting output never surfaces a null id to the GraphQL client (#2118).
+ */
+export function resolveMessageId(
+  eventMessageId: string | null | undefined,
+): string {
+  return eventMessageId || randomId();
+}

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) {