@copilotkit/runtime 1.57.2 → 1.57.4

package/src/v2/runtime/handlers/__tests__/handle-debug-events.test.ts

@@ -1,176 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { handleDebugEvents } from "../handle-debug-events";
-import { DebugEventBus } from "../../core/debug-event-bus";
-import type { CopilotRuntimeLike } from "../../core/runtime";
-import type { BaseEvent } from "@ag-ui/client";
-
-/* ------------------------------------------------------------------------------------------------
- * Helpers
- * --------------------------------------------------------------------------------------------- */
-
-function createMockRuntime(
-  overrides: { debugEventBus?: DebugEventBus } = {},
-): Pick<CopilotRuntimeLike, "debugEventBus"> {
-  return {
-    debugEventBus: overrides.debugEventBus ?? new DebugEventBus(),
-  };
-}
-
-function createMockRequest(options: { signal?: AbortSignal } = {}): Request {
-  return new Request("http://localhost/cpk-debug-events", {
-    method: "GET",
-    signal: options.signal,
-  });
-}
-
-function createTestEvent(): BaseEvent {
-  return { type: "custom" } as BaseEvent;
-}
-
-async function readNextSSELine(
-  reader: ReadableStreamDefaultReader<Uint8Array>,
-): Promise<string> {
-  const decoder = new TextDecoder();
-  let accumulated = "";
-  while (true) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    accumulated += decoder.decode(value, { stream: true });
-    if (accumulated.includes("\n\n")) return accumulated;
-  }
-  return accumulated;
-}
-
-/* ------------------------------------------------------------------------------------------------
- * Tests
- * --------------------------------------------------------------------------------------------- */
-
-describe("handleDebugEvents", () => {
-  let savedNodeEnv: string | undefined;
-
-  beforeEach(() => {
-    savedNodeEnv = process.env.NODE_ENV;
-  });
-
-  afterEach(() => {
-    if (savedNodeEnv === undefined) {
-      delete process.env.NODE_ENV;
-    } else {
-      process.env.NODE_ENV = savedNodeEnv;
-    }
-  });
-
-  it("returns 404 when NODE_ENV is production", async () => {
-    process.env.NODE_ENV = "production";
-
-    const runtime = createMockRuntime();
-    const request = createMockRequest();
-
-    const response = handleDebugEvents({
-      runtime: runtime as CopilotRuntimeLike,
-      request,
-    });
-
-    expect(response.status).toBe(404);
-    expect(await response.text()).toBe("Not Found");
-  });
-
-  it("returns 503 when debugEventBus is undefined", async () => {
-    process.env.NODE_ENV = "test";
-
-    const runtime = createMockRuntime({ debugEventBus: undefined });
-    // Remove the property so it's truly undefined
-    delete (runtime as Record<string, unknown>).debugEventBus;
-
-    const request = createMockRequest();
-
-    const response = handleDebugEvents({
-      runtime: runtime as CopilotRuntimeLike,
-      request,
-    });
-
-    expect(response.status).toBe(503);
-    expect(await response.text()).toBe("Debug event bus not available");
-  });
-
-  it("returns correct SSE response headers", () => {
-    process.env.NODE_ENV = "test";
-
-    const runtime = createMockRuntime();
-    const request = createMockRequest();
-
-    const response = handleDebugEvents({
-      runtime: runtime as CopilotRuntimeLike,
-      request,
-    });
-
-    expect(response.status).toBe(200);
-    expect(response.headers.get("Content-Type")).toBe("text/event-stream");
-    expect(response.headers.get("Cache-Control")).toBe("no-cache");
-    expect(response.headers.get("Connection")).toBe("keep-alive");
-  });
-
-  it("streams events as SSE data lines when bus broadcasts", async () => {
-    process.env.NODE_ENV = "test";
-
-    const bus = new DebugEventBus();
-    const runtime = createMockRuntime({ debugEventBus: bus });
-    const request = createMockRequest();
-
-    const response = handleDebugEvents({
-      runtime: runtime as CopilotRuntimeLike,
-      request,
-    });
-
-    const reader = response.body!.getReader();
-
-    // Read and discard the initial ": connected" SSE comment
-    const comment = await readNextSSELine(reader);
-    expect(comment).toMatch(/^: connected/);
-
-    // Broadcast an event through the bus
-    bus.broadcast(createTestEvent(), {
-      agentId: "agent-1",
-      threadId: "thread-1",
-      runId: "run-1",
-    });
-
-    const line = await readNextSSELine(reader);
-
-    // The line should be "data: {json}\n\n"
-    expect(line).toMatch(/^data: \{.*\}\n\n$/);
-
-    const parsed = JSON.parse(line.replace("data: ", "").trim());
-    expect(parsed.agentId).toBe("agent-1");
-    expect(parsed.threadId).toBe("thread-1");
-    expect(parsed.runId).toBe("run-1");
-    expect(parsed.event).toEqual(createTestEvent());
-    expect(typeof parsed.timestamp).toBe("number");
-
-    reader.releaseLock();
-  });
-
-  it("unsubscribes from bus when request is aborted", async () => {
-    process.env.NODE_ENV = "test";
-
-    const bus = new DebugEventBus();
-    const runtime = createMockRuntime({ debugEventBus: bus });
-
-    const abortController = new AbortController();
-    const request = createMockRequest({ signal: abortController.signal });
-
-    handleDebugEvents({
-      runtime: runtime as CopilotRuntimeLike,
-      request,
-    });
-
-    // Before abort, the bus should have one listener
-    expect(bus.listenerCount).toBe(1);
-
-    // Abort the request
-    abortController.abort();
-
-    // After abort, the listener should be cleaned up
-    expect(bus.listenerCount).toBe(0);
-  });
-});

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

