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

package/src/lib/runtime/__tests__/copilot-runtime-error.test.ts

@@ -1,183 +0,0 @@
-import {
-  CopilotErrorEvent,
-  CopilotRequestContext,
-  CopilotErrorHandler,
-} from "@copilotkit/shared";
-
-describe("CopilotRuntime onError types", () => {
-  it("should have correct CopilotTraceEvent type structure", () => {
-    const errorEvent: CopilotErrorEvent = {
-      type: "error",
-      timestamp: Date.now(),
-      context: {
-        threadId: "test-123",
-        source: "runtime",
-        request: {
-          operation: "test-operation",
-          startTime: Date.now(),
-        },
-        technical: {},
-        metadata: {},
-      },
-      error: new Error("Test error"),
-    };
-
-    expect(errorEvent.type).toBe("error");
-    expect(errorEvent.timestamp).toBeGreaterThan(0);
-    expect(errorEvent.context.threadId).toBe("test-123");
-    expect(errorEvent.error).toBeInstanceOf(Error);
-  });
-
-  it("should have correct CopilotRequestContext type structure", () => {
-    const context: CopilotRequestContext = {
-      threadId: "test-thread-456",
-      runId: "test-run-789",
-      source: "runtime",
-      request: {
-        operation: "processRuntimeRequest",
-        method: "POST",
-        url: "http://localhost:3000/api/copilotkit",
-        startTime: Date.now(),
-      },
-      response: {
-        status: 200,
-        endTime: Date.now(),
-        latency: 1200,
-      },
-      agent: {
-        name: "test-agent",
-        nodeName: "test-node",
-        state: { step: 1 },
-      },
-      messages: {
-        input: [],
-        output: [],
-        messageCount: 2,
-      },
-      technical: {
-        userAgent: "Mozilla/5.0...",
-        host: "localhost:3000",
-        environment: "test",
-        version: "1.0.0",
-        stackTrace: "Error: Test\n  at test.js:1:1",
-      },
-      performance: {
-        requestDuration: 1200,
-        streamingDuration: 800,
-        actionExecutionTime: 400,
-        memoryUsage: 45.2,
-      },
-      metadata: {
-        testFlag: true,
-        version: "1.0.0",
-      },
-    };
-
-    expect(context.threadId).toBe("test-thread-456");
-    expect(context.agent?.name).toBe("test-agent");
-    expect(context.messages?.messageCount).toBe(2);
-    expect(context.technical?.stackTrace).toContain("Error: Test");
-    expect(context.metadata?.testFlag).toBe(true);
-  });
-
-  it("should support all error event types", () => {
-    const eventTypes: CopilotErrorEvent["type"][] = [
-      "error",
-      "request",
-      "response",
-      "agent_state",
-      "action",
-      "message",
-      "performance",
-    ];
-
-    eventTypes.forEach((type) => {
-      const event: CopilotErrorEvent = {
-        type,
-        timestamp: Date.now(),
-        context: {
-          threadId: `test-${type}`,
-          source: "runtime",
-          request: {
-            operation: "test",
-            startTime: Date.now(),
-          },
-          technical: {},
-          metadata: {},
-        },
-      };
-
-      expect(event.type).toBe(type);
-    });
-  });
-
-  describe("publicApiKey gating logic", () => {
-    type ShouldHandleError = (
-      onError?: CopilotErrorHandler,
-      publicApiKey?: string,
-    ) => boolean;
-
-    const shouldHandleError: ShouldHandleError = (onError, publicApiKey) => {
-      return Boolean(onError && publicApiKey);
-    };
-
-    it("should return true when both onError and publicApiKey are provided", () => {
-      const onError = vi.fn();
-      const result = shouldHandleError(onError, "valid-api-key");
-      expect(result).toBe(true);
-    });
-
-    it("should return false when onError is missing", () => {
-      const result = shouldHandleError(undefined, "valid-api-key");
-      expect(result).toBe(false);
-    });
-
-    it("should return false when publicApiKey is missing", () => {
-      const onError = vi.fn();
-      const result = shouldHandleError(onError, undefined);
-      expect(result).toBe(false);
-    });
-
-    it("should return false when publicApiKey is empty string", () => {
-      const onError = vi.fn();
-      const result = shouldHandleError(onError, "");
-      expect(result).toBe(false);
-    });
-
-    it("should return false when both are missing", () => {
-      const result = shouldHandleError(undefined, undefined);
-      expect(result).toBe(false);
-    });
-
-    it("should extract publicApiKey from headers for both cloud and non-cloud requests", () => {
-      // Test the logic we just fixed in the GraphQL resolver
-      const mockHeaders = new Map([
-        ["x-copilotcloud-public-api-key", "test-key-123"],
-      ]);
-
-      // Simulate header extraction logic
-      const extractPublicApiKey = (
-        headers: Map<string, string>,
-        hasCloudConfig: boolean,
-      ) => {
-        const publicApiKeyFromHeaders = headers.get(
-          "x-copilotcloud-public-api-key",
-        );
-        return publicApiKeyFromHeaders || null;
-      };
-
-      // Should work for cloud requests
-      const cloudKey = extractPublicApiKey(mockHeaders, true);
-      expect(cloudKey).toBe("test-key-123");
-
-      // Should also work for non-cloud requests (this was the bug)
-      const nonCloudKey = extractPublicApiKey(mockHeaders, false);
-      expect(nonCloudKey).toBe("test-key-123");
-
-      // Both should enable error handling when onError is present
-      const onError = vi.fn();
-      expect(shouldHandleError(onError, cloudKey)).toBe(true);
-      expect(shouldHandleError(onError, nonCloudKey)).toBe(true);
-    });
-  });
-});

