@copilotkit/runtime 1.83.0 → 2.0.0-rc.0

package/dist/runtime/handlers/shared/platform-error.mjs

@@ -0,0 +1,39 @@
+import { errorResponse } from "./json-response.mjs";
+import { PlatformRequestError } from "../../intelligence-platform/client.mjs";
+
+//#region src/runtime/handlers/shared/platform-error.ts
+/**
+* Map a thrown error from a platform call onto a `Response`.
+*
+* Extracted from the memory handlers, which had it first and alone; the thread
+* handlers flattened every failure to 500, so a "this does not exist yet" was
+* indistinguishable from "the platform is down". One copy, because two would
+* drift the moment either grew a case.
+*
+* Forward only client-actionable **4xx** statuses verbatim (404 missing or
+* wrong-scope, 409 conflict, 422 unprocessable) so a consumer can branch on
+* them — a flat 500 erases that distinction. A platform **5xx**, or any non-4xx
+* or malformed status, means this runtime is healthy but its dependency failed,
+* so it surfaces as `502 Bad Gateway` rather than echoing the upstream status as
+* if the runtime itself broke. That also avoids a `RangeError` from
+* `new Response(..., { status })` on an out-of-range status. Anything that is
+* not a platform error at all stays 500.
+*
+* A platform **401** is also 502: it rejects the runtime's own credentials
+* (e.g. a rotated API key), not the end user, so forwarding it would tell the
+* browser the user is unauthenticated for a fault only the server can fix. A
+* **403** is different: the platform uses it to deny this user an action (e.g.
+* a write to read-only memory), so it is forwarded like any other 4xx.
+*/
+function platformErrorResponse(error, message) {
+	if (error instanceof PlatformRequestError) {
+		const { status } = error;
+		if (Number.isInteger(status) && status >= 400 && status <= 499 && status !== 401) return errorResponse(message, status);
+		return errorResponse(message, 502);
+	}
+	return errorResponse(message, 500);
+}
+
+//#endregion
+export { platformErrorResponse };
+//# sourceMappingURL=platform-error.mjs.map

package/dist/runtime/handlers/shared/platform-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-error.mjs","names":[],"sources":["../../../../src/runtime/handlers/shared/platform-error.ts"],"sourcesContent":["import { PlatformRequestError } from \"../../intelligence-platform/client\";\nimport { errorResponse } from \"./json-response\";\n\n/**\n * Map a thrown error from a platform call onto a `Response`.\n *\n * Extracted from the memory handlers, which had it first and alone; the thread\n * handlers flattened every failure to 500, so a \"this does not exist yet\" was\n * indistinguishable from \"the platform is down\". One copy, because two would\n * drift the moment either grew a case.\n *\n * Forward only client-actionable **4xx** statuses verbatim (404 missing or\n * wrong-scope, 409 conflict, 422 unprocessable) so a consumer can branch on\n * them — a flat 500 erases that distinction. A platform **5xx**, or any non-4xx\n * or malformed status, means this runtime is healthy but its dependency failed,\n * so it surfaces as `502 Bad Gateway` rather than echoing the upstream status as\n * if the runtime itself broke. That also avoids a `RangeError` from\n * `new Response(..., { status })` on an out-of-range status. Anything that is\n * not a platform error at all stays 500.\n *\n * A platform **401** is also 502: it rejects the runtime's own credentials\n * (e.g. a rotated API key), not the end user, so forwarding it would tell the\n * browser the user is unauthenticated for a fault only the server can fix. A\n * **403** is different: the platform uses it to deny this user an action (e.g.\n * a write to read-only memory), so it is forwarded like any other 4xx.\n */\nexport function platformErrorResponse(\n  error: unknown,\n  message: string,\n): Response {\n  if (error instanceof PlatformRequestError) {\n    const { status } = error;\n    if (\n      Number.isInteger(status) &&\n      status >= 400 &&\n      status <= 499 &&\n      status !== 401\n    ) {\n      return errorResponse(message, status);\n    }\n    return errorResponse(message, 502);\n  }\n  return errorResponse(message, 500);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,sBACd,OACA,SACU;AACV,KAAI,iBAAiB,sBAAsB;EACzC,MAAM,EAAE,WAAW;AACnB,MACE,OAAO,UAAU,OAAO,IACxB,UAAU,OACV,UAAU,OACV,WAAW,IAEX,QAAO,cAAc,SAAS,OAAO;AAEvC,SAAO,cAAc,SAAS,IAAI;;AAEpC,QAAO,cAAc,SAAS,IAAI"}

package/dist/runtime/handlers/shared/resolve-intelligence-user.cjs

@@ -0,0 +1,50 @@
+const require_json_response = require('./json-response.cjs');
+const require_intelligence_utils = require('./intelligence-utils.cjs');
+const require_runtime = require('../../core/runtime.cjs');
+
+//#region src/runtime/handlers/shared/resolve-intelligence-user.ts
+/** Narrows a runtime to one that has `identifyUser`. */
+function hasIdentifyUser(runtime) {
+	return typeof runtime.identifyUser === "function";
+}
+const resolvedUsers = /* @__PURE__ */ new WeakMap();
+/**
+* Resolves the request's user through `identifyUser`, once per request, for
+* both runtime kinds: the Intelligence runtime and an SSE runtime with
+* `identifyUser` (local Thread ownership). Only the Intelligence runtime
+* needs the user's `name`; an SSE runtime needs the `id` alone.
+*
+* A callback that throws gets a 500 on every route.
+*/
+async function resolveIntelligenceUser(params) {
+	const { runtime, request } = params;
+	const existing = resolvedUsers.get(request);
+	if (existing) return existing;
+	const resolution = resolveUser(runtime, request);
+	resolvedUsers.set(request, resolution);
+	return resolution;
+}
+async function resolveUser(runtime, request) {
+	if (!hasIdentifyUser(runtime)) {
+		console.error("Error identifying user: identifyUser is not configured");
+		return require_json_response.errorResponse("Failed to identify user", 500);
+	}
+	try {
+		const user = await runtime.identifyUser(request);
+		if (!require_intelligence_utils.isValidIdentifier(user?.id)) return require_json_response.errorResponse("identifyUser must return a valid user id", 400);
+		const hasName = typeof user?.name === "string" && user.name.trim().length > 0;
+		if (!hasName && require_runtime.isIntelligenceRuntime(runtime)) return require_json_response.errorResponse("identifyUser must return a valid user name", 400);
+		return {
+			id: user.id,
+			name: hasName ? user.name : user.id
+		};
+	} catch (error) {
+		console.error("Error identifying user:", error);
+		return require_json_response.errorResponse("Failed to identify user", 500);
+	}
+}
+
+//#endregion
+exports.hasIdentifyUser = hasIdentifyUser;
+exports.resolveIntelligenceUser = resolveIntelligenceUser;
+//# sourceMappingURL=resolve-intelligence-user.cjs.map

