@copilotkit/runtime 2.0.0-next.1 → 2.0.0-rc.1

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

@@ -0,0 +1,73 @@
+import { logger } from "@copilotkit/shared";
+import { createHeaders, createRequest, sendResponse } from "@remix-run/node-fetch-server";
+
+//#region src/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/runtime/endpoints/node-fetch-handler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-fetch-handler.mjs","names":[],"sources":["../../../src/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\";\n * import { createCopilotNodeHandler } from \"@copilotkit/runtime/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/runtime/endpoints/node.cjs

@@ -0,0 +1,16 @@
+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/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/runtime/endpoints/node.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.cjs","names":["createCopilotRuntimeHandler","createCopilotNodeHandler"],"sources":["../../../src/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\";\n * import { createCopilotNodeListener } from \"@copilotkit/runtime/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"}

package/dist/runtime/endpoints/node.d.cts

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

package/dist/runtime/endpoints/node.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.cts","names":[],"sources":["../../../src/runtime/endpoints/node.ts"],"mappings":";;;;;;;;AAgBA;;;;;;KAAY,mBAAA,GAAsB,gBAAA;EAChC,QAAA,GAAW,eAAA;AAAA;AAWb;;;;;;;;AAAA,KAAY,+BAAA,GAAkC,gBAAA;EAqE9B,6EAnEd,QAAA,EAAU,eAAA;AAAA;;;;;;;;;;;;;;AA6EZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAVgB,yBAAA,CACd,OAAA,EAAS,4BAAA;EACP,OAAA,EAAS,2BAAA;EACT,gBAAA;AAAA,IAED,+BAAA;;;;;iBAKa,yBAAA,CACd,OAAA,EAAS,4BAAA,GACR,mBAAA"}

package/dist/runtime/endpoints/node.d.mts

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

package/dist/runtime/endpoints/node.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.mts","names":[],"sources":["../../../src/runtime/endpoints/node.ts"],"mappings":";;;;;;;;AAgBA;;;;;;KAAY,mBAAA,GAAsB,gBAAA;EAChC,QAAA,GAAW,eAAA;AAAA;AAWb;;;;;;;;AAAA,KAAY,+BAAA,GAAkC,gBAAA;EAqE9B,6EAnEd,QAAA,EAAU,eAAA;AAAA;;;;;;;;;;;;;;AA6EZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAVgB,yBAAA,CACd,OAAA,EAAS,4BAAA;EACP,OAAA,EAAS,2BAAA;EACT,gBAAA;AAAA,IAED,+BAAA;;;;;iBAKa,yBAAA,CACd,OAAA,EAAS,4BAAA,GACR,mBAAA"}

package/dist/runtime/endpoints/node.mjs

@@ -0,0 +1,16 @@
+import { createCopilotRuntimeHandler } from "../core/fetch-handler.mjs";
+import { createCopilotNodeHandler } from "./node-fetch-handler.mjs";
+import { autoStartChannels } from "./auto-start-channels.mjs";
+
+//#region src/runtime/endpoints/node.ts
+function createCopilotNodeListener(options) {
+	const handler = createCopilotRuntimeHandler(options);
+	const listener = createCopilotNodeHandler(handler);
+	listener.channels = handler.channels;
+	autoStartChannels(listener.channels);
+	return listener;
+}
+
+//#endregion
+export { createCopilotNodeListener };
+//# sourceMappingURL=node.mjs.map

package/dist/runtime/endpoints/node.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.mjs","names":[],"sources":["../../../src/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\";\n * import { createCopilotNodeListener } from \"@copilotkit/runtime/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,UAAU,4BAA4B,QAAQ;CACpD,MAAM,WAAgC,yBAAyB,QAAQ;AACvE,UAAS,WAAW,QAAQ;AAC5B,mBAAkB,SAAS,SAAS;AACpC,QAAO"}

package/dist/runtime/endpoints/single-route-helpers.cjs

