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

package/src/v2/runtime/__tests__/sse-response-telemetry.test.ts

@@ -1,108 +0,0 @@
-/**
- * Telemetry lifecycle tests for `packages/runtime/src/v2/runtime/handlers/shared/sse-response.ts`.
- *
- * sse-response.ts fires three events across the SSE stream lifecycle:
- *   - oss.runtime.agent_execution_stream_started  (line 73, right after observableFactory resolves)
- *   - oss.runtime.agent_execution_stream_errored  (inside subscribe's error handler)
- *   - oss.runtime.agent_execution_stream_ended    (inside subscribe's complete handler)
- *
- * Paired with intelligence-run-telemetry.test.ts which covers the
- * intelligence/run path of the same event names — kept separate so a
- * regression in one source file fails only its own test.
- */
-import { BaseEvent } from "@ag-ui/client";
-import { Observable } from "rxjs";
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-import { createSseEventResponse } from "../handlers/shared/sse-response";
-import { telemetry } from "../telemetry";
-
-function makeRequest(): Request {
-  return new Request("https://example.com/agent/test/run", { method: "POST" });
-}
-
-describe("sse-response.ts — telemetry lifecycle", () => {
-  let captureSpy: ReturnType<typeof vi.spyOn>;
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    captureSpy = vi.spyOn(telemetry, "capture").mockResolvedValue(undefined);
-    // Swallow the console.error from SSE logError on simulated failures.
-    errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
-  });
-
-  afterEach(() => {
-    captureSpy.mockRestore();
-    errorSpy.mockRestore();
-  });
-
-  it("fires agent_execution_stream_started once the observable factory resolves", async () => {
-    // Observable that never completes — only started should fire.
-    const never = new Observable<BaseEvent>(() => {});
-    createSseEventResponse({
-      request: makeRequest(),
-      observableFactory: () => never,
-    });
-
-    await vi.waitFor(() => {
-      expect(captureSpy).toHaveBeenCalledWith(
-        "oss.runtime.agent_execution_stream_started",
-        {},
-      );
-    });
-
-    expect(captureSpy).not.toHaveBeenCalledWith(
-      "oss.runtime.agent_execution_stream_errored",
-      expect.anything(),
-    );
-    expect(captureSpy).not.toHaveBeenCalledWith(
-      "oss.runtime.agent_execution_stream_ended",
-      expect.anything(),
-    );
-  });
-
-  it("fires agent_execution_stream_ended when the observable completes", async () => {
-    const completing = new Observable<BaseEvent>((subscriber) => {
-      subscriber.complete();
-    });
-    createSseEventResponse({
-      request: makeRequest(),
-      observableFactory: () => completing,
-    });
-
-    await vi.waitFor(() => {
-      expect(captureSpy).toHaveBeenCalledWith(
-        "oss.runtime.agent_execution_stream_ended",
-        {},
-      );
-    });
-
-    // started should also have fired before ended
-    expect(captureSpy).toHaveBeenCalledWith(
-      "oss.runtime.agent_execution_stream_started",
-      {},
-    );
-  });
-
-  it("fires agent_execution_stream_errored with the error message when the observable errors", async () => {
-    const failing = new Observable<BaseEvent>((subscriber) => {
-      subscriber.error(new Error("stream blew up"));
-    });
-    createSseEventResponse({
-      request: makeRequest(),
-      observableFactory: () => failing,
-    });
-
-    await vi.waitFor(() => {
-      expect(captureSpy).toHaveBeenCalledWith(
-        "oss.runtime.agent_execution_stream_errored",
-        expect.objectContaining({ error: "stream blew up" }),
-      );
-    });
-
-    expect(captureSpy).toHaveBeenCalledWith(
-      "oss.runtime.agent_execution_stream_started",
-      {},
-    );
-  });
-});

package/src/v2/runtime/__tests__/telemetry.test.ts

