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

package/src/v2/runtime/telemetry/scarf-client.ts

@@ -1,39 +0,0 @@
-import * as packageJson from "../../../../package.json";
-
-const SCARF_BASE_URL = `https://copilotkit.gateway.scarf.sh/${packageJson.version}`;
-
-class ScarfClient {
-  constructor() {}
-
-  async logEvent(properties: Record<string, any>): Promise<void> {
-    try {
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 3000);
-
-      const queryParams = new URLSearchParams();
-
-      Object.entries(properties).forEach(([key, value]) => {
-        if (value !== null && value !== undefined) {
-          queryParams.append(key, String(value));
-        }
-      });
-
-      const url = `${SCARF_BASE_URL}?${queryParams.toString()}`;
-
-      const response = await fetch(url, {
-        method: "GET",
-        signal: controller.signal,
-      });
-
-      clearTimeout(timeoutId);
-
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
-    } catch {
-      // Silently fail - telemetry should not break the application
-    }
-  }
-}
-
-export default new ScarfClient();

package/src/v2/runtime/telemetry/telemetry-client.ts

@@ -1,70 +0,0 @@
-import { AnalyticsEvents } from "./events";
-import scarfClient from "./scarf-client";
-
-export function isTelemetryDisabled(): boolean {
-  return (
-    (process.env as Record<string, string | undefined>)
-      .COPILOTKIT_TELEMETRY_DISABLED === "true" ||
-    (process.env as Record<string, string | undefined>)
-      .COPILOTKIT_TELEMETRY_DISABLED === "1" ||
-    (process.env as Record<string, string | undefined>).DO_NOT_TRACK ===
-      "true" ||
-    (process.env as Record<string, string | undefined>).DO_NOT_TRACK === "1"
-  );
-}
-
-export class TelemetryClient {
-  private telemetryDisabled: boolean = false;
-  private sampleRate: number = 0.05;
-
-  constructor({
-    telemetryDisabled,
-    sampleRate,
-  }: {
-    telemetryDisabled?: boolean;
-    sampleRate?: number;
-  } = {}) {
-    this.telemetryDisabled = telemetryDisabled ?? isTelemetryDisabled();
-    this.setSampleRate(sampleRate);
-  }
-
-  private shouldSendEvent() {
-    if (this.telemetryDisabled) {
-      return false;
-    }
-    const randomNumber = Math.random();
-    return randomNumber < this.sampleRate;
-  }
-
-  async capture<K extends keyof AnalyticsEvents>(
-    event: K,
-    _properties: AnalyticsEvents[K],
-  ) {
-    if (!this.shouldSendEvent()) {
-      return;
-    }
-
-    await scarfClient.logEvent({
-      event,
-    });
-  }
-
-  private setSampleRate(sampleRate: number | undefined) {
-    let _sampleRate: number;
-
-    _sampleRate = sampleRate ?? 0.05;
-
-    if (process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE) {
-      _sampleRate = parseFloat(process.env.COPILOTKIT_TELEMETRY_SAMPLE_RATE);
-    }
-
-    if (_sampleRate < 0 || _sampleRate > 1) {
-      throw new Error("Sample rate must be between 0 and 1");
-    }
-
-    this.sampleRate = _sampleRate;
-  }
-}
-
-const telemetry = new TelemetryClient();
-export default telemetry;

package/src/v2/runtime/transcription-service/transcription-service.ts

@@ -1,11 +0,0 @@
-export interface TranscribeFileOptions {
-  audioFile: File;
-  /** MIME type of the audio file */
-  mimeType?: string;
-  /** Size of the audio file in bytes */
-  size?: number;
-}
-
-export abstract class TranscriptionService {
-  abstract transcribeFile(options: TranscribeFileOptions): Promise<string>;
-}

package/tests/global.d.ts

@@ -1 +0,0 @@
-/// <reference types="vitest/globals" />

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