package/dist/runtime/handlers/shared/resolve-intelligence-user.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-intelligence-user.cjs","names":["errorResponse","isValidIdentifier","isIntelligenceRuntime"],"sources":["../../../../src/runtime/handlers/shared/resolve-intelligence-user.ts"],"sourcesContent":["import type {\n  CopilotIntelligenceRuntimeLike,\n  CopilotRuntimeLike,\n  CopilotRuntimeUser,\n  IdentifyUserCallback,\n} from \"../../core/runtime\";\nimport { isIntelligenceRuntime } from \"../../core/runtime\";\nimport { errorResponse } from \"./json-response\";\nimport { isValidIdentifier } from \"./intelligence-utils\";\n\n/** A runtime whose `identifyUser` is known to be set. */\nexport type IdentifiedRuntimeLike = CopilotRuntimeLike & {\n  identifyUser: IdentifyUserCallback;\n};\n\n/** Narrows a runtime to one that has `identifyUser`. */\nexport function hasIdentifyUser(\n  runtime: CopilotRuntimeLike,\n): runtime is IdentifiedRuntimeLike {\n  return typeof runtime.identifyUser === \"function\";\n}\n\nconst resolvedUsers = new WeakMap<\n  Request,\n  Promise<CopilotRuntimeUser | Response>\n>();\n\n/**\n * Resolves the request's user through `identifyUser`, once per request, for\n * both runtime kinds: the Intelligence runtime and an SSE runtime with\n * `identifyUser` (local Thread ownership). Only the Intelligence runtime\n * needs the user's `name`; an SSE runtime needs the `id` alone.\n *\n * A callback that throws gets a 500 on every route.\n */\nexport async function resolveIntelligenceUser(params: {\n  runtime: CopilotIntelligenceRuntimeLike | IdentifiedRuntimeLike;\n  request: Request;\n}): Promise<CopilotRuntimeUser | Response> {\n  const { runtime, request } = params;\n\n  const existing = resolvedUsers.get(request);\n  if (existing) return existing;\n\n  const resolution = resolveUser(runtime, request);\n  resolvedUsers.set(request, resolution);\n  return resolution;\n}\n\nasync function resolveUser(\n  runtime: CopilotRuntimeLike,\n  request: Request,\n): Promise<CopilotRuntimeUser | Response> {\n  if (!hasIdentifyUser(runtime)) {\n    console.error(\"Error identifying user: identifyUser is not configured\");\n    return errorResponse(\"Failed to identify user\", 500);\n  }\n  try {\n    const user = await runtime.identifyUser(request);\n    if (!isValidIdentifier(user?.id)) {\n      return errorResponse(\"identifyUser must return a valid user id\", 400);\n    }\n    const hasName =\n      typeof user?.name === \"string\" && user.name.trim().length > 0;\n    if (!hasName && isIntelligenceRuntime(runtime)) {\n      return errorResponse(\"identifyUser must return a valid user name\", 400);\n    }\n\n    return { id: user.id, name: hasName ? user.name : user.id };\n  } catch (error) {\n    console.error(\"Error identifying user:\", error);\n    return errorResponse(\"Failed to identify user\", 500);\n  }\n}\n"],"mappings":";;;;;;AAgBA,SAAgB,gBACd,SACkC;AAClC,QAAO,OAAO,QAAQ,iBAAiB;;AAGzC,MAAM,gCAAgB,IAAI,SAGvB;;;;;;;;;AAUH,eAAsB,wBAAwB,QAGH;CACzC,MAAM,EAAE,SAAS,YAAY;CAE7B,MAAM,WAAW,cAAc,IAAI,QAAQ;AAC3C,KAAI,SAAU,QAAO;CAErB,MAAM,aAAa,YAAY,SAAS,QAAQ;AAChD,eAAc,IAAI,SAAS,WAAW;AACtC,QAAO;;AAGT,eAAe,YACb,SACA,SACwC;AACxC,KAAI,CAAC,gBAAgB,QAAQ,EAAE;AAC7B,UAAQ,MAAM,yDAAyD;AACvE,SAAOA,oCAAc,2BAA2B,IAAI;;AAEtD,KAAI;EACF,MAAM,OAAO,MAAM,QAAQ,aAAa,QAAQ;AAChD,MAAI,CAACC,6CAAkB,MAAM,GAAG,CAC9B,QAAOD,oCAAc,4CAA4C,IAAI;EAEvE,MAAM,UACJ,OAAO,MAAM,SAAS,YAAY,KAAK,KAAK,MAAM,CAAC,SAAS;AAC9D,MAAI,CAAC,WAAWE,sCAAsB,QAAQ,CAC5C,QAAOF,oCAAc,8CAA8C,IAAI;AAGzE,SAAO;GAAE,IAAI,KAAK;GAAI,MAAM,UAAU,KAAK,OAAO,KAAK;GAAI;UACpD,OAAO;AACd,UAAQ,MAAM,2BAA2B,MAAM;AAC/C,SAAOA,oCAAc,2BAA2B,IAAI"}

package/dist/runtime/handlers/shared/resolve-intelligence-user.mjs

@@ -0,0 +1,49 @@
+import { errorResponse } from "./json-response.mjs";
+import { isValidIdentifier } from "./intelligence-utils.mjs";
+import { isIntelligenceRuntime } from "../../core/runtime.mjs";
+
+//#region src/runtime/handlers/shared/resolve-intelligence-user.ts
+/** Narrows a runtime to one that has `identifyUser`. */
+function hasIdentifyUser(runtime) {
+	return typeof runtime.identifyUser === "function";
+}
+const resolvedUsers = /* @__PURE__ */ new WeakMap();
+/**
+* Resolves the request's user through `identifyUser`, once per request, for
+* both runtime kinds: the Intelligence runtime and an SSE runtime with
+* `identifyUser` (local Thread ownership). Only the Intelligence runtime
+* needs the user's `name`; an SSE runtime needs the `id` alone.
+*
+* A callback that throws gets a 500 on every route.
+*/
+async function resolveIntelligenceUser(params) {
+	const { runtime, request } = params;
+	const existing = resolvedUsers.get(request);
+	if (existing) return existing;
+	const resolution = resolveUser(runtime, request);
+	resolvedUsers.set(request, resolution);
+	return resolution;
+}
+async function resolveUser(runtime, request) {
+	if (!hasIdentifyUser(runtime)) {
+		console.error("Error identifying user: identifyUser is not configured");
+		return errorResponse("Failed to identify user", 500);
+	}
+	try {
+		const user = await runtime.identifyUser(request);
+		if (!isValidIdentifier(user?.id)) return errorResponse("identifyUser must return a valid user id", 400);
+		const hasName = typeof user?.name === "string" && user.name.trim().length > 0;
+		if (!hasName && isIntelligenceRuntime(runtime)) return errorResponse("identifyUser must return a valid user name", 400);
+		return {
+			id: user.id,
+			name: hasName ? user.name : user.id
+		};
+	} catch (error) {
+		console.error("Error identifying user:", error);
+		return errorResponse("Failed to identify user", 500);
+	}
+}
+
+//#endregion
+export { hasIdentifyUser, resolveIntelligenceUser };
+//# sourceMappingURL=resolve-intelligence-user.mjs.map

