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

package/dist/index.mjs

@@ -15,6 +15,7 @@ import { useDeferStream } from '@graphql-yoga/plugin-defer-stream';
 import createPinoLogger from 'pino';
 import pretty from 'pino-pretty';
 import { handle } from 'hono/vercel';
+import { Readable } from 'stream';
 
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -64,7 +65,7 @@ var require_package = __commonJS({
       publishConfig: {
         access: "public"
       },
-      version: "1.50.1",
+      version: "1.51.1",
       sideEffects: false,
       main: "./dist/index.js",
       module: "./dist/index.mjs",
@@ -88,7 +89,7 @@ var require_package = __commonJS({
       types: "./dist/index.d.ts",
       license: "MIT",
       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",
@@ -98,6 +99,9 @@ var require_package = __commonJS({
         "unlink:global": "pnpm unlink --global"
       },
       devDependencies: {
+        "@copilotkit/shared": "workspace:*",
+        "@copilotkitnext/agent": "workspace:*",
+        "@copilotkitnext/runtime": "workspace:*",
         "@jest/globals": "^29.7.0",
         "@swc/core": "1.5.28",
         "@types/jest": "^29.5.12",
@@ -115,12 +119,6 @@ var require_package = __commonJS({
         vitest: "^3.2.4"
       },
       dependencies: {
-        "@ag-ui/client": "^0.0.42",
-        "@ag-ui/core": "^0.0.42",
-        "@ag-ui/langgraph": "^0.0.20",
-        "@copilotkit/shared": "workspace:*",
-        "@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",
@@ -140,7 +138,13 @@ var require_package = __commonJS({
         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",
+        "@copilotkit/shared": "workspace:*",
+        "@copilotkitnext/agent": "workspace:*",
+        "@copilotkitnext/runtime": "workspace:*",
         "@langchain/aws": ">=0.1.9",
         "@langchain/core": ">=0.3.66",
         "@langchain/community": ">=0.3.58",
@@ -3580,7 +3584,7 @@ var CopilotRuntime = class {
         } : {},
         "cloud.base_url": cloudBaseUrl
       });
-      (_c = params == null ? void 0 : params.beforeRequestMiddleware) == null ? void 0 : _c.call(params, hookParams);
+      const middlewareResult = await ((_c = params == null ? void 0 : params.beforeRequestMiddleware) == null ? void 0 : _c.call(params, hookParams));
       if ((_d = params == null ? void 0 : params.middleware) == null ? void 0 : _d.onBeforeRequest) {
         const { request: request2, runtime, path } = hookParams;
         const gqlMessages = aguiToGQL(body.messages).reduce((acc, msg) => {
@@ -3603,6 +3607,7 @@ var CopilotRuntime = class {
           url: request2.url
         });
       }
+      return middlewareResult;
     };
   }
   createOnAfterRequestHandler(params) {
@@ -4729,6 +4734,98 @@ function copilotRuntimeNextJSAppRouterEndpoint(options) {
   };
 }
 __name(copilotRuntimeNextJSAppRouterEndpoint, "copilotRuntimeNextJSAppRouterEndpoint");
+function readableStreamToNodeStream(webStream) {
+  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);
+      }
+    }
+  });
+}
+__name(readableStreamToNodeStream, "readableStreamToNodeStream");
+function nodeStreamToReadableStream(nodeStream) {
+  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();
+    }
+  });
+}
+__name(nodeStreamToReadableStream, "nodeStreamToReadableStream");
+function getFullUrl(req) {
+  const path = req.url || "/";
+  const host = req.headers["x-forwarded-host"] || req.headers.host || "localhost";
+  const proto = req.headers["x-forwarded-proto"] || (req.socket.encrypted ? "https" : "http");
+  return `${proto}://${host}${path}`;
+}
+__name(getFullUrl, "getFullUrl");
+function toHeaders(rawHeaders) {
+  const headers = new Headers();
+  for (const [key, value] of Object.entries(rawHeaders)) {
+    if (value === void 0)
+      continue;
+    if (Array.isArray(value)) {
+      value.forEach((entry) => headers.append(key, entry));
+      continue;
+    }
+    headers.append(key, value);
+  }
+  return headers;
+}
+__name(toHeaders, "toHeaders");
+function isStreamConsumed(req) {
+  const readableState = req._readableState;
+  return Boolean(req.readableEnded || req.complete || (readableState == null ? void 0 : readableState.ended) || (readableState == null ? void 0 : readableState.endEmitted));
+}
+__name(isStreamConsumed, "isStreamConsumed");
+function synthesizeBodyFromParsedBody(parsedBody, headers) {
+  if (parsedBody === null || parsedBody === void 0) {
+    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"
+  };
+}
+__name(synthesizeBodyFromParsedBody, "synthesizeBodyFromParsedBody");
+function isDisturbedOrLockedError(error) {
+  return error instanceof TypeError && typeof error.message === "string" && (error.message.includes("disturbed") || error.message.includes("locked"));
+}
+__name(isDisturbedOrLockedError, "isDisturbedOrLockedError");
+
+// src/lib/integrations/node-http/index.ts
 function copilotRuntimeNodeHttpEndpoint(options) {
   var _a;
   const commonConfig = getCommonConfig(options);
@@ -4753,7 +4850,81 @@ function copilotRuntimeNodeHttpEndpoint(options) {
     runtime: options.runtime.instance,
     basePath: options.baseUrl ?? options.endpoint
   });