@@ -1,259 +0,0 @@
-describe("Anthropic Adapter - Allowlist Approach", () => {
-  it("should filter out tool_result messages with no corresponding tool_use ID", () => {
-    // Setup test data
-    const validToolUseIds = 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
-    ];
-
-    // Apply the allowlist filter approach
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        // Skip if no corresponding valid tool_use ID
-        if (!validToolUseIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Skip if we've already processed this ID
-        if (processedIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Mark this ID as processed
-        processedIds.add(message.actionExecutionId);
-      }
-
-      // Include all non-tool-result messages and valid tool results
-      filteredMessages.push(message);
-    }
-
-    // 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
-    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 with specific ordering
-    const validToolUseIds = new Set<string>(["tool-1", "tool-2", "tool-3"]);
-
-    // Messages in a specific order, with some invalid/duplicate results
-    const messages = [
-      { type: "text", role: "user", content: "Initial message" },
-      { type: "text", role: "assistant", content: "I'll help with that" },
-      { type: "tool_use", id: "tool-1", name: "firstTool" },
-      { type: "tool_result", actionExecutionId: "tool-1", result: "result1" },
-      { type: "text", role: "assistant", content: "Got the first result" },
-      { type: "tool_use", id: "tool-2", name: "secondTool" },
-      { type: "tool_result", actionExecutionId: "tool-2", result: "result2" },
-      {
-        type: "tool_result",
-        actionExecutionId: "invalid-id",
-        result: "invalid-result",
-      },
-      { type: "tool_use", 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 the allowlist filter approach
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        // Skip if no corresponding valid tool_use ID
-        if (!validToolUseIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Skip if we've already processed this ID
-        if (processedIds.has(message.actionExecutionId)) {
-          continue;
-        }
-
-        // Mark this ID as processed
-        processedIds.add(message.actionExecutionId);
-      }
-
-      // Include all non-tool-result messages and valid tool results
-      filteredMessages.push(message);
-    }
-
-    // Verify results
-    expect(filteredMessages.length).toBe(10); // 12 original - 2 filtered out
-
-    // Check that the order is preserved
-    expect(filteredMessages[0].type).toBe("text"); // Initial user message
-    expect(filteredMessages[1].type).toBe("text"); // Assistant response
-    expect(filteredMessages[2].type).toBe("tool_use"); // First tool
-    expect(filteredMessages[3].type).toBe("tool_result"); // First result
-    expect(filteredMessages[3].actionExecutionId).toBe("tool-1"); // First result
-    expect(filteredMessages[4].type).toBe("text"); // Assistant comment
-    expect(filteredMessages[5].type).toBe("tool_use"); // Second tool
-    expect(filteredMessages[6].type).toBe("tool_result"); // Second result
-    expect(filteredMessages[6].actionExecutionId).toBe("tool-2"); // Second result
-    expect(filteredMessages[7].type).toBe("tool_use"); // Third tool
-    expect(filteredMessages[8].type).toBe("tool_result"); // Third result
-    expect(filteredMessages[8].actionExecutionId).toBe("tool-3"); // Third result
-    expect(filteredMessages[9].type).toBe("text"); // Final user message
-
-    // Each valid tool ID should appear exactly once in the results
-    const toolResultCounts = {
-      "tool-1": 0,
-      "tool-2": 0,
-      "tool-3": 0,
-    };
-
-    filteredMessages.forEach((message) => {
-      if (
-        message.type === "tool_result" &&
-        message.actionExecutionId in toolResultCounts
-      ) {
-        toolResultCounts[message.actionExecutionId]++;
-      }
-    });
-
-    expect(toolResultCounts["tool-1"]).toBe(1);
-    expect(toolResultCounts["tool-2"]).toBe(1);
-    expect(toolResultCounts["tool-3"]).toBe(1);
-  });
-
-  it("should handle an empty message array", () => {
-    const validToolUseIds = new Set<string>(["valid-id-1", "valid-id-2"]);
-    const messages = [];
-
-    // Apply the filtering logic
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        if (
-          !validToolUseIds.has(message.actionExecutionId) ||
-          processedIds.has(message.actionExecutionId)
-        ) {
-          continue;
-        }
-        processedIds.add(message.actionExecutionId);
-      }
-      filteredMessages.push(message);
-    }
-
-    expect(filteredMessages.length).toBe(0);
-  });
-
-  it("should handle edge cases with mixed message types", () => {
-    // Setup with mixed message types
-    const validToolUseIds = 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 the filtering logic
-    const filteredMessages = [];
-    const processedIds = new Set<string>();
-
-    for (const message of messages) {
-      if (message.type === "tool_result") {
-        if (
-          !validToolUseIds.has(message.actionExecutionId) ||
-          processedIds.has(message.actionExecutionId)
-        ) {
-          continue;
-        }
-        processedIds.add(message.actionExecutionId);
-      }
-      filteredMessages.push(message);
-    }
-
-    // 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 other message types 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,
-    );
-  });
-});

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

