@copilotkit/runtime 1.57.1-canary.1778272612 → 1.57.2

package/src/lib/__tests__/telemetry-disclosure.test.ts

@@ -0,0 +1,55 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  it,
+  vi,
+  type MockInstance,
+} from "vitest";
+
+import {
+  _resetRuntimeTelemetryDisclosureForTesting,
+  logRuntimeTelemetryDisclosure,
+} from "../telemetry-disclosure";
+
+let consoleInfoSpy: MockInstance<typeof console.info>;
+const originalEnv = { ...process.env };
+
+beforeEach(() => {
+  _resetRuntimeTelemetryDisclosureForTesting();
+  consoleInfoSpy = vi.spyOn(console, "info").mockImplementation(() => {});
+  // Clear opt-out env vars so the disclosure can fire by default.
+  delete process.env.COPILOTKIT_TELEMETRY_DISABLED;
+  delete process.env.DO_NOT_TRACK;
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  process.env = { ...originalEnv };
+});
+
+describe("logRuntimeTelemetryDisclosure", () => {
+  it("logs once per process", () => {
+    logRuntimeTelemetryDisclosure();
+    logRuntimeTelemetryDisclosure();
+    logRuntimeTelemetryDisclosure();
+
+    expect(consoleInfoSpy).toHaveBeenCalledTimes(1);
+    const [message] = consoleInfoSpy.mock.calls[0]!;
+    expect(message).toMatch(/anonymous telemetry/i);
+    expect(message).toMatch(/COPILOTKIT_TELEMETRY_DISABLED/);
+  });
+
+  it("does not log when COPILOTKIT_TELEMETRY_DISABLED is set", () => {
+    process.env.COPILOTKIT_TELEMETRY_DISABLED = "true";
+    logRuntimeTelemetryDisclosure();
+    expect(consoleInfoSpy).not.toHaveBeenCalled();
+  });
+
+  it("does not log when DO_NOT_TRACK is set", () => {
+    process.env.DO_NOT_TRACK = "1";
+    logRuntimeTelemetryDisclosure();
+    expect(consoleInfoSpy).not.toHaveBeenCalled();
+  });
+});

package/src/lib/runtime/agent-integrations/langgraph/__tests__/run-message-filtering.test.ts