package/dist/runtime/handlers/shared/resolve-intelligence-user.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-intelligence-user.mjs","names":[],"sources":["../../../../src/runtime/handlers/shared/resolve-intelligence-user.ts"],"sourcesContent":["import type {\n  CopilotIntelligenceRuntimeLike,\n  CopilotRuntimeLike,\n  CopilotRuntimeUser,\n  IdentifyUserCallback,\n} from \"../../core/runtime\";\nimport { isIntelligenceRuntime } from \"../../core/runtime\";\nimport { errorResponse } from \"./json-response\";\nimport { isValidIdentifier } from \"./intelligence-utils\";\n\n/** A runtime whose `identifyUser` is known to be set. */\nexport type IdentifiedRuntimeLike = CopilotRuntimeLike & {\n  identifyUser: IdentifyUserCallback;\n};\n\n/** Narrows a runtime to one that has `identifyUser`. */\nexport function hasIdentifyUser(\n  runtime: CopilotRuntimeLike,\n): runtime is IdentifiedRuntimeLike {\n  return typeof runtime.identifyUser === \"function\";\n}\n\nconst resolvedUsers = new WeakMap<\n  Request,\n  Promise<CopilotRuntimeUser | Response>\n>();\n\n/**\n * Resolves the request's user through `identifyUser`, once per request, for\n * both runtime kinds: the Intelligence runtime and an SSE runtime with\n * `identifyUser` (local Thread ownership). Only the Intelligence runtime\n * needs the user's `name`; an SSE runtime needs the `id` alone.\n *\n * A callback that throws gets a 500 on every route.\n */\nexport async function resolveIntelligenceUser(params: {\n  runtime: CopilotIntelligenceRuntimeLike | IdentifiedRuntimeLike;\n  request: Request;\n}): Promise<CopilotRuntimeUser | Response> {\n  const { runtime, request } = params;\n\n  const existing = resolvedUsers.get(request);\n  if (existing) return existing;\n\n  const resolution = resolveUser(runtime, request);\n  resolvedUsers.set(request, resolution);\n  return resolution;\n}\n\nasync function resolveUser(\n  runtime: CopilotRuntimeLike,\n  request: Request,\n): Promise<CopilotRuntimeUser | Response> {\n  if (!hasIdentifyUser(runtime)) {\n    console.error(\"Error identifying user: identifyUser is not configured\");\n    return errorResponse(\"Failed to identify user\", 500);\n  }\n  try {\n    const user = await runtime.identifyUser(request);\n    if (!isValidIdentifier(user?.id)) {\n      return errorResponse(\"identifyUser must return a valid user id\", 400);\n    }\n    const hasName =\n      typeof user?.name === \"string\" && user.name.trim().length > 0;\n    if (!hasName && isIntelligenceRuntime(runtime)) {\n      return errorResponse(\"identifyUser must return a valid user name\", 400);\n    }\n\n    return { id: user.id, name: hasName ? user.name : user.id };\n  } catch (error) {\n    console.error(\"Error identifying user:\", error);\n    return errorResponse(\"Failed to identify user\", 500);\n  }\n}\n"],"mappings":";;;;;;AAgBA,SAAgB,gBACd,SACkC;AAClC,QAAO,OAAO,QAAQ,iBAAiB;;AAGzC,MAAM,gCAAgB,IAAI,SAGvB;;;;;;;;;AAUH,eAAsB,wBAAwB,QAGH;CACzC,MAAM,EAAE,SAAS,YAAY;CAE7B,MAAM,WAAW,cAAc,IAAI,QAAQ;AAC3C,KAAI,SAAU,QAAO;CAErB,MAAM,aAAa,YAAY,SAAS,QAAQ;AAChD,eAAc,IAAI,SAAS,WAAW;AACtC,QAAO;;AAGT,eAAe,YACb,SACA,SACwC;AACxC,KAAI,CAAC,gBAAgB,QAAQ,EAAE;AAC7B,UAAQ,MAAM,yDAAyD;AACvE,SAAO,cAAc,2BAA2B,IAAI;;AAEtD,KAAI;EACF,MAAM,OAAO,MAAM,QAAQ,aAAa,QAAQ;AAChD,MAAI,CAAC,kBAAkB,MAAM,GAAG,CAC9B,QAAO,cAAc,4CAA4C,IAAI;EAEvE,MAAM,UACJ,OAAO,MAAM,SAAS,YAAY,KAAK,KAAK,MAAM,CAAC,SAAS;AAC9D,MAAI,CAAC,WAAW,sBAAsB,QAAQ,CAC5C,QAAO,cAAc,8CAA8C,IAAI;AAGzE,SAAO;GAAE,IAAI,KAAK;GAAI,MAAM,UAAU,KAAK,OAAO,KAAK;GAAI;UACpD,OAAO;AACd,UAAQ,MAAM,2BAA2B,MAAM;AAC/C,SAAO,cAAc,2BAA2B,IAAI"}

package/dist/runtime/handlers/shared/sse-keep-alive.cjs

@@ -0,0 +1,68 @@
+
+//#region src/runtime/handlers/shared/sse-keep-alive.ts
+/**
+* Default silence, in seconds, before an SSE response carries a keep-alive
+* comment. Sits under the tightest common proxy idle timeouts (55–60 s) and
+* beside `lockHeartbeatIntervalSeconds`, which shares the unit and default.
+*/
+const DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS = 15;
+/**
+* Longest interval the timer can honour. Timers take a signed 32-bit
+* millisecond delay; Node silently replaces anything larger with 1 ms, which
+* would turn a keep-alive into a flood.
+*/
+const MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS = (2 ** 31 - 1) / 1e3;
+/**
+* Resolves the `sseKeepAliveIntervalSeconds` runtime option once, at
+* construction, so every SSE call site reads one validated value.
+* `undefined` takes the default; `0` disables the keep-alive.
+*/
+function resolveSseKeepAliveIntervalSeconds(value) {
+	const seconds = value ?? DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS;
+	if (!Number.isFinite(seconds) || seconds < 0 || seconds > MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS) throw new RangeError(`sseKeepAliveIntervalSeconds must be between 0 and ${MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS}, got ${String(value)}`);
+	return seconds;
+}
+/**
+* SSE comment frame. Parsers drop comment lines, so no AG-UI event is
+* invented and the verifier, history and middleware never see it.
+* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes
+*/
+const KEEP_ALIVE_FRAME = new TextEncoder().encode(": keep-alive\n\n");
+/**
+* Keeps a quiet SSE body open by writing a comment after `idleMs` of silence.
+*
+* Any byte from `source` resets the clock, so an active stream adds nothing
+* to the wire. A back-pressured reader skips the tick instead of queueing
+* frames. The timer stops when the pipe settles, which covers both the source
+* completing and the reader cancelling, on every supported Node version.
+*/
+function keepAliveSse(source, idleMs) {
+	let timer;
+	const stop = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	};
+	const arm = (controller) => {
+		stop();
+		timer = setTimeout(() => {
+			if (controller.desiredSize === 1) controller.enqueue(KEEP_ALIVE_FRAME);
+			arm(controller);
+		}, idleMs);
+		timer.unref?.();
+	};
+	const transform = new TransformStream({
+		start: arm,
+		transform(chunk, controller) {
+			controller.enqueue(chunk);
+			arm(controller);
+		},
+		flush: stop
+	}, void 0, { highWaterMark: 1 });
+	source.pipeTo(transform.writable).catch(() => {}).finally(stop);
+	return transform.readable;
+}
+
+//#endregion
+exports.keepAliveSse = keepAliveSse;
+exports.resolveSseKeepAliveIntervalSeconds = resolveSseKeepAliveIntervalSeconds;
+//# sourceMappingURL=sse-keep-alive.cjs.map

