@copilotkit/runtime 1.83.0 → 2.0.0-rc.0

package/dist/v2/runtime/endpoints/hono.d.cts

@@ -1,97 +0,0 @@
-
-import { CopilotRuntimeLike } from "../core/runtime.cjs";
-import { ActivateChannelEngine, ChannelsControl } from "../core/channel-manager.cjs";
-import { CopilotRuntimeHooks } from "../core/hooks.cjs";
-import { CopilotCorsConfig } from "../core/fetch-cors.cjs";
-import { Hono } from "hono";
-
-//#region src/v2/runtime/endpoints/hono.d.ts
-/**
- * A Hono app that may also carry an optional {@link ChannelsControl} surface.
- *
- * Unlike the Node and Express wrappers — which own a process and therefore START
- * managed-Channel activation at creation (OSS-641) — this wrapper stays LAZY:
- * activation is triggered by the first `app.channels.ready()` and never before.
- * A Hono app is multi-runtime and is our edge/serverless surface in practice:
- * every Next.js App Router route handler in `examples/showcases/*` builds one at
- * module scope, and those isolates freeze and recycle per request. Auto-starting
- * there would mint a competing listener for the same Channel on every cold
- * start, which is exactly what the lazy design exists to prevent (see the
- * `createCopilotRuntimeHandler` TSDoc).
- *
- * So on a LONG-RUNNING Hono host (`@hono/node-server`, Bun, Deno) calling
- * `await app.channels.ready()` once at startup is REQUIRED to connect declared
- * Channels; on an edge/serverless host do NOT call it.
- */
-type CopilotHonoApp = Hono & {
-  channels?: ChannelsControl;
-};
-/**
- * CORS configuration for CopilotKit endpoints.
- * When using credentials (e.g., HTTP-only cookies), you must specify an explicit origin.
- */
-interface CopilotEndpointCorsConfig {
-  /**
-   * Allowed origin(s) for CORS. Can be:
-   * - A string: exact origin (e.g., "https://myapp.com")
-   * - An array: list of allowed origins
-   * - A function: dynamic origin resolution
-   *
-   * Note: When credentials is true, origin cannot be "*"
-   */
-  origin: string | string[] | ((origin: string, c: any) => string | undefined | null);
-  /**
-   * Whether to allow credentials (cookies, HTTP authentication).
-   * When true, origin must be explicitly specified (not "*").
-   */
-  credentials?: boolean;
-}
-interface CopilotEndpointParams {
-  runtime: CopilotRuntimeLike;
-  basePath: string;
-  /**
-   * Endpoint mode.
-   * - `"multi-route"` (default): separate routes for each operation
-   * - `"single-route"`: single POST endpoint with JSON envelope dispatch
-   */
-  mode?: "multi-route" | "single-route";
-  /**
-   * Optional CORS configuration. When not provided, defaults to allowing all origins without credentials.
-   * To support HTTP-only cookies, provide cors config with credentials: true and explicit origin.
-   */
-  cors?: CopilotEndpointCorsConfig;
-  /**
-   * Lifecycle hooks for request processing.
-   */
-  hooks?: CopilotRuntimeHooks;
-  /**
-   * Whether the underlying handler builds the control surface for the runtime's
-   * declared managed Channels. Defaults to `true`. Building it opens no
-   * connection — activation is deferred to the first `channels.ready()`. See
-   * `CopilotRuntimeHandlerOptions.activateChannels`.
-   */
-  activateChannels?: boolean;
-  /**
-   * @internal Test seam: inject a fake Channel activation engine. Forwarded
-   * to `createCopilotRuntimeHandler`. Not part of the public API.
-   */
-  __channelEngine?: ActivateChannelEngine;
-}
-/** @deprecated Use `createCopilotHonoHandler` instead. */
-declare const createCopilotEndpoint: typeof createCopilotHonoHandler;
-declare function createCopilotHonoHandler({
-  runtime,
-  basePath,
-  mode,
-  cors: corsConfig,
-  hooks,
-  activateChannels,
-  __channelEngine
-}: CopilotEndpointParams): CopilotHonoApp;
-/**
- * Convert Hono-specific CORS config to the fetch handler's CopilotCorsConfig.
- */
-declare function toFetchCorsConfig(config: CopilotEndpointCorsConfig): CopilotCorsConfig;
-//#endregion
-export { CopilotEndpointCorsConfig, CopilotHonoApp, createCopilotEndpoint, createCopilotHonoHandler, toFetchCorsConfig };
-//# sourceMappingURL=hono.d.cts.map

package/dist/v2/runtime/endpoints/hono.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hono.d.cts","names":[],"sources":["../../../../src/v2/runtime/endpoints/hono.ts"],"mappings":";;;;;;;;;;AA2BA;;;;;;;;;AAMA;;;;;;KANY,cAAA,GAAiB,IAAA;EAAS,QAAA,GAAW,eAAA;AAAA;;AAwBhD;;;UAlBgB,yBAAA;EAmCR;;;;;;;;EA1BP,MAAA,wBAGM,MAAA,UAAgB,CAAA;EAuBtB;;;;EAlBA,WAAA;AAAA;AAAA,UAGQ,qBAAA;EACR,OAAA,EAAS,kBAAA;EACT,QAAA;EAkCW;;;;;EA3BX,IAAA;EA6BsC;;;;EAvBtC,IAAA,GAAO,yBAAA;EA2BD;;;EAvBN,KAAA,GAAQ,mBAAA;EA2BP;;;;;;EAnBD,gBAAA;EAaA;;;;EAPA,eAAA,GAAkB,qBAAA;AAAA;;cAGP,qBAAA,SAAqB,wBAAA;AAAA,iBAElB,wBAAA,CAAA;EACd,OAAA;EACA,QAAA;EACA,IAAA;EACA,IAAA,EAAM,UAAA;EACN,KAAA;EACA,gBAAA;EACA;AAAA,GACC,qBAAA,GAAwB,cAAA;;;;iBAuBX,iBAAA,CACd,MAAA,EAAQ,yBAAA,GACP,iBAAA"}

package/dist/v2/runtime/endpoints/hono.d.mts

