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

package/tests/service-adapters/anthropic/utils-token-trimming.test.ts

@@ -1,301 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { limitMessagesToTokenCount } from "../../../src/service-adapters/anthropic/utils";
-
-// Helper to build messages for testing. The token counter is length/3,
-// so we can control token counts via string length.
-
-function textUser(text: string) {
-  return { role: "user", content: [{ type: "text", text }] };
-}
-
-function textAssistant(text: string) {
-  return { role: "assistant", content: [{ type: "text", text }] };
-}
-
-function toolUseAssistant(id: string, name = "my_tool", input = {}) {
-  return {
-    role: "assistant",
-    content: [{ type: "tool_use", id, name, input }],
-  };
-}
-
-function toolResultUser(toolUseId: string, content = "result") {
-  return {
-    role: "user",
-    content: [{ type: "tool_result", tool_use_id: toolUseId, content }],
-  };
-}
-
-function mixedAssistant(blocks: any[]) {
-  return { role: "assistant", content: blocks };
-}
-
-function mixedUser(blocks: any[]) {
-  return { role: "user", content: blocks };
-}
-
-describe("limitMessagesToTokenCount - orphan handling", () => {
-  // Use a high token limit so trimming doesn't kick in for these tests
-  const HIGH_LIMIT = 999999;
-
-  it("preserves matched tool_use / tool_result pairs", () => {
-    const messages = [
-      textUser("hello"),
-      toolUseAssistant("t1", "tool_a"),
-      toolResultUser("t1", "done"),
-      textAssistant("ok"),
-    ];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    // All four messages should survive
-    expect(result).toHaveLength(4);
-    // The tool_use and tool_result should still be present
-    const toolUse = result.find(
-      (m: any) =>
-        m.role === "assistant" &&
-        Array.isArray(m.content) &&
-        m.content.some((b: any) => b.type === "tool_use"),
-    );
-    const toolResult = result.find(
-      (m: any) =>
-        m.role === "user" &&
-        Array.isArray(m.content) &&
-        m.content.some((b: any) => b.type === "tool_result"),
-    );
-    expect(toolUse).toBeDefined();
-    expect(toolResult).toBeDefined();
-  });
-
-  it("removes orphaned tool_result when tool_use was trimmed", () => {
-    // Simulate: tool_use message was removed by token trimming, leaving
-    // a tool_result without a matching tool_use.
-    const messages = [
-      textUser("hello"),
-      // no toolUseAssistant for "t1"
-      toolResultUser("t1", "orphaned result"),
-      textAssistant("ok"),
-    ];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    // The orphaned tool_result message should be gone
-    const hasToolResult = result.some(
-      (m: any) =>
-        m.role === "user" &&
-        Array.isArray(m.content) &&
-        m.content.some((b: any) => b.type === "tool_result"),
-    );
-    expect(hasToolResult).toBe(false);
-    expect(result).toHaveLength(2); // textUser + textAssistant
-  });
-
-  it("removes orphaned tool_use when tool_result was trimmed", () => {
-    // Simulate: tool_result message was removed by token trimming, leaving
-    // a tool_use without a matching tool_result.
-    const messages = [
-      textUser("hello"),
-      toolUseAssistant("t1", "tool_a"),
-      // no toolResultUser for "t1"
-      textAssistant("ok"),
-    ];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    // The orphaned tool_use message should be gone
-    const hasToolUse = result.some(
-      (m: any) =>
-        m.role === "assistant" &&
-        Array.isArray(m.content) &&
-        m.content.some((b: any) => b.type === "tool_use"),
-    );
-    expect(hasToolUse).toBe(false);
-    expect(result).toHaveLength(2); // textUser + textAssistant
-  });
-
-  it("retains non-orphaned blocks in mixed-content messages", () => {
-    // Assistant message has both a text block and an orphaned tool_use
-    const messages = [
-      textUser("hello"),
-      mixedAssistant([
-        { type: "text", text: "thinking..." },
-        { type: "tool_use", id: "t1", name: "tool_a", input: {} },
-      ]),
-      // no tool_result for t1
-      textAssistant("done"),
-    ];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    // The assistant message should survive with only the text block
-    const assistantMixed = result.find(
-      (m: any) =>
-        m.role === "assistant" &&
-        Array.isArray(m.content) &&
-        m.content.some(
-          (b: any) => b.type === "text" && b.text === "thinking...",
-        ),
-    );
-    expect(assistantMixed).toBeDefined();
-    expect(assistantMixed.content).toHaveLength(1);
-    expect(assistantMixed.content[0].type).toBe("text");
-  });
-
-  it("retains non-orphaned blocks in mixed user messages", () => {
-    // User message has both a text block and an orphaned tool_result
-    const messages = [
-      textUser("hello"),
-      mixedUser([
-        { type: "text", text: "here is context" },
-        { type: "tool_result", tool_use_id: "t_missing", content: "orphan" },
-      ]),
-      textAssistant("ok"),
-    ];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    const userMixed = result.find(
-      (m: any) =>
-        m.role === "user" &&
-        Array.isArray(m.content) &&
-        m.content.some(
-          (b: any) => b.type === "text" && b.text === "here is context",
-        ),
-    );
-    expect(userMixed).toBeDefined();
-    expect(userMixed.content).toHaveLength(1);
-    expect(userMixed.content[0].type).toBe("text");
-  });
-
-  it("drops message entirely when all blocks are orphaned", () => {
-    const messages = [
-      textUser("hello"),
-      mixedUser([
-        { type: "tool_result", tool_use_id: "t_a", content: "orphan a" },
-        { type: "tool_result", tool_use_id: "t_b", content: "orphan b" },
-      ]),
-      textAssistant("ok"),
-    ];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    expect(result).toHaveLength(2);
-    expect(result[0].role).toBe("user");
-    expect(result[1].role).toBe("assistant");
-  });
-
-  it("drops assistant message entirely when all tool_use blocks are orphaned", () => {
-    const messages = [
-      textUser("hello"),
-      mixedAssistant([
-        { type: "tool_use", id: "t_x", name: "tool_x", input: {} },
-        { type: "tool_use", id: "t_y", name: "tool_y", input: {} },
-      ]),
-      // no tool_results for either
-      textAssistant("done"),
-    ];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    expect(result).toHaveLength(2);
-  });
-
-  it("does not mutate the original messages array or message objects", () => {
-    const originalContent = [
-      { type: "text", text: "context" },
-      { type: "tool_result", tool_use_id: "t_orphan", content: "orphan" },
-    ];
-    const userMsg = { role: "user", content: [...originalContent] };
-    const messages = [textUser("hello"), userMsg, textAssistant("ok")];
-
-    const result = limitMessagesToTokenCount(
-      messages,
-      [],
-      "claude-3",
-      HIGH_LIMIT,
-    );
-
-    // Original message should still have both blocks
-    expect(userMsg.content).toHaveLength(2);
-    expect(userMsg.content[1].type).toBe("tool_result");
-
-    // Original messages array should still have 3 entries
-    expect(messages).toHaveLength(3);
-
-    // Result should have the filtered version
-    const filtered = result.find(
-      (m: any) =>
-        m.role === "user" &&
-        Array.isArray(m.content) &&
-        m.content.some((b: any) => b.text === "context"),
-    );
-    expect(filtered).toBeDefined();
-    expect(filtered.content).toHaveLength(1);
-  });
-
-  it("handles token trimming that creates orphans via cutoff", () => {
-    // Build messages where token trimming will cut off early messages,
-    // leaving orphaned tool_result for a tool_use that got trimmed.
-    // Each char ~0.33 tokens, so 300 chars ~ 100 tokens
-    const longText = "x".repeat(300);
-
-    const messages = [
-      toolUseAssistant("t_old"),
-      toolResultUser("t_old", "old result"),
-      textUser(longText),
-      textAssistant(longText),
-      toolUseAssistant("t_new"),
-      toolResultUser("t_new", "new result"),
-    ];
-
-    // Set a limit that keeps only the last few messages, trimming t_old's tool_use
-    const result = limitMessagesToTokenCount(messages, [], "claude-3", 300);
-
-    // t_old's tool_use should have been trimmed by the token limit,
-    // and then t_old's tool_result should be cleaned up as orphaned
-    const hasOldResult = result.some(
-      (m: any) =>
-        m.role === "user" &&
-        Array.isArray(m.content) &&
-        m.content.some(
-          (b: any) => b.type === "tool_result" && b.tool_use_id === "t_old",
-        ),
-    );
-    expect(hasOldResult).toBe(false);
-  });
-});