package/dist/runtime/handlers/shared/sse-keep-alive.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-keep-alive.cjs","names":[],"sources":["../../../../src/runtime/handlers/shared/sse-keep-alive.ts"],"sourcesContent":["/**\n * Default silence, in seconds, before an SSE response carries a keep-alive\n * comment. Sits under the tightest common proxy idle timeouts (55–60 s) and\n * beside `lockHeartbeatIntervalSeconds`, which shares the unit and default.\n */\nexport const DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS = 15;\n\n/**\n * Longest interval the timer can honour. Timers take a signed 32-bit\n * millisecond delay; Node silently replaces anything larger with 1 ms, which\n * would turn a keep-alive into a flood.\n */\nexport const MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS = (2 ** 31 - 1) / 1000;\n\n/**\n * Resolves the `sseKeepAliveIntervalSeconds` runtime option once, at\n * construction, so every SSE call site reads one validated value.\n * `undefined` takes the default; `0` disables the keep-alive.\n */\nexport function resolveSseKeepAliveIntervalSeconds(\n  value: number | undefined,\n): number {\n  const seconds = value ?? DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS;\n  if (\n    !Number.isFinite(seconds) ||\n    seconds < 0 ||\n    seconds > MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS\n  ) {\n    throw new RangeError(\n      `sseKeepAliveIntervalSeconds must be between 0 and ${MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS}, got ${String(value)}`,\n    );\n  }\n  return seconds;\n}\n\n/**\n * SSE comment frame. Parsers drop comment lines, so no AG-UI event is\n * invented and the verifier, history and middleware never see it.\n * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes\n */\nconst KEEP_ALIVE_FRAME = new TextEncoder().encode(\": keep-alive\\n\\n\");\n\n/**\n * Keeps a quiet SSE body open by writing a comment after `idleMs` of silence.\n *\n * Any byte from `source` resets the clock, so an active stream adds nothing\n * to the wire. A back-pressured reader skips the tick instead of queueing\n * frames. The timer stops when the pipe settles, which covers both the source\n * completing and the reader cancelling, on every supported Node version.\n */\nexport function keepAliveSse(\n  source: ReadableStream<Uint8Array>,\n  idleMs: number,\n): ReadableStream<Uint8Array> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const stop = () => {\n    if (timer !== undefined) clearTimeout(timer);\n    timer = undefined;\n  };\n  const arm = (controller: TransformStreamDefaultController<Uint8Array>) => {\n    stop();\n    timer = setTimeout(() => {\n      // `desiredSize` is 1 only while the readable queue is empty; 0 means a\n      // slow reader still holds the previous chunk, null means it went away.\n      if (controller.desiredSize === 1) controller.enqueue(KEEP_ALIVE_FRAME);\n      arm(controller);\n    }, idleMs);\n    timer.unref?.();\n  };\n  const transform = new TransformStream<Uint8Array, Uint8Array>(\n    {\n      start: arm,\n      transform(chunk, controller) {\n        controller.enqueue(chunk);\n        arm(controller);\n      },\n      flush: stop,\n    },\n    undefined,\n    { highWaterMark: 1 },\n  );\n  // `flush` stops the timer when the source completes. The pipe settling\n  // covers the reader cancelling, on every supported Node version; the source\n  // writer surfaces that cancellation to the caller.\n  void source\n    .pipeTo(transform.writable)\n    .catch(() => {})\n    .finally(stop);\n  return transform.readable;\n}\n"],"mappings":";;;;;;;AAKA,MAAa,0CAA0C;;;;;;AAOvD,MAAa,uCAAuC,KAAK,KAAK,KAAK;;;;;;AAOnE,SAAgB,mCACd,OACQ;CACR,MAAM,UAAU,SAAS;AACzB,KACE,CAAC,OAAO,SAAS,QAAQ,IACzB,UAAU,KACV,UAAU,oCAEV,OAAM,IAAI,WACR,qDAAqD,oCAAoC,QAAQ,OAAO,MAAM,GAC/G;AAEH,QAAO;;;;;;;AAQT,MAAM,mBAAmB,IAAI,aAAa,CAAC,OAAO,mBAAmB;;;;;;;;;AAUrE,SAAgB,aACd,QACA,QAC4B;CAC5B,IAAI;CACJ,MAAM,aAAa;AACjB,MAAI,UAAU,OAAW,cAAa,MAAM;AAC5C,UAAQ;;CAEV,MAAM,OAAO,eAA6D;AACxE,QAAM;AACN,UAAQ,iBAAiB;AAGvB,OAAI,WAAW,gBAAgB,EAAG,YAAW,QAAQ,iBAAiB;AACtE,OAAI,WAAW;KACd,OAAO;AACV,QAAM,SAAS;;CAEjB,MAAM,YAAY,IAAI,gBACpB;EACE,OAAO;EACP,UAAU,OAAO,YAAY;AAC3B,cAAW,QAAQ,MAAM;AACzB,OAAI,WAAW;;EAEjB,OAAO;EACR,EACD,QACA,EAAE,eAAe,GAAG,CACrB;AAID,CAAK,OACF,OAAO,UAAU,SAAS,CAC1B,YAAY,GAAG,CACf,QAAQ,KAAK;AAChB,QAAO,UAAU"}

package/dist/runtime/handlers/shared/sse-keep-alive.mjs

@@ -0,0 +1,66 @@
+//#region src/runtime/handlers/shared/sse-keep-alive.ts
+/**
+* Default silence, in seconds, before an SSE response carries a keep-alive
+* comment. Sits under the tightest common proxy idle timeouts (55–60 s) and
+* beside `lockHeartbeatIntervalSeconds`, which shares the unit and default.
+*/
+const DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS = 15;
+/**
+* Longest interval the timer can honour. Timers take a signed 32-bit
+* millisecond delay; Node silently replaces anything larger with 1 ms, which
+* would turn a keep-alive into a flood.
+*/
+const MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS = (2 ** 31 - 1) / 1e3;
+/**
+* Resolves the `sseKeepAliveIntervalSeconds` runtime option once, at
+* construction, so every SSE call site reads one validated value.
+* `undefined` takes the default; `0` disables the keep-alive.
+*/
+function resolveSseKeepAliveIntervalSeconds(value) {
+	const seconds = value ?? DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS;
+	if (!Number.isFinite(seconds) || seconds < 0 || seconds > MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS) throw new RangeError(`sseKeepAliveIntervalSeconds must be between 0 and ${MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS}, got ${String(value)}`);
+	return seconds;
+}
+/**
+* SSE comment frame. Parsers drop comment lines, so no AG-UI event is
+* invented and the verifier, history and middleware never see it.
+* @see https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes
+*/
+const KEEP_ALIVE_FRAME = new TextEncoder().encode(": keep-alive\n\n");
+/**
+* Keeps a quiet SSE body open by writing a comment after `idleMs` of silence.
+*
+* Any byte from `source` resets the clock, so an active stream adds nothing
+* to the wire. A back-pressured reader skips the tick instead of queueing
+* frames. The timer stops when the pipe settles, which covers both the source
+* completing and the reader cancelling, on every supported Node version.
+*/
+function keepAliveSse(source, idleMs) {
+	let timer;
+	const stop = () => {
+		if (timer !== void 0) clearTimeout(timer);
+		timer = void 0;
+	};
+	const arm = (controller) => {
+		stop();
+		timer = setTimeout(() => {
+			if (controller.desiredSize === 1) controller.enqueue(KEEP_ALIVE_FRAME);
+			arm(controller);
+		}, idleMs);
+		timer.unref?.();
+	};
+	const transform = new TransformStream({
+		start: arm,
+		transform(chunk, controller) {
+			controller.enqueue(chunk);
+			arm(controller);
+		},
+		flush: stop
+	}, void 0, { highWaterMark: 1 });
+	source.pipeTo(transform.writable).catch(() => {}).finally(stop);
+	return transform.readable;
+}
+
+//#endregion
+export { keepAliveSse, resolveSseKeepAliveIntervalSeconds };
+//# sourceMappingURL=sse-keep-alive.mjs.map