@@ -1,97 +0,0 @@
-
-import { CopilotRuntimeLike } from "../core/runtime.mjs";
-import { ActivateChannelEngine, ChannelsControl } from "../core/channel-manager.mjs";
-import { CopilotRuntimeHooks } from "../core/hooks.mjs";
-import { CopilotCorsConfig } from "../core/fetch-cors.mjs";
-import { Hono } from "hono";
-
-//#region src/v2/runtime/endpoints/hono.d.ts
-/**
- * A Hono app that may also carry an optional {@link ChannelsControl} surface.
- *
- * Unlike the Node and Express wrappers — which own a process and therefore START
- * managed-Channel activation at creation (OSS-641) — this wrapper stays LAZY:
- * activation is triggered by the first `app.channels.ready()` and never before.
- * A Hono app is multi-runtime and is our edge/serverless surface in practice:
- * every Next.js App Router route handler in `examples/showcases/*` builds one at
- * module scope, and those isolates freeze and recycle per request. Auto-starting
- * there would mint a competing listener for the same Channel on every cold
- * start, which is exactly what the lazy design exists to prevent (see the
- * `createCopilotRuntimeHandler` TSDoc).
- *
- * So on a LONG-RUNNING Hono host (`@hono/node-server`, Bun, Deno) calling
- * `await app.channels.ready()` once at startup is REQUIRED to connect declared
- * Channels; on an edge/serverless host do NOT call it.
- */
-type CopilotHonoApp = Hono & {
-  channels?: ChannelsControl;
-};
-/**
- * CORS configuration for CopilotKit endpoints.
- * When using credentials (e.g., HTTP-only cookies), you must specify an explicit origin.
- */
-interface CopilotEndpointCorsConfig {
-  /**
-   * Allowed origin(s) for CORS. Can be:
-   * - A string: exact origin (e.g., "https://myapp.com")
-   * - An array: list of allowed origins
-   * - A function: dynamic origin resolution
-   *
-   * Note: When credentials is true, origin cannot be "*"
-   */
-  origin: string | string[] | ((origin: string, c: any) => string | undefined | null);
-  /**
-   * Whether to allow credentials (cookies, HTTP authentication).
-   * When true, origin must be explicitly specified (not "*").
-   */
-  credentials?: boolean;
-}
-interface CopilotEndpointParams {
-  runtime: CopilotRuntimeLike;
-  basePath: string;
-  /**
-   * Endpoint mode.
-   * - `"multi-route"` (default): separate routes for each operation
-   * - `"single-route"`: single POST endpoint with JSON envelope dispatch
-   */
-  mode?: "multi-route" | "single-route";
-  /**
-   * Optional CORS configuration. When not provided, defaults to allowing all origins without credentials.
-   * To support HTTP-only cookies, provide cors config with credentials: true and explicit origin.
-   */
-  cors?: CopilotEndpointCorsConfig;
-  /**
-   * Lifecycle hooks for request processing.
-   */
-  hooks?: CopilotRuntimeHooks;
-  /**
-   * Whether the underlying handler builds the control surface for the runtime's
-   * declared managed Channels. Defaults to `true`. Building it opens no
-   * connection — activation is deferred to the first `channels.ready()`. See
-   * `CopilotRuntimeHandlerOptions.activateChannels`.
-   */
-  activateChannels?: boolean;
-  /**
-   * @internal Test seam: inject a fake Channel activation engine. Forwarded
-   * to `createCopilotRuntimeHandler`. Not part of the public API.
-   */
-  __channelEngine?: ActivateChannelEngine;
-}
-/** @deprecated Use `createCopilotHonoHandler` instead. */
-declare const createCopilotEndpoint: typeof createCopilotHonoHandler;
-declare function createCopilotHonoHandler({
-  runtime,
-  basePath,
-  mode,
-  cors: corsConfig,
-  hooks,
-  activateChannels,
-  __channelEngine
-}: CopilotEndpointParams): CopilotHonoApp;
-/**
- * Convert Hono-specific CORS config to the fetch handler's CopilotCorsConfig.
- */
-declare function toFetchCorsConfig(config: CopilotEndpointCorsConfig): CopilotCorsConfig;
-//#endregion
-export { CopilotEndpointCorsConfig, CopilotHonoApp, createCopilotEndpoint, createCopilotHonoHandler, toFetchCorsConfig };
-//# sourceMappingURL=hono.d.mts.map

package/dist/v2/runtime/endpoints/hono.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hono.d.mts","names":[],"sources":["../../../../src/v2/runtime/endpoints/hono.ts"],"mappings":";;;;;;;;;;AA2BA;;;;;;;;;AAMA;;;;;;KANY,cAAA,GAAiB,IAAA;EAAS,QAAA,GAAW,eAAA;AAAA;;AAwBhD;;;UAlBgB,yBAAA;EAmCR;;;;;;;;EA1BP,MAAA,wBAGM,MAAA,UAAgB,CAAA;EAuBtB;;;;EAlBA,WAAA;AAAA;AAAA,UAGQ,qBAAA;EACR,OAAA,EAAS,kBAAA;EACT,QAAA;EAkCW;;;;;EA3BX,IAAA;EA6BsC;;;;EAvBtC,IAAA,GAAO,yBAAA;EA2BD;;;EAvBN,KAAA,GAAQ,mBAAA;EA2BP;;;;;;EAnBD,gBAAA;EAaA;;;;EAPA,eAAA,GAAkB,qBAAA;AAAA;;cAGP,qBAAA,SAAqB,wBAAA;AAAA,iBAElB,wBAAA,CAAA;EACd,OAAA;EACA,QAAA;EACA,IAAA;EACA,IAAA,EAAM,UAAA;EACN,KAAA;EACA,gBAAA;EACA;AAAA,GACC,qBAAA,GAAwB,cAAA;;;;iBAuBX,iBAAA,CACd,MAAA,EAAQ,yBAAA,GACP,iBAAA"}

package/dist/v2/runtime/endpoints/hono.mjs

@@ -1,35 +0,0 @@
-import "reflect-metadata";
-import { createCopilotRuntimeHandler } from "../core/fetch-handler.mjs";
-import { Hono } from "hono";
-
-//#region src/v2/runtime/endpoints/hono.ts
-/** @deprecated Use `createCopilotHonoHandler` instead. */
-const createCopilotEndpoint = createCopilotHonoHandler;
-function createCopilotHonoHandler({ runtime, basePath, mode = "multi-route", cors: corsConfig, hooks, activateChannels, __channelEngine }) {
-	const handler = createCopilotRuntimeHandler({
-		runtime,
-		basePath,
-		mode,
-		cors: corsConfig ? toFetchCorsConfig(corsConfig) : true,
-		hooks,
-		activateChannels,
-		__channelEngine
-	});
-	const scopedApp = new Hono().basePath(basePath).all("*", async (c) => handler(c.req.raw));
-	scopedApp.channels = handler.channels;
-	return scopedApp;
-}
-/**
-* Convert Hono-specific CORS config to the fetch handler's CopilotCorsConfig.
-*/
-function toFetchCorsConfig(config) {
-	const origin = config.origin;
-	return {
-		origin: typeof origin === "function" ? (reqOrigin) => origin(reqOrigin, void 0) ?? null : origin,
-		credentials: config.credentials
-	};
-}
-
-//#endregion
-export { createCopilotEndpoint, createCopilotHonoHandler, toFetchCorsConfig };
-//# sourceMappingURL=hono.mjs.map

