@copilotkit/runtime 1.83.0 → 2.0.0-rc.0

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

@@ -1,105 +0,0 @@
-
-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/v2/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/v2";
- * import { createCopilotNodeListener } from "@copilotkit/runtime/v2/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/v2/runtime/endpoints/node.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.cts","names":[],"sources":["../../../../src/v2/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/v2/runtime/endpoints/node.d.mts

@@ -1,105 +0,0 @@
-
-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/v2/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/v2";
- * import { createCopilotNodeListener } from "@copilotkit/runtime/v2/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/v2/runtime/endpoints/node.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"node.d.mts","names":[],"sources":["../../../../src/v2/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/v2/runtime/endpoints/node.mjs

@@ -1,17 +0,0 @@
-import "reflect-metadata";
-import { createCopilotRuntimeHandler } from "../core/fetch-handler.mjs";
-import { createCopilotNodeHandler } from "./node-fetch-handler.mjs";
-import { autoStartChannels } from "./auto-start-channels.mjs";
-
-//#region src/v2/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/v2/runtime/endpoints/node.mjs.map

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

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

@@ -1,131 +0,0 @@
-require("reflect-metadata");
-
-//#region src/v2/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/v2/runtime/endpoints/single-route-helpers.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"single-route-helpers.cjs","names":[],"sources":["../../../../src/v2/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/v2/runtime/endpoints/single-route-helpers.mjs

@@ -1,126 +0,0 @@
-import "reflect-metadata";
-//#region src/v2/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/v2/runtime/endpoints/single-route-helpers.mjs.map

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

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

package/dist/v2/runtime/express.d.mts

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