package/dist/runtime/handlers/shared/sse-keep-alive.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-keep-alive.mjs","names":[],"sources":["../../../../src/runtime/handlers/shared/sse-keep-alive.ts"],"sourcesContent":["/**\n * Default silence, in seconds, before an SSE response carries a keep-alive\n * comment. Sits under the tightest common proxy idle timeouts (55–60 s) and\n * beside `lockHeartbeatIntervalSeconds`, which shares the unit and default.\n */\nexport const DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS = 15;\n\n/**\n * Longest interval the timer can honour. Timers take a signed 32-bit\n * millisecond delay; Node silently replaces anything larger with 1 ms, which\n * would turn a keep-alive into a flood.\n */\nexport const MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS = (2 ** 31 - 1) / 1000;\n\n/**\n * Resolves the `sseKeepAliveIntervalSeconds` runtime option once, at\n * construction, so every SSE call site reads one validated value.\n * `undefined` takes the default; `0` disables the keep-alive.\n */\nexport function resolveSseKeepAliveIntervalSeconds(\n  value: number | undefined,\n): number {\n  const seconds = value ?? DEFAULT_SSE_KEEP_ALIVE_INTERVAL_SECONDS;\n  if (\n    !Number.isFinite(seconds) ||\n    seconds < 0 ||\n    seconds > MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS\n  ) {\n    throw new RangeError(\n      `sseKeepAliveIntervalSeconds must be between 0 and ${MAX_SSE_KEEP_ALIVE_INTERVAL_SECONDS}, got ${String(value)}`,\n    );\n  }\n  return seconds;\n}\n\n/**\n * SSE comment frame. Parsers drop comment lines, so no AG-UI event is\n * invented and the verifier, history and middleware never see it.\n * @see https://html.spec.whatwg.org/multipage/server-sent-events.html#authoring-notes\n */\nconst KEEP_ALIVE_FRAME = new TextEncoder().encode(\": keep-alive\\n\\n\");\n\n/**\n * Keeps a quiet SSE body open by writing a comment after `idleMs` of silence.\n *\n * Any byte from `source` resets the clock, so an active stream adds nothing\n * to the wire. A back-pressured reader skips the tick instead of queueing\n * frames. The timer stops when the pipe settles, which covers both the source\n * completing and the reader cancelling, on every supported Node version.\n */\nexport function keepAliveSse(\n  source: ReadableStream<Uint8Array>,\n  idleMs: number,\n): ReadableStream<Uint8Array> {\n  let timer: ReturnType<typeof setTimeout> | undefined;\n  const stop = () => {\n    if (timer !== undefined) clearTimeout(timer);\n    timer = undefined;\n  };\n  const arm = (controller: TransformStreamDefaultController<Uint8Array>) => {\n    stop();\n    timer = setTimeout(() => {\n      // `desiredSize` is 1 only while the readable queue is empty; 0 means a\n      // slow reader still holds the previous chunk, null means it went away.\n      if (controller.desiredSize === 1) controller.enqueue(KEEP_ALIVE_FRAME);\n      arm(controller);\n    }, idleMs);\n    timer.unref?.();\n  };\n  const transform = new TransformStream<Uint8Array, Uint8Array>(\n    {\n      start: arm,\n      transform(chunk, controller) {\n        controller.enqueue(chunk);\n        arm(controller);\n      },\n      flush: stop,\n    },\n    undefined,\n    { highWaterMark: 1 },\n  );\n  // `flush` stops the timer when the source completes. The pipe settling\n  // covers the reader cancelling, on every supported Node version; the source\n  // writer surfaces that cancellation to the caller.\n  void source\n    .pipeTo(transform.writable)\n    .catch(() => {})\n    .finally(stop);\n  return transform.readable;\n}\n"],"mappings":";;;;;;AAKA,MAAa,0CAA0C;;;;;;AAOvD,MAAa,uCAAuC,KAAK,KAAK,KAAK;;;;;;AAOnE,SAAgB,mCACd,OACQ;CACR,MAAM,UAAU,SAAS;AACzB,KACE,CAAC,OAAO,SAAS,QAAQ,IACzB,UAAU,KACV,UAAU,oCAEV,OAAM,IAAI,WACR,qDAAqD,oCAAoC,QAAQ,OAAO,MAAM,GAC/G;AAEH,QAAO;;;;;;;AAQT,MAAM,mBAAmB,IAAI,aAAa,CAAC,OAAO,mBAAmB;;;;;;;;;AAUrE,SAAgB,aACd,QACA,QAC4B;CAC5B,IAAI;CACJ,MAAM,aAAa;AACjB,MAAI,UAAU,OAAW,cAAa,MAAM;AAC5C,UAAQ;;CAEV,MAAM,OAAO,eAA6D;AACxE,QAAM;AACN,UAAQ,iBAAiB;AAGvB,OAAI,WAAW,gBAAgB,EAAG,YAAW,QAAQ,iBAAiB;AACtE,OAAI,WAAW;KACd,OAAO;AACV,QAAM,SAAS;;CAEjB,MAAM,YAAY,IAAI,gBACpB;EACE,OAAO;EACP,UAAU,OAAO,YAAY;AAC3B,cAAW,QAAQ,MAAM;AACzB,OAAI,WAAW;;EAEjB,OAAO;EACR,EACD,QACA,EAAE,eAAe,GAAG,CACrB;AAID,CAAK,OACF,OAAO,UAAU,SAAS,CAC1B,YAAY,GAAG,CACf,QAAQ,KAAK;AAChB,QAAO,UAAU"}

package/dist/runtime/handlers/shared/sse-response.cjs

