@copilotkit/runtime 1.50.1 → 1.50.2-next.0

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.50.1",
+  "version": "1.50.2-next.0",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -72,7 +72,7 @@
     "rxjs": "7.8.1",
     "type-graphql": "2.0.0-rc.1",
     "zod": "^3.23.3",
-    "@copilotkit/shared": "1.50.1"
+    "@copilotkit/shared": "1.50.2-next.0"
   },
   "peerDependencies": {
     "@anthropic-ai/sdk": "^0.57.0",

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

@@ -1,98 +1,17 @@
 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";
-
-type IncomingWithBody = IncomingMessage & { body?: unknown; complete?: boolean };
-
-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 expressPath =
-    (req as any).originalUrl ??
-    ((req as any).baseUrl ? `${(req as any).baseUrl}${req.url ?? ""}` : undefined);
-  const path = expressPath || 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}`;
-}
-
-function toHeaders(rawHeaders: IncomingMessage["headers"]): Headers {
-  const headers = new Headers();
-
-  for (const [key, value] of Object.entries(rawHeaders)) {
-    if (value === undefined) continue;
-
-    if (Array.isArray(value)) {
-      value.forEach((entry) => headers.append(key, entry));
-      continue;
-    }
-
-    headers.append(key, value);
-  }
-
-  return headers;
-}
-
-function isStreamConsumed(req: IncomingWithBody): boolean {
-  const readableState = (req as any)._readableState;
-
-  return Boolean(
-    req.readableEnded || req.complete || readableState?.ended || readableState?.endEmitted,
-  );
-}
-
-function synthesizeBodyFromParsedBody(
-  parsedBody: unknown,
-  headers: Headers,
-): { body: BodyInit | null; contentType?: string } {
-  if (parsedBody === null || parsedBody === undefined) {
-    return { body: null };
-  }
-
-  if (parsedBody instanceof Buffer || parsedBody instanceof Uint8Array) {
-    return { body: parsedBody };
-  }
-
-  if (typeof parsedBody === "string") {
-    return { body: parsedBody, contentType: headers.get("content-type") ?? "text/plain" };
-  }
-
-  return {
-    body: JSON.stringify(parsedBody),
-    contentType: "application/json",
-  };
-}
-
-function isDisturbedOrLockedError(error: unknown): boolean {
-  return (
-    error instanceof TypeError &&
-    typeof error.message === "string" &&
-    (error.message.includes("disturbed") || error.message.includes("locked"))
-  );
-}
+import type { IncomingMessage, ServerResponse } from "node:http";
+import {
+  getFullUrl,
+  IncomingWithBody,
+  isDisturbedOrLockedError,
+  isStreamConsumed,
+  nodeStreamToReadableStream,
+  readableStreamToNodeStream,
+  synthesizeBodyFromParsedBody,
+  toHeaders,
+} from "./request-handler";
 
 export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServerOptions) {
   const commonConfig = getCommonConfig(options);
@@ -124,7 +43,7 @@ export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServ
     basePath: options.baseUrl ?? options.endpoint,
   });
 
-  return async function handler(req: IncomingWithBody, res: ServerResponse) {
+  const handle = async function handler(req: IncomingWithBody, res: ServerResponse) {
     const url = getFullUrl(req);
     const hasBody = req.method !== "GET" && req.method !== "HEAD";
 
@@ -138,7 +57,7 @@ export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServ
     let useDuplex = false;
 
     if (hasBody && canStream) {
-      requestBody = req as unknown as BodyInit;
+      requestBody = nodeStreamToReadableStream(req);
       useDuplex = true;
     }
 
@@ -208,4 +127,17 @@ export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServ
       res.end();
     }
   };
+
+  return function (
+    reqOrRequest: IncomingMessage | Request,
+    res?: ServerResponse,
+  ): Promise<void> | Promise<Response> | Response {
+    if (reqOrRequest instanceof Request) {
+      return honoApp.fetch(reqOrRequest as Request);
+    }
+    if (!res) {
+      throw new TypeError("ServerResponse is required for Node HTTP requests");
+    }
+    return handle(reqOrRequest as IncomingMessage, res);
+  };
 }

package/src/lib/integrations/node-http/request-handler.ts

@@ -0,0 +1,111 @@
+import type { IncomingMessage } from "http";
+import { Readable } from "node:stream";
+
+export type IncomingWithBody = IncomingMessage & { body?: unknown; complete?: boolean };
+
+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);
+      }
+    },
+  });
+}
+
+export function nodeStreamToReadableStream(nodeStream: Readable): ReadableStream<Uint8Array> {
+  return new ReadableStream({
+    start(controller) {
+      nodeStream.on("data", (chunk) => {
+        controller.enqueue(chunk instanceof Buffer ? new Uint8Array(chunk) : chunk);
+      });
+      nodeStream.on("end", () => {
+        controller.close();
+      });
+      nodeStream.on("error", (err) => {
+        controller.error(err);
+      });
+    },
+    cancel() {
+      nodeStream.destroy();
+    },
+  });
+}
+
+export function getFullUrl(req: IncomingMessage): string {
+  // Use req.url (path relative to mount point) for Hono routing to work correctly.
+  // Express sets req.url to the path after the mount point (e.g., "/" when mounted at "/copilotkit").
+  // Pure Node HTTP sets req.url to the full path.
+  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 toHeaders(rawHeaders: IncomingMessage["headers"]): Headers {
+  const headers = new Headers();
+
+  for (const [key, value] of Object.entries(rawHeaders)) {
+    if (value === undefined) continue;
+
+    if (Array.isArray(value)) {
+      value.forEach((entry) => headers.append(key, entry));
+      continue;
+    }
+
+    headers.append(key, value);
+  }
+
+  return headers;
+}
+
+export function isStreamConsumed(req: IncomingWithBody): boolean {
+  const readableState = (req as any)._readableState;
+
+  return Boolean(
+    req.readableEnded || req.complete || readableState?.ended || readableState?.endEmitted,
+  );
+}
+
+export function synthesizeBodyFromParsedBody(
+  parsedBody: unknown,
+  headers: Headers,
+): { body: BodyInit | null; contentType?: string } {
+  if (parsedBody === null || parsedBody === undefined) {
+    return { body: null };
+  }
+
+  if (parsedBody instanceof Buffer || parsedBody instanceof Uint8Array) {
+    return { body: parsedBody };
+  }
+
+  if (typeof parsedBody === "string") {
+    return { body: parsedBody, contentType: headers.get("content-type") ?? "text/plain" };
+  }
+
+  return {
+    body: JSON.stringify(parsedBody),
+    contentType: "application/json",
+  };
+}
+
+export function isDisturbedOrLockedError(error: unknown): boolean {
+  return (
+    error instanceof TypeError &&
+    typeof error.message === "string" &&
+    (error.message.includes("disturbed") || error.message.includes("locked"))
+  );
+}