@@ -0,0 +1,156 @@
+import { of } from "rxjs";
+import { vi } from "vitest";
+import { LangGraphAgent } from "../agent";
+
+// REGRESSION: `@ag-ui/langgraph`'s message converter only handles
+// {user, assistant, system, tool} and throws "message role is not
+// supported." on anything else. Reasoning-stream agents (OpenAI
+// Responses API with `reasoning={summary:"detailed"}`) emit AG-UI
+// messages with `role:"reasoning"` that the AG-UI client persists in
+// the thread and replays on the NEXT turn's `input.messages` — which
+// crashes the converter before the model is called.
+//
+// CopilotKit's LangGraphAgent.run subclass strips those reasoning
+// messages from the inbound `input.messages` before delegating to
+// super. This file verifies that filter:
+//   - `role:"reasoning"` is dropped.
+//   - All other roles (user, assistant, system, tool, plus unknown
+//     roles we don't recognize) are preserved in order.
+//   - The pre-existing forwardedProps enrichment (`streamSubgraphs`)
+//     still applies.
+
+function createAgent() {
+  return new LangGraphAgent({
+    graphId: "test-graph",
+    url: "http://localhost:8000",
+  });
+}
+
+/**
+ * Mock the parent class's `run` method for a single test so we can
+ * capture the `input` it receives without actually opening a stream.
+ * The harness spies on the prototype TWO levels up because the
+ * CopilotKit `LangGraphAgent` extends `@ag-ui/langgraph`'s
+ * `LangGraphAgent`. Mirror the pattern from
+ * `dispatch-event-filtering.test.ts`'s `withMockedParentMerge`.
+ */
+function withMockedParentRun(agent: LangGraphAgent) {
+  const parentProto = Object.getPrototypeOf(Object.getPrototypeOf(agent));
+  const calls: any[] = [];
+  const spy = vi.spyOn(parentProto, "run").mockImplementation(function (
+    this: unknown,
+    input: unknown,
+  ) {
+    calls.push(input);
+    // Return an empty Observable — none of our assertions consume it,
+    // we only care about what was passed in.
+    return of();
+  });
+  return { spy, calls };
+}
+
+function makeInput(messages: Array<{ role: string; id?: string }>) {
+  return {
+    runId: "run-1",
+    threadId: "thread-1",
+    messages,
+    tools: [],
+    context: [],
+    state: {},
+    forwardedProps: {},
+  } as any;
+}
+
+describe("LangGraphAgent.run reasoning-role message filtering", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("strips role:'reasoning' messages from input before delegating to super.run", () => {
+    const agent = createAgent();
+    const { calls } = withMockedParentRun(agent);
+
+    agent.run(
+      makeInput([
+        { role: "user", id: "u1" },
+        { role: "reasoning", id: "r1" },
+        { role: "assistant", id: "a1" },
+        { role: "tool", id: "t1" },
+        { role: "reasoning", id: "r2" },
+      ]),
+    );
+
+    expect(calls).toHaveLength(1);
+    expect(calls[0].messages.map((m: { id: string }) => m.id)).toEqual([
+      "u1",
+      "a1",
+      "t1",
+    ]);
+    expect(
+      calls[0].messages.some((m: { role: string }) => m.role === "reasoning"),
+    ).toBe(false);
+  });
+
+  it("preserves user/assistant/system/tool messages in their original order", () => {
+    const agent = createAgent();
+    const { calls } = withMockedParentRun(agent);
+
+    agent.run(
+      makeInput([
+        { role: "system", id: "s1" },
+        { role: "user", id: "u1" },
+        { role: "assistant", id: "a1" },
+        { role: "tool", id: "t1" },
+        { role: "user", id: "u2" },
+      ]),
+    );
+
+    expect(calls[0].messages.map((m: { id: string }) => m.id)).toEqual([
+      "s1",
+      "u1",
+      "a1",
+      "t1",
+      "u2",
+    ]);
+  });
+
+  it("tolerates an empty messages array without throwing", () => {
+    const agent = createAgent();
+    const { calls } = withMockedParentRun(agent);
+
+    agent.run(makeInput([]));
+
+    expect(calls[0].messages).toEqual([]);
+  });
+
+  it("tolerates omitted messages (defaults to empty array)", () => {
+    const agent = createAgent();
+    const { calls } = withMockedParentRun(agent);
+
+    const input = makeInput([{ role: "user", id: "u1" }]);
+    delete input.messages;
+    agent.run(input);
+
+    expect(calls[0].messages).toEqual([]);
+  });
+
+  it("preserves the pre-existing forwardedProps.streamSubgraphs default", () => {
+    const agent = createAgent();
+    const { calls } = withMockedParentRun(agent);
+
+    agent.run(makeInput([{ role: "user", id: "u1" }]));
+
+    expect(calls[0].forwardedProps).toMatchObject({ streamSubgraphs: true });
+  });
+
+  it("respects an explicit forwardedProps.streamSubgraphs=false", () => {
+    const agent = createAgent();
+    const { calls } = withMockedParentRun(agent);
+
+    const input = makeInput([{ role: "user", id: "u1" }]);
+    input.forwardedProps = { streamSubgraphs: false };
+    agent.run(input);
+
+    expect(calls[0].forwardedProps.streamSubgraphs).toBe(false);
+  });
+});

package/src/lib/runtime/agent-integrations/langgraph/agent.ts

@@ -1,17 +1,20 @@
-import { map, Observable } from "rxjs";
+import type { Observable } from "rxjs";
+import { map } from "rxjs";
 import { LangGraphEventTypes } from "../../../../agents/langgraph/events";
-import { BaseEvent, RawEvent } from "@ag-ui/core";
+import type { BaseEvent, RawEvent } from "@ag-ui/core";
+import type {
+  ProcessedEvents,
+  SchemaKeys,
+  StateEnrichment,
+} from "@ag-ui/langgraph";
 import {
   LangGraphAgent as AGUILangGraphAgent,
   LangGraphHttpAgent,
   type LangGraphAgentConfig,
-  ProcessedEvents,
-  SchemaKeys,
   type State,
-  StateEnrichment,
 } from "@ag-ui/langgraph";