package/dist/v2/runtime/endpoints/hono.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"hono.mjs","names":[],"sources":["../../../../src/v2/runtime/endpoints/hono.ts"],"sourcesContent":["import { Hono } from \"hono\";\nimport type { CopilotRuntimeLike } from \"../core/runtime\";\nimport { createCopilotRuntimeHandler } from \"../core/fetch-handler\";\nimport type { CopilotCorsConfig } from \"../core/fetch-cors\";\nimport type { CopilotRuntimeHooks } from \"../core/hooks\";\nimport type {\n  ActivateChannelEngine,\n  ChannelsControl,\n} from \"../core/channel-manager\";\n\n/**\n * A Hono app that may also carry an optional {@link ChannelsControl} surface.\n *\n * Unlike the Node and Express wrappers — which own a process and therefore START\n * managed-Channel activation at creation (OSS-641) — this wrapper stays LAZY:\n * activation is triggered by the first `app.channels.ready()` and never before.\n * A Hono app is multi-runtime and is our edge/serverless surface in practice:\n * every Next.js App Router route handler in `examples/showcases/*` builds one at\n * module scope, and those isolates freeze and recycle per request. Auto-starting\n * there would mint a competing listener for the same Channel on every cold\n * start, which is exactly what the lazy design exists to prevent (see the\n * `createCopilotRuntimeHandler` TSDoc).\n *\n * So on a LONG-RUNNING Hono host (`@hono/node-server`, Bun, Deno) calling\n * `await app.channels.ready()` once at startup is REQUIRED to connect declared\n * Channels; on an edge/serverless host do NOT call it.\n */\nexport type CopilotHonoApp = Hono & { channels?: ChannelsControl };\n\n/**\n * CORS configuration for CopilotKit endpoints.\n * When using credentials (e.g., HTTP-only cookies), you must specify an explicit origin.\n */\nexport interface CopilotEndpointCorsConfig {\n  /**\n   * Allowed origin(s) for CORS. Can be:\n   * - A string: exact origin (e.g., \"https://myapp.com\")\n   * - An array: list of allowed origins\n   * - A function: dynamic origin resolution\n   *\n   * Note: When credentials is true, origin cannot be \"*\"\n   */\n  origin:\n    | string\n    | string[]\n    | ((origin: string, c: any) => string | undefined | null);\n  /**\n   * Whether to allow credentials (cookies, HTTP authentication).\n   * When true, origin must be explicitly specified (not \"*\").\n   */\n  credentials?: boolean;\n}\n\ninterface CopilotEndpointParams {\n  runtime: CopilotRuntimeLike;\n  basePath: string;\n\n  /**\n   * Endpoint mode.\n   * - `\"multi-route\"` (default): separate routes for each operation\n   * - `\"single-route\"`: single POST endpoint with JSON envelope dispatch\n   */\n  mode?: \"multi-route\" | \"single-route\";\n\n  /**\n   * Optional CORS configuration. When not provided, defaults to allowing all origins without credentials.\n   * To support HTTP-only cookies, provide cors config with credentials: true and explicit origin.\n   */\n  cors?: CopilotEndpointCorsConfig;\n  /**\n   * Lifecycle hooks for request processing.\n   */\n  hooks?: CopilotRuntimeHooks;\n\n  /**\n   * Whether the underlying handler builds the control surface for the runtime's\n   * declared managed Channels. Defaults to `true`. Building it opens no\n   * connection — activation is deferred to the first `channels.ready()`. See\n   * `CopilotRuntimeHandlerOptions.activateChannels`.\n   */\n  activateChannels?: boolean;\n\n  /**\n   * @internal Test seam: inject a fake Channel activation engine. Forwarded\n   * to `createCopilotRuntimeHandler`. Not part of the public API.\n   */\n  __channelEngine?: ActivateChannelEngine;\n}\n/** @deprecated Use `createCopilotHonoHandler` instead. */\nexport const createCopilotEndpoint = createCopilotHonoHandler;\n\nexport function createCopilotHonoHandler({\n  runtime,\n  basePath,\n  mode = \"multi-route\",\n  cors: corsConfig,\n  hooks,\n  activateChannels,\n  __channelEngine,\n}: CopilotEndpointParams): CopilotHonoApp {\n  const handler = createCopilotRuntimeHandler({\n    runtime,\n    basePath,\n    mode,\n    cors: corsConfig ? toFetchCorsConfig(corsConfig) : true,\n    hooks,\n    activateChannels,\n    __channelEngine,\n  });\n\n  const app = new Hono();\n\n  const scopedApp: CopilotHonoApp = app\n    .basePath(basePath)\n    .all(\"*\", async (c) => handler(c.req.raw));\n  scopedApp.channels = handler.channels;\n  return scopedApp;\n}\n\n/**\n * Convert Hono-specific CORS config to the fetch handler's CopilotCorsConfig.\n */\nexport function toFetchCorsConfig(\n  config: CopilotEndpointCorsConfig,\n): CopilotCorsConfig {\n  const origin = config.origin;\n  return {\n    origin:\n      typeof origin === \"function\"\n        ? (reqOrigin: string) => origin(reqOrigin, undefined) ?? null\n        : origin,\n    credentials: config.credentials,\n  };\n}\n"],"mappings":";;;;;;AAyFA,MAAa,wBAAwB;AAErC,SAAgB,yBAAyB,EACvC,SACA,UACA,OAAO,eACP,MAAM,YACN,OACA,kBACA,mBACwC;CACxC,MAAM,UAAU,4BAA4B;EAC1C;EACA;EACA;EACA,MAAM,aAAa,kBAAkB,WAAW,GAAG;EACnD;EACA;EACA;EACD,CAAC;CAIF,MAAM,YAFM,IAAI,MAAM,CAGnB,SAAS,SAAS,CAClB,IAAI,KAAK,OAAO,MAAM,QAAQ,EAAE,IAAI,IAAI,CAAC;AAC5C,WAAU,WAAW,QAAQ;AAC7B,QAAO;;;;;AAMT,SAAgB,kBACd,QACmB;CACnB,MAAM,SAAS,OAAO;AACtB,QAAO;EACL,QACE,OAAO,WAAW,cACb,cAAsB,OAAO,WAAW,OAAU,IAAI,OACvD;EACN,aAAa,OAAO;EACrB"}

package/dist/v2/runtime/endpoints/index.d.cts

@@ -1,5 +0,0 @@
-
-import { CopilotExpressEndpointParams, CopilotExpressRouter, createCopilotExpressHandler } from "./express.cjs";
-import { createCopilotEndpointSingleRouteExpress } from "./express-single.cjs";
-import { CopilotEndpointCorsConfig, CopilotHonoApp, createCopilotEndpoint, createCopilotHonoHandler, toFetchCorsConfig } from "./hono.cjs";
-import { createCopilotEndpointSingleRoute } from "./hono-single.cjs";

package/dist/v2/runtime/endpoints/index.d.mts

@@ -1,5 +0,0 @@
-
-import { CopilotExpressEndpointParams, CopilotExpressRouter, createCopilotExpressHandler } from "./express.mjs";
-import { createCopilotEndpointSingleRouteExpress } from "./express-single.mjs";
-import { CopilotEndpointCorsConfig, CopilotHonoApp, createCopilotEndpoint, createCopilotHonoHandler, toFetchCorsConfig } from "./hono.mjs";
-import { createCopilotEndpointSingleRoute } from "./hono-single.mjs";

package/dist/v2/runtime/endpoints/load-express.cjs

@@ -1,36 +0,0 @@
-require("reflect-metadata");
-const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
-let node_module = require("node:module");
-
-//#region src/v2/runtime/endpoints/load-express.ts
-/**
-* Load `express` at call time rather than at module load time.
-*
-* `express` is an OPTIONAL peer: an app that mounts the Hono or Node adapter
-* never installs it. The Express adapter is re-exported from the
-* `@copilotkit/runtime/v2` barrel, so a static `import express from "express"`
-* there would make that barrel unimportable for every consumer who does not use
-* Express. Loading it inside the factory keeps the barrel free of Express and
-* moves the failure to the only place it is a real failure: calling an Express
-* factory without Express installed.
-*
-* This lives in its own module, and not beside the factory, for two reasons: it
-* is not part of the published surface (the endpoints barrel does not re-export
-* it), and a test can reach it directly and inject `requireFrom`.
-*
-* `scripts/validate-optional-peer-entries.ts` is what keeps the loading lazy: it
-* fails if any entry point reaches an optional peer at module-initialization
-* time, in either published format.
-*/
-function loadExpress(requireFrom = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)) {
-	try {
-		requireFrom.resolve("express");
-	} catch (cause) {
-		throw new Error("@copilotkit/runtime: the Express adapter requires `express`, which is an optional peer dependency and is not installed. Install it with `npm install express` (^4.18.0 || ^5.0.0), or mount the Hono adapter from `@copilotkit/runtime/v2/hono` instead.", { cause });
-	}
-	return requireFrom("express");
-}
-
-//#endregion
-exports.loadExpress = loadExpress;
-//# sourceMappingURL=load-express.cjs.map