package/tests/service-adapters/groq/groq-adapter-language-model.test.ts

@@ -1,102 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { OpenAIProviderSettings } from "@ai-sdk/openai";
-import { GroqAdapter } from "../../../src/service-adapters/groq/groq-adapter";
-import { Groq } from "groq-sdk";
-
-// Groq uses createOpenAI (OpenAI-compatible API), so we check against
-// OpenAIProviderSettings. Same exhaustiveness guard as the OpenAI test.
-type ForwardedGroqKeys = "baseURL" | "apiKey" | "headers" | "fetch";
-
-// Keys we set ourselves or that don't apply to Groq.
-type ControlledGroqKeys = "name" | "organization" | "project";
-
-type _exhaustive =
-  Exclude<
-    keyof OpenAIProviderSettings,
-    ForwardedGroqKeys | ControlledGroqKeys
-  > extends never
-    ? true
-    : {
-        error: "OpenAIProviderSettings has unhandled keys";
-        unhandled: Exclude<
-          keyof OpenAIProviderSettings,
-          ForwardedGroqKeys | ControlledGroqKeys
-        >;
-      };
-const _check: _exhaustive = true;
-
-const { mockProviderFn, mockCreateOpenAI } = vi.hoisted(() => {
-  const mockProviderFn = vi.fn().mockReturnValue({ modelId: "test-model" });
-  const mockCreateOpenAI = vi.fn().mockReturnValue(mockProviderFn);
-  return { mockProviderFn, mockCreateOpenAI };
-});
-
-vi.mock("@ai-sdk/openai", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@ai-sdk/openai")>();
-  return { ...actual, createOpenAI: mockCreateOpenAI };
-});
-
-vi.mock("groq-sdk", () => {
-  return {
-    Groq: class MockGroq {
-      baseURL: string;
-      apiKey: string;
-      _options: Record<string, any>;
-      chat = { completions: { create: vi.fn() } };
-
-      constructor(opts: any = {}) {
-        this.baseURL = opts.baseURL ?? "https://api.groq.com";
-        this.apiKey = opts.apiKey ?? "default-key";
-        this._options = {
-          defaultHeaders: opts.defaultHeaders,
-          fetch: opts.fetch,
-          ...opts,
-        };
-      }
-    },
-  };
-});
-
-describe("GroqAdapter.getLanguageModel()", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("forwards all provider-relevant options from the Groq SDK client", () => {
-    const customFetch = vi.fn();
-    const groq = new Groq({
-      apiKey: "gsk-test",
-      baseURL: "https://custom-groq.example.com",
-      defaultHeaders: { "x-groq": "value" },
-      fetch: customFetch,
-    });
-
-    const adapter = new GroqAdapter({
-      groq,
-      model: "llama-3.3-70b-versatile",
-    });
-    adapter.getLanguageModel();
-
-    expect(mockCreateOpenAI).toHaveBeenCalledOnce();
-    const settings = mockCreateOpenAI.mock.calls[0][0];
-
-    expect(settings.baseURL).toBe("https://custom-groq.example.com");
-    expect(settings.apiKey).toBe("gsk-test");
-    expect(settings.headers).toEqual({ "x-groq": "value" });
-    expect(settings.fetch).toBe(customFetch);
-    expect(settings.name).toBe("groq");
-
-    expect(mockProviderFn).toHaveBeenCalledWith("llama-3.3-70b-versatile");
-  });
-
-  it("works with default Groq config (no custom options)", () => {
-    const groq = new Groq({ apiKey: "gsk-default" });
-    const adapter = new GroqAdapter({ groq });
-    adapter.getLanguageModel();
-
-    const settings = mockCreateOpenAI.mock.calls[0][0];
-    expect(settings.baseURL).toBe("https://api.groq.com");
-    expect(settings.apiKey).toBe("gsk-default");
-    expect(settings.name).toBe("groq");
-  });
-});

