@copilotkit/runtime 1.10.6 → 1.50.0-beta.0

package/src/graphql/types/enums.ts

@@ -1,11 +1,11 @@
 import { registerEnumType } from "type-graphql";
 
 export enum MessageRole {
-  user = "user",
   assistant = "assistant",
+  developer = "developer",
   system = "system",
   tool = "tool",
-  developer = "developer",
+  user = "user",
 }
 
 export enum CopilotRequestType {

package/src/graphql/types/message-status.type.ts

@@ -11,7 +11,7 @@ registerEnumType(MessageStatusCode, {
 });
 
 @ObjectType()
-class BaseMessageStatus {
+export class BaseMessageStatus {
   @Field(() => MessageStatusCode)
   code: MessageStatusCode;
 }
@@ -38,3 +38,5 @@ export const MessageStatusUnion = createUnionType({
   name: "MessageStatus",
   types: () => [PendingMessageStatus, SuccessMessageStatus, FailedMessageStatus] as const,
 });
+
+export type MessageStatus = typeof MessageStatusUnion;

package/src/lib/index.ts

@@ -8,4 +8,4 @@ export * from "./integrations";
 export * from "./logger";
 export * from "./runtime/copilot-runtime";
 export * from "./runtime/mcp-tools-utils";
-export * from "./runtime/langgraph/langgraph-agent";
+export * from "./runtime/agent-integrations/langgraph.agent";

package/src/lib/integrations/nextjs/app-router.ts

@@ -1,6 +1,7 @@
-import { createYoga } from "graphql-yoga";
+import { createCopilotEndpointSingleRoute } from "@copilotkitnext/runtime";
 import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
 import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+import { handle } from "hono/vercel";
 
 export function copilotRuntimeNextJSAppRouterEndpoint(options: CreateCopilotRuntimeServerOptions) {
   const commonConfig = getCommonConfig(options);
@@ -22,16 +23,14 @@ export function copilotRuntimeNextJSAppRouterEndpoint(options: CreateCopilotRunt
   const logger = commonConfig.logging;
   logger.debug("Creating NextJS App Router endpoint");
 
-  const yoga = createYoga({
-    ...commonConfig,
-    graphqlEndpoint: options.endpoint,
-    fetchAPI: { Response: globalThis.Response },
+  const serviceAdapter = options.serviceAdapter;
+  options.runtime.handleServiceAdapter(serviceAdapter);
+
+  const copilotRoute = createCopilotEndpointSingleRoute({
+    runtime: options.runtime.instance,
+    basePath: options.baseUrl ?? options.endpoint,
   });
 
-  return {
-    handleRequest: yoga,
-    GET: yoga as any,
-    POST: yoga as any,
-    OPTIONS: yoga as any,
-  };
+  const handleRequest = handle(copilotRoute as any);
+  return { handleRequest };
 }

package/src/lib/integrations/nextjs/pages-router.ts

@@ -1,6 +1,6 @@
-import { YogaServerInstance, createYoga } from "graphql-yoga";
-import { CreateCopilotRuntimeServerOptions, GraphQLContext, getCommonConfig } from "../shared";
+import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
 import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+import { copilotRuntimeNodeHttpEndpoint } from "../node-http";
 
 export const config = {
   api: {
@@ -8,8 +8,6 @@ export const config = {
   },
 };
 
-export type CopilotRuntimeServerInstance<T> = YogaServerInstance<T, Partial<GraphQLContext>>;
-
 // This import is needed to fix the type error
 // Fix is currently in TypeScript 5.5 beta, waiting for stable version
 // https://github.com/microsoft/TypeScript/issues/42873#issuecomment-2066874644
@@ -17,7 +15,7 @@ export type {} from "@whatwg-node/server";
 
 export function copilotRuntimeNextJSPagesRouterEndpoint(
   options: CreateCopilotRuntimeServerOptions,
-): CopilotRuntimeServerInstance<GraphQLContext> {
+) {
   const commonConfig = getCommonConfig(options);
 
   telemetry.setGlobalProperties({
@@ -37,10 +35,5 @@ export function copilotRuntimeNextJSPagesRouterEndpoint(
   const logger = commonConfig.logging;
   logger.debug("Creating NextJS Pages Router endpoint");
 
-  const yoga = createYoga({
-    ...commonConfig,
-    graphqlEndpoint: options.endpoint,
-  });
-
-  return yoga;
+  return copilotRuntimeNodeHttpEndpoint(options);
 }

package/src/lib/integrations/node-http/index.ts

@@ -1,6 +1,38 @@
-import { createYoga } from "graphql-yoga";
 import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
 import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
+import { createCopilotEndpointSingleRoute } from "@copilotkitnext/runtime";
+import { IncomingMessage, ServerResponse } from "http";
+import { Readable } from "node:stream";
+
+export function readableStreamToNodeStream(webStream: ReadableStream): Readable {
+  const reader = webStream.getReader();
+
+  return new Readable({
+    async read() {
+      try {
+        const { done, value } = await reader.read();
+        if (done) {
+          this.push(null);
+        } else {
+          this.push(Buffer.from(value));
+        }
+      } catch (err) {
+        this.destroy(err as Error);
+      }
+    },
+  });
+}
+
+function getFullUrl(req: IncomingMessage): string {
+  const path = req.url || "/";
+  const host =
+    (req.headers["x-forwarded-host"] as string) || (req.headers.host as string) || "localhost";
+  const proto =
+    (req.headers["x-forwarded-proto"] as string) ||
+    ((req.socket as any).encrypted ? "https" : "http");
+
+  return `${proto}://${host}${path}`;
+}
 
 export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServerOptions) {
   const commonConfig = getCommonConfig(options);
@@ -22,10 +54,37 @@ export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServ
   const logger = commonConfig.logging;
   logger.debug("Creating Node HTTP endpoint");
 
-  const yoga = createYoga({
-    ...commonConfig,
-    graphqlEndpoint: options.endpoint,
+  const serviceAdapter = options.serviceAdapter;
+  options.runtime.handleServiceAdapter(serviceAdapter);
+
+  const honoApp = createCopilotEndpointSingleRoute({
+    runtime: options.runtime.instance,
+    basePath: options.baseUrl ?? options.endpoint,
   });
 
-  return yoga;
+  return async function handler(req: IncomingMessage, res: ServerResponse) {
+    const url = getFullUrl(req);
+    const hasBody = req.method !== "GET" && req.method !== "HEAD";
+
+    const request = new Request(url, {
+      method: req.method,
+      headers: req.headers as any,
+      body: hasBody ? (req as any) : undefined,
+      // Node/undici extension
+      duplex: hasBody ? "half" : undefined,
+    } as any);
+
+    const response = await honoApp.fetch(request);
+
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+      res.setHeader(key, value);
+    });
+
+    if (response.body) {
+      readableStreamToNodeStream(response.body).pipe(res);
+    } else {
+      res.end();
+    }
+  };
 }

package/src/lib/integrations/shared.ts

@@ -34,7 +34,7 @@ export type GraphQLContext = YogaInitialContext & {
 };
 
 export interface CreateCopilotRuntimeServerOptions {
-  runtime: CopilotRuntime<any>;
+  runtime: CopilotRuntime;
   serviceAdapter: CopilotServiceAdapter;
   endpoint: string;
   baseUrl?: string;

package/src/lib/observability.ts

@@ -1,3 +1,5 @@
+import { RuntimeEventSource, RuntimeEventTypes } from "../service-adapters/events";
+
 export interface LLMRequestData {
   threadId?: string;
   runId?: string;
@@ -71,3 +73,88 @@ export interface CopilotObservabilityConfig {
    */
   hooks: CopilotObservabilityHooks;
 }
+
+/**
+ * Setup progressive logging by wrapping the event stream
+ */
+function setupProgressiveLogging(
+  eventSource: RuntimeEventSource,
+  streamedChunks: any[],
+  requestStartTime: number,
+  context: {
+    threadId?: string;
+    runId?: string;
+    model?: string;
+    provider?: string;
+    agentName?: string;
+    nodeName?: string;
+  },
+  publicApiKey?: string,
+): void {
+  if (this.observability?.enabled && this.observability.progressive && publicApiKey) {
+    // Keep reference to original stream function
+    const originalStream = eventSource.stream.bind(eventSource);
+
+    // Wrap the stream function to intercept events
+    eventSource.stream = async (callback) => {
+      await originalStream(async (eventStream$) => {
+        // Create subscription to capture streaming events
+        eventStream$.subscribe({
+          next: (event) => {
+            // Only log content chunks
+            if (event.type === RuntimeEventTypes.TextMessageContent) {
+              // Store the chunk
+              streamedChunks.push(event.content);
+
+              // Log each chunk separately for progressive mode
+              try {
+                const progressiveData: LLMResponseData = {
+                  threadId: context.threadId || "",
+                  runId: context.runId,
+                  model: context.model,
+                  output: event.content,
+                  latency: Date.now() - requestStartTime,
+                  timestamp: Date.now(),
+                  provider: context.provider,
+                  isProgressiveChunk: true,
+                  agentName: context.agentName,
+                  nodeName: context.nodeName,
+                };
+
+                // Use Promise to handle async logger without awaiting
+                Promise.resolve()
+                  .then(() => {
+                    this.observability.hooks.handleResponse(progressiveData);
+                  })
+                  .catch((error) => {
+                    console.error("Error in progressive logging:", error);
+                  });
+              } catch (error) {
+                console.error("Error preparing progressive log data:", error);
+              }
+            }
+          },
+        });
+
+        // Call the original callback with the event stream
+        await callback(eventStream$);
+      });
+    };
+  }
+}
+
+/**
+ * Log error if observability is enabled
+ */
+async function logObservabilityError(
+  errorData: LLMErrorData,
+  publicApiKey?: string,
+): Promise<void> {
+  if (this.observability?.enabled && publicApiKey) {
+    try {
+      await this.observability.hooks.handleError(errorData);
+    } catch (logError) {
+      console.error("Error logging LLM error:", logError);
+    }
+  }
+}

package/src/lib/runtime/{langgraph/langgraph-agent.ts → agent-integrations/langgraph.agent.ts}

@@ -56,6 +56,11 @@ export class LangGraphAgent extends AGUILangGraphAgent {
     super(config);
   }
 
+  // @ts-ignore
+  public clone() {
+    return new LangGraphAgent(this.config);
+  }
+
   dispatchEvent(event: ProcessedEvents) {
     if (event.type === EventType.CUSTOM) {
       // const event = processedEvent as unknown as CustomEvent;