@@ -1,167 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { TelemetryClient } from "../telemetry/telemetry-client";
-import scarfClient from "../telemetry/scarf-client";
-
-describe("TelemetryClient", () => {
-  let scarfSpy: ReturnType<typeof vi.spyOn>;
-
-  beforeEach(() => {
-    scarfSpy = vi.spyOn(scarfClient, "logEvent").mockResolvedValue(undefined);
-  });
-
-  afterEach(() => {
-    scarfSpy.mockRestore();
-  });
-
-  it("sends event to scarf when sampled in", async () => {
-    vi.spyOn(Math, "random").mockReturnValue(0);
-    const client = new TelemetryClient({
-      telemetryDisabled: false,
-      sampleRate: 1,
-    });
-
-    await client.capture("oss.runtime.instance_created", {
-      actionsAmount: 0,
-      endpointTypes: [],
-      endpointsAmount: 0,
-      "cloud.api_key_provided": false,
-    });
-
-    expect(scarfSpy).toHaveBeenCalledWith({
-      event: "oss.runtime.instance_created",
-    });
-  });
-
-  it("only sends event name to scarf, not properties", async () => {
-    const client = new TelemetryClient({
-      telemetryDisabled: false,
-      sampleRate: 1,
-    });
-
-    await client.capture("oss.runtime.copilot_request_created", {
-      "cloud.guardrails.enabled": true,
-      requestType: "run",
-      "cloud.api_key_provided": true,
-      "cloud.public_api_key": "pk_test_123",
-    });
-
-    expect(scarfSpy).toHaveBeenCalledWith({
-      event: "oss.runtime.copilot_request_created",
-    });
-    // Properties should NOT be forwarded to scarf
-    const callArg = scarfSpy.mock.calls[0][0];
-    expect(Object.keys(callArg)).toEqual(["event"]);
-  });
-
-  it("does not send events when telemetryDisabled is true", async () => {
-    const client = new TelemetryClient({
-      telemetryDisabled: true,
-      sampleRate: 1,
-    });
-
-    await client.capture("oss.runtime.instance_created", {
-      actionsAmount: 0,
-      endpointTypes: [],
-      endpointsAmount: 0,
-      "cloud.api_key_provided": false,
-    });
-
-    expect(scarfSpy).not.toHaveBeenCalled();
-  });
-
-  it("does not send events when sampled out", async () => {
-    vi.spyOn(Math, "random").mockReturnValue(0.99);
-    const client = new TelemetryClient({
-      telemetryDisabled: false,
-      sampleRate: 0.05,
-    });
-
-    await client.capture("oss.runtime.instance_created", {
-      actionsAmount: 0,
-      endpointTypes: [],
-      endpointsAmount: 0,
-      "cloud.api_key_provided": false,
-    });
-
-    expect(scarfSpy).not.toHaveBeenCalled();
-  });
-
-  it("respects sample rate boundary", async () => {
-    vi.spyOn(Math, "random").mockReturnValue(0.04);
-    const client = new TelemetryClient({
-      telemetryDisabled: false,
-      sampleRate: 0.05,
-    });
-
-    await client.capture("oss.runtime.agent_execution_stream_started", {});
-
-    expect(scarfSpy).toHaveBeenCalled();
-  });
-
-  it("throws when sample rate is out of range", () => {
-    expect(() => new TelemetryClient({ sampleRate: 1.5 })).toThrow(
-      "Sample rate must be between 0 and 1",
-    );
-    expect(() => new TelemetryClient({ sampleRate: -0.1 })).toThrow(
-      "Sample rate must be between 0 and 1",
-    );
-  });
-});
-
-describe("ScarfClient", () => {
-  let originalFetch: typeof fetch;
-  let fetchMock: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    originalFetch = global.fetch;
-    fetchMock = vi.fn().mockResolvedValue(new Response("", { status: 200 }));
-    global.fetch = fetchMock as unknown as typeof fetch;
-  });
-
-  afterEach(() => {
-    global.fetch = originalFetch;
-  });
-
-  it("sends GET request to scarf gateway with event as query param", async () => {
-    await scarfClient.logEvent({ event: "oss.runtime.instance_created" });
-
-    expect(fetchMock).toHaveBeenCalledTimes(1);
-    const [url, options] = fetchMock.mock.calls[0];
-    expect(url).toContain("https://copilotkit.gateway.scarf.sh/");
-    expect(url).toContain("event=oss.runtime.instance_created");
-    expect(options.method).toBe("GET");
-  });
-
-  it("silently fails on network error", async () => {
-    fetchMock.mockRejectedValue(new Error("Network error"));
-
-    // Should not throw
-    await expect(
-      scarfClient.logEvent({ event: "oss.runtime.instance_created" }),
-    ).resolves.toBeUndefined();
-  });
-
-  it("silently fails on non-ok response", async () => {
-    fetchMock.mockResolvedValue(new Response("", { status: 500 }));
-
-    // Should not throw
-    await expect(
-      scarfClient.logEvent({ event: "oss.runtime.instance_created" }),
-    ).resolves.toBeUndefined();
-  });
-
-  it("skips null and undefined values in query params", async () => {
-    await scarfClient.logEvent({
-      event: "oss.runtime.instance_created",
-      nullVal: null,
-      undefinedVal: undefined,
-      validVal: "test",
-    });
-
-    const url = fetchMock.mock.calls[0][0] as string;
-    expect(url).toContain("event=oss.runtime.instance_created");
-    expect(url).toContain("validVal=test");
-    expect(url).not.toContain("nullVal");
-    expect(url).not.toContain("undefinedVal");
-  });
-});