package/dist/v2/runtime/endpoints/load-express.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-express.cjs","names":[],"sources":["../../../../src/v2/runtime/endpoints/load-express.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\n/**\n * How `loadExpress` reaches the module system. `createRequire(...)` returns\n * exactly this shape; a test can pass its own.\n */\nexport interface RequireLike {\n  (specifier: string): any;\n  resolve(specifier: string): string;\n}\n\n/**\n * Load `express` at call time rather than at module load time.\n *\n * `express` is an OPTIONAL peer: an app that mounts the Hono or Node adapter\n * never installs it. The Express adapter is re-exported from the\n * `@copilotkit/runtime/v2` barrel, so a static `import express from \"express\"`\n * there would make that barrel unimportable for every consumer who does not use\n * Express. Loading it inside the factory keeps the barrel free of Express and\n * moves the failure to the only place it is a real failure: calling an Express\n * factory without Express installed.\n *\n * This lives in its own module, and not beside the factory, for two reasons: it\n * is not part of the published surface (the endpoints barrel does not re-export\n * it), and a test can reach it directly and inject `requireFrom`.\n *\n * `scripts/validate-optional-peer-entries.ts` is what keeps the loading lazy: it\n * fails if any entry point reaches an optional peer at module-initialization\n * time, in either published format.\n */\nexport function loadExpress(\n  requireFrom: RequireLike = createRequire(import.meta.url) as RequireLike,\n): { Router: () => any } {\n  // Resolve and evaluate in two steps, so that only a RESOLUTION failure is\n  // reported as \"not installed\". Wrapping the whole load would also catch\n  // express throwing while it evaluates -- a broken transitive dependency, a\n  // failed native binding, a syntax error in a patched copy -- and would send\n  // the reader off to install a package they already have. Those errors must\n  // surface as themselves.\n  try {\n    requireFrom.resolve(\"express\");\n  } catch (cause) {\n    throw new Error(\n      \"@copilotkit/runtime: the Express adapter requires `express`, which is an \" +\n        \"optional peer dependency and is not installed. Install it with \" +\n        \"`npm install express` (^4.18.0 || ^5.0.0), or mount the Hono adapter \" +\n        \"from `@copilotkit/runtime/v2/hono` instead.\",\n      { cause },\n    );\n  }\n\n  return requireFrom(\"express\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,YACd,2FAAyD,EAClC;AAOvB,KAAI;AACF,cAAY,QAAQ,UAAU;UACvB,OAAO;AACd,QAAM,IAAI,MACR,4PAIA,EAAE,OAAO,CACV;;AAGH,QAAO,YAAY,UAAU"}

package/dist/v2/runtime/endpoints/load-express.mjs

@@ -1,35 +0,0 @@
-import "reflect-metadata";
-import { createRequire } from "node:module";
-
-//#region src/v2/runtime/endpoints/load-express.ts
-/**
-* Load `express` at call time rather than at module load time.
-*
-* `express` is an OPTIONAL peer: an app that mounts the Hono or Node adapter
-* never installs it. The Express adapter is re-exported from the
-* `@copilotkit/runtime/v2` barrel, so a static `import express from "express"`
-* there would make that barrel unimportable for every consumer who does not use
-* Express. Loading it inside the factory keeps the barrel free of Express and
-* moves the failure to the only place it is a real failure: calling an Express
-* factory without Express installed.
-*
-* This lives in its own module, and not beside the factory, for two reasons: it
-* is not part of the published surface (the endpoints barrel does not re-export
-* it), and a test can reach it directly and inject `requireFrom`.
-*
-* `scripts/validate-optional-peer-entries.ts` is what keeps the loading lazy: it
-* fails if any entry point reaches an optional peer at module-initialization
-* time, in either published format.
-*/
-function loadExpress(requireFrom = createRequire(import.meta.url)) {
-	try {
-		requireFrom.resolve("express");
-	} catch (cause) {
-		throw new Error("@copilotkit/runtime: the Express adapter requires `express`, which is an optional peer dependency and is not installed. Install it with `npm install express` (^4.18.0 || ^5.0.0), or mount the Hono adapter from `@copilotkit/runtime/v2/hono` instead.", { cause });
-	}
-	return requireFrom("express");
-}
-
-//#endregion
-export { loadExpress };
-//# sourceMappingURL=load-express.mjs.map

package/dist/v2/runtime/endpoints/load-express.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"load-express.mjs","names":[],"sources":["../../../../src/v2/runtime/endpoints/load-express.ts"],"sourcesContent":["import { createRequire } from \"node:module\";\n\n/**\n * How `loadExpress` reaches the module system. `createRequire(...)` returns\n * exactly this shape; a test can pass its own.\n */\nexport interface RequireLike {\n  (specifier: string): any;\n  resolve(specifier: string): string;\n}\n\n/**\n * Load `express` at call time rather than at module load time.\n *\n * `express` is an OPTIONAL peer: an app that mounts the Hono or Node adapter\n * never installs it. The Express adapter is re-exported from the\n * `@copilotkit/runtime/v2` barrel, so a static `import express from \"express\"`\n * there would make that barrel unimportable for every consumer who does not use\n * Express. Loading it inside the factory keeps the barrel free of Express and\n * moves the failure to the only place it is a real failure: calling an Express\n * factory without Express installed.\n *\n * This lives in its own module, and not beside the factory, for two reasons: it\n * is not part of the published surface (the endpoints barrel does not re-export\n * it), and a test can reach it directly and inject `requireFrom`.\n *\n * `scripts/validate-optional-peer-entries.ts` is what keeps the loading lazy: it\n * fails if any entry point reaches an optional peer at module-initialization\n * time, in either published format.\n */\nexport function loadExpress(\n  requireFrom: RequireLike = createRequire(import.meta.url) as RequireLike,\n): { Router: () => any } {\n  // Resolve and evaluate in two steps, so that only a RESOLUTION failure is\n  // reported as \"not installed\". Wrapping the whole load would also catch\n  // express throwing while it evaluates -- a broken transitive dependency, a\n  // failed native binding, a syntax error in a patched copy -- and would send\n  // the reader off to install a package they already have. Those errors must\n  // surface as themselves.\n  try {\n    requireFrom.resolve(\"express\");\n  } catch (cause) {\n    throw new Error(\n      \"@copilotkit/runtime: the Express adapter requires `express`, which is an \" +\n        \"optional peer dependency and is not installed. Install it with \" +\n        \"`npm install express` (^4.18.0 || ^5.0.0), or mount the Hono adapter \" +\n        \"from `@copilotkit/runtime/v2/hono` instead.\",\n      { cause },\n    );\n  }\n\n  return requireFrom(\"express\");\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,YACd,cAA2B,cAAc,OAAO,KAAK,IAAI,EAClC;AAOvB,KAAI;AACF,cAAY,QAAQ,UAAU;UACvB,OAAO;AACd,QAAM,IAAI,MACR,4PAIA,EAAE,OAAO,CACV;;AAGH,QAAO,YAAY,UAAU"}

package/dist/v2/runtime/endpoints/node-fetch-handler.cjs

@@ -1,76 +0,0 @@
-require("reflect-metadata");
-const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
-let _copilotkit_shared = require("@copilotkit/shared");
-let _remix_run_node_fetch_server = require("@remix-run/node-fetch-server");
-
-//#region src/v2/runtime/endpoints/node-fetch-handler.ts
-const METHODS_WITHOUT_BODY = new Set([
-	"GET",
-	"HEAD",
-	"OPTIONS"
-]);
-function createCopilotNodeHandler(handler) {
-	return async (req, res) => {
-		try {
-			const method = (req.method ?? "GET").toUpperCase();
-			await (0, _remix_run_node_fetch_server.sendResponse)(res, await handler(!METHODS_WITHOUT_BODY.has(method) && hasPreParsedBody(req) ? buildPreParsedRequest(req, res) : (0, _remix_run_node_fetch_server.createRequest)(req, res)));
-		} catch (err) {
-			_copilotkit_shared.logger.error({ err }, "Error in Node fetch handler");
-			if (!res.headersSent) {
-				res.statusCode = 500;
-				res.end("Internal Server Error");
-			}
-		}
-	};
-}
-/** @deprecated Use `createCopilotNodeHandler` instead. */
-const createNodeFetchHandler = createCopilotNodeHandler;
-/**
-* Build a Fetch Request from a Node IncomingMessage whose body stream has
-* already been consumed by a body parser.
-*
-* The URL, headers and abort wiring match `createRequest` (the streaming path),
-* so a request routes the same way whether or not a parser ran first. In
-* particular the URL comes from `req.url`, which is what a mounting router
-* matched against; `originalUrl` still carries the mount prefix and would miss
-* the handler's `basePath`.
-*/
-function buildPreParsedRequest(req, res) {
-	const method = (req.method ?? "GET").toUpperCase();
-	const headers = (0, _remix_run_node_fetch_server.createHeaders)(req);
-	const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-	const host = headers.get("host") ?? "localhost";
-	const url = new URL(req.url ?? "/", `${protocol}//${host}`);
-	const controller = new AbortController();
-	res.on("close", () => {
-		if (!res.writableFinished) controller.abort();
-	});
-	const init = {
-		method,
-		headers,
-		signal: controller.signal
-	};
-	const { body, contentType } = synthesizeBody(req.body);
-	if (contentType) headers.set("content-type", contentType);
-	headers.delete("content-length");
-	if (body !== void 0) init.body = body;
-	return new Request(url, init);
-}
-function hasPreParsedBody(req) {
-	if (req.body === void 0 || req.body === null) return false;
-	return Boolean(req.readableEnded);
-}
-function synthesizeBody(body) {
-	if (Buffer.isBuffer(body) || body instanceof Uint8Array) return { body };
-	if (typeof body === "string") return { body };
-	if (typeof body === "object" && body !== null) return {
-		body: JSON.stringify(body),
-		contentType: "application/json"
-	};
-	return {};
-}
-
-//#endregion
-exports.createCopilotNodeHandler = createCopilotNodeHandler;
-exports.createNodeFetchHandler = createNodeFetchHandler;
-//# sourceMappingURL=node-fetch-handler.cjs.map

package/dist/v2/runtime/endpoints/node-fetch-handler.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-fetch-handler.cjs","names":[],"sources":["../../../../src/v2/runtime/endpoints/node-fetch-handler.ts"],"sourcesContent":["/**\n * Generic Node ↔ Fetch bridge for CopilotKit runtime.\n *\n * Wraps a `CopilotRuntimeFetchHandler` as a Node HTTP handler using\n * `@remix-run/node-fetch-server` for reliable streaming and conversion.\n *\n * When body-parsing middleware (Express `express.json()`, NestJS's default\n * parser, …) runs first, the Node request stream is already consumed and\n * `req.body` holds the parsed content. Reading the exhausted stream would hang,\n * so that case re-serialises `req.body` into the Fetch `Request` instead.\n *\n * @example\n * ```typescript\n * import { createServer } from \"node:http\";\n * import { createCopilotRuntimeHandler } from \"@copilotkit/runtime/v2\";\n * import { createCopilotNodeHandler } from \"@copilotkit/runtime/v2/node\";\n *\n * const handler = createCopilotRuntimeHandler({ runtime, basePath: \"/api/copilotkit\", cors: true });\n * const nodeHandler = createCopilotNodeHandler(handler);\n * createServer(nodeHandler).listen(3000);\n * ```\n */\n\nimport type { IncomingMessage, ServerResponse } from \"node:http\";\nimport {\n  createHeaders,\n  createRequest,\n  sendResponse,\n} from \"@remix-run/node-fetch-server\";\nimport type { CopilotRuntimeFetchHandler } from \"../core/fetch-handler\";\nimport { logger } from \"@copilotkit/shared\";\n\nconst METHODS_WITHOUT_BODY = new Set([\"GET\", \"HEAD\", \"OPTIONS\"]);\n\nexport type NodeFetchHandler = (\n  req: IncomingMessage,\n  res: ServerResponse,\n) => Promise<void>;\n\nexport function createCopilotNodeHandler(\n  handler: CopilotRuntimeFetchHandler,\n): NodeFetchHandler {\n  return async (req: IncomingMessage, res: ServerResponse) => {\n    try {\n      const method = (req.method ?? \"GET\").toUpperCase();\n      const fetchReq =\n        !METHODS_WITHOUT_BODY.has(method) && hasPreParsedBody(req)\n          ? buildPreParsedRequest(req, res)\n          : createRequest(req, res);\n      const fetchRes = await handler(fetchReq);\n      await sendResponse(res, fetchRes);\n    } catch (err: unknown) {\n      logger.error({ err }, \"Error in Node fetch handler\");\n      if (!res.headersSent) {\n        res.statusCode = 500;\n        res.end(\"Internal Server Error\");\n      }\n    }\n  };\n}\n\n/** @deprecated Use `createCopilotNodeHandler` instead. */\nexport const createNodeFetchHandler = createCopilotNodeHandler;\n\n/**\n * Build a Fetch Request from a Node IncomingMessage whose body stream has\n * already been consumed by a body parser.\n *\n * The URL, headers and abort wiring match `createRequest` (the streaming path),\n * so a request routes the same way whether or not a parser ran first. In\n * particular the URL comes from `req.url`, which is what a mounting router\n * matched against; `originalUrl` still carries the mount prefix and would miss\n * the handler's `basePath`.\n */\nfunction buildPreParsedRequest(\n  req: IncomingMessage & { body?: unknown },\n  res: ServerResponse,\n): Request {\n  const method = (req.method ?? \"GET\").toUpperCase();\n  const headers = createHeaders(req);\n  const protocol =\n    \"encrypted\" in req.socket && req.socket.encrypted ? \"https:\" : \"http:\";\n  const host = headers.get(\"host\") ?? \"localhost\";\n  const url = new URL(req.url ?? \"/\", `${protocol}//${host}`);\n\n  // Wire an AbortSignal so client disconnects propagate to the fetch handler\n  const controller = new AbortController();\n  res.on(\"close\", () => {\n    if (!res.writableFinished) controller.abort();\n  });\n\n  const init: RequestInit = {\n    method,\n    headers,\n    signal: controller.signal,\n  };\n\n  const { body, contentType } = synthesizeBody(req.body);\n  if (contentType) {\n    headers.set(\"content-type\", contentType);\n  }\n  headers.delete(\"content-length\");\n  if (body !== undefined) {\n    init.body = body;\n  }\n\n  return new Request(url, init);\n}\n\nfunction hasPreParsedBody(req: IncomingMessage & { body?: unknown }): boolean {\n  if (req.body === undefined || req.body === null) return false;\n\n  // Only `readableEnded` means \"a parser drained this stream to its end\".\n  // `req.complete` and the private `_readableState.ended` are set by the HTTP\n  // parser once the socket has all the bytes, whether or not anything read them.\n  //\n  // That distinction matters because `req.body` being set does not prove a parser\n  // ran: body-parser 1.x (Express 4) assigns `req.body = req.body || {}` before\n  // its own content-type checks, so a request it declines to parse — multipart\n  // upload, text/plain — reaches us with `req.body === {}` and a full, unread\n  // stream. Treating that as pre-parsed rebuilt the request from `{}` and\n  // dropped the real payload.\n  return Boolean(req.readableEnded);\n}\n\nfunction synthesizeBody(body: unknown): {\n  body?: BodyInit;\n  contentType?: string;\n} {\n  if (Buffer.isBuffer(body) || body instanceof Uint8Array) {\n    // Buffer/Uint8Array<ArrayBufferLike> are valid fetch bodies at runtime,\n    // but the DOM lib's BodyInit only admits ArrayBuffer-backed views.\n    return { body: body as BodyInit };\n  }\n  if (typeof body === \"string\") {\n    return { body };\n  }\n  if (typeof body === \"object\" && body !== null) {\n    return { body: JSON.stringify(body), contentType: \"application/json\" };\n  }\n  return {};\n}\n"],"mappings":";;;;;;AAgCA,MAAM,uBAAuB,IAAI,IAAI;CAAC;CAAO;CAAQ;CAAU,CAAC;AAOhE,SAAgB,yBACd,SACkB;AAClB,QAAO,OAAO,KAAsB,QAAwB;AAC1D,MAAI;GACF,MAAM,UAAU,IAAI,UAAU,OAAO,aAAa;AAMlD,wDAAmB,KADF,MAAM,QAHrB,CAAC,qBAAqB,IAAI,OAAO,IAAI,iBAAiB,IAAI,GACtD,sBAAsB,KAAK,IAAI,mDACjB,KAAK,IAAI,CACW,CACP;WAC1B,KAAc;AACrB,6BAAO,MAAM,EAAE,KAAK,EAAE,8BAA8B;AACpD,OAAI,CAAC,IAAI,aAAa;AACpB,QAAI,aAAa;AACjB,QAAI,IAAI,wBAAwB;;;;;;AAOxC,MAAa,yBAAyB;;;;;;;;;;;AAYtC,SAAS,sBACP,KACA,KACS;CACT,MAAM,UAAU,IAAI,UAAU,OAAO,aAAa;CAClD,MAAM,0DAAwB,IAAI;CAClC,MAAM,WACJ,eAAe,IAAI,UAAU,IAAI,OAAO,YAAY,WAAW;CACjE,MAAM,OAAO,QAAQ,IAAI,OAAO,IAAI;CACpC,MAAM,MAAM,IAAI,IAAI,IAAI,OAAO,KAAK,GAAG,SAAS,IAAI,OAAO;CAG3D,MAAM,aAAa,IAAI,iBAAiB;AACxC,KAAI,GAAG,eAAe;AACpB,MAAI,CAAC,IAAI,iBAAkB,YAAW,OAAO;GAC7C;CAEF,MAAM,OAAoB;EACxB;EACA;EACA,QAAQ,WAAW;EACpB;CAED,MAAM,EAAE,MAAM,gBAAgB,eAAe,IAAI,KAAK;AACtD,KAAI,YACF,SAAQ,IAAI,gBAAgB,YAAY;AAE1C,SAAQ,OAAO,iBAAiB;AAChC,KAAI,SAAS,OACX,MAAK,OAAO;AAGd,QAAO,IAAI,QAAQ,KAAK,KAAK;;AAG/B,SAAS,iBAAiB,KAAoD;AAC5E,KAAI,IAAI,SAAS,UAAa,IAAI,SAAS,KAAM,QAAO;AAYxD,QAAO,QAAQ,IAAI,cAAc;;AAGnC,SAAS,eAAe,MAGtB;AACA,KAAI,OAAO,SAAS,KAAK,IAAI,gBAAgB,WAG3C,QAAO,EAAQ,MAAkB;AAEnC,KAAI,OAAO,SAAS,SAClB,QAAO,EAAE,MAAM;AAEjB,KAAI,OAAO,SAAS,YAAY,SAAS,KACvC,QAAO;EAAE,MAAM,KAAK,UAAU,KAAK;EAAE,aAAa;EAAoB;AAExE,QAAO,EAAE"}