package/src/lib/runtime/__tests__/handle-service-adapter.test.ts

@@ -1,108 +0,0 @@
-import type { LanguageModel } from "ai";
-import { CopilotKitMisuseError } from "@copilotkit/shared";
-import { describe, expect, it } from "vitest";
-import { BuiltInAgent } from "../../../agent";
-import type { CopilotServiceAdapter } from "../../../service-adapters";
-import { CopilotRuntime } from "../copilot-runtime";
-
-function makeAdapter(
-  overrides?: Partial<CopilotServiceAdapter>,
-): CopilotServiceAdapter {
-  return {
-    name: "TestAdapter",
-    async process() {
-      throw new Error("process() is not expected to be called in these tests");
-    },
-    ...overrides,
-  };
-}
-
-async function getDefaultAgent(runtime: CopilotRuntime) {
-  const agents = await runtime.instance.agents;
-  return agents.default;
-}
-
-// `BuiltInAgent.config` is private; reading it is the only way to verify the
-// correct model was passed through without running the entire agent pipeline.
-// This narrow accessor is the Rule 2 exception, documented here once rather
-// than inline at each call site.
-function getBuiltInAgentModel(agent: BuiltInAgent): unknown {
-  return (agent as unknown as { config: { model: unknown } }).config.model;
-}
-
-describe("CopilotRuntime#handleServiceAdapter (#3217)", () => {
-  it("uses the adapter's pre-configured LanguageModel when getLanguageModel() returns one", async () => {
-    const fakeLanguageModel = {
-      specificationVersion: "v1",
-    } as unknown as LanguageModel;
-    const runtime = new CopilotRuntime();
-
-    runtime.handleServiceAdapter(
-      makeAdapter({
-        name: "OpenAIAdapter",
-        provider: "openai",
-        model: "gpt-4o",
-        getLanguageModel: () => fakeLanguageModel,
-      }),
-    );
-
-    const agent = await getDefaultAgent(runtime);
-    expect(agent).toBeInstanceOf(BuiltInAgent);
-    expect(getBuiltInAgentModel(agent as BuiltInAgent)).toBe(fakeLanguageModel);
-  });
-
-  it("builds a 'provider/model' string when only provider+model are exposed", async () => {
-    const runtime = new CopilotRuntime();
-
-    runtime.handleServiceAdapter(
-      makeAdapter({
-        name: "GroqAdapter",
-        provider: "groq",
-        model: "llama-3.3-70b-versatile",
-      }),
-    );
-
-    const agent = await getDefaultAgent(runtime);
-    expect(agent).toBeInstanceOf(BuiltInAgent);
-    expect(getBuiltInAgentModel(agent as BuiltInAgent)).toBe(
-      "groq/llama-3.3-70b-versatile",
-    );
-  });
-
-  it("throws CopilotKitMisuseError when no model source is available (LangChainAdapter regression)", async () => {
-    const runtime = new CopilotRuntime();
-
-    runtime.handleServiceAdapter(makeAdapter({ name: "LangChainAdapter" }));
-
-    await expect(runtime.instance.agents).rejects.toBeInstanceOf(
-      CopilotKitMisuseError,
-    );
-    await expect(runtime.instance.agents).rejects.toThrow(
-      /Service adapter "LangChainAdapter" does not provide model information/,
-    );
-  });
-
-  it("falls back to 'unknown' in the thrown error when the adapter has no name", async () => {
-    const runtime = new CopilotRuntime();
-
-    runtime.handleServiceAdapter(makeAdapter({ name: undefined }));
-
-    await expect(runtime.instance.agents).rejects.toThrow(
-      /Service adapter "unknown" does not provide model information/,
-    );
-  });
-
-  it("does not throw when provider is set without a model — but must not emit 'undefined/undefined'", async () => {
-    // Guards the specific #3217 regression: when only one half of the pair is
-    // present, we must NOT synthesize a bogus "provider/undefined" string.
-    const runtime = new CopilotRuntime();
-
-    runtime.handleServiceAdapter(
-      makeAdapter({ name: "PartialAdapter", provider: "openai" }),
-    );
-
-    await expect(runtime.instance.agents).rejects.toThrow(
-      CopilotKitMisuseError,
-    );
-  });
-});