package/src/v2/runtime/__tests__/thread-names.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Message } from "@ag-ui/client";
-
-import {
-  ɵnormalizeGeneratedTitle as normalizeGeneratedTitle,
-  ɵbuildThreadTitlePrompt as buildThreadTitlePrompt,
-  ɵhasThreadName as hasThreadName,
-} from "../handlers/intelligence/thread-names";
-
-// ---------------------------------------------------------------------------
-// normalizeGeneratedTitle
-// ---------------------------------------------------------------------------
-
-describe("normalizeGeneratedTitle", () => {
-  it("extracts title from valid JSON response", () => {
-    expect(normalizeGeneratedTitle('{"title":"Budget Review"}')).toBe(
-      "Budget Review",
-    );
-  });
-
-  it("extracts title from JSON wrapped in code fences", () => {
-    expect(
-      normalizeGeneratedTitle('```json\n{"title":"Budget Review"}\n```'),
-    ).toBe("Budget Review");
-  });
-
-  it("strips surrounding quotes from plain text", () => {
-    expect(normalizeGeneratedTitle('"Budget Review"')).toBe("Budget Review");
-    expect(normalizeGeneratedTitle("'Budget Review'")).toBe("Budget Review");
-    expect(normalizeGeneratedTitle("`Budget Review`")).toBe("Budget Review");
-  });
-
-  it("strips markdown characters", () => {
-    expect(normalizeGeneratedTitle("**Budget** _Review_")).toBe(
-      "Budget Review",
-    );
-    expect(normalizeGeneratedTitle("# Budget Review")).toBe("Budget Review");
-    expect(normalizeGeneratedTitle("[Budget](Review)")).toBe("BudgetReview");
-  });
-
-  it("strips trailing punctuation", () => {
-    expect(normalizeGeneratedTitle("Budget Review.")).toBe("Budget Review");
-    expect(normalizeGeneratedTitle("Budget Review!")).toBe("Budget Review");
-    expect(normalizeGeneratedTitle("Budget Review?")).toBe("Budget Review");
-    expect(normalizeGeneratedTitle("Budget Review;")).toBe("Budget Review");
-  });
-
-  it("collapses whitespace", () => {
-    expect(normalizeGeneratedTitle("Budget   Review")).toBe("Budget Review");
-    expect(normalizeGeneratedTitle("  Budget  Review  ")).toBe("Budget Review");
-  });
-
-  it("returns null for empty or whitespace-only input", () => {
-    expect(normalizeGeneratedTitle("")).toBeNull();
-    expect(normalizeGeneratedTitle("   ")).toBeNull();
-  });
-
-  it("returns null when all content is stripped", () => {
-    expect(normalizeGeneratedTitle("***")).toBeNull();
-    expect(normalizeGeneratedTitle("[]()")).toBeNull();
-  });
-
-  it("truncates titles longer than 80 characters", () => {
-    const long = "A".repeat(100);
-    const result = normalizeGeneratedTitle(long);
-    expect(result).not.toBeNull();
-    expect(result!.length).toBeLessThanOrEqual(80);
-  });
-
-  it("returns null when title has more than 8 words", () => {
-    expect(
-      normalizeGeneratedTitle("one two three four five six seven eight nine"),
-    ).toBeNull();
-  });
-
-  it("accepts title with exactly 8 words", () => {
-    expect(
-      normalizeGeneratedTitle("one two three four five six seven eight"),
-    ).toBe("one two three four five six seven eight");
-  });
-
-  it("handles JSON with non-string title gracefully", () => {
-    // Falls back to raw text path
-    expect(normalizeGeneratedTitle('{"title":42}')).toBe('{"title":42}');
-  });
-
-  it("handles malformed JSON gracefully", () => {
-    expect(normalizeGeneratedTitle("{not json}")).toBe("{not json}");
-  });
-});
-
-// ---------------------------------------------------------------------------
-// buildThreadTitlePrompt
-// ---------------------------------------------------------------------------
-
-describe("buildThreadTitlePrompt", () => {
-  const msg = (role: string, content: string): Message =>
-    ({ id: `msg-${role}`, role, content }) as Message;
-
-  it("returns null for empty messages", () => {
-    expect(buildThreadTitlePrompt([])).toBeNull();
-    expect(
-      buildThreadTitlePrompt(undefined as unknown as Message[]),
-    ).toBeNull();
-  });
-
-  it("builds a prompt from user and assistant messages", () => {
-    const messages = [
-      msg("user", "What is the weather?"),
-      msg("assistant", "It is sunny today."),
-    ];
-
-    const result = buildThreadTitlePrompt(messages);
-    expect(result).toContain("Generate a short title");
-    expect(result).toContain("user: What is the weather?");
-    expect(result).toContain("assistant: It is sunny today.");
-  });
-
-  it("filters out tool role messages", () => {
-    const messages = [
-      msg("user", "Search for cats"),
-      msg("tool", '{"results": []}'),
-      msg("assistant", "Found some cats."),
-    ];
-
-    const result = buildThreadTitlePrompt(messages);
-    expect(result).not.toContain("tool:");
-    expect(result).toContain("user: Search for cats");
-    expect(result).toContain("assistant: Found some cats.");
-  });
-
-  it("includes system and developer messages", () => {
-    const messages = [
-      msg("system", "You are helpful."),
-      msg("developer", "Be concise."),
-      msg("user", "Hello"),
-    ];
-
-    const result = buildThreadTitlePrompt(messages);
-    expect(result).toContain("system: You are helpful.");
-    expect(result).toContain("developer: Be concise.");
-  });
-
-  it("takes only the last 8 messages", () => {
-    const messages = Array.from({ length: 12 }, (_, i) =>
-      msg("user", `Message ${i}`),
-    );
-
-    const result = buildThreadTitlePrompt(messages)!;
-    // Should contain messages 4-11 (last 8) but not 0-3
-    expect(result).not.toContain("Message 3");
-    expect(result).toContain("Message 4");
-    expect(result).toContain("Message 11");
-  });
-
-  it("skips messages with empty content", () => {
-    const messages = [msg("user", ""), msg("assistant", "Hello")];
-
-    const result = buildThreadTitlePrompt(messages);
-    expect(result).not.toContain("user:");
-    expect(result).toContain("assistant: Hello");
-  });
-
-  it("returns null when all messages have empty content", () => {
-    const messages = [msg("user", ""), msg("assistant", "")];
-    expect(buildThreadTitlePrompt(messages)).toBeNull();
-  });
-});
-
-// ---------------------------------------------------------------------------
-// hasThreadName
-// ---------------------------------------------------------------------------
-
-describe("hasThreadName", () => {
-  it("returns true for non-empty strings", () => {
-    expect(hasThreadName("Budget Review")).toBe(true);
-  });
-
-  it("returns false for null and undefined", () => {
-    expect(hasThreadName(null)).toBe(false);
-    expect(hasThreadName(undefined)).toBe(false);
-  });
-
-  it("returns false for empty or whitespace-only strings", () => {
-    expect(hasThreadName("")).toBe(false);
-    expect(hasThreadName("   ")).toBe(false);
-  });
-});

