@copilotkit/runtime 1.54.1-next.6 → 1.55.0-next.7

package/src/v2/runtime/handlers/shared/sse-response.ts

@@ -0,0 +1,100 @@
+import { BaseEvent } from "@ag-ui/client";
+import { EventEncoder } from "@ag-ui/encoder";
+import { Observable, Subscription } from "rxjs";
+import { telemetry } from "../../telemetry";
+
+interface CreateSseEventResponseParams {
+  request: Request;
+  observableFactory: () =>
+    | Promise<Observable<BaseEvent>>
+    | Observable<BaseEvent>;
+}
+
+export function createSseEventResponse({
+  request,
+  observableFactory,
+}: CreateSseEventResponseParams): Response {
+  const stream = new TransformStream();
+  const writer = stream.writable.getWriter();
+  const encoder = new EventEncoder();
+  let streamClosed = false;
+
+  const closeStream = async () => {
+    if (!streamClosed) {
+      try {
+        await writer.close();
+        streamClosed = true;
+      } catch {
+        // Stream already closed.
+      }
+    }
+  };
+
+  const logError = (error: unknown) => {
+    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,
+    });
+  };
+
+  let subscription: Subscription | undefined;
+
+  (async () => {
+    const observable = await observableFactory();
+
+    telemetry.capture("oss.runtime.agent_execution_stream_started", {});
+
+    subscription = observable.subscribe({
+      next: async (event) => {
+        if (!request.signal.aborted && !streamClosed) {
+          try {
+            await writer.write(encoder.encode(event));
+          } catch (error) {
+            if (error instanceof Error && error.name === "AbortError") {
+              streamClosed = true;
+            }
+          }
+        }
+      },
+      error: async (error) => {
+        telemetry.capture("oss.runtime.agent_execution_stream_errored", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+        logError(error);
+        await closeStream();
+      },
+      complete: async () => {
+        telemetry.capture("oss.runtime.agent_execution_stream_ended", {});
+        await closeStream();
+      },
+    });
+
+    // If the client disconnected before the subscription was created,
+    // unsubscribe immediately to avoid leaking the observable.
+    if (request.signal.aborted) {
+      subscription.unsubscribe();
+    }
+  })().catch(async (error) => {
+    logError(error);
+    await closeStream();
+  });
+
+  request.signal.addEventListener("abort", () => {
+    subscription?.unsubscribe();
+  });
+
+  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/sse/connect.ts

@@ -0,0 +1,24 @@
+import { CopilotRuntimeLike } from "../../runtime";
+import { createSseEventResponse } from "../shared/sse-response";
+import { extractForwardableHeaders } from "../header-utils";
+
+interface HandleSseConnectParams {
+  runtime: CopilotRuntimeLike;
+  request: Request;
+  threadId: string;
+}
+
+export function handleSseConnect({
+  runtime,
+  request,
+  threadId,
+}: HandleSseConnectParams): Response {
+  return createSseEventResponse({
+    request,
+    observableFactory: () =>
+      runtime.runner.connect({
+        threadId,
+        headers: extractForwardableHeaders(request),
+      }),
+  });
+}

package/src/v2/runtime/handlers/sse/run.ts

@@ -0,0 +1,27 @@
+import { AbstractAgent, RunAgentInput } from "@ag-ui/client";
+import { CopilotRuntimeLike } from "../../runtime";
+import { createSseEventResponse } from "../shared/sse-response";
+
+interface HandleSseRunParams {
+  runtime: CopilotRuntimeLike;
+  request: Request;
+  agent: AbstractAgent;
+  input: RunAgentInput;
+}
+
+export function handleSseRun({
+  runtime,
+  request,
+  agent,
+  input,
+}: HandleSseRunParams): Response {
+  return createSseEventResponse({
+    request,
+    observableFactory: () =>
+      runtime.runner.run({
+        threadId: input.threadId,
+        agent,
+        input,
+      }),
+  });
+}

package/src/v2/runtime/index.ts

@@ -0,0 +1,20 @@
+export * from "./runtime";
+export * from "./endpoints";
+
+// Export agent runners and base types
+export * from "./runner";
+
+// Export transcription services
+export * from "./transcription-service/transcription-service";
+
+// Export intelligence platform client and types
+export {
+  CopilotKitIntelligence,
+  type CopilotKitIntelligenceConfig,
+  type CreateThreadRequest,
+  type ThreadSummary,
+  type ListThreadsResponse,
+  type SubscribeToThreadsRequest,
+  type SubscribeToThreadsResponse,
+  type UpdateThreadRequest,
+} from "./intelligence-platform";