@@ -1,101 +0,0 @@
-import type { AgentCapabilities } from "@ag-ui/core";
-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,
-): RuntimeLicenseStatus {
-  if (!runtime.licenseChecker) return "none";
-  const status = runtime.licenseChecker.getStatus();
-  if (status.warningSeverity === "none") return "valid";
-  if (status.error === "expired") return "expired";
-  if (status.warningSeverity === "warning") return "expiring";
-  if (status.error) return "invalid";
-  if (status.warningSeverity === "info") return "none";
-  return "unknown";
-}
-
-interface HandleGetRuntimeInfoParameters {
-  runtime: CopilotRuntimeLike;
-  request: Request;
-}
-
-export async function handleGetRuntimeInfo({
-  runtime,
-  request,
-}: HandleGetRuntimeInfoParameters) {
-  try {
-    const agents = await resolveAgents(runtime.agents, request);
-
-    const agentEntries = await Promise.all(
-      Object.entries(agents).map(async ([name, agent]) => {
-        let capabilities: AgentCapabilities | undefined;
-        try {
-          capabilities = agent.getCapabilities
-            ? await agent.getCapabilities()
-            : undefined;
-        } catch (error) {
-          // Per-agent isolation: a single agent failing to report capabilities
-          // must not take down the entire /info endpoint.
-          console.warn(
-            `Failed to fetch capabilities for agent "${name}":`,
-            error instanceof Error ? error.message : error,
-          );
-          capabilities = undefined;
-        }
-
-        const description: AgentDescription = {
-          name,
-          description: agent.description,
-          className: agent.constructor.name,
-          ...(capabilities ? { capabilities } : {}),
-        };
-
-        return [name, description] as const;
-      }),
-    );
-
-    const agentsDict: Record<string, AgentDescription> =
-      Object.fromEntries(agentEntries);
-
-    const runtimeInfo: RuntimeInfo = {
-      version: VERSION,
-      agents: agentsDict,
-      audioFileTranscriptionEnabled: !!runtime.transcriptionService,
-      mode: runtime.mode,
-      ...(isIntelligenceRuntime(runtime)
-        ? {
-            intelligence: {
-              wsUrl: runtime.intelligence.ɵgetClientWsUrl(),
-            },
-          }
-        : {}),
-      a2uiEnabled: !!runtime.a2ui,
-      openGenerativeUIEnabled: !!runtime.openGenerativeUI,
-      ...(isIntelligenceRuntime(runtime)
-        ? { licenseStatus: resolveLicenseStatus(runtime) }
-        : {}),
-      telemetryDisabled: isTelemetryDisabled(),
-    };
-
-    return new Response(JSON.stringify(runtimeInfo), {
-      status: 200,
-      headers: { "Content-Type": "application/json" },
-    });
-  } catch (error) {
-    return new Response(
-      JSON.stringify({
-        error: "Failed to retrieve runtime information",
-        message: error instanceof Error ? error.message : "Unknown error",
-      }),
-      {
-        status: 500,
-        headers: { "Content-Type": "application/json" },
-      },
-    );
-  }
-}

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