package/dist/v2/runtime/endpoints/node-fetch-handler.d.cts

@@ -1,12 +0,0 @@
-
-import { CopilotRuntimeFetchHandler } from "../core/fetch-handler.cjs";
-import { IncomingMessage, ServerResponse } from "node:http";
-
-//#region src/v2/runtime/endpoints/node-fetch-handler.d.ts
-type NodeFetchHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-declare function createCopilotNodeHandler(handler: CopilotRuntimeFetchHandler): NodeFetchHandler;
-/** @deprecated Use `createCopilotNodeHandler` instead. */
-declare const createNodeFetchHandler: typeof createCopilotNodeHandler;
-//#endregion
-export { NodeFetchHandler, createCopilotNodeHandler, createNodeFetchHandler };
-//# sourceMappingURL=node-fetch-handler.d.cts.map

package/dist/v2/runtime/endpoints/node-fetch-handler.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-fetch-handler.d.cts","names":[],"sources":["../../../../src/v2/runtime/endpoints/node-fetch-handler.ts"],"mappings":";;;;;KAkCY,gBAAA,IACV,GAAA,EAAK,eAAA,EACL,GAAA,EAAK,cAAA,KACF,OAAA;AAAA,iBAEW,wBAAA,CACd,OAAA,EAAS,0BAAA,GACR,gBAAA;;cAqBU,sBAAA,SAAsB,wBAAA"}