@@ -0,0 +1,237 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.cjs');
+const require_sse_keep_alive = require('./sse-keep-alive.cjs');
+const require_agent_runner = require('../../runner/agent-runner.cjs');
+const require_logger = require('../../core/logger.cjs');
+const require_telemetry_client = require('../../telemetry/telemetry-client.cjs');
+let _copilotkit_shared = require("@copilotkit/shared");
+let _ag_ui_client = require("@ag-ui/client");
+let _ag_ui_encoder = require("@ag-ui/encoder");
+
+//#region src/runtime/handlers/shared/sse-response.ts
+/**
+* Whether a runner rejected the run because the thread is busy. Matches the
+* `code` of {@link ThreadAlreadyRunningError}, and the plain message that
+* custom runners copied from the built-in ones still throw.
+*/
+function isThreadAlreadyRunning(error) {
+	return error instanceof Error && (error.code === _copilotkit_shared.THREAD_ALREADY_RUNNING_ERROR_CODE || error.message === "Thread already running");
+}
+function createSseEventResponse({ request, observableFactory, debugEventBus, agentId, debug, logger, telemetry: telemetry$1 = require_telemetry_client.default, executionSeed, captureTelemetry = true, runtimeErrorReporter, startTime, keepAliveIntervalSeconds }) {
+	const keepAliveSeconds = require_sse_keep_alive.resolveSseKeepAliveIntervalSeconds(keepAliveIntervalSeconds);
+	const stream = new TransformStream();
+	const writer = stream.writable.getWriter();
+	const encoder = new _ag_ui_encoder.EventEncoder();
+	let streamClosed = false;
+	let terminalEventWritten = false;
+	let debugThreadId = "";
+	let debugRunId = "";
+	const debugLogger = debug?.enabled ? logger ?? require_logger.createLogger({
+		level: "debug",
+		component: "copilotkit-debug"
+	}) : void 0;
+	const closeStream = async () => {
+		if (!streamClosed) try {
+			await writer.close();
+			streamClosed = true;
+		} catch {}
+	};
+	const writeRunError = async (error) => {
+		if (terminalEventWritten || streamClosed || request.signal.aborted) return;
+		terminalEventWritten = true;
+		const event = isThreadAlreadyRunning(error) ? {
+			type: _ag_ui_client.EventType.RUN_ERROR,
+			message: "Thread already running",
+			code: _copilotkit_shared.THREAD_ALREADY_RUNNING_ERROR_CODE
+		} : require_agent_runner.isThreadAccessDeniedError(error) ? {
+			type: _ag_ui_client.EventType.RUN_ERROR,
+			message: "Thread access denied",
+			code: require_agent_runner.THREAD_ACCESS_DENIED_ERROR_CODE
+		} : {
+			type: _ag_ui_client.EventType.RUN_ERROR,
+			message: "Agent run failed"
+		};
+		if (debugEventBus && debugRunId) try {
+			debugEventBus.broadcast(event, {
+				agentId: agentId ?? "",
+				threadId: debugThreadId,
+				runId: debugRunId
+			});
+		} catch (broadcastError) {
+			logError(broadcastError);
+		}
+		try {
+			await writer.write(encoder.encodeBinary(event));
+		} catch {}
+	};
+	const logError = (error) => {
+		console.error("Error running agent:", error);
+		console.error("Error stack:", error instanceof Error ? error.stack : "No stack trace");
+		console.error("Error details:", {
+			name: error instanceof Error ? error.name : "Unknown",
+			message: error instanceof Error ? error.message : String(error),
+			cause: error instanceof Error ? error.cause : void 0
+		});
+	};
+	let subscription;
+	let agentErrorReported = false;
+	const logAccessDenied = (error) => {
+		console.warn("[CopilotKit] Run refused: the thread belongs to another identity.", error instanceof Error ? error.message : String(error));
+	};
+	const reportAgentError = (error, phase) => {
+		if (agentErrorReported) return;
+		agentErrorReported = true;
+		runtimeErrorReporter?.report({
+			request,
+			error,
+			operation: "agent.run",
+			agentId,
+			threadId: debugThreadId || void 0,
+			runId: debugRunId || void 0,
+			phase,
+			startTime
+		});
+	};
+	(async () => {
+		const observable = await observableFactory();
+		if (captureTelemetry) telemetry$1.capture("oss.runtime.agent_execution_stream_started", {});
+		if (debug?.lifecycle) debugLogger.debug("SSE stream opened");
+		let eventCount = 0;
+		let loggedEventCount = 0;
+		const executionInfo = { ...executionSeed };
+		subscription = observable.subscribe({
+			next: async (event) => {
+				collectExecutionInfo(event, executionInfo);
+				if (event.type === "RUN_STARTED") {
+					const e = event;
+					debugThreadId = e.threadId ?? "";
+					debugRunId = e.runId ?? "";
+				}
+				if (event.type === "RUN_ERROR") {
+					const e = event;
+					debugThreadId = e.threadId ?? debugThreadId;
+					debugRunId = e.runId ?? debugRunId;
+					reportAgentError(new Error(typeof e.message === "string" ? e.message : "Runner reported a run error"), "sse.subscription");
+				}
+				if (debugEventBus) try {
+					debugEventBus.broadcast(event, {
+						agentId: agentId ?? "",
+						threadId: debugThreadId,
+						runId: debugRunId
+					});
+				} catch (broadcastError) {
+					logError(broadcastError);
+				}
+				if (!request.signal.aborted && !streamClosed) try {
+					eventCount++;
+					if (debug?.events) {
+						loggedEventCount++;
+						if (debug.verbose) debugLogger.debug({ event }, "Event emitted");
+						else debugLogger.debug({
+							type: event.type,
+							...summarizeEvent(event)
+						}, "Event emitted");
+					}
+					if (event.type === _ag_ui_client.EventType.RUN_STARTED) terminalEventWritten = false;
+					else if (event.type === _ag_ui_client.EventType.RUN_FINISHED || event.type === _ag_ui_client.EventType.RUN_ERROR) terminalEventWritten = true;
+					await writer.write(encoder.encodeBinary(event));
+				} catch (error) {
+					if (error instanceof Error && error.name === "AbortError") streamClosed = true;
+					else {
+						logError(error);
+						streamClosed = true;
+					}
+				}
+			},
+			error: async (error) => {
+				if (require_agent_runner.isThreadAccessDeniedError(error)) {
+					logAccessDenied(error);
+					await writeRunError(error);
+					await closeStream();
+					return;
+				}
+				reportAgentError(error, "sse.subscription");
+				if (captureTelemetry) telemetry$1.capture("oss.runtime.agent_execution_stream_errored", {
+					...executionInfo,
+					error: "AGENT_EXECUTION_FAILED"
+				});
+				if (debug?.lifecycle) debugLogger.debug({ error: error instanceof Error ? error.message : String(error) }, "SSE stream errored");
+				logError(error);
+				await writeRunError(error);
+				await closeStream();
+			},
+			complete: async () => {
+				if (captureTelemetry) telemetry$1.capture("oss.runtime.agent_execution_stream_ended", executionInfo);
+				if (debug?.lifecycle) debugLogger.debug({
+					eventCount,
+					loggedEventCount
+				}, "SSE stream completed");
+				await closeStream();
+			}
+		});
+		if (request.signal.aborted) subscription.unsubscribe();
+	})().catch(async (error) => {
+		if (require_agent_runner.isThreadAccessDeniedError(error)) logAccessDenied(error);
+		else {
+			reportAgentError(error, "sse.factory");
+			logError(error);
+		}
+		await writeRunError(error);
+		await closeStream();
+	});
+	request.signal.addEventListener("abort", () => {
+		subscription?.unsubscribe();
+	});
+	const body = keepAliveSeconds > 0 ? require_sse_keep_alive.keepAliveSse(stream.readable, keepAliveSeconds * 1e3) : stream.readable;
+	return new Response(body, {
+		status: 200,
+		headers: {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive"
+		}
+	});
+}
+function summarizeEvent(event) {
+	const e = event;
+	const summary = {};
+	if (e.messageId) summary.messageId = e.messageId;
+	if (e.toolCallId) summary.toolCallId = e.toolCallId;
+	if (e.toolCallName) summary.toolCallName = e.toolCallName;
+	if (e.role) summary.role = e.role;
+	if (e.delta != null && typeof e.delta === "string") summary.deltaLength = e.delta.length;
+	if (e.snapshot && typeof e.snapshot === "object") summary.snapshotKeys = Object.keys(e.snapshot);
+	if (e.delta && Array.isArray(e.delta)) summary.operationCount = e.delta.length;
+	if (e.threadId) summary.threadId = e.threadId;
+	if (e.runId) summary.runId = e.runId;
+	if (e.message) summary.message = e.message;
+	if (e.code) summary.code = e.code;
+	if (e.stepName) summary.stepName = e.stepName;
+	return summary;
+}
+/**
+* Accumulate provider, model, and LangGraph facts from one upstream event.
+*
+* Mutates rather than returns so the caller keeps one record across the whole
+* stream: these arrive on different events and the last one wins. Only fields
+* the upstream actually sent are set, so an agent that reports none leaves the
+* record empty and the stream events carry `{}` as before.
+*
+* `rawEvent` is the untransformed upstream payload, present on AG-UI events
+* that wrap one. Its shape is the provider's, not ours, hence the narrowing.
+*/
+function collectExecutionInfo(event, into) {
+	const rawEvent = event.rawEvent;
+	if (!rawEvent) return;
+	const model = rawEvent.data?.output?.model;
+	if (model) {
+		into.model = model;
+		into.provider = model;
+	}
+	const metadata = rawEvent.metadata;
+	if (metadata?.langgraph_host) into.langGraphHost = metadata.langgraph_host;
+	if (metadata?.langgraph_version) into.langGraphVersion = metadata.langgraph_version;
+}
+
+//#endregion
+exports.createSseEventResponse = createSseEventResponse;
+//# sourceMappingURL=sse-response.cjs.map