-import { Message as LangGraphMessage } from "@langchain/langgraph-sdk/dist/types.messages";
-import { ThreadState } from "@langchain/langgraph-sdk";
+import type { Message as LangGraphMessage } from "@langchain/langgraph-sdk/dist/types.messages";
+import type { ThreadState } from "@langchain/langgraph-sdk";
 
 interface CopilotKitStateEnrichment {
   copilotkit: {
@@ -20,15 +23,16 @@ interface CopilotKitStateEnrichment {
   };
 }
 
-import { RunAgentInput, EventType, CustomEvent } from "@ag-ui/client";
+import type { RunAgentInput, CustomEvent } from "@ag-ui/client";
+import { EventType } from "@ag-ui/client";
 
 // Import and re-export from separate file to maintain API compatibility
-import {
-  CustomEventNames,
+import type {
   TextMessageEvents,
   ToolCallEvents,
   PredictStateTool,
 } from "./consts";
+import { CustomEventNames } from "./consts";
 export { CustomEventNames };
 
 export class LangGraphAgent extends AGUILangGraphAgent {
@@ -154,8 +158,18 @@ export class LangGraphAgent extends AGUILangGraphAgent {
 
   // @ts-ignore
   run(input: RunAgentInput): Observable<BaseEvent> {
+    // @ag-ui/langgraph's message converter throws "message role is not
+    // supported." on any role it doesn't enumerate (user|assistant|system|tool).
+    // Reasoning-stream agents (e.g. OpenAI Responses API with reasoning summaries)
+    // emit AG-UI messages with role:"reasoning" that the client then replays on
+    // subsequent turns; without this filter the second turn crashes before the
+    // model is ever called.
+    const messages = (input.messages ?? []).filter(
+      (m: { role?: string }) => m?.role !== "reasoning",
+    );
     const enrichedInput = {
       ...input,
+      messages,
       forwardedProps: {
         ...input.forwardedProps,
         streamSubgraphs: input.forwardedProps?.streamSubgraphs ?? true,

package/src/lib/runtime/copilot-runtime.ts

@@ -45,6 +45,7 @@ import {
 export type { AgentsConfig, AgentsFactory, AgentFactoryContext };
 import { TelemetryAgentRunner } from "./telemetry-agent-runner";
 import telemetry from "../telemetry-client";
+import { logRuntimeTelemetryDisclosure } from "../telemetry-disclosure";
 
 import type { MessageInput } from "../../graphql/inputs/message.input";
 import type { Message } from "../../graphql/types/converted";
@@ -356,6 +357,8 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
     params?: CopilotRuntimeConstructorParams<T> &
       PartialBy<CopilotRuntimeOptions, "agents">,
   ) {
+    logRuntimeTelemetryDisclosure();
+
     const agents = params?.agents ?? {};
     const endpointAgents = this.assignEndpointsToAgents(
       params?.remoteEndpoints ?? [],

package/src/lib/telemetry-disclosure.ts

@@ -0,0 +1,53 @@
+// Runtime-side anonymous telemetry disclosure log.
+//
+// The runtime has shipped anonymous telemetry for some time (see
+// `packages/shared/src/telemetry/telemetry-client.ts`). This file just
+// surfaces a one-line pointer to the opt-out docs on first
+// instantiation so operators don't have to dig through the docs site
+// to discover the existing behavior. Pairs with the inspector's
+// first-run console disclosure for a consistent operator-facing
+// surface.
+//
+// Fires at most once per process — runtime instances may be constructed
+// multiple times (tests, hot-reload), but the disclosure is informational
+// and a single line is enough.
+
+// Canonical telemetry docs page on main.
+// Mirror constant: packages/web-inspector/src/lib/telemetry.ts
+const TELEMETRY_DOCS_URL = "https://docs.copilotkit.ai/telemetry";
+
+function isTelemetryDisabled(): boolean {
+  const env = process.env as Record<string, string | undefined>;
+  return (
+    env.COPILOTKIT_TELEMETRY_DISABLED === "true" ||
+    env.COPILOTKIT_TELEMETRY_DISABLED === "1" ||
+    env.DO_NOT_TRACK === "true" ||
+    env.DO_NOT_TRACK === "1"
+  );
+}
+
+let disclosureLogged = false;
+
+/**
+ * Logs a one-line console.info about anonymous telemetry on runtime
+ * startup. No-op when telemetry is disabled via `COPILOTKIT_TELEMETRY_DISABLED`
+ * or `DO_NOT_TRACK`, or when already logged once in this process.
+ *
+ * Idempotent — safe to call from multiple constructor paths.
+ */
+export function logRuntimeTelemetryDisclosure(): void {
+  if (disclosureLogged) return;
+  if (isTelemetryDisabled()) return;
+  disclosureLogged = true;
+  // eslint-disable-next-line no-console
+  console.info(
+    `[CopilotKit Runtime] anonymous telemetry enabled — see ${TELEMETRY_DOCS_URL} to opt out (set COPILOTKIT_TELEMETRY_DISABLED=true).`,
+  );
+}
+
+// Test-only reset hook so the once-per-process guard doesn't leak between
+// test cases. Not part of the public package surface — used by the runtime
+// disclosure tests.
+export function _resetRuntimeTelemetryDisclosureForTesting(): void {
+  disclosureLogged = false;
+}

package/src/v2/runtime/__tests__/get-runtime-info.test.ts

@@ -1,7 +1,7 @@
 import { handleGetRuntimeInfo } from "../handlers/get-runtime-info";
 import { CopilotRuntime } from "../core/runtime";
 import { TranscriptionService } from "../transcription-service/transcription-service";
-import { describe, it, expect, vi } from "vitest";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import type { AbstractAgent } from "@ag-ui/client";
 
 // Mock transcription service
@@ -35,6 +35,7 @@ describe("handleGetRuntimeInfo", () => {
       mode: "sse",
       a2uiEnabled: false,
       openGenerativeUIEnabled: false,
+      telemetryDisabled: false,
     });
   });
 
@@ -60,6 +61,7 @@ describe("handleGetRuntimeInfo", () => {
       mode: "sse",
       a2uiEnabled: false,
       openGenerativeUIEnabled: false,
+      telemetryDisabled: false,
     });
   });
 
@@ -97,6 +99,7 @@ describe("handleGetRuntimeInfo", () => {
       mode: "sse",
       a2uiEnabled: false,
       openGenerativeUIEnabled: false,
+      telemetryDisabled: false,
     });
   });
 
@@ -250,6 +253,61 @@ describe("handleGetRuntimeInfo", () => {
     warnSpy.mockRestore();
   });
 
+  describe("telemetryDisabled", () => {
+    beforeEach(() => {
+      delete process.env.COPILOTKIT_TELEMETRY_DISABLED;
+      delete process.env.DO_NOT_TRACK;
+    });
+
+    afterEach(() => {
+      delete process.env.COPILOTKIT_TELEMETRY_DISABLED;
+      delete process.env.DO_NOT_TRACK;
+    });
+
+    it("returns telemetryDisabled: false when env var is not set", async () => {
+      const runtime = new CopilotRuntime({ agents: {} });
+      const response = await handleGetRuntimeInfo({
+        runtime,
+        request: mockRequest,
+      });
+      const data = await response.json();
+      expect(data.telemetryDisabled).toBe(false);
+    });
+
+    it("returns telemetryDisabled: true when COPILOTKIT_TELEMETRY_DISABLED=true", async () => {
+      process.env.COPILOTKIT_TELEMETRY_DISABLED = "true";
+      const runtime = new CopilotRuntime({ agents: {} });
+      const response = await handleGetRuntimeInfo({
+        runtime,
+        request: mockRequest,
+      });
+      const data = await response.json();
+      expect(data.telemetryDisabled).toBe(true);
+    });
+
+    it("returns telemetryDisabled: true when COPILOTKIT_TELEMETRY_DISABLED=1", async () => {
+      process.env.COPILOTKIT_TELEMETRY_DISABLED = "1";
+      const runtime = new CopilotRuntime({ agents: {} });
+      const response = await handleGetRuntimeInfo({
+        runtime,
+        request: mockRequest,
+      });
+      const data = await response.json();
+      expect(data.telemetryDisabled).toBe(true);
+    });
+
+    it("returns telemetryDisabled: true when DO_NOT_TRACK=1", async () => {
+      process.env.DO_NOT_TRACK = "1";
+      const runtime = new CopilotRuntime({ agents: {} });
+      const response = await handleGetRuntimeInfo({
+        runtime,
+        request: mockRequest,
+      });
+      const data = await response.json();
+      expect(data.telemetryDisabled).toBe(true);
+    });
+  });
+
   it("should return 500 error when runtime.agents throws an error", async () => {
     const runtime = {
       get agents(): Record<string, AbstractAgent> {

package/src/v2/runtime/core/runtime.ts

@@ -23,6 +23,7 @@ import type {
   AfterRequestMiddleware,
 } from "./middleware";
 import { createLogger, type CopilotRuntimeLogger } from "../../../lib/logger";
+import { logRuntimeTelemetryDisclosure } from "../../../lib/telemetry-disclosure";
 import { TranscriptionService } from "../transcription-service/transcription-service";
 import { DebugEventBus } from "./debug-event-bus";
 import { AgentRunner } from "../runner/agent-runner";
@@ -229,6 +230,8 @@ abstract class BaseCopilotRuntime implements CopilotRuntimeLike {
   abstract readonly mode: RuntimeMode;
 
   constructor(options: BaseCopilotRuntimeOptions, runner: AgentRunner) {
+    logRuntimeTelemetryDisclosure();
+
     const {
       agents,
       transcriptionService,

package/src/v2/runtime/handlers/get-runtime-info.ts

@@ -1,15 +1,10 @@
 import type { AgentCapabilities } from "@ag-ui/core";
-import {
-  CopilotRuntimeLike,
-  isIntelligenceRuntime,
-  resolveAgents,
-} from "../core/runtime";
-import {
-  AgentDescription,
-  RuntimeInfo,
-  type RuntimeLicenseStatus,
-} from "@copilotkit/shared";
+import type { CopilotRuntimeLike } from "../core/runtime";
+import { isIntelligenceRuntime, resolveAgents } from "../core/runtime";
+import type { AgentDescription, RuntimeInfo } from "@copilotkit/shared";
+import { type RuntimeLicenseStatus } from "@copilotkit/shared";
 import { VERSION } from "../core/runtime";
+import { isTelemetryDisabled } from "../telemetry/telemetry-client";
 
 function resolveLicenseStatus(
   runtime: CopilotRuntimeLike,
@@ -84,6 +79,7 @@ export async function handleGetRuntimeInfo({
       ...(isIntelligenceRuntime(runtime)
         ? { licenseStatus: resolveLicenseStatus(runtime) }
         : {}),
+      telemetryDisabled: isTelemetryDisabled(),
     };
 
     return new Response(JSON.stringify(runtimeInfo), {

package/src/v2/runtime/handlers/handle-transcribe.ts

@@ -87,7 +87,7 @@ async function extractAudioFromFormData(
   request: Request,
 ): Promise<{ file: File } | { error: Response }> {
   const formData = await request.formData();
-  const audioFile = formData.get("audio") as File | null;
+  let audioFile = formData.get("audio") as File | null;
 
   if (!audioFile || !(audioFile instanceof File)) {
     const err = TranscriptionErrors.invalidRequest(
@@ -104,6 +104,19 @@ async function extractAudioFromFormData(
     return { error: createErrorResponse(err) };
   }
 
+  // Browser MediaRecorder Blobs often arrive at the server with their
+  // `type` field empty (and `application/octet-stream` is also accepted by
+  // isValidAudioType for compatibility). OpenAI Whisper rejects files
+  // without a recognizable MIME / extension with a 502 "Invalid file
+  // format" — even though the bytes themselves are valid WebM Opus.
+  // Stamp `audio/webm` (the standard MediaRecorder default in Chromium /
+  // Firefox / Safari) so Whisper can pick the right decoder.
+  if (!audioFile.type || audioFile.type === "application/octet-stream") {
+    audioFile = new File([audioFile], audioFile.name || "recording.webm", {
+      type: "audio/webm",
+    });
+  }
+
   return { file: audioFile };
 }