package/dist/v2/runtime/endpoints/node-fetch-handler.d.mts

@@ -1,12 +0,0 @@
-
-import { CopilotRuntimeFetchHandler } from "../core/fetch-handler.mjs";
-import { IncomingMessage, ServerResponse } from "node:http";
-
-//#region src/v2/runtime/endpoints/node-fetch-handler.d.ts
-type NodeFetchHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-declare function createCopilotNodeHandler(handler: CopilotRuntimeFetchHandler): NodeFetchHandler;
-/** @deprecated Use `createCopilotNodeHandler` instead. */
-declare const createNodeFetchHandler: typeof createCopilotNodeHandler;
-//#endregion
-export { NodeFetchHandler, createCopilotNodeHandler, createNodeFetchHandler };
-//# sourceMappingURL=node-fetch-handler.d.mts.map

package/dist/v2/runtime/endpoints/node-fetch-handler.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-fetch-handler.d.mts","names":[],"sources":["../../../../src/v2/runtime/endpoints/node-fetch-handler.ts"],"mappings":";;;;;KAkCY,gBAAA,IACV,GAAA,EAAK,eAAA,EACL,GAAA,EAAK,cAAA,KACF,OAAA;AAAA,iBAEW,wBAAA,CACd,OAAA,EAAS,0BAAA,GACR,gBAAA;;cAqBU,sBAAA,SAAsB,wBAAA"}

package/dist/v2/runtime/endpoints/node-fetch-handler.mjs

@@ -1,74 +0,0 @@
-import "reflect-metadata";
-import { logger } from "@copilotkit/shared";
-import { createHeaders, createRequest, sendResponse } from "@remix-run/node-fetch-server";
-
-//#region src/v2/runtime/endpoints/node-fetch-handler.ts
-const METHODS_WITHOUT_BODY = new Set([
-	"GET",
-	"HEAD",
-	"OPTIONS"
-]);
-function createCopilotNodeHandler(handler) {
-	return async (req, res) => {
-		try {
-			const method = (req.method ?? "GET").toUpperCase();
-			await sendResponse(res, await handler(!METHODS_WITHOUT_BODY.has(method) && hasPreParsedBody(req) ? buildPreParsedRequest(req, res) : createRequest(req, res)));
-		} catch (err) {
-			logger.error({ err }, "Error in Node fetch handler");
-			if (!res.headersSent) {
-				res.statusCode = 500;
-				res.end("Internal Server Error");
-			}
-		}
-	};
-}
-/** @deprecated Use `createCopilotNodeHandler` instead. */
-const createNodeFetchHandler = createCopilotNodeHandler;
-/**
-* Build a Fetch Request from a Node IncomingMessage whose body stream has
-* already been consumed by a body parser.
-*
-* The URL, headers and abort wiring match `createRequest` (the streaming path),
-* so a request routes the same way whether or not a parser ran first. In
-* particular the URL comes from `req.url`, which is what a mounting router
-* matched against; `originalUrl` still carries the mount prefix and would miss
-* the handler's `basePath`.
-*/
-function buildPreParsedRequest(req, res) {
-	const method = (req.method ?? "GET").toUpperCase();
-	const headers = createHeaders(req);
-	const protocol = "encrypted" in req.socket && req.socket.encrypted ? "https:" : "http:";
-	const host = headers.get("host") ?? "localhost";
-	const url = new URL(req.url ?? "/", `${protocol}//${host}`);
-	const controller = new AbortController();
-	res.on("close", () => {
-		if (!res.writableFinished) controller.abort();
-	});
-	const init = {
-		method,
-		headers,
-		signal: controller.signal
-	};
-	const { body, contentType } = synthesizeBody(req.body);
-	if (contentType) headers.set("content-type", contentType);
-	headers.delete("content-length");
-	if (body !== void 0) init.body = body;
-	return new Request(url, init);
-}
-function hasPreParsedBody(req) {
-	if (req.body === void 0 || req.body === null) return false;
-	return Boolean(req.readableEnded);
-}
-function synthesizeBody(body) {
-	if (Buffer.isBuffer(body) || body instanceof Uint8Array) return { body };
-	if (typeof body === "string") return { body };
-	if (typeof body === "object" && body !== null) return {
-		body: JSON.stringify(body),
-		contentType: "application/json"
-	};
-	return {};
-}
-
-//#endregion
-export { createCopilotNodeHandler, createNodeFetchHandler };
-//# sourceMappingURL=node-fetch-handler.mjs.map