package/dist/runtime/handlers/shared/sse-response.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sse-response.cjs","names":["THREAD_ALREADY_RUNNING_ERROR_CODE","defaultTelemetry","resolveSseKeepAliveIntervalSeconds","EventEncoder","createLogger","EventType","isThreadAccessDeniedError","THREAD_ACCESS_DENIED_ERROR_CODE","keepAliveSse"],"sources":["../../../../src/runtime/handlers/shared/sse-response.ts"],"sourcesContent":["import { EventType } from \"@ag-ui/client\";\nimport type { BaseEvent } from \"@ag-ui/client\";\nimport { EventEncoder } from \"@ag-ui/encoder\";\nimport type { Observable, Subscription } from \"rxjs\";\nimport {\n  keepAliveSse,\n  resolveSseKeepAliveIntervalSeconds,\n} from \"./sse-keep-alive\";\nimport { THREAD_ALREADY_RUNNING_ERROR_CODE } from \"@copilotkit/shared\";\nimport {\n  THREAD_ACCESS_DENIED_ERROR_CODE,\n  isThreadAccessDeniedError,\n} from \"../../runner/agent-runner\";\nimport type { ResolvedDebugConfig } from \"@copilotkit/shared\";\nimport { createLogger } from \"../../core/logger\";\nimport type { CopilotRuntimeLogger } from \"../../core/logger\";\nimport { telemetry as defaultTelemetry } from \"../../telemetry\";\nimport type { TelemetryCapture } from \"../../telemetry/telemetry-client\";\nimport type { AgentExecutionResponseInfo } from \"../../telemetry/events\";\nimport type { DebugEventBus } from \"../../core/debug-event-bus\";\nimport type {\n  RuntimeErrorPhase,\n  RuntimeErrorReporter,\n} from \"../../core/runtime-error-reporter\";\n\n/**\n * Whether a runner rejected the run because the thread is busy. Matches the\n * `code` of {@link ThreadAlreadyRunningError}, and the plain message that\n * custom runners copied from the built-in ones still throw.\n */\nfunction isThreadAlreadyRunning(error: unknown): boolean {\n  return (\n    error instanceof Error &&\n    ((error as { code?: unknown }).code === THREAD_ALREADY_RUNNING_ERROR_CODE ||\n      error.message === \"Thread already running\")\n  );\n}\n\ninterface CreateSseEventResponseParams {\n  request: Request;\n  observableFactory: () =>\n    | Promise<Observable<BaseEvent>>\n    | Observable<BaseEvent>;\n  debugEventBus?: DebugEventBus;\n  agentId?: string;\n  debug?: ResolvedDebugConfig;\n  /** Pre-created logger instance to avoid creating a new pino logger per request. */\n  logger?: CopilotRuntimeLogger;\n  /** Runtime-bound telemetry capture. Falls back for external direct callers. */\n  telemetry?: TelemetryCapture;\n  /**\n   * Execution facts known before the stream opens, merged under anything the\n   * upstream reports as it runs. Carries `llmHostClass`, which is knowable\n   * from the agent's configuration and never appears on a streamed event.\n   */\n  executionSeed?: AgentExecutionResponseInfo;\n  /**\n   * Whether to emit `oss.runtime.agent_execution_stream_*` telemetry for this\n   * stream. Defaults to `true`. The stateless `/suggest` path sets this to\n   * `false`: a suggestion is a side-effect-free structured completion, not a\n   * tracked run, and under `available: \"always\"` it fires often enough to flood\n   * run telemetry.\n   */\n  captureTelemetry?: boolean;\n  runtimeErrorReporter?: RuntimeErrorReporter;\n  startTime?: number;\n  /**\n   * Seconds of silence before a `: keep-alive` SSE comment is written.\n   * `0` disables the keep-alive. Resolved by\n   * {@link resolveSseKeepAliveIntervalSeconds}, which supplies the default\n   * and enforces the timer bound for every caller.\n   */\n  keepAliveIntervalSeconds?: number;\n}\n\nexport function createSseEventResponse({\n  request,\n  observableFactory,\n  debugEventBus,\n  agentId,\n  debug,\n  logger,\n  telemetry = defaultTelemetry,\n  executionSeed,\n  captureTelemetry = true,\n  runtimeErrorReporter,\n  startTime,\n  keepAliveIntervalSeconds,\n}: CreateSseEventResponseParams): Response {\n  const keepAliveSeconds = resolveSseKeepAliveIntervalSeconds(\n    keepAliveIntervalSeconds,\n  );\n  const stream = new TransformStream();\n  const writer = stream.writable.getWriter();\n  const encoder = new EventEncoder();\n  let streamClosed = false;\n  // Set once the current run's RUN_FINISHED or RUN_ERROR has been queued for\n  // the client. AG-UI allows nothing after either until the next RUN_STARTED,\n  // so a later failure must not add a RUN_ERROR.\n  let terminalEventWritten = false;\n  let debugThreadId = \"\";\n  let debugRunId = \"\";\n\n  const debugLogger = debug?.enabled\n    ? (logger ??\n      createLogger({ level: \"debug\", component: \"copilotkit-debug\" }))\n    : undefined;\n\n  const closeStream = async () => {\n    if (!streamClosed) {\n      try {\n        await writer.close();\n        streamClosed = true;\n      } catch {\n        // Stream already closed.\n      }\n    }\n  };\n\n  // Report a failure to the client as a terminal RUN_ERROR. Without it the\n  // client sees an empty stream that ends normally, so its run \"succeeds\"\n  // with no reply and no error (e.g. \"Thread already running\" on a busy\n  // thread). Only a busy thread is named, with a code clients can branch on;\n  // anything else may carry internal detail, so the client gets a generic\n  // message and the full error stays in the server log.\n  const writeRunError = async (error: unknown) => {\n    if (terminalEventWritten || streamClosed || request.signal.aborted) {\n      return;\n    }\n    terminalEventWritten = true;\n    const event = isThreadAlreadyRunning(error)\n      ? {\n          type: EventType.RUN_ERROR,\n          message: \"Thread already running\",\n          code: THREAD_ALREADY_RUNNING_ERROR_CODE,\n        }\n      : isThreadAccessDeniedError(error)\n        ? {\n            type: EventType.RUN_ERROR,\n            message: \"Thread access denied\",\n            code: THREAD_ACCESS_DENIED_ERROR_CODE,\n          }\n        : { type: EventType.RUN_ERROR, message: \"Agent run failed\" };\n    // The inspector sees every streamed event, so it needs this one too or\n    // the run it saw start never ends there. A run that never started has\n    // no ids to file it under, so it is not sent.\n    if (debugEventBus && debugRunId) {\n      try {\n        debugEventBus.broadcast(event as BaseEvent, {\n          agentId: agentId ?? \"\",\n          threadId: debugThreadId,\n          runId: debugRunId,\n        });\n      } catch (broadcastError) {\n        logError(broadcastError);\n      }\n    }\n    try {\n      await writer.write(encoder.encodeBinary(event as BaseEvent));\n    } catch {\n      // The client is already gone; closeStream() handles the rest.\n    }\n  };\n\n  const logError = (error: unknown) => {\n    console.error(\"Error running agent:\", error);\n    console.error(\n      \"Error stack:\",\n      error instanceof Error ? error.stack : \"No stack trace\",\n    );\n    console.error(\"Error details:\", {\n      name: error instanceof Error ? error.name : \"Unknown\",\n      message: error instanceof Error ? error.message : String(error),\n      cause: error instanceof Error ? error.cause : undefined,\n    });\n  };\n\n  let subscription: Subscription | undefined;\n  let agentErrorReported = false;\n\n  // A refused run is an access decision, not an agent failure: log it as a\n  // warning and keep it out of the error reporter.\n  const logAccessDenied = (error: unknown) => {\n    console.warn(\n      \"[CopilotKit] Run refused: the thread belongs to another identity.\",\n      error instanceof Error ? error.message : String(error),\n    );\n  };\n\n  const reportAgentError = (error: unknown, phase: RuntimeErrorPhase) => {\n    if (agentErrorReported) return;\n    agentErrorReported = true;\n    runtimeErrorReporter?.report({\n      request,\n      error,\n      operation: \"agent.run\",\n      agentId,\n      threadId: debugThreadId || undefined,\n      runId: debugRunId || undefined,\n      phase,\n      startTime,\n    });\n  };\n\n  (async () => {\n    const observable = await observableFactory();\n\n    if (captureTelemetry) {\n      telemetry.capture(\"oss.runtime.agent_execution_stream_started\", {});\n    }\n\n    if (debug?.lifecycle) {\n      debugLogger!.debug(\"SSE stream opened\");\n    }\n\n    let eventCount = 0;\n    let loggedEventCount = 0;\n\n    // Provider/model/LangGraph facts, scraped off raw upstream events as\n    // they pass and reported once the stream finishes. This moved here from\n    // the v1 TelemetryAgentRunner, which wrapped the runner purely to\n    // collect it and emitted its own duplicate copy of every stream event\n    // to carry it. v2 callers had no equivalent and reported `{}`.\n    // Seeded rather than empty: `llmHostClass` comes from the agent's config,\n    // not from the wire, so nothing streamed will ever fill it in. Scraped\n    // fields still win, since `collectExecutionInfo` writes over this.\n    const executionInfo: AgentExecutionResponseInfo = { ...executionSeed };\n\n    subscription = observable.subscribe({\n      next: async (event) => {\n        collectExecutionInfo(event, executionInfo);\n\n        // Extract threadId/runId from RUN_STARTED\n        if (event.type === \"RUN_STARTED\") {\n          const e = event as { threadId?: string; runId?: string };\n          debugThreadId = e.threadId ?? \"\";\n          debugRunId = e.runId ?? \"\";\n        }\n\n        if (event.type === \"RUN_ERROR\") {\n          const e = event as {\n            message?: unknown;\n            threadId?: string;\n            runId?: string;\n          };\n          debugThreadId = e.threadId ?? debugThreadId;\n          debugRunId = e.runId ?? debugRunId;\n          reportAgentError(\n            new Error(\n              typeof e.message === \"string\"\n                ? e.message\n                : \"Runner reported a run error\",\n            ),\n            \"sse.subscription\",\n          );\n        }\n\n        // Broadcast to debug listeners BEFORE the stream-closed gate below.\n        // Intentional: debug subscribers (e.g. the VS Code Inspector panel)\n        // should still receive trailing events after the SSE client for\n        // this request closed its connection — they're independent\n        // consumers observing the underlying runtime, not the request's\n        // response stream.\n        //\n        // Wrapped in try/catch so a buggy debug subscriber can't propagate\n        // an exception into this observer — if the throw reached the\n        // `next` callback it would get routed to `error` by RxJS, closing\n        // the SSE stream for an unrelated reason. Log via `logError` and\n        // move on.\n        if (debugEventBus) {\n          try {\n            debugEventBus.broadcast(event, {\n              agentId: agentId ?? \"\",\n              threadId: debugThreadId,\n              runId: debugRunId,\n            });\n          } catch (broadcastError) {\n            logError(broadcastError);\n          }\n        }\n\n        if (!request.signal.aborted && !streamClosed) {\n          try {\n            eventCount++;\n            if (debug?.events) {\n              loggedEventCount++;\n              if (debug.verbose) {\n                debugLogger!.debug({ event }, \"Event emitted\");\n              } else {\n                debugLogger!.debug(\n                  { type: event.type, ...summarizeEvent(event) },\n                  \"Event emitted\",\n                );\n              }\n            }\n            // /connect replays finished runs before the live one, so a new\n            // RUN_STARTED reopens the stream for a RUN_ERROR.\n            if (event.type === EventType.RUN_STARTED) {\n              terminalEventWritten = false;\n            } else if (\n              event.type === EventType.RUN_FINISHED ||\n              event.type === EventType.RUN_ERROR\n            ) {\n              terminalEventWritten = true;\n            }\n            await writer.write(encoder.encodeBinary(event));\n          } catch (error) {\n            if (error instanceof Error && error.name === \"AbortError\") {\n              streamClosed = true;\n            } else {\n              // Non-abort write failures (backpressure disconnects,\n              // transform-stream exceptions, …) were previously swallowed\n              // silently — `streamClosed` stayed `false` and the next\n              // event re-attempted a broken writer. Log and mark the\n              // stream closed so we stop trying.\n              logError(error);\n              streamClosed = true;\n            }\n          }\n        }\n      },\n      error: async (error) => {\n        if (isThreadAccessDeniedError(error)) {\n          logAccessDenied(error);\n          await writeRunError(error);\n          await closeStream();\n          return;\n        }\n        reportAgentError(error, \"sse.subscription\");\n        if (captureTelemetry) {\n          // Analytics gets the outcome, not the message: provider and tool\n          // errors can quote prompts, arguments or URLs. Same as Intelligence.\n          telemetry.capture(\"oss.runtime.agent_execution_stream_errored\", {\n            ...executionInfo,\n            error: \"AGENT_EXECUTION_FAILED\",\n          });\n        }\n        if (debug?.lifecycle) {\n          debugLogger!.debug(\n            { error: error instanceof Error ? error.message : String(error) },\n            \"SSE stream errored\",\n          );\n        }\n        logError(error);\n        await writeRunError(error);\n        await closeStream();\n      },\n      complete: async () => {\n        if (captureTelemetry) {\n          telemetry.capture(\n            \"oss.runtime.agent_execution_stream_ended\",\n            executionInfo,\n          );\n        }\n        if (debug?.lifecycle) {\n          debugLogger!.debug(\n            { eventCount, loggedEventCount },\n            \"SSE stream completed\",\n          );\n        }\n        await closeStream();\n      },\n    });\n\n    // If the client disconnected before the subscription was created,\n    // unsubscribe immediately to avoid leaking the observable.\n    if (request.signal.aborted) {\n      subscription.unsubscribe();\n    }\n  })().catch(async (error) => {\n    if (isThreadAccessDeniedError(error)) {\n      logAccessDenied(error);\n    } else {\n      reportAgentError(error, \"sse.factory\");\n      logError(error);\n    }\n    await writeRunError(error);\n    await closeStream();\n  });\n\n  request.signal.addEventListener(\"abort\", () => {\n    subscription?.unsubscribe();\n  });\n\n  const body =\n    keepAliveSeconds > 0\n      ? keepAliveSse(stream.readable, keepAliveSeconds * 1_000)\n      : stream.readable;\n\n  return new Response(body, {\n    status: 200,\n    headers: {\n      \"Content-Type\": \"text/event-stream\",\n      \"Cache-Control\": \"no-cache\",\n      Connection: \"keep-alive\",\n    },\n  });\n}\n\nfunction summarizeEvent(event: BaseEvent): Record<string, unknown> {\n  const e = event as any;\n  const summary: Record<string, unknown> = {};\n\n  if (e.messageId) summary.messageId = e.messageId;\n  if (e.toolCallId) summary.toolCallId = e.toolCallId;\n  if (e.toolCallName) summary.toolCallName = e.toolCallName;\n  if (e.role) summary.role = e.role;\n  if (e.delta != null && typeof e.delta === \"string\")\n    summary.deltaLength = e.delta.length;\n  if (e.snapshot && typeof e.snapshot === \"object\")\n    summary.snapshotKeys = Object.keys(e.snapshot);\n  if (e.delta && Array.isArray(e.delta))\n    summary.operationCount = e.delta.length;\n  if (e.threadId) summary.threadId = e.threadId;\n  if (e.runId) summary.runId = e.runId;\n  if (e.message) summary.message = e.message;\n  if (e.code) summary.code = e.code;\n  if (e.stepName) summary.stepName = e.stepName;\n\n  return summary;\n}\n\n/**\n * Accumulate provider, model, and LangGraph facts from one upstream event.\n *\n * Mutates rather than returns so the caller keeps one record across the whole\n * stream: these arrive on different events and the last one wins. Only fields\n * the upstream actually sent are set, so an agent that reports none leaves the\n * record empty and the stream events carry `{}` as before.\n *\n * `rawEvent` is the untransformed upstream payload, present on AG-UI events\n * that wrap one. Its shape is the provider's, not ours, hence the narrowing.\n */\nfunction collectExecutionInfo(\n  event: BaseEvent,\n  into: AgentExecutionResponseInfo,\n): void {\n  const rawEvent = (\n    event as {\n      rawEvent?: {\n        metadata?: Record<string, unknown>;\n        data?: Record<string, unknown>;\n      };\n    }\n  ).rawEvent;\n  if (!rawEvent) return;\n\n  const model = (rawEvent.data as { output?: { model?: string } } | undefined)\n    ?.output?.model;\n  if (model) {\n    into.model = model;\n    // Carried forward from the v1 implementation, which set both from the\n    // same field. The upstream sends no separate provider name.\n    into.provider = model;\n  }\n\n  const metadata = rawEvent.metadata as\n    | { langgraph_host?: string; langgraph_version?: string }\n    | undefined;\n  if (metadata?.langgraph_host) into.langGraphHost = metadata.langgraph_host;\n  if (metadata?.langgraph_version) {\n    into.langGraphVersion = metadata.langgraph_version;\n  }\n}\n"],"mappings":"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"}