@@ -1,101 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { AnthropicProviderSettings } from "@ai-sdk/anthropic";
-import { AnthropicAdapter } from "../../../src/service-adapters/anthropic/anthropic-adapter";
-import Anthropic from "@anthropic-ai/sdk";
-
-// Keys from AnthropicProviderSettings that we forward from the Anthropic SDK client.
-type ForwardedAnthropicKeys = "baseURL" | "apiKey" | "headers" | "fetch";
-
-// We don't set `name` or `generateId` — they're provider-internal concerns.
-type ControlledAnthropicKeys = "name" | "generateId";
-
-// Compile-time exhaustiveness check: every key in AnthropicProviderSettings
-// must be accounted for. If this line errors, a new key was added.
-type _exhaustive =
-  Exclude<
-    keyof AnthropicProviderSettings,
-    ForwardedAnthropicKeys | ControlledAnthropicKeys
-  > extends never
-    ? true
-    : {
-        error: "AnthropicProviderSettings has unhandled keys";
-        unhandled: Exclude<
-          keyof AnthropicProviderSettings,
-          ForwardedAnthropicKeys | ControlledAnthropicKeys
-        >;
-      };
-const _check: _exhaustive = true;
-
-const { mockProviderFn, mockCreateAnthropic } = vi.hoisted(() => {
-  const mockProviderFn = vi.fn().mockReturnValue({ modelId: "test-model" });
-  const mockCreateAnthropic = vi.fn().mockReturnValue(mockProviderFn);
-  return { mockProviderFn, mockCreateAnthropic };
-});
-
-vi.mock("@ai-sdk/anthropic", async (importOriginal) => {
-  const actual = await importOriginal<typeof import("@ai-sdk/anthropic")>();
-  return { ...actual, createAnthropic: mockCreateAnthropic };
-});
-
-vi.mock("@anthropic-ai/sdk", () => {
-  return {
-    default: class MockAnthropic {
-      baseURL: string;
-      apiKey: string;
-      _options: Record<string, any>;
-      messages = { create: vi.fn() };
-
-      constructor(opts: any = {}) {
-        this.baseURL = opts.baseURL ?? "https://api.anthropic.com/v1";
-        this.apiKey = opts.apiKey ?? "default-key";
-        this._options = {
-          defaultHeaders: opts.defaultHeaders,
-          fetch: opts.fetch,
-          ...opts,
-        };
-      }
-    },
-  };
-});
-
-describe("AnthropicAdapter.getLanguageModel()", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("forwards all provider-relevant options from the Anthropic SDK client", () => {
-    const customFetch = vi.fn();
-    const anthropic = new Anthropic({
-      apiKey: "sk-ant-test",
-      baseURL: "https://proxy.example.com/v1",
-      defaultHeaders: { "x-custom": "value" },
-      fetch: customFetch,
-    });
-
-    const adapter = new AnthropicAdapter({
-      anthropic,
-      model: "claude-3-5-sonnet-latest",
-    });
-    adapter.getLanguageModel();
-
-    expect(mockCreateAnthropic).toHaveBeenCalledOnce();
-    const settings = mockCreateAnthropic.mock.calls[0][0];
-
-    expect(settings.baseURL).toBe("https://proxy.example.com/v1");
-    expect(settings.apiKey).toBe("sk-ant-test");
-    expect(settings.headers).toEqual({ "x-custom": "value" });
-    expect(settings.fetch).toBe(customFetch);
-
-    expect(mockProviderFn).toHaveBeenCalledWith("claude-3-5-sonnet-latest");
-  });
-
-  it("works with default Anthropic config (no custom options)", () => {
-    const anthropic = new Anthropic({ apiKey: "sk-ant-default" });
-    const adapter = new AnthropicAdapter({ anthropic });
-    adapter.getLanguageModel();
-
-    const settings = mockCreateAnthropic.mock.calls[0][0];
-    expect(settings.baseURL).toBe("https://api.anthropic.com/v1");
-    expect(settings.apiKey).toBe("sk-ant-default");
-  });
-});