package/dist/v2/runtime/endpoints/node-fetch-handler.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"node-fetch-handler.mjs","names":[],"sources":["../../../../src/v2/runtime/endpoints/node-fetch-handler.ts"],"sourcesContent":["/**\n * Generic Node ↔ Fetch bridge for CopilotKit runtime.\n *\n * Wraps a `CopilotRuntimeFetchHandler` as a Node HTTP handler using\n * `@remix-run/node-fetch-server` for reliable streaming and conversion.\n *\n * When body-parsing middleware (Express `express.json()`, NestJS's default\n * parser, …) runs first, the Node request stream is already consumed and\n * `req.body` holds the parsed content. Reading the exhausted stream would hang,\n * so that case re-serialises `req.body` into the Fetch `Request` instead.\n *\n * @example\n * ```typescript\n * import { createServer } from \"node:http\";\n * import { createCopilotRuntimeHandler } from \"@copilotkit/runtime/v2\";\n * import { createCopilotNodeHandler } from \"@copilotkit/runtime/v2/node\";\n *\n * const handler = createCopilotRuntimeHandler({ runtime, basePath: \"/api/copilotkit\", cors: true });\n * const nodeHandler = createCopilotNodeHandler(handler);\n * createServer(nodeHandler).listen(3000);\n * ```\n */\n\nimport type { IncomingMessage, ServerResponse } from \"node:http\";\nimport {\n  createHeaders,\n  createRequest,\n  sendResponse,\n} from \"@remix-run/node-fetch-server\";\nimport type { CopilotRuntimeFetchHandler } from \"../core/fetch-handler\";\nimport { logger } from \"@copilotkit/shared\";\n\nconst METHODS_WITHOUT_BODY = new Set([\"GET\", \"HEAD\", \"OPTIONS\"]);\n\nexport type NodeFetchHandler = (\n  req: IncomingMessage,\n  res: ServerResponse,\n) => Promise<void>;\n\nexport function createCopilotNodeHandler(\n  handler: CopilotRuntimeFetchHandler,\n): NodeFetchHandler {\n  return async (req: IncomingMessage, res: ServerResponse) => {\n    try {\n      const method = (req.method ?? \"GET\").toUpperCase();\n      const fetchReq =\n        !METHODS_WITHOUT_BODY.has(method) && hasPreParsedBody(req)\n          ? buildPreParsedRequest(req, res)\n          : createRequest(req, res);\n      const fetchRes = await handler(fetchReq);\n      await sendResponse(res, fetchRes);\n    } catch (err: unknown) {\n      logger.error({ err }, \"Error in Node fetch handler\");\n      if (!res.headersSent) {\n        res.statusCode = 500;\n        res.end(\"Internal Server Error\");\n      }\n    }\n  };\n}\n\n/** @deprecated Use `createCopilotNodeHandler` instead. */\nexport const createNodeFetchHandler = createCopilotNodeHandler;\n\n/**\n * Build a Fetch Request from a Node IncomingMessage whose body stream has\n * already been consumed by a body parser.\n *\n * The URL, headers and abort wiring match `createRequest` (the streaming path),\n * so a request routes the same way whether or not a parser ran first. In\n * particular the URL comes from `req.url`, which is what a mounting router\n * matched against; `originalUrl` still carries the mount prefix and would miss\n * the handler's `basePath`.\n */\nfunction buildPreParsedRequest(\n  req: IncomingMessage & { body?: unknown },\n  res: ServerResponse,\n): Request {\n  const method = (req.method ?? \"GET\").toUpperCase();\n  const headers = createHeaders(req);\n  const protocol =\n    \"encrypted\" in req.socket && req.socket.encrypted ? \"https:\" : \"http:\";\n  const host = headers.get(\"host\") ?? \"localhost\";\n  const url = new URL(req.url ?? \"/\", `${protocol}//${host}`);\n\n  // Wire an AbortSignal so client disconnects propagate to the fetch handler\n  const controller = new AbortController();\n  res.on(\"close\", () => {\n    if (!res.writableFinished) controller.abort();\n  });\n\n  const init: RequestInit = {\n    method,\n    headers,\n    signal: controller.signal,\n  };\n\n  const { body, contentType } = synthesizeBody(req.body);\n  if (contentType) {\n    headers.set(\"content-type\", contentType);\n  }\n  headers.delete(\"content-length\");\n  if (body !== undefined) {\n    init.body = body;\n  }\n\n  return new Request(url, init);\n}\n\nfunction hasPreParsedBody(req: IncomingMessage & { body?: unknown }): boolean {\n  if (req.body === undefined || req.body === null) return false;\n\n  // Only `readableEnded` means \"a parser drained this stream to its end\".\n  // `req.complete` and the private `_readableState.ended` are set by the HTTP\n  // parser once the socket has all the bytes, whether or not anything read them.\n  //\n  // That distinction matters because `req.body` being set does not prove a parser\n  // ran: body-parser 1.x (Express 4) assigns `req.body = req.body || {}` before\n  // its own content-type checks, so a request it declines to parse — multipart\n  // upload, text/plain — reaches us with `req.body === {}` and a full, unread\n  // stream. Treating that as pre-parsed rebuilt the request from `{}` and\n  // dropped the real payload.\n  return Boolean(req.readableEnded);\n}\n\nfunction synthesizeBody(body: unknown): {\n  body?: BodyInit;\n  contentType?: string;\n} {\n  if (Buffer.isBuffer(body) || body instanceof Uint8Array) {\n    // Buffer/Uint8Array<ArrayBufferLike> are valid fetch bodies at runtime,\n    // but the DOM lib's BodyInit only admits ArrayBuffer-backed views.\n    return { body: body as BodyInit };\n  }\n  if (typeof body === \"string\") {\n    return { body };\n  }\n  if (typeof body === \"object\" && body !== null) {\n    return { body: JSON.stringify(body), contentType: \"application/json\" };\n  }\n  return {};\n}\n"],"mappings":";;;;;AAgCA,MAAM,uBAAuB,IAAI,IAAI;CAAC;CAAO;CAAQ;CAAU,CAAC;AAOhE,SAAgB,yBACd,SACkB;AAClB,QAAO,OAAO,KAAsB,QAAwB;AAC1D,MAAI;GACF,MAAM,UAAU,IAAI,UAAU,OAAO,aAAa;AAMlD,SAAM,aAAa,KADF,MAAM,QAHrB,CAAC,qBAAqB,IAAI,OAAO,IAAI,iBAAiB,IAAI,GACtD,sBAAsB,KAAK,IAAI,GAC/B,cAAc,KAAK,IAAI,CACW,CACP;WAC1B,KAAc;AACrB,UAAO,MAAM,EAAE,KAAK,EAAE,8BAA8B;AACpD,OAAI,CAAC,IAAI,aAAa;AACpB,QAAI,aAAa;AACjB,QAAI,IAAI,wBAAwB;;;;;;AAOxC,MAAa,yBAAyB;;;;;;;;;;;AAYtC,SAAS,sBACP,KACA,KACS;CACT,MAAM,UAAU,IAAI,UAAU,OAAO,aAAa;CAClD,MAAM,UAAU,cAAc,IAAI;CAClC,MAAM,WACJ,eAAe,IAAI,UAAU,IAAI,OAAO,YAAY,WAAW;CACjE,MAAM,OAAO,QAAQ,IAAI,OAAO,IAAI;CACpC,MAAM,MAAM,IAAI,IAAI,IAAI,OAAO,KAAK,GAAG,SAAS,IAAI,OAAO;CAG3D,MAAM,aAAa,IAAI,iBAAiB;AACxC,KAAI,GAAG,eAAe;AACpB,MAAI,CAAC,IAAI,iBAAkB,YAAW,OAAO;GAC7C;CAEF,MAAM,OAAoB;EACxB;EACA;EACA,QAAQ,WAAW;EACpB;CAED,MAAM,EAAE,MAAM,gBAAgB,eAAe,IAAI,KAAK;AACtD,KAAI,YACF,SAAQ,IAAI,gBAAgB,YAAY;AAE1C,SAAQ,OAAO,iBAAiB;AAChC,KAAI,SAAS,OACX,MAAK,OAAO;AAGd,QAAO,IAAI,QAAQ,KAAK,KAAK;;AAG/B,SAAS,iBAAiB,KAAoD;AAC5E,KAAI,IAAI,SAAS,UAAa,IAAI,SAAS,KAAM,QAAO;AAYxD,QAAO,QAAQ,IAAI,cAAc;;AAGnC,SAAS,eAAe,MAGtB;AACA,KAAI,OAAO,SAAS,KAAK,IAAI,gBAAgB,WAG3C,QAAO,EAAQ,MAAkB;AAEnC,KAAI,OAAO,SAAS,SAClB,QAAO,EAAE,MAAM;AAEjB,KAAI,OAAO,SAAS,YAAY,SAAS,KACvC,QAAO;EAAE,MAAM,KAAK,UAAU,KAAK;EAAE,aAAa;EAAoB;AAExE,QAAO,EAAE"}