@@ -0,0 +1,130 @@
+
+//#region src/runtime/endpoints/single-route-helpers.ts
+const METHOD_NAMES = [
+	"agent/run",
+	"agent/suggest",
+	"agent/connect",
+	"trajectory/connect",
+	"agent/stop",
+	"info",
+	"inspector/metadata",
+	"inspector/learning",
+	"transcribe",
+	"resource/request"
+];
+/**
+* Detect a single-route JSON envelope on a request the multi-route router
+* could not match.
+*
+* A single-endpoint client (`useSingleEndpoint` on the frontend provider)
+* POSTs `{ method, params, body }` at the base path. A multi-route runtime
+* matches no route for that path and would otherwise answer a bare 404, giving
+* the developer nothing to go on. Recognising the envelope here lets the
+* handler name the actual cause instead.
+*
+* Deliberately conservative: it reports a method only for a POST carrying a
+* JSON body whose `method` is one the single-route endpoint actually accepts.
+* Anything else is a genuine 404 and must stay one.
+*
+* @returns The envelope's method name, or `null` if this is not an envelope.
+*/
+async function detectSingleRouteEnvelope(request) {
+	if (request.method !== "POST") return null;
+	if (!(request.headers.get("content-type") || "").includes("application/json")) return null;
+	let envelope;
+	try {
+		envelope = await request.clone().json();
+	} catch {
+		return null;
+	}
+	if (typeof envelope !== "object" || envelope === null) return null;
+	const method = envelope.method;
+	if (typeof method !== "string") return null;
+	if (!METHOD_NAMES.includes(method)) return null;
+	return method;
+}
+async function parseMethodCall(request) {
+	if (!(request.headers.get("content-type") || "").includes("application/json")) throw createResponseError("Single-route endpoint expects JSON payloads", 415);
+	let jsonEnvelope;
+	try {
+		jsonEnvelope = await request.clone().json();
+	} catch {
+		throw createResponseError("Invalid JSON payload", 400);
+	}
+	return {
+		method: validateMethod(jsonEnvelope.method),
+		params: jsonEnvelope.params,
+		body: jsonEnvelope.body
+	};
+}
+function expectString(params, key) {
+	const value = params?.[key];
+	if (typeof value === "string" && value.trim().length > 0) return value;
+	throw createResponseError(`Missing or invalid parameter '${key}'`, 400);
+}
+function createJsonRequest(base, body) {
+	if (body === void 0 || body === null) throw createResponseError("Missing request body for JSON handler", 400);
+	const headers = new Headers(base.headers);
+	headers.set("content-type", "application/json");
+	headers.delete("content-length");
+	const serializedBody = serializeJsonBody(body);
+	return new Request(base.url, {
+		method: "POST",
+		headers,
+		body: serializedBody,
+		signal: base.signal
+	});
+}
+/**
+* Rebuild a resource request carried inside the single-route JSON envelope.
+*
+* The resource path must stay relative to the mounted Runtime. This prevents
+* the envelope from becoming an open HTTP proxy while preserving the method,
+* query string, headers, and cancellation signal used by the REST handler.
+*/
+function createResourceRequest(base, path, httpMethod, body) {
+	if (!path.startsWith("/") || path.startsWith("//")) throw createResponseError("Resource path must be Runtime-relative", 400);
+	const resourceUrl = new URL(path, "http://copilotkit.resource");
+	if (resourceUrl.origin !== "http://copilotkit.resource") throw createResponseError("Resource path must be Runtime-relative", 400);
+	const targetUrl = new URL(base.url);
+	targetUrl.pathname = `${targetUrl.pathname.replace(/\/$/, "")}${resourceUrl.pathname}`;
+	targetUrl.search = resourceUrl.search;
+	const method = httpMethod.toUpperCase();
+	const headers = new Headers(base.headers);
+	headers.delete("content-length");
+	const hasBody = method !== "GET" && method !== "HEAD" && body != null;
+	return new Request(targetUrl, {
+		method,
+		headers,
+		...hasBody ? { body: serializeJsonBody(body) } : {},
+		signal: base.signal
+	});
+}
+function createResponseError(message, status) {
+	return new Response(JSON.stringify({
+		error: "invalid_request",
+		message
+	}), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+function validateMethod(method) {
+	if (!method) throw createResponseError("Missing method field", 400);
+	if (METHOD_NAMES.includes(method)) return method;
+	throw createResponseError(`Unsupported method '${method}'`, 400);
+}
+function serializeJsonBody(body) {
+	if (typeof body === "string") return body;
+	if (body instanceof Blob || body instanceof ArrayBuffer || body instanceof Uint8Array) return body;
+	if (body instanceof FormData || body instanceof URLSearchParams) return body;
+	return JSON.stringify(body);
+}
+
+//#endregion
+exports.createJsonRequest = createJsonRequest;
+exports.createResourceRequest = createResourceRequest;
+exports.detectSingleRouteEnvelope = detectSingleRouteEnvelope;
+exports.expectString = expectString;
+exports.parseMethodCall = parseMethodCall;
+//# sourceMappingURL=single-route-helpers.cjs.map

package/dist/runtime/endpoints/single-route-helpers.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-route-helpers.cjs","names":[],"sources":["../../../src/runtime/endpoints/single-route-helpers.ts"],"sourcesContent":["const METHOD_NAMES = [\n  \"agent/run\",\n  \"agent/suggest\",\n  \"agent/connect\",\n  \"trajectory/connect\",\n  \"agent/stop\",\n  \"info\",\n  \"inspector/metadata\",\n  \"inspector/learning\",\n  \"transcribe\",\n  \"resource/request\",\n] as const;\n\nexport type EndpointMethod = (typeof METHOD_NAMES)[number];\n\ninterface JsonEnvelope {\n  method?: string;\n  params?: Record<string, unknown>;\n  body?: unknown;\n}\n\nexport interface MethodCall {\n  method: EndpointMethod;\n  params?: Record<string, unknown>;\n  body?: unknown;\n}\n\n/**\n * Detect a single-route JSON envelope on a request the multi-route router\n * could not match.\n *\n * A single-endpoint client (`useSingleEndpoint` on the frontend provider)\n * POSTs `{ method, params, body }` at the base path. A multi-route runtime\n * matches no route for that path and would otherwise answer a bare 404, giving\n * the developer nothing to go on. Recognising the envelope here lets the\n * handler name the actual cause instead.\n *\n * Deliberately conservative: it reports a method only for a POST carrying a\n * JSON body whose `method` is one the single-route endpoint actually accepts.\n * Anything else is a genuine 404 and must stay one.\n *\n * @returns The envelope's method name, or `null` if this is not an envelope.\n */\nexport async function detectSingleRouteEnvelope(\n  request: Request,\n): Promise<EndpointMethod | null> {\n  if (request.method !== \"POST\") return null;\n\n  const contentType = request.headers.get(\"content-type\") || \"\";\n  if (!contentType.includes(\"application/json\")) return null;\n\n  let envelope: unknown;\n  try {\n    envelope = await request.clone().json();\n  } catch {\n    return null;\n  }\n\n  if (typeof envelope !== \"object\" || envelope === null) return null;\n\n  const method = (envelope as JsonEnvelope).method;\n  if (typeof method !== \"string\") return null;\n  if (!(METHOD_NAMES as readonly string[]).includes(method)) return null;\n\n  return method as EndpointMethod;\n}\n\nexport async function parseMethodCall(request: Request): Promise<MethodCall> {\n  const contentType = request.headers.get(\"content-type\") || \"\";\n\n  if (!contentType.includes(\"application/json\")) {\n    throw createResponseError(\n      \"Single-route endpoint expects JSON payloads\",\n      415,\n    );\n  }\n\n  let jsonEnvelope: JsonEnvelope;\n  try {\n    jsonEnvelope = (await request.clone().json()) as JsonEnvelope;\n  } catch {\n    throw createResponseError(\"Invalid JSON payload\", 400);\n  }\n\n  const method = validateMethod(jsonEnvelope.method);\n\n  return {\n    method,\n    params: jsonEnvelope.params,\n    body: jsonEnvelope.body,\n  };\n}\n\nexport function expectString(\n  params: Record<string, unknown> | undefined,\n  key: string,\n): string {\n  const value = params?.[key];\n  if (typeof value === \"string\" && value.trim().length > 0) {\n    return value;\n  }\n\n  throw createResponseError(`Missing or invalid parameter '${key}'`, 400);\n}\n\nexport function createJsonRequest(base: Request, body: unknown): Request {\n  if (body === undefined || body === null) {\n    throw createResponseError(\"Missing request body for JSON handler\", 400);\n  }\n\n  const headers = new Headers(base.headers);\n  headers.set(\"content-type\", \"application/json\");\n  headers.delete(\"content-length\");\n\n  const serializedBody = serializeJsonBody(body);\n\n  return new Request(base.url, {\n    method: \"POST\",\n    headers,\n    body: serializedBody,\n    signal: base.signal,\n  });\n}\n\n/**\n * Rebuild a resource request carried inside the single-route JSON envelope.\n *\n * The resource path must stay relative to the mounted Runtime. This prevents\n * the envelope from becoming an open HTTP proxy while preserving the method,\n * query string, headers, and cancellation signal used by the REST handler.\n */\nexport function createResourceRequest(\n  base: Request,\n  path: string,\n  httpMethod: string,\n  body: unknown,\n): Request {\n  if (!path.startsWith(\"/\") || path.startsWith(\"//\")) {\n    throw createResponseError(\"Resource path must be Runtime-relative\", 400);\n  }\n\n  const resourceUrl = new URL(path, \"http://copilotkit.resource\");\n  if (resourceUrl.origin !== \"http://copilotkit.resource\") {\n    throw createResponseError(\"Resource path must be Runtime-relative\", 400);\n  }\n\n  const targetUrl = new URL(base.url);\n  targetUrl.pathname = `${targetUrl.pathname.replace(/\\/$/, \"\")}${resourceUrl.pathname}`;\n  targetUrl.search = resourceUrl.search;\n\n  const method = httpMethod.toUpperCase();\n  const headers = new Headers(base.headers);\n  headers.delete(\"content-length\");\n  const hasBody = method !== \"GET\" && method !== \"HEAD\" && body != null;\n\n  return new Request(targetUrl, {\n    method,\n    headers,\n    ...(hasBody ? { body: serializeJsonBody(body) } : {}),\n    signal: base.signal,\n  });\n}\n\nexport function createResponseError(message: string, status: number): Response {\n  return new Response(\n    JSON.stringify({\n      error: \"invalid_request\",\n      message,\n    }),\n    {\n      status,\n      headers: {\n        \"Content-Type\": \"application/json\",\n      },\n    },\n  );\n}\n\nfunction validateMethod(method: string | undefined): EndpointMethod {\n  if (!method) {\n    throw createResponseError(\"Missing method field\", 400);\n  }\n\n  if ((METHOD_NAMES as readonly string[]).includes(method)) {\n    return method as EndpointMethod;\n  }\n\n  throw createResponseError(`Unsupported method '${method}'`, 400);\n}\n\nfunction serializeJsonBody(body: unknown): BodyInit {\n  if (typeof body === \"string\") {\n    return body;\n  }\n\n  if (\n    body instanceof Blob ||\n    body instanceof ArrayBuffer ||\n    body instanceof Uint8Array\n  ) {\n    // Uint8Array<ArrayBufferLike> is a valid fetch body at runtime, but the\n    // DOM lib's BodyInit only admits ArrayBuffer-backed views.\n    return body as BodyInit;\n  }\n\n  if (body instanceof FormData || body instanceof URLSearchParams) {\n    return body;\n  }\n\n  return JSON.stringify(body);\n}\n"],"mappings":"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"}

package/dist/runtime/endpoints/single-route-helpers.mjs

@@ -0,0 +1,125 @@
+//#region src/runtime/endpoints/single-route-helpers.ts
+const METHOD_NAMES = [
+	"agent/run",
+	"agent/suggest",
+	"agent/connect",
+	"trajectory/connect",
+	"agent/stop",
+	"info",
+	"inspector/metadata",
+	"inspector/learning",
+	"transcribe",
+	"resource/request"
+];
+/**
+* Detect a single-route JSON envelope on a request the multi-route router
+* could not match.
+*
+* A single-endpoint client (`useSingleEndpoint` on the frontend provider)
+* POSTs `{ method, params, body }` at the base path. A multi-route runtime
+* matches no route for that path and would otherwise answer a bare 404, giving
+* the developer nothing to go on. Recognising the envelope here lets the
+* handler name the actual cause instead.
+*
+* Deliberately conservative: it reports a method only for a POST carrying a
+* JSON body whose `method` is one the single-route endpoint actually accepts.
+* Anything else is a genuine 404 and must stay one.
+*
+* @returns The envelope's method name, or `null` if this is not an envelope.
+*/
+async function detectSingleRouteEnvelope(request) {
+	if (request.method !== "POST") return null;
+	if (!(request.headers.get("content-type") || "").includes("application/json")) return null;
+	let envelope;
+	try {
+		envelope = await request.clone().json();
+	} catch {
+		return null;
+	}
+	if (typeof envelope !== "object" || envelope === null) return null;
+	const method = envelope.method;
+	if (typeof method !== "string") return null;
+	if (!METHOD_NAMES.includes(method)) return null;
+	return method;
+}
+async function parseMethodCall(request) {
+	if (!(request.headers.get("content-type") || "").includes("application/json")) throw createResponseError("Single-route endpoint expects JSON payloads", 415);
+	let jsonEnvelope;
+	try {
+		jsonEnvelope = await request.clone().json();
+	} catch {
+		throw createResponseError("Invalid JSON payload", 400);
+	}
+	return {
+		method: validateMethod(jsonEnvelope.method),
+		params: jsonEnvelope.params,
+		body: jsonEnvelope.body
+	};
+}
+function expectString(params, key) {
+	const value = params?.[key];
+	if (typeof value === "string" && value.trim().length > 0) return value;
+	throw createResponseError(`Missing or invalid parameter '${key}'`, 400);
+}
+function createJsonRequest(base, body) {
+	if (body === void 0 || body === null) throw createResponseError("Missing request body for JSON handler", 400);
+	const headers = new Headers(base.headers);
+	headers.set("content-type", "application/json");
+	headers.delete("content-length");
+	const serializedBody = serializeJsonBody(body);
+	return new Request(base.url, {
+		method: "POST",
+		headers,
+		body: serializedBody,
+		signal: base.signal
+	});
+}
+/**
+* Rebuild a resource request carried inside the single-route JSON envelope.
+*
+* The resource path must stay relative to the mounted Runtime. This prevents
+* the envelope from becoming an open HTTP proxy while preserving the method,
+* query string, headers, and cancellation signal used by the REST handler.
+*/
+function createResourceRequest(base, path, httpMethod, body) {
+	if (!path.startsWith("/") || path.startsWith("//")) throw createResponseError("Resource path must be Runtime-relative", 400);
+	const resourceUrl = new URL(path, "http://copilotkit.resource");
+	if (resourceUrl.origin !== "http://copilotkit.resource") throw createResponseError("Resource path must be Runtime-relative", 400);
+	const targetUrl = new URL(base.url);
+	targetUrl.pathname = `${targetUrl.pathname.replace(/\/$/, "")}${resourceUrl.pathname}`;
+	targetUrl.search = resourceUrl.search;
+	const method = httpMethod.toUpperCase();
+	const headers = new Headers(base.headers);
+	headers.delete("content-length");
+	const hasBody = method !== "GET" && method !== "HEAD" && body != null;
+	return new Request(targetUrl, {
+		method,
+		headers,
+		...hasBody ? { body: serializeJsonBody(body) } : {},
+		signal: base.signal
+	});
+}
+function createResponseError(message, status) {
+	return new Response(JSON.stringify({
+		error: "invalid_request",
+		message
+	}), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+function validateMethod(method) {
+	if (!method) throw createResponseError("Missing method field", 400);
+	if (METHOD_NAMES.includes(method)) return method;
+	throw createResponseError(`Unsupported method '${method}'`, 400);
+}
+function serializeJsonBody(body) {
+	if (typeof body === "string") return body;
+	if (body instanceof Blob || body instanceof ArrayBuffer || body instanceof Uint8Array) return body;
+	if (body instanceof FormData || body instanceof URLSearchParams) return body;
+	return JSON.stringify(body);
+}
+
+//#endregion
+export { createJsonRequest, createResourceRequest, detectSingleRouteEnvelope, expectString, parseMethodCall };
+//# sourceMappingURL=single-route-helpers.mjs.map