@copilotkit/runtime 1.55.2-next.0 → 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__/multimodal-tanstack.test.ts

@@ -0,0 +1,284 @@
+import { describe, it, expect } from "vitest";
+import { convertInputToTanStackAI } from "../converters/tanstack";
+import { createDefaultInput } from "./agent-test-helpers";
+import type { Message, InputContent } from "@ag-ui/client";
+
+/**
+ * Helper: build a user message with the given content parts, run through
+ * convertInputToTanStackAI, and return the first converted message for assertion.
+ */
+function convertUserContent(content: string | InputContent[]) {
+  const input = createDefaultInput({
+    messages: [{ role: "user", content } as Message],
+  });
+  const { messages } = convertInputToTanStackAI(input);
+  return messages[0];
+}
+
+/** Shorthand factories for AG-UI input parts */
+function dataSource(value: string, mimeType: string) {
+  return { type: "data" as const, value, mimeType };
+}
+
+function urlSource(value: string, mimeType?: string) {
+  return { type: "url" as const, value, ...(mimeType ? { mimeType } : {}) };
+}
+
+describe("convertInputToTanStackAI — multimodal", () => {
+  it("passes through plain string user content", () => {
+    const result = convertUserContent("Hello");
+    expect(result.content).toBe("Hello");
+  });
+
+  it("converts text-only InputContent[] to TanStack TextPart array", () => {
+    const result = convertUserContent([{ type: "text", text: "Hello world" }]);
+    expect(result.content).toEqual([{ type: "text", content: "Hello world" }]);
+  });
+
+  it("converts ImageInputPart with data source", () => {
+    const result = convertUserContent([
+      { type: "text", text: "What is this?" },
+      { type: "image", source: dataSource("iVBORw0KGgo=", "image/png") },
+    ]);
+    expect(result.content).toEqual([
+      { type: "text", content: "What is this?" },
+      {
+        type: "image",
+        source: { type: "data", value: "iVBORw0KGgo=", mimeType: "image/png" },
+      },
+    ]);
+  });
+
+  it("converts ImageInputPart with url source", () => {
+    const result = convertUserContent([
+      {
+        type: "image",
+        source: urlSource("https://example.com/photo.jpg", "image/jpeg"),
+      },
+    ]);
+    expect(result.content).toEqual([
+      {
+        type: "image",
+        source: {
+          type: "url",
+          value: "https://example.com/photo.jpg",
+          mimeType: "image/jpeg",
+        },
+      },
+    ]);
+  });
+
+  it("converts AudioInputPart", () => {
+    const result = convertUserContent([
+      { type: "audio", source: dataSource("base64audiodata", "audio/mp3") },
+    ]);
+    expect(result.content).toEqual([
+      {
+        type: "audio",
+        source: {
+          type: "data",
+          value: "base64audiodata",
+          mimeType: "audio/mp3",
+        },
+      },
+    ]);
+  });
+
+  it("converts VideoInputPart with url source", () => {
+    const result = convertUserContent([
+      {
+        type: "video",
+        source: urlSource("https://example.com/video.mp4", "video/mp4"),
+      },
+    ]);
+    expect(result.content).toEqual([
+      {
+        type: "video",
+        source: {
+          type: "url",
+          value: "https://example.com/video.mp4",
+          mimeType: "video/mp4",
+        },
+      },
+    ]);
+  });
+
+  it("converts DocumentInputPart", () => {
+    const result = convertUserContent([
+      {
+        type: "document",
+        source: dataSource("base64pdfdata", "application/pdf"),
+      },
+    ]);
+    expect(result.content).toEqual([
+      {
+        type: "document",
+        source: {
+          type: "data",
+          value: "base64pdfdata",
+          mimeType: "application/pdf",
+        },
+      },
+    ]);
+  });
+
+  it("handles mixed text and multimodal parts", () => {
+    const result = convertUserContent([
+      { type: "text", text: "Analyze these:" },
+      { type: "image", source: dataSource("imgdata", "image/png") },
+      {
+        type: "document",
+        source: dataSource("docdata", "application/pdf"),
+      },
+    ]);
+    expect(result.content).toEqual([
+      { type: "text", content: "Analyze these:" },
+      {
+        type: "image",
+        source: { type: "data", value: "imgdata", mimeType: "image/png" },
+      },
+      {
+        type: "document",
+        source: {
+          type: "data",
+          value: "docdata",
+          mimeType: "application/pdf",
+        },
+      },
+    ]);
+  });
+
+  it("returns empty string for empty content array", () => {
+    const result = convertUserContent([]);
+    expect(result.content).toBe("");
+  });
+
+  it("preserves empty string text parts", () => {
+    const result = convertUserContent([{ type: "text", text: "" }]);
+    expect(result.content).toEqual([{ type: "text", content: "" }]);
+  });
+
+  it("skips parts with missing source without crashing", () => {
+    const result = convertUserContent([
+      { type: "text", text: "check this" },
+      { type: "image" } as any,
+    ]);
+    expect(result.content).toEqual([{ type: "text", content: "check this" }]);
+  });
+
+  it("silently skips unknown part types", () => {
+    const result = convertUserContent([
+      { type: "text", text: "hello" },
+      { type: "spreadsheet", source: dataSource("data", "text/csv") } as any,
+    ]);
+    expect(result.content).toEqual([{ type: "text", content: "hello" }]);
+  });
+
+  it("returns null for null or undefined content", () => {
+    const nullInput = createDefaultInput({
+      messages: [{ role: "user", content: null } as unknown as Message],
+    });
+    const { messages: nullMessages } = convertInputToTanStackAI(nullInput);
+    expect(nullMessages[0].content).toBeNull();
+
+    const undefinedInput = createDefaultInput({
+      messages: [{ role: "user", content: undefined } as unknown as Message],
+    });
+    const { messages: undefinedMessages } =
+      convertInputToTanStackAI(undefinedInput);
+    expect(undefinedMessages[0].content).toBeNull();
+  });
+
+  describe("legacy BinaryInputContent backward compat", () => {
+    it("converts binary with image mimeType and data", () => {
+      const legacyPart = {
+        type: "binary",
+        mimeType: "image/jpeg",
+        data: "legacybase64",
+      };
+      const input = createDefaultInput({
+        messages: [
+          {
+            role: "user",
+            content: [legacyPart] as unknown as InputContent[],
+          } as Message,
+        ],
+      });
+      const { messages } = convertInputToTanStackAI(input);
+      expect(messages[0].content).toEqual([
+        {
+          type: "image",
+          source: {
+            type: "data",
+            value: "legacybase64",
+            mimeType: "image/jpeg",
+          },
+        },
+      ]);
+    });
+
+    it("skips binary with neither data nor url", () => {
+      const legacyPart = {
+        type: "binary",
+        mimeType: "image/png",
+      };
+      const input = createDefaultInput({
+        messages: [
+          {
+            role: "user",
+            content: [legacyPart] as unknown as InputContent[],
+          } as Message,
+        ],
+      });
+      const { messages } = convertInputToTanStackAI(input);
+      expect(messages[0].content).toBe("");
+    });
+
+    it("converts binary with non-image mimeType and url", () => {
+      const legacyPart = {
+        type: "binary",
+        mimeType: "application/pdf",
+        url: "https://example.com/doc.pdf",
+      };
+      const input = createDefaultInput({
+        messages: [
+          {
+            role: "user",
+            content: [legacyPart] as unknown as InputContent[],
+          } as Message,
+        ],
+      });
+      const { messages } = convertInputToTanStackAI(input);
+      expect(messages[0].content).toEqual([
+        {
+          type: "document",
+          source: {
+            type: "url",
+            value: "https://example.com/doc.pdf",
+            mimeType: "application/pdf",
+          },
+        },
+      ]);
+    });
+  });
+
+  it("only converts user message content, not assistant messages", () => {
+    const input = createDefaultInput({
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: "Look at this" },
+            { type: "image", source: dataSource("imgdata", "image/png") },
+          ],
+        } as Message,
+        { role: "assistant", content: "I see an image" } as Message,
+      ],
+    });
+    const { messages } = convertInputToTanStackAI(input);
+    // User message should have array content
+    expect(Array.isArray(messages[0].content)).toBe(true);
+    // Assistant message should keep string content
+    expect(messages[1].content).toBe("I see an image");
+  });
+});

package/src/agent/__tests__/test-helpers.ts

@@ -178,16 +178,20 @@ export async function collectEvents(
 ): Promise<BaseEvent[]> {
   return new Promise((resolve, reject) => {
     const events: BaseEvent[] = [];
-    const subscription = observable.subscribe({
-      next: (event) => events.push(event),
-      error: (err: unknown) => reject(err),
-      complete: () => resolve(events),
-    });
-
-    // Set a timeout to prevent hanging tests
-    setTimeout(() => {
+    const timeoutId = setTimeout(() => {
       subscription.unsubscribe();
       reject(new Error("Observable did not complete within timeout"));
     }, 5000);
+    const subscription = observable.subscribe({
+      next: (event) => events.push(event),
+      error: (err: unknown) => {
+        clearTimeout(timeoutId);
+        reject(err);
+      },
+      complete: () => {
+        clearTimeout(timeoutId);
+        resolve(events);
+      },
+    });
   });
 }