package/tests/service-adapters/openai/allowlist-approach.test.ts

@@ -1,294 +0,0 @@
-describe("OpenAI Adapter - Allowlist Approach", () => {
-  it("should filter out tool_result messages with no corresponding tool_call ID", () => {
-    // Setup test data
-    const validToolCallIds = new Set<string>(["valid-id-1", "valid-id-2"]);
-
-    // Messages to filter - valid and invalid ones
-    const messages = [
-      { type: "text", role: "user", content: "Hello" },
-      {
-        type: "tool_result",
-        actionExecutionId: "valid-id-1",
-        result: "result1",
-      },
-      {
-        type: "tool_result",
-        actionExecutionId: "invalid-id",
-        result: "invalid",
-      },
-      {
-        type: "tool_result",
-        actionExecutionId: "valid-id-2",
-        result: "result2",
-      },
-      {
-        type: "tool_result",
-        actionExecutionId: "valid-id-1",
-        result: "duplicate",
-      }, // Duplicate ID
-    ];
-
-    // Implement the filtering logic, similar to the adapter
-    const filteredMessages = messages.filter((message) => {
-      if (message.type === "tool_result") {
-        // Skip if there's no corresponding tool_call
-        if (!validToolCallIds.has(message.actionExecutionId)) {
-          return false;
-        }
-
-        // Remove this ID from valid IDs so we don't process duplicates
-        validToolCallIds.delete(message.actionExecutionId);
-      }
-
-      // Keep all non-tool-result messages
-      return true;
-    });
-
-    // Verify results
-    expect(filteredMessages.length).toBe(3); // text + 2 valid tool results (no duplicates or invalid)
-
-    // Valid results should be included
-    expect(
-      filteredMessages.some(
-        (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-1",
-      ),
-    ).toBe(true);
-
-    expect(
-      filteredMessages.some(
-        (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-2",
-      ),
-    ).toBe(true);
-
-    // Invalid result should be excluded
-    expect(
-      filteredMessages.some(
-        (m) => m.type === "tool_result" && m.actionExecutionId === "invalid-id",
-      ),
-    ).toBe(false);
-
-    // Duplicate should be excluded - we used a different approach than Anthropic
-    const validId1Count = filteredMessages.filter(
-      (m) => m.type === "tool_result" && m.actionExecutionId === "valid-id-1",
-    ).length;
-
-    expect(validId1Count).toBe(1);
-  });
-
-  it("should maintain correct order of messages when filtering", () => {
-    // Setup test data
-    const validToolCallIds = new Set<string>(["tool-1", "tool-2", "tool-3"]);
-
-    // Test with a complex conversation pattern
-    const messages = [
-      { type: "text", role: "user", content: "Initial message" },
-      { type: "text", role: "assistant", content: "I'll help with that" },
-      { type: "tool_call", id: "tool-1", name: "firstTool" },
-      { type: "tool_result", actionExecutionId: "tool-1", result: "result1" },
-      { type: "text", role: "assistant", content: "Got the first result" },
-      { type: "tool_call", id: "tool-2", name: "secondTool" },
-      { type: "tool_result", actionExecutionId: "tool-2", result: "result2" },
-      {
-        type: "tool_result",
-        actionExecutionId: "invalid-id",
-        result: "invalid-result",
-      },
-      { type: "tool_call", id: "tool-3", name: "thirdTool" },
-      {
-        type: "tool_result",
-        actionExecutionId: "tool-1",
-        result: "duplicate-result",
-      }, // Duplicate
-      { type: "tool_result", actionExecutionId: "tool-3", result: "result3" },
-      { type: "text", role: "user", content: "Final message" },
-    ];
-
-    // Apply OpenAI's filter approach (using filter instead of loop)
-    const filteredMessages = messages.filter((message) => {
-      if (message.type === "tool_result") {
-        // Skip if there's no corresponding tool_call
-        if (!validToolCallIds.has(message.actionExecutionId)) {
-          return false;
-        }
-
-        // Remove this ID from valid IDs so we don't process duplicates
-        validToolCallIds.delete(message.actionExecutionId);
-      }
-
-      // Keep all non-tool-result messages
-      return true;
-    });
-
-    // Verify results
-    expect(filteredMessages.length).toBe(10); // 12 original - 2 filtered out
-
-    // Check that the message order is preserved
-    expect(filteredMessages[0].type).toBe("text"); // Initial user message
-    expect(filteredMessages[0].content).toBe("Initial message");
-    expect(filteredMessages[1].type).toBe("text"); // Assistant response
-    expect(filteredMessages[2].type).toBe("tool_call"); // First tool
-    expect(filteredMessages[3].type).toBe("tool_result"); // First result
-    expect(filteredMessages[3].actionExecutionId).toBe("tool-1");
-    expect(filteredMessages[4].type).toBe("text"); // Assistant comment
-    expect(filteredMessages[5].type).toBe("tool_call"); // Second tool
-    expect(filteredMessages[6].type).toBe("tool_result"); // Second result
-    expect(filteredMessages[6].actionExecutionId).toBe("tool-2");
-    expect(filteredMessages[7].type).toBe("tool_call"); // Third tool
-    expect(filteredMessages[8].type).toBe("tool_result"); // Third result
-    expect(filteredMessages[8].actionExecutionId).toBe("tool-3");
-    expect(filteredMessages[9].type).toBe("text"); // Final user message
-
-    // Each valid tool result should appear exactly once
-    const toolResultCounts = new Map();
-    filteredMessages.forEach((message) => {
-      if (message.type === "tool_result") {
-        const id = message.actionExecutionId;
-        toolResultCounts.set(id, (toolResultCounts.get(id) || 0) + 1);
-      }
-    });
-
-    expect(toolResultCounts.size).toBe(3); // Should have 3 different tool results
-    expect(toolResultCounts.get("tool-1")).toBe(1);
-    expect(toolResultCounts.get("tool-2")).toBe(1);
-    expect(toolResultCounts.get("tool-3")).toBe(1);
-    expect(toolResultCounts.has("invalid-id")).toBe(false);
-  });
-
-  it("should handle empty message array", () => {
-    const validToolCallIds = new Set<string>(["valid-id-1", "valid-id-2"]);
-    const messages = [];
-
-    // Apply OpenAI's filter approach
-    const filteredMessages = messages.filter((message) => {
-      if (message.type === "tool_result") {
-        if (!validToolCallIds.has(message.actionExecutionId)) {
-          return false;
-        }
-        validToolCallIds.delete(message.actionExecutionId);
-      }
-      return true;
-    });
-
-    expect(filteredMessages.length).toBe(0);
-  });
-
-  it("should handle edge cases with mixed message types", () => {
-    // Setup test data with various message types
-    const validToolCallIds = new Set<string>(["valid-id-1"]);
-
-    const messages = [
-      { type: "text", role: "user", content: "Hello" },
-      { type: "image", url: "https://example.com/image.jpg" }, // Non-tool message type
-      {
-        type: "tool_result",
-        actionExecutionId: "valid-id-1",
-        result: "result1",
-      },
-      { type: "custom", data: { key: "value" } }, // Another custom type
-      {
-        type: "tool_result",
-        actionExecutionId: "valid-id-1",
-        result: "duplicate",
-      }, // Duplicate
-      { type: "null", value: null }, // Edge case
-      { type: "undefined" }, // Edge case
-    ];
-
-    // Apply OpenAI's filter approach
-    const filteredMessages = messages.filter((message) => {
-      if (message.type === "tool_result") {
-        if (!validToolCallIds.has(message.actionExecutionId)) {
-          return false;
-        }
-        validToolCallIds.delete(message.actionExecutionId);
-      }
-      return true;
-    });
-
-    // Should have all non-tool_result messages + 1 valid tool_result
-    expect(filteredMessages.length).toBe(6); // 7 original - 1 duplicate
-
-    // Valid tool_result should be included exactly once
-    const toolResults = filteredMessages.filter(
-      (m) => m.type === "tool_result",
-    );
-    expect(toolResults.length).toBe(1);
-    expect(toolResults[0].actionExecutionId).toBe("valid-id-1");
-
-    // All non-tool_result messages should be preserved
-    expect(filteredMessages.filter((m) => m.type === "text").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "image").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "custom").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "null").length).toBe(1);
-    expect(filteredMessages.filter((m) => m.type === "undefined").length).toBe(
-      1,
-    );
-  });
-
-  it("should properly handle multiple duplicate tool results", () => {
-    // Setup test data with multiple duplicates
-    const validToolCallIds = new Set<string>(["tool-1", "tool-2"]);
-
-    const messages = [
-      { type: "text", role: "user", content: "Initial prompt" },
-      { type: "tool_call", id: "tool-1", name: "firstTool" },
-      {
-        type: "tool_result",
-        actionExecutionId: "tool-1",
-        result: "first-result",
-      },
-      {
-        type: "tool_result",
-        actionExecutionId: "tool-1",
-        result: "duplicate-1",
-      }, // Duplicate 1
-      { type: "tool_call", id: "tool-2", name: "secondTool" },
-      {
-        type: "tool_result",
-        actionExecutionId: "tool-1",
-        result: "duplicate-2",
-      }, // Duplicate 2
-      {
-        type: "tool_result",
-        actionExecutionId: "tool-2",
-        result: "second-result",
-      },
-      {
-        type: "tool_result",
-        actionExecutionId: "tool-2",
-        result: "duplicate-3",
-      }, // Duplicate 3
-      {
-        type: "tool_result",
-        actionExecutionId: "tool-1",
-        result: "duplicate-4",
-      }, // Duplicate 4
-    ];
-
-    // Apply OpenAI's filter approach
-    const filteredMessages = messages.filter((message) => {
-      if (message.type === "tool_result") {
-        if (!validToolCallIds.has(message.actionExecutionId)) {
-          return false;
-        }
-        validToolCallIds.delete(message.actionExecutionId);
-      }
-      return true;
-    });
-
-    // Should have text + tool calls + only the first occurrence of each tool result
-    expect(filteredMessages.length).toBe(5);
-
-    // Check that only the first occurrence of each tool result is kept
-    const toolResults = filteredMessages.filter(
-      (m) => m.type === "tool_result",
-    );
-    expect(toolResults.length).toBe(2);
-
-    expect(toolResults[0].actionExecutionId).toBe("tool-1");
-    expect(toolResults[0].result).toBe("first-result"); // First occurrence should be kept
-
-    expect(toolResults[1].actionExecutionId).toBe("tool-2");
-    expect(toolResults[1].result).toBe("second-result"); // First occurrence should be kept
-  });
-});