@@ -1,80 +0,0 @@
-import { handleIntelligenceConnect } from "./intelligence/connect";
-import { handleSseConnect } from "./sse/connect";
-import { isIntelligenceRuntime } from "../core/runtime";
-import { telemetry } from "../telemetry";
-import {
-  parseConnectRequest,
-  RunAgentParameters as ConnectAgentParameters,
-  cloneAgentForRequest,
-} from "./shared/agent-utils";
-
-export async function handleConnectAgent({
-  runtime,
-  request,
-  agentId,
-}: ConnectAgentParameters) {
-  telemetry.capture("oss.runtime.copilot_request_created", {
-    "cloud.guardrails.enabled": false,
-    requestType: "connect",
-    "cloud.api_key_provided": !!request.headers.get(
-      "x-copilotcloud-public-api-key",
-    ),
-    ...(request.headers.get("x-copilotcloud-public-api-key")
-      ? {
-          "cloud.public_api_key": request.headers.get(
-            "x-copilotcloud-public-api-key",
-          )!,
-        }
-      : {}),
-  });
-
-  try {
-    const agent = await cloneAgentForRequest(runtime, agentId, request);
-    if (agent instanceof Response) {
-      return agent;
-    }
-
-    const connectRequest = await parseConnectRequest(request);
-    if (connectRequest instanceof Response) {
-      return connectRequest;
-    }
-
-    if (isIntelligenceRuntime(runtime)) {
-      return handleIntelligenceConnect({
-        runtime,
-        request,
-        agentId,
-        threadId: connectRequest.input.threadId,
-      });
-    }
-
-    return handleSseConnect({
-      runtime,
-      request,
-      agentId,
-      threadId: connectRequest.input.threadId,
-    });
-  } catch (error) {
-    console.error("Error running agent:", error);
-    console.error(
-      "Error stack:",
-      error instanceof Error ? error.stack : "No stack trace",
-    );
-    console.error("Error details:", {
-      name: error instanceof Error ? error.name : "Unknown",
-      message: error instanceof Error ? error.message : String(error),
-      cause: error instanceof Error ? error.cause : undefined,
-    });
-
-    return new Response(
-      JSON.stringify({
-        error: "Failed to run agent",
-        message: error instanceof Error ? error.message : "Unknown error",
-      }),
-      {
-        status: 500,
-        headers: { "Content-Type": "application/json" },
-      },
-    );
-  }
-}

package/src/v2/runtime/handlers/handle-debug-events.ts

@@ -1,52 +0,0 @@
-import { CopilotRuntimeLike } from "../core/runtime";
-import { DebugEventEnvelope } from "@copilotkit/shared";
-
-interface HandleDebugEventsParams {
-  runtime: CopilotRuntimeLike;
-  request: Request;
-}
-
-export function handleDebugEvents({
-  runtime,
-  request,
-}: HandleDebugEventsParams): Response {
-  if (process.env.NODE_ENV === "production") {
-    return new Response("Not Found", { status: 404 });
-  }
-
-  if (!runtime.debugEventBus) {
-    return new Response("Debug event bus not available", { status: 503 });
-  }
-
-  const bus = runtime.debugEventBus;
-  const encoder = new TextEncoder();
-  const stream = new TransformStream();
-  const writer = stream.writable.getWriter();
-
-  // Send an SSE comment immediately to flush response headers to the client.
-  // Without this, some frameworks buffer the response until actual data is written,
-  // leaving the client stuck in "connecting" state.
-  writer.write(encoder.encode(": connected\n\n")).catch(() => {});
-
-  const unsubscribe = bus.subscribe((envelope: DebugEventEnvelope) => {
-    if (request.signal.aborted) return;
-    const line = `data: ${JSON.stringify(envelope)}\n\n`;
-    writer.write(encoder.encode(line)).catch(() => {
-      // Client disconnected, will be cleaned up by abort handler.
-    });
-  });
-
-  request.signal.addEventListener("abort", () => {
-    unsubscribe();
-    writer.close().catch(() => {});
-  });
-
-  return new Response(stream.readable, {
-    status: 200,
-    headers: {
-      "Content-Type": "text/event-stream",
-      "Cache-Control": "no-cache",
-      Connection: "keep-alive",
-    },
-  });
-}

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

