@copilotkit/runtime 0.0.0-fix-restore-handle-method-node-http-20251222114321 → 0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.0.0-fix-restore-handle-method-node-http-20251222114321",
+  "version": "0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142",
   "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -46,15 +46,13 @@
     "tsup": "^6.7.0",
     "typescript": "^5.2.3",
     "vitest": "^3.2.4",
+    "@copilotkit/shared": "0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142",
+    "@copilotkitnext/agent": "0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142",
+    "@copilotkitnext/runtime": "0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142",
     "eslint-config-custom": "1.4.6",
     "tsconfig": "1.4.6"
   },
   "dependencies": {
-    "@ag-ui/client": "^0.0.42",
-    "@ag-ui/core": "^0.0.42",
-    "@ag-ui/langgraph": "^0.0.20",
-    "@copilotkitnext/agent": "0.0.33",
-    "@copilotkitnext/runtime": "0.0.33",
     "@graphql-yoga/plugin-defer-stream": "^3.3.1",
     "@hono/node-server": "^1.13.5",
     "@scarf/scarf": "^1.3.0",
@@ -71,10 +69,12 @@
     "reflect-metadata": "^0.2.2",
     "rxjs": "7.8.1",
     "type-graphql": "2.0.0-rc.1",
-    "zod": "^3.23.3",
-    "@copilotkit/shared": "0.0.0-fix-restore-handle-method-node-http-20251222114321"
+    "zod": "^3.23.3"
   },
   "peerDependencies": {
+    "@ag-ui/client": "^0.0.42",
+    "@ag-ui/core": "^0.0.42",
+    "@ag-ui/langgraph": "^0.0.20",
     "@anthropic-ai/sdk": "^0.57.0",
     "@langchain/aws": ">=0.1.9",
     "@langchain/core": ">=0.3.66",
@@ -84,7 +84,10 @@
     "@langchain/openai": ">=0.4.2",
     "groq-sdk": ">=0.3.0 <1.0.0",
     "langchain": ">=0.3.3",
-    "openai": "^4.85.1"
+    "openai": "^4.85.1",
+    "@copilotkit/shared": "0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142",
+    "@copilotkitnext/agent": "0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142",
+    "@copilotkitnext/runtime": "0.0.0-fix-runtime-openai-api-key-passthrough-20260115003142"
   },
   "peerDependenciesMeta": {
     "@anthropic-ai/sdk": {
@@ -128,7 +131,7 @@
     "textarea"
   ],
   "scripts": {
-    "build": "tsup --onSuccess \"pnpm run generate-graphql-schema\"",
+    "build": "pnpm run generate-graphql-schema && tsup",
     "dev": "tsup --watch --onSuccess \"pnpm run generate-graphql-schema\"",
     "test": "jest --passWithNoTests",
     "check-types": "tsc --noEmit",

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

@@ -1,6 +1,17 @@
 import { CreateCopilotRuntimeServerOptions, getCommonConfig } from "../shared";
 import telemetry, { getRuntimeInstanceTelemetryInfo } from "../../telemetry-client";
 import { createCopilotEndpointSingleRoute } from "@copilotkitnext/runtime";
+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);
@@ -32,5 +43,101 @@ export function copilotRuntimeNodeHttpEndpoint(options: CreateCopilotRuntimeServ
     basePath: options.baseUrl ?? options.endpoint,
   });
 
-  return honoApp.fetch;
+  const handle = async function handler(req: IncomingWithBody, res: ServerResponse) {
+    const url = getFullUrl(req);
+    const hasBody = req.method !== "GET" && req.method !== "HEAD";
+
+    const baseHeaders = toHeaders(req.headers);
+    const parsedBody = req.body;
+
+    const streamConsumed = isStreamConsumed(req) || parsedBody !== undefined;
+    const canStream = hasBody && !streamConsumed;
+
+    let requestBody: BodyInit | null | undefined = undefined;
+    let useDuplex = false;
+
+    if (hasBody && canStream) {
+      requestBody = nodeStreamToReadableStream(req);
+      useDuplex = true;
+    }
+
+    if (hasBody && streamConsumed) {
+      if (parsedBody !== undefined) {
+        const synthesized = synthesizeBodyFromParsedBody(parsedBody, baseHeaders);
+        requestBody = synthesized.body ?? undefined;
+        baseHeaders.delete("content-length");
+
+        if (synthesized.contentType) {
+          baseHeaders.set("content-type", synthesized.contentType);
+        }
+
+        logger.debug("Request stream already consumed; using parsed req.body to rebuild request.");
+      } else {
+        logger.warn("Request stream consumed with no available body; sending empty payload.");
+        requestBody = undefined;
+      }
+    }
+
+    const buildRequest = (body: BodyInit | null | undefined, headers: Headers, duplex: boolean) =>
+      new Request(url, {
+        method: req.method,
+        headers,
+        body,
+        duplex: duplex ? "half" : undefined,
+      } as RequestInit);
+
+    let response: Response;
+    try {
+      response = await honoApp.fetch(buildRequest(requestBody, baseHeaders, useDuplex));
+    } catch (error) {
+      if (isDisturbedOrLockedError(error) && hasBody) {
+        logger.warn(
+          "Encountered disturbed/locked request body; rebuilding request using parsed body or empty payload.",
+        );
+
+        const fallbackHeaders = new Headers(baseHeaders);
+        let fallbackBody: BodyInit | null | undefined;
+
+        if (parsedBody !== undefined) {
+          const synthesized = synthesizeBodyFromParsedBody(parsedBody, fallbackHeaders);
+          fallbackBody = synthesized.body ?? undefined;
+          fallbackHeaders.delete("content-length");
+
+          if (synthesized.contentType) {
+            fallbackHeaders.set("content-type", synthesized.contentType);
+          }
+        } else {
+          fallbackBody = undefined;
+        }
+
+        response = await honoApp.fetch(buildRequest(fallbackBody, fallbackHeaders, false));
+      } else {
+        throw error;
+      }
+    }
+
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => {
+      res.setHeader(key, value);
+    });
+
+    if (response.body) {
+      readableStreamToNodeStream(response.body).pipe(res);
+    } else {
+      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"))
+  );
+}

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

@@ -480,7 +480,7 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
       // }
 
       // TODO: replace hooksParams top argument type with BeforeRequestMiddlewareParameters when exported
-      params?.beforeRequestMiddleware?.(hookParams);
+      const middlewareResult = await params?.beforeRequestMiddleware?.(hookParams);
 
       if (params?.middleware?.onBeforeRequest) {
         const { request, runtime, path } = hookParams;
@@ -504,6 +504,8 @@ export class CopilotRuntime<const T extends Parameter[] | [] = []> {
           url: request.url,
         } satisfies OnBeforeRequestOptions);
       }
+
+      return middlewareResult;
     };
   }