@copilotkit/runtime 1.56.2 → 1.56.4

package/src/v2/runtime/runner/__tests__/intelligence-runner.test.ts

@@ -286,6 +286,49 @@ describe("IntelligenceAgentRunner", () => {
       expect(ch.pushLog[2].payload.metadata.cpki_event_seq).toBe(3);
     });
 
+    it("overrides conflicting event thread and run ownership before pushing to the channel", async () => {
+      const threadId = "t-canonical";
+      const input = createRunInput({ threadId, runId: "r-canonical" });
+
+      const agent = new MockAgent([
+        {
+          type: EventType.RUN_STARTED,
+          threadId: "backend-thread",
+          runId: "backend-run",
+        } as RunStartedEvent,
+        {
+          type: EventType.RUN_FINISHED,
+          threadId: "backend-thread",
+          runId: "backend-run",
+        } as RunFinishedEvent,
+      ]);
+
+      const eventsPromise = collectEvents(
+        runner.run({ threadId, agent, input }),
+      );
+      const ch = mockChannels[0];
+      ch.triggerJoin("ok");
+
+      await eventsPromise;
+
+      expect(ch.pushLog.map((entry) => entry.payload)).toEqual([
+        expect.objectContaining({
+          type: EventType.RUN_STARTED,
+          threadId,
+          runId: input.runId,
+          thread_id: threadId,
+          run_id: input.runId,
+        }),
+        expect.objectContaining({
+          type: EventType.RUN_FINISHED,
+          threadId,
+          runId: input.runId,
+          thread_id: threadId,
+          run_id: input.runId,
+        }),
+      ]);
+    });
+
     it("rewrites RUN_STARTED input.messages to the unseen persisted subset", async () => {
       const threadId = "t-persisted-input";
       const input = createRunInput({
@@ -442,7 +485,14 @@ describe("IntelligenceAgentRunner", () => {
         (p) => p.payload?.type === EventType.RUN_ERROR,
       );
       expect(errorPush).toBeDefined();
-      expect(errorPush!.payload.message).toBe("Something went wrong");
+      expect(errorPush!.payload).toMatchObject({
+        type: EventType.RUN_ERROR,
+        message: "Something went wrong",
+        threadId,
+        runId: input.runId,
+        thread_id: threadId,
+        run_id: input.runId,
+      });
     });
 
     it("finalizes open message streams before completing", async () => {
@@ -569,10 +619,9 @@ describe("IntelligenceAgentRunner", () => {
     });
   });
 
-  describe("run with joinCode", () => {
-    it("uses joinCode for the channel topic when provided", async () => {
+  describe("run channel ownership", () => {
+    it("uses runId for the ingestion channel topic", async () => {
       const threadId = "t-jc";
-      const joinCode = "join-abc-123";
       const input = createRunInput({ threadId, runId: "r-jc" });
       const agent = new MockAgent([
         {
@@ -583,15 +632,16 @@ describe("IntelligenceAgentRunner", () => {
       ]);
 
       const eventsPromise = collectEvents(
-        runner.run({ threadId, agent, input, joinCode }),
+        runner.run({ threadId, agent, input }),
       );
       const ch = mockChannels[0];
-      expect(ch.topic).toBe(`ingestion:${joinCode}`);
+      expect(ch.topic).toBe("ingestion:r-jc");
+      expect(ch.params).toEqual({ thread_id: threadId, run_id: "r-jc" });
       ch.triggerJoin("ok");
       await eventsPromise;
     });
 
-    it("falls back to threadId when joinCode is not provided", async () => {
+    it("keeps pushed event payload ownership on canonical threadId and runId", async () => {
       const threadId = "t-no-jc";
       const input = createRunInput({ threadId, runId: "r-no-jc" });
       const agent = new MockAgent([
@@ -606,9 +656,17 @@ describe("IntelligenceAgentRunner", () => {
         runner.run({ threadId, agent, input }),
       );
       const ch = mockChannels[0];
-      expect(ch.topic).toBe(`ingestion:${threadId}`);
       ch.triggerJoin("ok");
       await eventsPromise;
+
+      expect(ch.pushLog[0].payload).toEqual(
+        expect.objectContaining({
+          threadId,
+          runId: "r-no-jc",
+          thread_id: threadId,
+          run_id: "r-no-jc",
+        }),
+      );
     });
   });
 

package/src/v2/runtime/runner/agent-runner.ts

@@ -10,7 +10,6 @@ export interface AgentRunnerRunRequest {
   threadId: string;
   agent: AbstractAgent;
   input: RunAgentInput;
-  joinCode?: string;
   persistedInputMessages?: Message[];
 }
 

package/src/v2/runtime/runner/intelligence.ts

@@ -32,6 +32,11 @@ export interface IntelligenceAgentRunnerOptions {
   maxRejoinMs?: number;
 }
 
+export interface RunnerStartupBoundary {
+  events: Observable<BaseEvent>;
+  startup: Promise<void>;
+}
+
 interface ThreadState {
   socket: Socket;
   channel: Channel;
@@ -95,22 +100,33 @@ export class IntelligenceAgentRunner extends AgentRunner {
     request: AgentRunnerRunRequest,
     state: ThreadState,
   ): Record<string, unknown> {
-    const canonicalEvent = this.stampRunnerMetadata(event, state);
+    const canonicalEvent = this.stampRunnerMetadata(
+      this.stampCanonicalRunOwnership(event, request),
+      state,
+    );
     const payload = {
       ...(canonicalEvent as Record<string, unknown>),
     };
 
-    payload.thread_id ??= request.threadId;
-
-    const runId = payload.runId ?? payload.run_id ?? request.input.runId;
-
-    if (runId) {
-      payload.run_id = runId;
-    }
+    payload.threadId = request.threadId;
+    payload.runId = request.input.runId;
+    payload.thread_id = request.threadId;
+    payload.run_id = request.input.runId;
 
     return payload;
   }
 
+  private stampCanonicalRunOwnership(
+    event: BaseEvent,
+    request: AgentRunnerRunRequest,
+  ): BaseEvent {
+    return {
+      ...(event as BaseEvent & Record<string, unknown>),
+      threadId: request.threadId,
+      runId: request.input.runId,
+    } as BaseEvent;
+  }
+
   private stampRunnerMetadata(event: BaseEvent, state: ThreadState): BaseEvent {
     const eventRecord = event as BaseEvent & {
       metadata?: Record<string, unknown>;
@@ -142,7 +158,36 @@ export class IntelligenceAgentRunner extends AgentRunner {
   }
 
   run(request: AgentRunnerRunRequest): Observable<BaseEvent> {
-    const { threadId, agent, input, joinCode } = request;
+    return this.createRunObservable(request);
+  }
+
+  runWithStartupBoundary(
+    request: AgentRunnerRunRequest,
+  ): RunnerStartupBoundary {
+    let resolveStartup: (() => void) | undefined;
+    let rejectStartup: ((reason: Error) => void) | undefined;
+    const startup = new Promise<void>((resolve, reject) => {
+      resolveStartup = resolve;
+      rejectStartup = reject;
+    });
+
+    return {
+      events: this.createRunObservable(request, {
+        resolveStartup: () => resolveStartup?.(),
+        rejectStartup: (error) => rejectStartup?.(error),
+      }),
+      startup,
+    };
+  }
+
+  private createRunObservable(
+    request: AgentRunnerRunRequest,
+    startupBoundary?: {
+      resolveStartup: () => void;
+      rejectStartup: (error: Error) => void;
+    },
+  ): Observable<BaseEvent> {
+    const { threadId, agent, input } = request;
 
     const existing = this.threads.get(threadId);
     if (existing?.isRunning) {
@@ -152,9 +197,9 @@ export class IntelligenceAgentRunner extends AgentRunner {
     return new Observable((observer) => {
       const socket = this.createSocket();
 
-      const channelTopic = joinCode ?? threadId;
-      const channel = socket.channel(`ingestion:${channelTopic}`, {
-        runId: input.runId,
+      const channel = socket.channel(`ingestion:${input.runId}`, {
+        thread_id: threadId,
+        run_id: input.runId,
       });
 
       const state: ThreadState = {
@@ -218,30 +263,37 @@ export class IntelligenceAgentRunner extends AgentRunner {
       channel
         .join()
         .receive("ok", () => {
+          startupBoundary?.resolveStartup();
           this.executeAgentRun(request, state, threadId).subscribe({
             complete: () => observer.complete(),
           });
         })
         .receive("error", (resp) => {
+          const error = new Error(
+            `Failed to join channel: ${JSON.stringify(resp)}`,
+          );
           const errorEvent = {
             type: EventType.RUN_ERROR,
-            message: `Failed to join channel: ${JSON.stringify(resp)}`,
+            message: error.message,
             code: "CHANNEL_JOIN_ERROR",
           } as BaseEvent;
           observer.next(errorEvent);
           state.currentEvents.push(errorEvent);
           this.removeThread(threadId);
+          startupBoundary?.rejectStartup(error);
           observer.complete();
         })
         .receive("timeout", () => {
+          const error = new Error("Timed out joining channel");
           const errorEvent = {
             type: EventType.RUN_ERROR,
-            message: "Timed out joining channel",
+            message: error.message,
             code: "CHANNEL_JOIN_TIMEOUT",
           } as BaseEvent;
           observer.next(errorEvent);
           state.currentEvents.push(errorEvent);
           this.removeThread(threadId);
+          startupBoundary?.rejectStartup(error);
           observer.complete();
         });
 
@@ -327,7 +379,10 @@ export class IntelligenceAgentRunner extends AgentRunner {
   ): Observable<void> {
     const { currentEvents, channel } = state;
     const pushCanonicalEvent = (event: BaseEvent): void => {
-      const canonicalEvent = this.stampRunnerMetadata(event, state);
+      const canonicalEvent = this.stampRunnerMetadata(
+        this.stampCanonicalRunOwnership(event, request),
+        state,
+      );
       currentEvents.push(canonicalEvent);
 
       if (canonicalEvent.type === EventType.RUN_STARTED) {
@@ -355,8 +410,12 @@ export class IntelligenceAgentRunner extends AgentRunner {
           threadId: request.threadId,
           runId: request.input.runId,
         }),
+        threadId: request.threadId,
+        runId: request.input.runId,
         input: {
           ...baseInput,
+          threadId: request.threadId,
+          runId: request.input.runId,
           ...(persistedInputMessages !== undefined
             ? { messages: persistedInputMessages }
             : {}),

package/src/v2/runtime/telemetry/__tests__/instance-created.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { telemetry } from "..";
+import { fireInstanceCreatedTelemetry } from "../instance-created";
+import type { CopilotRuntimeLike } from "../../core/runtime";
+
+// Minimal runtime stub: we only use `agents` from CopilotRuntimeLike inside
+// the helper, so we cast the stub rather than construct a full runtime.
+function makeRuntime(
+  agents:
+    | Record<string, unknown>
+    | Promise<Record<string, unknown>>
+    | ((ctx: { request: Request }) => Record<string, unknown>),
+): CopilotRuntimeLike {
+  return { agents } as unknown as CopilotRuntimeLike;
+}
+
+describe("fireInstanceCreatedTelemetry", () => {
+  let captureSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    captureSpy = vi.spyOn(telemetry, "capture").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    captureSpy.mockRestore();
+  });
+
+  it("captures instance_created with agent count from static agents record", async () => {
+    fireInstanceCreatedTelemetry({
+      runtime: makeRuntime({ a1: {}, a2: {}, a3: {} }),
+    });
+
+    await vi.waitFor(() => expect(captureSpy).toHaveBeenCalled());
+
+    expect(captureSpy).toHaveBeenCalledWith("oss.runtime.instance_created", {
+      actionsAmount: 0,
+      endpointTypes: [],
+      endpointsAmount: 0,
+      agentsAmount: 3,
+      "cloud.api_key_provided": false,
+    });
+  });
+
+  it("awaits Promise-based agents before capturing", async () => {
+    fireInstanceCreatedTelemetry({
+      runtime: makeRuntime(Promise.resolve({ only: {} })),
+    });
+
+    await vi.waitFor(() => expect(captureSpy).toHaveBeenCalled());
+
+    const call = captureSpy.mock.calls[0][1] as { agentsAmount: number | null };
+    expect(call.agentsAmount).toBe(1);
+  });
+
+  it("reports agentsAmount: null when agents is a factory (cannot resolve without request)", async () => {
+    fireInstanceCreatedTelemetry({
+      runtime: makeRuntime(() => ({ x: {} })),
+    });
+
+    await vi.waitFor(() => expect(captureSpy).toHaveBeenCalled());
+
+    const call = captureSpy.mock.calls[0][1] as { agentsAmount: number | null };
+    expect(call.agentsAmount).toBeNull();
+  });
+
+  it("does not hardcode cloud.api_key_provided — it is false at handler-creation time by design (key arrives per-request via header)", async () => {
+    fireInstanceCreatedTelemetry({
+      runtime: makeRuntime({ a1: {} }),
+    });
+
+    await vi.waitFor(() => expect(captureSpy).toHaveBeenCalled());
+
+    const call = captureSpy.mock.calls[0][1] as {
+      "cloud.api_key_provided": boolean;
+    };
+    expect(call["cloud.api_key_provided"]).toBe(false);
+  });
+
+  it("does not throw or reject when agents Promise rejects", async () => {
+    // Swallow the unhandled rejection from the input Promise itself — the
+    // Promise we pass in rejects synchronously regardless of whether we
+    // attach a .catch downstream.
+    const rejectingAgents = Promise.reject(new Error("boom"));
+    rejectingAgents.catch(() => {});
+
+    expect(() =>
+      fireInstanceCreatedTelemetry({
+        runtime: makeRuntime(rejectingAgents as any),
+      }),
+    ).not.toThrow();
+
+    // Wait a microtask to let the internal catch fire; no capture should happen.
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    expect(captureSpy).not.toHaveBeenCalled();
+  });
+});

package/src/v2/runtime/telemetry/instance-created.ts

@@ -0,0 +1,44 @@
+import { telemetry } from ".";
+import type { CopilotRuntimeLike } from "../core/runtime";
+
+/**
+ * Fire the `oss.runtime.instance_created` telemetry event for a v2 runtime
+ * handler. Called once per handler factory invocation (not per request).
+ *
+ * v2 does not have a concept of remote endpoints or standalone actions, so
+ * those counts are 0 / []. `cloud.api_key_provided` is false at this level
+ * because in v2 the cloud public key arrives per-request via the
+ * `x-copilotcloud-public-api-key` header — not at handler creation time.
+ * See `handlers/handle-run.ts` for the per-request event that DOES carry
+ * the key when present.
+ *
+ * Errors resolving agents are swallowed — telemetry must never break
+ * runtime setup.
+ */
+export function fireInstanceCreatedTelemetry({
+  runtime,
+}: {
+  runtime: CopilotRuntimeLike;
+}): void {
+  // agents can be a static Record, a Promise, or a per-request factory.
+  // Factory configs cannot be resolved at handler-creation time (no Request
+  // context), so report agentsAmount as null in that case.
+  const agentsPromise =
+    typeof runtime.agents === "function"
+      ? Promise.resolve<Record<string, unknown> | null>(null)
+      : Promise.resolve(runtime.agents);
+
+  agentsPromise
+    .then((agents) => {
+      telemetry.capture("oss.runtime.instance_created", {
+        actionsAmount: 0,
+        endpointTypes: [],
+        endpointsAmount: 0,
+        agentsAmount: agents ? Object.keys(agents).length : null,
+        "cloud.api_key_provided": false,
+      });
+    })
+    .catch(() => {
+      // Swallow — telemetry must not break runtime creation.
+    });
+}

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

@@ -1,7 +1,4 @@
-import { Analytics } from "@segment/analytics-node";
 import { AnalyticsEvents } from "./events";
-import { flattenObject } from "./utils";
-import { v4 as uuidv4 } from "uuid";
 import scarfClient from "./scarf-client";
 
 export function isTelemetryDisabled(): boolean {
@@ -17,11 +14,8 @@ export function isTelemetryDisabled(): boolean {
 }
 
 export class TelemetryClient {
-  segment: Analytics | undefined;
-  globalProperties: Record<string, any> = {};
   private telemetryDisabled: boolean = false;
   private sampleRate: number = 0.05;
-  private anonymousId = `anon_${uuidv4()}`;
 
   constructor({
     telemetryDisabled,
@@ -31,21 +25,7 @@ export class TelemetryClient {
     sampleRate?: number;
   } = {}) {
     this.telemetryDisabled = telemetryDisabled ?? isTelemetryDisabled();
-
-    if (this.telemetryDisabled) {
-      this.setSampleRate(sampleRate);
-      return;
-    }
-
     this.setSampleRate(sampleRate);
-
-    const writeKey =
-      process.env.COPILOTKIT_SEGMENT_WRITE_KEY ||
-      "n7XAZtQCGS2v1vvBy3LgBCv2h3Y8whja";
-
-    this.segment = new Analytics({
-      writeKey,
-    });
   }
 
   private shouldSendEvent() {
@@ -58,48 +38,17 @@ export class TelemetryClient {
 
   async capture<K extends keyof AnalyticsEvents>(
     event: K,
-    properties: AnalyticsEvents[K],
+    _properties: AnalyticsEvents[K],
   ) {
     if (!this.shouldSendEvent()) {
       return;
     }
 
-    const flattenedProperties = flattenObject(properties);
-    const propertiesWithGlobal = {
-      ...this.globalProperties,
-      ...flattenedProperties,
-    };
-    const orderedPropertiesWithGlobal = Object.keys(propertiesWithGlobal)
-      .sort()
-      .reduce(
-        (obj, key) => {
-          obj[key] = propertiesWithGlobal[key];
-          return obj;
-        },
-        {} as Record<string, any>,
-      );
-
-    if (this.segment) {
-      this.segment.track({
-        anonymousId: this.anonymousId,
-        event,
-        properties: { ...orderedPropertiesWithGlobal },
-      });
-    }
-
     await scarfClient.logEvent({
       event,
     });
   }
 
-  setGlobalProperties(properties: Record<string, any>) {
-    const flattenedProperties = flattenObject(properties);
-    this.globalProperties = {
-      ...this.globalProperties,
-      ...flattenedProperties,
-    };
-  }
-
   private setSampleRate(sampleRate: number | undefined) {
     let _sampleRate: number;
 
@@ -114,11 +63,6 @@ export class TelemetryClient {
     }
 
     this.sampleRate = _sampleRate;
-    this.setGlobalProperties({
-      sampleRate: this.sampleRate,
-      sampleRateAdjustmentFactor: 1 - this.sampleRate,
-      sampleWeight: 1 / this.sampleRate,
-    });
   }
 }
 

package/dist/v2/runtime/intelligence-platform/index.d.mts

@@ -1,2 +0,0 @@
-import "reflect-metadata";
-import { CopilotKitIntelligence, CopilotKitIntelligenceConfig, CreateThreadRequest, ListThreadsResponse, SubscribeToThreadsRequest, SubscribeToThreadsResponse, ThreadSummary, UpdateThreadRequest } from "./client.mjs";

package/dist/v2/runtime/telemetry/utils.cjs

@@ -1,15 +0,0 @@
-require("reflect-metadata");
-
-//#region src/v2/runtime/telemetry/utils.ts
-function flattenObject(obj, parentKey = "", res = {}) {
-	for (const key in obj) {
-		const propName = parentKey ? `${parentKey}.${key}` : key;
-		if (typeof obj[key] === "object" && obj[key] !== null) flattenObject(obj[key], propName, res);
-		else res[propName] = obj[key];
-	}
-	return res;
-}
-
-//#endregion
-exports.flattenObject = flattenObject;
-//# sourceMappingURL=utils.cjs.map

package/dist/v2/runtime/telemetry/utils.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.cjs","names":[],"sources":["../../../../src/v2/runtime/telemetry/utils.ts"],"sourcesContent":["export function flattenObject(\n  obj: Record<string, any>,\n  parentKey = \"\",\n  res: Record<string, any> = {},\n): Record<string, any> {\n  for (const key in obj) {\n    const propName = parentKey ? `${parentKey}.${key}` : key;\n    if (typeof obj[key] === \"object\" && obj[key] !== null) {\n      flattenObject(obj[key], propName, res);\n    } else {\n      res[propName] = obj[key];\n    }\n  }\n  return res;\n}\n"],"mappings":";;;AAAA,SAAgB,cACd,KACA,YAAY,IACZ,MAA2B,EAAE,EACR;AACrB,MAAK,MAAM,OAAO,KAAK;EACrB,MAAM,WAAW,YAAY,GAAG,UAAU,GAAG,QAAQ;AACrD,MAAI,OAAO,IAAI,SAAS,YAAY,IAAI,SAAS,KAC/C,eAAc,IAAI,MAAM,UAAU,IAAI;MAEtC,KAAI,YAAY,IAAI;;AAGxB,QAAO"}

package/dist/v2/runtime/telemetry/utils.mjs

@@ -1,14 +0,0 @@
-import "reflect-metadata";
-//#region src/v2/runtime/telemetry/utils.ts
-function flattenObject(obj, parentKey = "", res = {}) {
-	for (const key in obj) {
-		const propName = parentKey ? `${parentKey}.${key}` : key;
-		if (typeof obj[key] === "object" && obj[key] !== null) flattenObject(obj[key], propName, res);
-		else res[propName] = obj[key];
-	}
-	return res;
-}
-
-//#endregion
-export { flattenObject };
-//# sourceMappingURL=utils.mjs.map

package/dist/v2/runtime/telemetry/utils.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.mjs","names":[],"sources":["../../../../src/v2/runtime/telemetry/utils.ts"],"sourcesContent":["export function flattenObject(\n  obj: Record<string, any>,\n  parentKey = \"\",\n  res: Record<string, any> = {},\n): Record<string, any> {\n  for (const key in obj) {\n    const propName = parentKey ? `${parentKey}.${key}` : key;\n    if (typeof obj[key] === \"object\" && obj[key] !== null) {\n      flattenObject(obj[key], propName, res);\n    } else {\n      res[propName] = obj[key];\n    }\n  }\n  return res;\n}\n"],"mappings":";;AAAA,SAAgB,cACd,KACA,YAAY,IACZ,MAA2B,EAAE,EACR;AACrB,MAAK,MAAM,OAAO,KAAK;EACrB,MAAM,WAAW,YAAY,GAAG,UAAU,GAAG,QAAQ;AACrD,MAAI,OAAO,IAAI,SAAS,YAAY,IAAI,SAAS,KAC/C,eAAc,IAAI,MAAM,UAAU,IAAI;MAEtC,KAAI,YAAY,IAAI;;AAGxB,QAAO"}

package/src/v2/runtime/telemetry/utils.ts

@@ -1,15 +0,0 @@
-export function flattenObject(
-  obj: Record<string, any>,
-  parentKey = "",
-  res: Record<string, any> = {},
-): Record<string, any> {
-  for (const key in obj) {
-    const propName = parentKey ? `${parentKey}.${key}` : key;
-    if (typeof obj[key] === "object" && obj[key] !== null) {
-      flattenObject(obj[key], propName, res);
-    } else {
-      res[propName] = obj[key];
-    }
-  }
-  return res;
-}