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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"single-route-helpers.mjs","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/express.d.cts

@@ -0,0 +1,2 @@
+import { CopilotExpressEndpointParams, CopilotExpressRouter, createCopilotExpressHandler } from "./endpoints/express.cjs";
+import { createCopilotEndpointSingleRouteExpress } from "./endpoints/express-single.cjs";

package/dist/runtime/express.d.mts

@@ -0,0 +1,2 @@
+import { CopilotExpressEndpointParams, CopilotExpressRouter, createCopilotExpressHandler } from "./endpoints/express.mjs";
+import { createCopilotEndpointSingleRouteExpress } from "./endpoints/express-single.mjs";