package/dist/v2/runtime/endpoints/node.cjs

@@ -1,17 +0,0 @@
-require("reflect-metadata");
-const require_fetch_handler = require('../core/fetch-handler.cjs');
-const require_node_fetch_handler = require('./node-fetch-handler.cjs');
-const require_auto_start_channels = require('./auto-start-channels.cjs');
-
-//#region src/v2/runtime/endpoints/node.ts
-function createCopilotNodeListener(options) {
-	const handler = require_fetch_handler.createCopilotRuntimeHandler(options);
-	const listener = require_node_fetch_handler.createCopilotNodeHandler(handler);
-	listener.channels = handler.channels;
-	require_auto_start_channels.autoStartChannels(listener.channels);
-	return listener;
-}
-
-//#endregion
-exports.createCopilotNodeListener = createCopilotNodeListener;
-//# sourceMappingURL=node.cjs.map

package/dist/v2/runtime/endpoints/node.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.cjs","names":["createCopilotRuntimeHandler","createCopilotNodeHandler"],"sources":["../../../../src/v2/runtime/endpoints/node.ts"],"sourcesContent":["import { createCopilotRuntimeHandler } from \"../core/fetch-handler\";\nimport type { CopilotRuntimeHandlerOptions } from \"../core/fetch-handler\";\nimport type { RuntimeWithDeclaredChannels } from \"../core/runtime\";\nimport type { ChannelsControl } from \"../core/channel-manager\";\nimport { createCopilotNodeHandler } from \"./node-fetch-handler\";\nimport type { NodeFetchHandler } from \"./node-fetch-handler\";\nimport { autoStartChannels } from \"./auto-start-channels\";\n\n/**\n * A Node.js HTTP request listener that is also a callable object carrying an\n * optional {@link ChannelsControl} surface, mirroring\n * `CopilotRuntimeFetchHandler.channels`. Node is the long-running,\n * lifecycle-owning entry point for the runtime, so it is the surface that\n * exposes `.channels` for callers that need to observe or stop the managed\n * Channel activation the listener starts at creation.\n */\nexport type NodeCopilotListener = NodeFetchHandler & {\n  channels?: ChannelsControl;\n};\n\n/**\n * A {@link NodeCopilotListener} whose {@link ChannelsControl} surface is\n * guaranteed present. Returned when the runtime was constructed with at least\n * one declared Intelligence Channel and activation was not opted out of, so the\n * documented `listener.channels.ready(...)` call type-checks without a `!` or a\n * `?.` under strict TypeScript — the Node mirror of\n * `CopilotRuntimeFetchHandlerWithChannels`.\n */\nexport type NodeCopilotListenerWithChannels = NodeFetchHandler & {\n  /** Lifecycle control surface for the runtime's declared managed Channels. */\n  channels: ChannelsControl;\n};\n\n/**\n * Convenience wrapper for creating a Node.js HTTP request listener\n * from CopilotKit runtime handler options.\n *\n * When the runtime declares managed Channels (and activation was not opted\n * out of via `activateChannels: false`), the returned listener exposes\n * `.channels` — the same {@link ChannelsControl} surface carried by the\n * underlying fetch handler.\n *\n * ## Managed Channels lifecycle\n *\n * Creating the listener STARTS activation — which opens the persistent Realtime\n * Gateway WebSocket and starts every direct adapter on the declared Channels.\n * Node owns its own process lifetime, so there is nothing to defer to and no\n * required incantation: a declared Channel connects because it was declared.\n * (The generic `createCopilotRuntimeHandler` is the opposite — it stays lazy for\n * serverless/edge safety; see its TSDoc.)\n *\n * `await listener.channels.ready()` is therefore OPTIONAL and purely\n * await-and-observe: it resolves once every declared Channel has settled to\n * `online`/`setup_required` and rejects with the activation failure, observing\n * the activation started at creation rather than triggering a second one. Await\n * it when startup should block on Channels being live (or should exit non-zero\n * when they are not); skip it and activation failures land in the logs instead.\n * `listener.channels.stop()` tears activation down.\n *\n * Pass `activateChannels: false` to build no control surface and open no socket\n * — the clean opt-out for a test or a short-lived script that mounts the\n * listener without wanting its Channels connected.\n *\n * @example\n * ```typescript\n * import { createServer } from \"node:http\";\n * import { CopilotRuntime } from \"@copilotkit/runtime/v2\";\n * import { createCopilotNodeListener } from \"@copilotkit/runtime/v2/node\";\n *\n * const listener = createCopilotNodeListener({\n *   runtime: new CopilotRuntime({ agents: { ... } }),\n *   basePath: \"/api/copilotkit\",\n *   cors: true,\n * });\n * createServer(listener).listen(3000);\n * // Declared managed Channels are already connecting at this point.\n *\n * // Optional: block startup on them being live. Bound it so one wedged adapter\n * // cannot hang startup forever.\n * await listener.channels.ready({ timeoutMs: 30_000 });\n * ```\n */\n/**\n * Overload: a runtime constructed with at least one declared Intelligence\n * Channel (a {@link RuntimeWithDeclaredChannels}-branded runtime), when\n * activation is not disabled, yields a listener with a **non-optional**\n * {@link ChannelsControl}. `activateChannels` is constrained to\n * `true | undefined` here so passing `activateChannels: false` (which leaves no\n * `.channels`) falls through to the optional-shape overload below rather than\n * dishonestly promising a control surface that will not exist. Mirrors the\n * `createCopilotRuntimeHandler` overload pair so the brand survives the wrapper.\n *\n * The brand comes from constructing the runtime with a literal non-empty\n * `channels` list (`readonly [Channel, ...Channel[]]`). A runtime built from a\n * dynamically-assembled `Channel[]` is not branded, so it falls to the\n * optional-shape overload and its call sites still need `?.`.\n */\nexport function createCopilotNodeListener(\n  options: CopilotRuntimeHandlerOptions & {\n    runtime: RuntimeWithDeclaredChannels;\n    activateChannels?: true | undefined;\n  },\n): NodeCopilotListenerWithChannels;\n/**\n * Overload: every other runtime (SSE, Intelligence without channels, or with\n * activation disabled) yields a listener whose `.channels` is optional.\n */\nexport function createCopilotNodeListener(\n  options: CopilotRuntimeHandlerOptions,\n): NodeCopilotListener;\nexport function createCopilotNodeListener(\n  options: CopilotRuntimeHandlerOptions,\n): NodeCopilotListener {\n  const handler = createCopilotRuntimeHandler(options);\n  const listener: NodeCopilotListener = createCopilotNodeHandler(handler);\n  listener.channels = handler.channels;\n  autoStartChannels(listener.channels);\n  return listener;\n}\n"],"mappings":";;;;;;AA8GA,SAAgB,0BACd,SACqB;CACrB,MAAM,UAAUA,kDAA4B,QAAQ;CACpD,MAAM,WAAgCC,oDAAyB,QAAQ;AACvE,UAAS,WAAW,QAAQ;AAC5B,+CAAkB,SAAS,SAAS;AACpC,QAAO"}