@@ -1,111 +0,0 @@
-import { isIntelligenceRuntime } from "../core/runtime";
-import { telemetry } from "../telemetry";
-import {
-  cloneAgentForRequest,
-  configureAgentForRequest,
-  parseRunRequest,
-  RunAgentParameters,
-} from "./shared/agent-utils";
-import { handleIntelligenceRun } from "./intelligence/run";
-import { handleSseRun } from "./sse/run";
-
-export async function handleRunAgent({
-  runtime,
-  request,
-  agentId,
-}: RunAgentParameters) {
-  telemetry.capture("oss.runtime.copilot_request_created", {
-    "cloud.guardrails.enabled": false,
-    requestType: "run",
-    "cloud.api_key_provided": !!request.headers.get(
-      "x-copilotcloud-public-api-key",
-    ),
-    ...(request.headers.get("x-copilotcloud-public-api-key")
-      ? {
-          "cloud.public_api_key": request.headers.get(
-            "x-copilotcloud-public-api-key",
-          )!,
-        }
-      : {}),
-  });
-
-  try {
-    const agent = await cloneAgentForRequest(runtime, agentId, request);
-    if (agent instanceof Response) {
-      return agent;
-    }
-
-    // Ensure the clone carries the registry key so InMemoryAgentRunner can
-    // tag historic runs with the correct agentId for filtering.
-    agent.agentId = agentId;
-
-    configureAgentForRequest({ runtime, request, agentId, agent });
-
-    if (
-      runtime.licenseChecker &&
-      !runtime.licenseChecker.checkFeature("agents")
-    ) {
-      console.warn(
-        '[CopilotKit Runtime] Warning: "agents" feature is not licensed. Visit copilotkit.ai/pricing',
-      );
-    }
-
-    const input = await parseRunRequest(request);
-    if (input instanceof Response) {
-      return input;
-    }
-
-    agent.setMessages(input.messages);
-    agent.setState(input.state);
-    agent.threadId = input.threadId;
-
-    if (runtime.debug?.lifecycle && runtime.debugLogger) {
-      runtime.debugLogger.debug(
-        { agentName: agentId, threadId: input.threadId },
-        "Agent run started",
-      );
-    }
-
-    if (isIntelligenceRuntime(runtime)) {
-      return handleIntelligenceRun({
-        runtime,
-        request,
-        agentId,
-        agent,
-        input,
-      });
-    }
-
-    return handleSseRun({
-      runtime,
-      request,
-      agent,
-      input,
-      agentId,
-      debug: runtime.debug,
-      logger: runtime.debugLogger,
-    });
-  } catch (error) {
-    console.error("Error running agent:", error);
-    console.error(
-      "Error stack:",
-      error instanceof Error ? error.stack : "No stack trace",
-    );
-    console.error("Error details:", {
-      name: error instanceof Error ? error.name : "Unknown",
-      message: error instanceof Error ? error.message : String(error),
-      cause: error instanceof Error ? error.cause : undefined,
-    });
-
-    return new Response(
-      JSON.stringify({
-        error: "Failed to run agent",
-        message: error instanceof Error ? error.message : "Unknown error",
-      }),
-      {
-        status: 500,
-        headers: { "Content-Type": "application/json" },
-      },
-    );
-  }
-}

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

@@ -1,77 +0,0 @@
-import type { CopilotRuntimeLike } from "../core/runtime";
-import { resolveAgents } from "../core/runtime";
-import { EventType } from "@ag-ui/client";
-
-interface StopAgentParameters {
-  request: Request;
-  runtime: CopilotRuntimeLike;
-  agentId: string;
-  threadId: string;
-}
-
-export async function handleStopAgent({
-  runtime,
-  request,
-  agentId,
-  threadId,
-}: StopAgentParameters) {
-  try {
-    const agents = await resolveAgents(runtime.agents, request);
-
-    if (!agents[agentId]) {
-      return new Response(
-        JSON.stringify({
-          error: "Agent not found",
-          message: `Agent '${agentId}' does not exist`,
-        }),
-        {
-          status: 404,
-          headers: { "Content-Type": "application/json" },
-        },
-      );
-    }
-
-    const stopped = await runtime.runner.stop({ threadId });
-
-    if (!stopped) {
-      return new Response(
-        JSON.stringify({
-          stopped: false,
-          message: `No active run for thread '${threadId}'.`,
-        }),
-        {
-          status: 200,
-          headers: { "Content-Type": "application/json" },
-        },
-      );
-    }
-
-    return new Response(
-      JSON.stringify({
-        stopped: true,
-        interrupt: {
-          type: EventType.RUN_ERROR,
-          message: "Run stopped by user",
-          code: "STOPPED",
-        },
-      }),
-      {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      },
-    );
-  } catch (error) {
-    console.error("Error stopping agent run:", error);
-
-    return new Response(
-      JSON.stringify({
-        error: "Failed to stop agent",
-        message: error instanceof Error ? error.message : "Unknown error",
-      }),
-      {
-        status: 500,
-        headers: { "Content-Type": "application/json" },
-      },
-    );
-  }
-}

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

@@ -1,11 +0,0 @@
-export {
-  handleArchiveThread,
-  handleClearThreads,
-  handleDeleteThread,
-  handleGetThreadEvents,
-  handleGetThreadMessages,
-  handleGetThreadState,
-  handleListThreads,
-  handleSubscribeToThreads,
-  handleUpdateThread,
-} from "./intelligence/threads";