-  return honoApp.fetch;
+  const handle2 = /* @__PURE__ */ __name(async function handler(req, res) {
+    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 !== void 0;
+    const canStream = hasBody && !streamConsumed;
+    let requestBody = void 0;
+    let useDuplex = false;
+    if (hasBody && canStream) {
+      requestBody = nodeStreamToReadableStream(req);
+      useDuplex = true;
+    }
+    if (hasBody && streamConsumed) {
+      if (parsedBody !== void 0) {
+        const synthesized = synthesizeBodyFromParsedBody(parsedBody, baseHeaders);
+        requestBody = synthesized.body ?? void 0;
+        baseHeaders.delete("content-length");
+        if (synthesized.contentType) {
+          baseHeaders.set("content-type", synthesized.contentType);
+        }
+        logger2.debug("Request stream already consumed; using parsed req.body to rebuild request.");
+      } else {
+        logger2.warn("Request stream consumed with no available body; sending empty payload.");
+        requestBody = void 0;
+      }
+    }
+    const buildRequest = /* @__PURE__ */ __name((body, headers, duplex) => new Request(url, {
+      method: req.method,
+      headers,
+      body,
+      duplex: duplex ? "half" : void 0
+    }), "buildRequest");
+    let response;
+    try {
+      response = await honoApp.fetch(buildRequest(requestBody, baseHeaders, useDuplex));
+    } catch (error) {
+      if (isDisturbedOrLockedError(error) && hasBody) {
+        logger2.warn("Encountered disturbed/locked request body; rebuilding request using parsed body or empty payload.");
+        const fallbackHeaders = new Headers(baseHeaders);
+        let fallbackBody;
+        if (parsedBody !== void 0) {
+          const synthesized = synthesizeBodyFromParsedBody(parsedBody, fallbackHeaders);
+          fallbackBody = synthesized.body ?? void 0;
+          fallbackHeaders.delete("content-length");
+          if (synthesized.contentType) {
+            fallbackHeaders.set("content-type", synthesized.contentType);
+          }
+        } else {
+          fallbackBody = void 0;
+        }
+        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();
+    }
+  }, "handler");
+  return function(reqOrRequest, res) {
+    if (reqOrRequest instanceof Request) {
+      return honoApp.fetch(reqOrRequest);
+    }
+    if (!res) {
+      throw new TypeError("ServerResponse is required for Node HTTP requests");
+    }
+    return handle2(reqOrRequest, res);
+  };
 }
 __name(copilotRuntimeNodeHttpEndpoint, "copilotRuntimeNodeHttpEndpoint");