package/src/v2/runtime/core/__tests__/debug-event-bus.test.ts

@@ -1,156 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { EventType } from "@ag-ui/client";
-import type { BaseEvent } from "@ag-ui/client";
-import type { DebugEventEnvelope } from "@copilotkit/shared";
-import { DebugEventBus } from "../debug-event-bus";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function createBaseEvent(
-  overrides: Partial<BaseEvent> & { type: EventType } = {
-    type: EventType.RUN_STARTED,
-  },
-): BaseEvent {
-  return { type: overrides.type, ...overrides };
-}
-
-const defaultMetadata = {
-  agentId: "test-agent",
-  threadId: "thread-1",
-  runId: "run-1",
-};
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe("DebugEventBus", () => {
-  it("subscribe adds a listener and broadcast calls it with the correct envelope shape", () => {
-    const bus = new DebugEventBus();
-    const listener = vi.fn<[DebugEventEnvelope], void>();
-    const event = createBaseEvent({ type: EventType.RUN_STARTED });
-
-    bus.subscribe(listener);
-    bus.broadcast(event, defaultMetadata);
-
-    expect(listener).toHaveBeenCalledOnce();
-    const envelope = listener.mock.calls[0][0];
-    expect(envelope).toEqual(
-      expect.objectContaining({
-        agentId: "test-agent",
-        threadId: "thread-1",
-        runId: "run-1",
-        event,
-      }),
-    );
-    expect(typeof envelope.timestamp).toBe("number");
-  });
-
-  it("unsubscribe removes the listener so subsequent broadcasts don't reach it", () => {
-    const bus = new DebugEventBus();
-    const listener = vi.fn<[DebugEventEnvelope], void>();
-    const event = createBaseEvent();
-
-    const unsub = bus.subscribe(listener);
-    unsub();
-    bus.broadcast(event, defaultMetadata);
-
-    expect(listener).not.toHaveBeenCalled();
-  });
-
-  it("multiple listeners all receive the same broadcast", () => {
-    const bus = new DebugEventBus();
-    const listenerA = vi.fn<[DebugEventEnvelope], void>();
-    const listenerB = vi.fn<[DebugEventEnvelope], void>();
-    const event = createBaseEvent();
-
-    bus.subscribe(listenerA);
-    bus.subscribe(listenerB);
-    bus.broadcast(event, defaultMetadata);
-
-    expect(listenerA).toHaveBeenCalledOnce();
-    expect(listenerB).toHaveBeenCalledOnce();
-    // Both receive the same envelope object
-    expect(listenerA.mock.calls[0][0]).toBe(listenerB.mock.calls[0][0]);
-  });
-
-  it("listener errors are swallowed and other listeners still receive the event", () => {
-    const bus = new DebugEventBus();
-    const failingListener = vi
-      .fn<[DebugEventEnvelope], void>()
-      .mockImplementation(() => {
-        throw new Error("boom");
-      });
-    const healthyListener = vi.fn<[DebugEventEnvelope], void>();
-    const event = createBaseEvent();
-
-    bus.subscribe(failingListener);
-    bus.subscribe(healthyListener);
-
-    // Should not throw
-    expect(() => bus.broadcast(event, defaultMetadata)).not.toThrow();
-    expect(failingListener).toHaveBeenCalledOnce();
-    expect(healthyListener).toHaveBeenCalledOnce();
-  });
-
-  it("broadcasting with no listeners does not throw", () => {
-    const bus = new DebugEventBus();
-    const event = createBaseEvent();
-
-    expect(() => bus.broadcast(event, defaultMetadata)).not.toThrow();
-  });
-
-  it("listenerCount reflects current count after subscribe and unsubscribe", () => {
-    const bus = new DebugEventBus();
-
-    expect(bus.listenerCount).toBe(0);
-
-    const unsub1 = bus.subscribe(vi.fn());
-    expect(bus.listenerCount).toBe(1);
-
-    const unsub2 = bus.subscribe(vi.fn());
-    expect(bus.listenerCount).toBe(2);
-
-    unsub1();
-    expect(bus.listenerCount).toBe(1);
-
-    unsub2();
-    expect(bus.listenerCount).toBe(0);
-  });
-
-  it("envelope has correct timestamp, agentId, threadId, runId, and the original event", () => {
-    const bus = new DebugEventBus();
-    const listener = vi.fn<[DebugEventEnvelope], void>();
-    const event = createBaseEvent({ type: EventType.STEP_STARTED });
-    const metadata = { agentId: "agent-x", threadId: "t-42", runId: "r-99" };
-
-    const before = Date.now();
-    bus.subscribe(listener);
-    bus.broadcast(event, metadata);
-    const after = Date.now();
-
-    const envelope = listener.mock.calls[0][0];
-    expect(envelope.agentId).toBe("agent-x");
-    expect(envelope.threadId).toBe("t-42");
-    expect(envelope.runId).toBe("r-99");
-    expect(envelope.event).toBe(event);
-    expect(envelope.timestamp).toBeGreaterThanOrEqual(before);
-    expect(envelope.timestamp).toBeLessThanOrEqual(after);
-  });
-
-  it("RUN_STARTED event type passthrough: envelope.event is the original object, not a copy", () => {
-    const bus = new DebugEventBus();
-    const listener = vi.fn<[DebugEventEnvelope], void>();
-    const event = createBaseEvent({ type: EventType.RUN_STARTED });
-
-    bus.subscribe(listener);
-    bus.broadcast(event, defaultMetadata);
-
-    const envelope = listener.mock.calls[0][0];
-    // Strict referential equality — the event is passed through, not cloned
-    expect(envelope.event).toBe(event);
-    expect(envelope.event.type).toBe(EventType.RUN_STARTED);
-  });
-});

package/src/v2/runtime/core/debug-event-bus.ts

@@ -1,45 +0,0 @@
-import { BaseEvent } from "@ag-ui/client";
-import { DebugEventEnvelope } from "@copilotkit/shared";
-
-export type DebugEventListener = (envelope: DebugEventEnvelope) => void;
-
-export class DebugEventBus {
-  private listeners = new Set<DebugEventListener>();
-
-  subscribe(listener: DebugEventListener): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  broadcast(
-    event: BaseEvent,
-    metadata: { agentId: string; threadId: string; runId: string },
-  ): void {
-    if (this.listeners.size === 0) return;
-
-    const envelope: DebugEventEnvelope = {
-      timestamp: Date.now(),
-      agentId: metadata.agentId,
-      threadId: metadata.threadId,
-      runId: metadata.runId,
-      event,
-    };
-
-    for (const listener of this.listeners) {
-      try {
-        listener(envelope);
-      } catch (err) {
-        console.warn(
-          "[DebugEventBus] Listener error suppressed:",
-          err instanceof Error ? err.message : err,
-        );
-      }
-    }
-  }
-
-  get listenerCount(): number {
-    return this.listeners.size;
-  }
-}