@copilotkit/runtime 1.83.0 → 2.0.0-rc.0

package/dist/runtime/intelligence-platform/trajectories.mjs

@@ -0,0 +1,91 @@
+import { logger } from "@copilotkit/shared";
+import { z } from "zod";
+
+//#region src/runtime/intelligence-platform/trajectories.ts
+const trajectoryIdSchema = z.string().uuid();
+function isValidTrajectoryId(value) {
+	return trajectoryIdSchema.safeParse(value).success;
+}
+const joinResponseSchema = z.object({
+	joinToken: z.string().refine((value) => value.trim().length > 0),
+	trajectoryId: trajectoryIdSchema
+});
+const grantSchema = z.object({
+	joinToken: z.string().refine((value) => value.trim().length > 0),
+	realtime: z.object({
+		clientUrl: z.string().url().refine((value) => {
+			const url = new URL(value);
+			return (url.protocol === "wss:" || url.protocol === "ws:") && !url.username && !url.password;
+		}),
+		topic: z.string().refine((value) => value.trim().length > 0 && !/\p{Cc}/u.test(value))
+	})
+});
+const runtimeConfigurationErrorSchema = z.object({ error: z.object({ code: z.enum([
+	"AUTH_UNAUTHENTICATED",
+	"API_KEY_NOT_FOUND",
+	"ORG_NOT_FOUND",
+	"PROJECT_NOT_FOUND"
+]) }) });
+const contractErrorSchema = z.object({ error: z.object({
+	code: z.enum([
+		"VALIDATION_ERROR",
+		"TRAJECTORY_APP_USER_CONFLICT",
+		"LEARNING_CONTAINER_NOT_FOUND",
+		"RATE_LIMIT_EXCEEDED",
+		"INTERNAL_SERVER_ERROR",
+		"MARKETPLACE_LICENSE_REQUIRED",
+		"TRAJECTORIES_NOT_ENABLED"
+	]),
+	message: z.string().trim().min(1).max(512)
+}) });
+var TrajectoryConnectionError = class extends Error {
+	constructor(code, message, status) {
+		super(message);
+		this.code = code;
+		this.status = status;
+		this.name = "TrajectoryConnectionError";
+	}
+};
+function parseTrajectoryConnectionGrant(value, trajectoryId, clientUrl) {
+	const join = joinResponseSchema.safeParse(value);
+	const result = grantSchema.safeParse(join.success && join.data.trajectoryId === trajectoryId ? {
+		joinToken: join.data.joinToken,
+		realtime: {
+			clientUrl,
+			topic: `trajectory:${trajectoryId}`
+		}
+	} : void 0);
+	if (!result.success) {
+		const joinValid = join.success && join.data.trajectoryId === trajectoryId;
+		logger.warn({ trajectoryIdMatches: joinValid }, joinValid ? "Intelligence returned a Trajectory join token, but the Gateway URL is invalid; check the Intelligence wsUrl" : "Intelligence returned an invalid Trajectory join response");
+		throw new TrajectoryConnectionError("CONNECTION_FAILED", "Intelligence returned an invalid trajectory connection grant", 502);
+	}
+	return {
+		joinToken: result.data.joinToken,
+		realtime: {
+			clientUrl: result.data.realtime.clientUrl,
+			topic: result.data.realtime.topic
+		}
+	};
+}
+const routeNotFoundSchema = z.object({ error: z.object({ code: z.literal("ROUTE_NOT_FOUND") }) });
+const upstreamCodeSchema = z.object({ error: z.object({ code: z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/) }) });
+/** Forward only the public contract, never raw platform errors or credentials. */
+function trajectoryResponseError(value, status, apiKey) {
+	const result = contractErrorSchema.safeParse(value);
+	if (result.success && !result.data.error.message.includes(apiKey)) return new TrajectoryConnectionError(result.data.error.code, result.data.error.message, status);
+	if (status === 404 && routeNotFoundSchema.safeParse(value).success) {
+		logger.warn({ status }, "Intelligence does not serve Trajectory capture; enable Trajectories for this deployment");
+		return new TrajectoryConnectionError("TRAJECTORIES_UNAVAILABLE", "This Intelligence deployment does not serve Trajectory capture", 404);
+	}
+	logger.warn({
+		status,
+		upstreamCode: upstreamCodeSchema.safeParse(value).data?.error.code
+	}, "Intelligence rejected the Trajectory connection request; the browser receives CONNECTION_FAILED");
+	if (runtimeConfigurationErrorSchema.safeParse(value).success) return new TrajectoryConnectionError("CONNECTION_FAILED", "Could not connect to Intelligence", 502);
+	return new TrajectoryConnectionError("CONNECTION_FAILED", "Intelligence rejected the trajectory connection request", status);
+}
+
+//#endregion
+export { TrajectoryConnectionError, isValidTrajectoryId, parseTrajectoryConnectionGrant, trajectoryResponseError };
+//# sourceMappingURL=trajectories.mjs.map

package/dist/runtime/intelligence-platform/trajectories.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"trajectories.mjs","names":[],"sources":["../../../src/runtime/intelligence-platform/trajectories.ts"],"sourcesContent":["import { logger } from \"@copilotkit/shared\";\nimport { z } from \"zod\";\n\nexport interface TrajectoryConnectionGrant {\n  joinToken: string;\n  realtime: { clientUrl: string; topic: string };\n}\n\nconst trajectoryIdSchema = z.string().uuid();\n\nexport function isValidTrajectoryId(value: unknown): value is string {\n  return trajectoryIdSchema.safeParse(value).success;\n}\n\nconst joinResponseSchema = z.object({\n  joinToken: z.string().refine((value) => value.trim().length > 0),\n  trajectoryId: trajectoryIdSchema,\n});\n\nconst grantSchema = z.object({\n  joinToken: z.string().refine((value) => value.trim().length > 0),\n  realtime: z.object({\n    clientUrl: z\n      .string()\n      .url()\n      .refine((value) => {\n        const url = new URL(value);\n        return (\n          (url.protocol === \"wss:\" || url.protocol === \"ws:\") &&\n          !url.username &&\n          !url.password\n        );\n      }),\n    topic: z\n      .string()\n      .refine((value) => value.trim().length > 0 && !/\\p{Cc}/u.test(value)),\n  }),\n});\n\nconst runtimeConfigurationErrorSchema = z.object({\n  error: z.object({\n    code: z.enum([\n      \"AUTH_UNAUTHENTICATED\",\n      \"API_KEY_NOT_FOUND\",\n      \"ORG_NOT_FOUND\",\n      \"PROJECT_NOT_FOUND\",\n    ]),\n  }),\n});\n\nconst contractErrorSchema = z.object({\n  error: z.object({\n    code: z.enum([\n      \"VALIDATION_ERROR\",\n      \"TRAJECTORY_APP_USER_CONFLICT\",\n      \"LEARNING_CONTAINER_NOT_FOUND\",\n      \"RATE_LIMIT_EXCEEDED\",\n      \"INTERNAL_SERVER_ERROR\",\n      \"MARKETPLACE_LICENSE_REQUIRED\",\n      \"TRAJECTORIES_NOT_ENABLED\",\n    ]),\n    message: z.string().trim().min(1).max(512),\n  }),\n});\n\nexport class TrajectoryConnectionError extends Error {\n  constructor(\n    public readonly code: string,\n    message: string,\n    public readonly status: number,\n  ) {\n    super(message);\n    this.name = \"TrajectoryConnectionError\";\n  }\n}\n\nexport function parseTrajectoryConnectionGrant(\n  value: unknown,\n  trajectoryId: string,\n  clientUrl: string,\n): TrajectoryConnectionGrant {\n  const join = joinResponseSchema.safeParse(value);\n  const result = grantSchema.safeParse(\n    join.success && join.data.trajectoryId === trajectoryId\n      ? {\n          joinToken: join.data.joinToken,\n          realtime: { clientUrl, topic: `trajectory:${trajectoryId}` },\n        }\n      : undefined,\n  );\n  if (!result.success) {\n    const joinValid = join.success && join.data.trajectoryId === trajectoryId;\n    logger.warn(\n      { trajectoryIdMatches: joinValid },\n      joinValid\n        ? \"Intelligence returned a Trajectory join token, but the Gateway URL is invalid; check the Intelligence wsUrl\"\n        : \"Intelligence returned an invalid Trajectory join response\",\n    );\n    throw new TrajectoryConnectionError(\n      \"CONNECTION_FAILED\",\n      \"Intelligence returned an invalid trajectory connection grant\",\n      502,\n    );\n  }\n  return {\n    joinToken: result.data.joinToken,\n    realtime: {\n      clientUrl: result.data.realtime.clientUrl,\n      topic: result.data.realtime.topic,\n    },\n  };\n}\n\n// Intelligence answers with this code when Trajectory capture is switched off\n// for the deployment, because the join route is then not registered.\nconst routeNotFoundSchema = z.object({\n  error: z.object({ code: z.literal(\"ROUTE_NOT_FOUND\") }),\n});\n\nconst upstreamCodeSchema = z.object({\n  error: z.object({ code: z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/) }),\n});\n\n/** Forward only the public contract, never raw platform errors or credentials. */\nexport function trajectoryResponseError(\n  value: unknown,\n  status: number,\n  apiKey: string,\n): TrajectoryConnectionError {\n  const result = contractErrorSchema.safeParse(value);\n  if (result.success && !result.data.error.message.includes(apiKey)) {\n    return new TrajectoryConnectionError(\n      result.data.error.code,\n      result.data.error.message,\n      status,\n    );\n  }\n  if (status === 404 && routeNotFoundSchema.safeParse(value).success) {\n    logger.warn(\n      { status },\n      \"Intelligence does not serve Trajectory capture; enable Trajectories for this deployment\",\n    );\n    return new TrajectoryConnectionError(\n      \"TRAJECTORIES_UNAVAILABLE\",\n      \"This Intelligence deployment does not serve Trajectory capture\",\n      404,\n    );\n  }\n  // The browser only learns that the connection failed. Log the upstream code,\n  // never the message, so the cause is visible to the Runtime's operator.\n  logger.warn(\n    {\n      status,\n      upstreamCode: upstreamCodeSchema.safeParse(value).data?.error.code,\n    },\n    \"Intelligence rejected the Trajectory connection request; the browser receives CONNECTION_FAILED\",\n  );\n  // These failures describe the Runtime's server credentials or tenant setup,\n  // not the browser user's identity. Do not expose them as a client auth error.\n  if (runtimeConfigurationErrorSchema.safeParse(value).success) {\n    return new TrajectoryConnectionError(\n      \"CONNECTION_FAILED\",\n      \"Could not connect to Intelligence\",\n      502,\n    );\n  }\n  return new TrajectoryConnectionError(\n    \"CONNECTION_FAILED\",\n    \"Intelligence rejected the trajectory connection request\",\n    status,\n  );\n}\n"],"mappings":";;;;AAQA,MAAM,qBAAqB,EAAE,QAAQ,CAAC,MAAM;AAE5C,SAAgB,oBAAoB,OAAiC;AACnE,QAAO,mBAAmB,UAAU,MAAM,CAAC;;AAG7C,MAAM,qBAAqB,EAAE,OAAO;CAClC,WAAW,EAAE,QAAQ,CAAC,QAAQ,UAAU,MAAM,MAAM,CAAC,SAAS,EAAE;CAChE,cAAc;CACf,CAAC;AAEF,MAAM,cAAc,EAAE,OAAO;CAC3B,WAAW,EAAE,QAAQ,CAAC,QAAQ,UAAU,MAAM,MAAM,CAAC,SAAS,EAAE;CAChE,UAAU,EAAE,OAAO;EACjB,WAAW,EACR,QAAQ,CACR,KAAK,CACL,QAAQ,UAAU;GACjB,MAAM,MAAM,IAAI,IAAI,MAAM;AAC1B,WACG,IAAI,aAAa,UAAU,IAAI,aAAa,UAC7C,CAAC,IAAI,YACL,CAAC,IAAI;IAEP;EACJ,OAAO,EACJ,QAAQ,CACR,QAAQ,UAAU,MAAM,MAAM,CAAC,SAAS,KAAK,CAAC,UAAU,KAAK,MAAM,CAAC;EACxE,CAAC;CACH,CAAC;AAEF,MAAM,kCAAkC,EAAE,OAAO,EAC/C,OAAO,EAAE,OAAO,EACd,MAAM,EAAE,KAAK;CACX;CACA;CACA;CACA;CACD,CAAC,EACH,CAAC,EACH,CAAC;AAEF,MAAM,sBAAsB,EAAE,OAAO,EACnC,OAAO,EAAE,OAAO;CACd,MAAM,EAAE,KAAK;EACX;EACA;EACA;EACA;EACA;EACA;EACA;EACD,CAAC;CACF,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,IAAI,IAAI;CAC3C,CAAC,EACH,CAAC;AAEF,IAAa,4BAAb,cAA+C,MAAM;CACnD,YACE,AAAgB,MAChB,SACA,AAAgB,QAChB;AACA,QAAM,QAAQ;EAJE;EAEA;AAGhB,OAAK,OAAO;;;AAIhB,SAAgB,+BACd,OACA,cACA,WAC2B;CAC3B,MAAM,OAAO,mBAAmB,UAAU,MAAM;CAChD,MAAM,SAAS,YAAY,UACzB,KAAK,WAAW,KAAK,KAAK,iBAAiB,eACvC;EACE,WAAW,KAAK,KAAK;EACrB,UAAU;GAAE;GAAW,OAAO,cAAc;GAAgB;EAC7D,GACD,OACL;AACD,KAAI,CAAC,OAAO,SAAS;EACnB,MAAM,YAAY,KAAK,WAAW,KAAK,KAAK,iBAAiB;AAC7D,SAAO,KACL,EAAE,qBAAqB,WAAW,EAClC,YACI,gHACA,4DACL;AACD,QAAM,IAAI,0BACR,qBACA,gEACA,IACD;;AAEH,QAAO;EACL,WAAW,OAAO,KAAK;EACvB,UAAU;GACR,WAAW,OAAO,KAAK,SAAS;GAChC,OAAO,OAAO,KAAK,SAAS;GAC7B;EACF;;AAKH,MAAM,sBAAsB,EAAE,OAAO,EACnC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,kBAAkB,EAAE,CAAC,EACxD,CAAC;AAEF,MAAM,qBAAqB,EAAE,OAAO,EAClC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,yBAAyB,EAAE,CAAC,EACtE,CAAC;;AAGF,SAAgB,wBACd,OACA,QACA,QAC2B;CAC3B,MAAM,SAAS,oBAAoB,UAAU,MAAM;AACnD,KAAI,OAAO,WAAW,CAAC,OAAO,KAAK,MAAM,QAAQ,SAAS,OAAO,CAC/D,QAAO,IAAI,0BACT,OAAO,KAAK,MAAM,MAClB,OAAO,KAAK,MAAM,SAClB,OACD;AAEH,KAAI,WAAW,OAAO,oBAAoB,UAAU,MAAM,CAAC,SAAS;AAClE,SAAO,KACL,EAAE,QAAQ,EACV,0FACD;AACD,SAAO,IAAI,0BACT,4BACA,kEACA,IACD;;AAIH,QAAO,KACL;EACE;EACA,cAAc,mBAAmB,UAAU,MAAM,CAAC,MAAM,MAAM;EAC/D,EACD,kGACD;AAGD,KAAI,gCAAgC,UAAU,MAAM,CAAC,QACnD,QAAO,IAAI,0BACT,qBACA,qCACA,IACD;AAEH,QAAO,IAAI,0BACT,qBACA,2DACA,OACD"}

package/dist/runtime/node.d.cts

@@ -0,0 +1,2 @@
+import { NodeFetchHandler, createCopilotNodeHandler, createNodeFetchHandler } from "./endpoints/node-fetch-handler.cjs";
+import { NodeCopilotListener, NodeCopilotListenerWithChannels, createCopilotNodeListener } from "./endpoints/node.cjs";

package/dist/runtime/node.d.mts

@@ -0,0 +1,2 @@
+import { NodeFetchHandler, createCopilotNodeHandler, createNodeFetchHandler } from "./endpoints/node-fetch-handler.mjs";
+import { NodeCopilotListener, NodeCopilotListenerWithChannels, createCopilotNodeListener } from "./endpoints/node.mjs";

package/dist/runtime/runner/agent-runner.cjs

@@ -0,0 +1,82 @@
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+let _copilotkit_shared = require("@copilotkit/shared");
+
+//#region src/runtime/runner/agent-runner.ts
+/**
+* Thrown by a runner when the thread already has a run in flight. The SSE
+* handler sends it to the client as a `RUN_ERROR` with
+* {@link THREAD_ALREADY_RUNNING_ERROR_CODE}, matched on `code` so a copy of
+* this class from another package version still counts.
+*/
+var ThreadAlreadyRunningError = class extends Error {
+	constructor() {
+		super("Thread already running");
+		this.code = _copilotkit_shared.THREAD_ALREADY_RUNNING_ERROR_CODE;
+		this.name = "ThreadAlreadyRunningError";
+	}
+};
+/** `code` of {@link ThreadAccessDeniedError}, also sent on the SSE `RUN_ERROR`. */
+const THREAD_ACCESS_DENIED_ERROR_CODE = "THREAD_ACCESS_DENIED";
+/**
+* Thrown by a runner when a run targets a Thread that another identity owns.
+*
+* Defense in depth: the run handler checks `isThreadAccessible` first and
+* refuses with an HTTP error, so the runner throws this only when another
+* identity claims the Thread between that check and the run, or for direct
+* runner callers. A synchronous throw from `run()` is still mapped to the
+* HTTP error; a later one reaches the client as a `RUN_ERROR` with
+* {@link THREAD_ACCESS_DENIED_ERROR_CODE}. Neither is reported as an agent
+* failure. Matched on `code`, so a copy of this class from another package
+* version still counts.
+*/
+var ThreadAccessDeniedError = class extends Error {
+	constructor() {
+		super("Thread access denied");
+		this.code = THREAD_ACCESS_DENIED_ERROR_CODE;
+		this.name = "ThreadAccessDeniedError";
+	}
+};
+/** True for a {@link ThreadAccessDeniedError}, from any package version. */
+function isThreadAccessDeniedError(error) {
+	return error instanceof Error && error.code === THREAD_ACCESS_DENIED_ERROR_CODE;
+}
+/**
+* Owner of a Thread created, or reached, by a runner call that names no owner:
+* a run, connect, stop or isRunning without `ownerId`, or a Thread endpoint call
+* without a scope. Such calls come only from trusted server-side code (for
+* example a Channel listener), and they act as this one server identity.
+*
+* No HTTP caller can act as it: request identities are `""` (anonymous) or an
+* id that `identifyUser` returned, and a valid id cannot hold a NUL character.
+* So an omitted owner never means "every Thread", and a Thread created
+* server-side is never reachable by an anonymous caller.
+*/
+const ɵSERVER_THREAD_OWNER = "\0server";
+/** The owner a runner call acts as: `ownerId`, or the server owner when omitted. */
+function ɵresolveThreadOwner(ownerId) {
+	return ownerId ?? ɵSERVER_THREAD_OWNER;
+}
+function supportsLocalThreadEndpoints(runner) {
+	return runner.ɵsupportsLocalThreadEndpoints === true;
+}
+/**
+* True when `runner` enforces Thread owners. Checks the method itself, so a
+* runner built against an older interface (one that sets the endpoint flag
+* but has no `isThreadAccessible`) is not taken to enforce them.
+*/
+function enforcesThreadOwnership(runner) {
+	return typeof runner.isThreadAccessible === "function";
+}
+var AgentRunner = class {};
+
+//#endregion
+exports.AgentRunner = AgentRunner;
+exports.THREAD_ACCESS_DENIED_ERROR_CODE = THREAD_ACCESS_DENIED_ERROR_CODE;
+exports.ThreadAccessDeniedError = ThreadAccessDeniedError;
+exports.ThreadAlreadyRunningError = ThreadAlreadyRunningError;
+exports.enforcesThreadOwnership = enforcesThreadOwnership;
+exports.isThreadAccessDeniedError = isThreadAccessDeniedError;
+exports.supportsLocalThreadEndpoints = supportsLocalThreadEndpoints;
+exports.ɵSERVER_THREAD_OWNER = ɵSERVER_THREAD_OWNER;
+exports.ɵresolveThreadOwner = ɵresolveThreadOwner;
+//# sourceMappingURL=agent-runner.cjs.map

package/dist/runtime/runner/agent-runner.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner.cjs","names":["THREAD_ALREADY_RUNNING_ERROR_CODE"],"sources":["../../../src/runtime/runner/agent-runner.ts"],"sourcesContent":["import type {\n  AbstractAgent,\n  BaseEvent,\n  Message,\n  RunAgentInput,\n} from \"@ag-ui/client\";\nimport type { Observable } from \"rxjs\";\nimport { THREAD_ALREADY_RUNNING_ERROR_CODE } from \"@copilotkit/shared\";\n\n/**\n * Thrown by a runner when the thread already has a run in flight. The SSE\n * handler sends it to the client as a `RUN_ERROR` with\n * {@link THREAD_ALREADY_RUNNING_ERROR_CODE}, matched on `code` so a copy of\n * this class from another package version still counts.\n */\nexport class ThreadAlreadyRunningError extends Error {\n  readonly code = THREAD_ALREADY_RUNNING_ERROR_CODE;\n\n  constructor() {\n    super(\"Thread already running\");\n    this.name = \"ThreadAlreadyRunningError\";\n  }\n}\n\n/** `code` of {@link ThreadAccessDeniedError}, also sent on the SSE `RUN_ERROR`. */\nexport const THREAD_ACCESS_DENIED_ERROR_CODE = \"THREAD_ACCESS_DENIED\";\n\n/**\n * Thrown by a runner when a run targets a Thread that another identity owns.\n *\n * Defense in depth: the run handler checks `isThreadAccessible` first and\n * refuses with an HTTP error, so the runner throws this only when another\n * identity claims the Thread between that check and the run, or for direct\n * runner callers. A synchronous throw from `run()` is still mapped to the\n * HTTP error; a later one reaches the client as a `RUN_ERROR` with\n * {@link THREAD_ACCESS_DENIED_ERROR_CODE}. Neither is reported as an agent\n * failure. Matched on `code`, so a copy of this class from another package\n * version still counts.\n */\nexport class ThreadAccessDeniedError extends Error {\n  readonly code = THREAD_ACCESS_DENIED_ERROR_CODE;\n\n  constructor() {\n    super(\"Thread access denied\");\n    this.name = \"ThreadAccessDeniedError\";\n  }\n}\n\n/** True for a {@link ThreadAccessDeniedError}, from any package version. */\nexport function isThreadAccessDeniedError(error: unknown): boolean {\n  return (\n    error instanceof Error &&\n    (error as { code?: unknown }).code === THREAD_ACCESS_DENIED_ERROR_CODE\n  );\n}\n\n/**\n * Owner of a Thread created, or reached, by a runner call that names no owner:\n * a run, connect, stop or isRunning without `ownerId`, or a Thread endpoint call\n * without a scope. Such calls come only from trusted server-side code (for\n * example a Channel listener), and they act as this one server identity.\n *\n * No HTTP caller can act as it: request identities are `\"\"` (anonymous) or an\n * id that `identifyUser` returned, and a valid id cannot hold a NUL character.\n * So an omitted owner never means \"every Thread\", and a Thread created\n * server-side is never reachable by an anonymous caller.\n */\nexport const ɵSERVER_THREAD_OWNER = \"\\u0000server\";\n\n/** The owner a runner call acts as: `ownerId`, or the server owner when omitted. */\nexport function ɵresolveThreadOwner(ownerId: string | undefined): string {\n  return ownerId ?? ɵSERVER_THREAD_OWNER;\n}\n\nexport interface AgentRunnerRunRequest {\n  threadId: string;\n  /** Backend execution ID supplied by Intelligence for imported non-UUID sessions. */\n  backendThreadId?: string;\n  agent: AbstractAgent;\n  input: RunAgentInput;\n  persistedInputMessages?: Message[];\n  /** Short-lived token scoped to this runner invocation. */\n  authToken?: string;\n  /**\n   * Identity the run acts as. A runner that tracks owners records it on the\n   * Thread's first run and refuses a run from any other identity. `\"\"` is the\n   * anonymous owner. When omitted, the run acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface AgentRunnerConnectRequest {\n  threadId: string;\n  agentId?: string;\n  headers?: Record<string, string>;\n  joinCode?: string;\n  /**\n   * Caller identity. A Thread owned by another identity is treated as unknown.\n   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface AgentRunnerIsRunningRequest {\n  threadId: string;\n  /**\n   * Caller identity. A Thread owned by another identity reports \"not running\".\n   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface AgentRunnerStopRequest {\n  threadId: string;\n  /** When present, stop only this exact run and never a newer run on the Thread. */\n  runId?: string;\n  /**\n   * Caller identity. A run on a Thread owned by another identity is not\n   * stopped. When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface LocalThreadEndpointRecord {\n  id: string;\n  name: string | null;\n  agentId: string;\n  organizationId: string;\n  createdById: string;\n  archived: boolean;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/**\n * Limits a local Thread endpoint call to the Threads of one owner. `\"\"` is the\n * anonymous owner. A call without a scope acts as\n * {@link ɵSERVER_THREAD_OWNER}: it sees only Threads created server-side, never\n * every Thread.\n */\nexport interface LocalThreadEndpointScope {\n  ownerId: string;\n}\n\nexport interface LocalThreadEndpointRunner extends AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints: true;\n  listThreads(scope?: LocalThreadEndpointScope): LocalThreadEndpointRecord[];\n  getThreadMessages(\n    threadId: string,\n    scope?: LocalThreadEndpointScope,\n  ): Message[];\n  getThreadEvents(\n    threadId: string,\n    scope?: LocalThreadEndpointScope,\n  ): BaseEvent[];\n  getThreadState(\n    threadId: string,\n    scope?: LocalThreadEndpointScope,\n  ): Record<string, unknown> | null;\n  clearThreads(scope?: LocalThreadEndpointScope): void;\n  /** See {@link ThreadOwnershipRunner.isThreadAccessible}. */\n  isThreadAccessible(\n    threadId: string,\n    scope: LocalThreadEndpointScope,\n  ): boolean;\n}\n\nexport function supportsLocalThreadEndpoints(\n  runner: AgentRunner,\n): runner is LocalThreadEndpointRunner {\n  return runner.ɵsupportsLocalThreadEndpoints === true;\n}\n\n/**\n * A runner that records each Thread's owner and enforces it. Implementing\n * `isThreadAccessible` is the promise that `run`, `connect`, `stop` and\n * `isRunning` honor `ownerId` the same way: a call never reaches a Thread that\n * another owner holds.\n */\nexport interface ThreadOwnershipRunner extends AgentRunner {\n  /** False when the Thread id is held by an owner other than `scope`'s. */\n  isThreadAccessible(\n    threadId: string,\n    scope: LocalThreadEndpointScope,\n  ): boolean | Promise<boolean>;\n}\n\n/**\n * True when `runner` enforces Thread owners. Checks the method itself, so a\n * runner built against an older interface (one that sets the endpoint flag\n * but has no `isThreadAccessible`) is not taken to enforce them.\n */\nexport function enforcesThreadOwnership(\n  runner: AgentRunner,\n): runner is ThreadOwnershipRunner {\n  return typeof runner.isThreadAccessible === \"function\";\n}\n\nexport abstract class AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints?: boolean;\n\n  /** See {@link ThreadOwnershipRunner}. Optional: not every runner tracks owners. */\n  isThreadAccessible?(\n    threadId: string,\n    scope: LocalThreadEndpointScope,\n  ): boolean | Promise<boolean>;\n\n  abstract run(request: AgentRunnerRunRequest): Observable<BaseEvent>;\n  abstract connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;\n  abstract isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;\n  abstract stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;\n}\n"],"mappings":";;;;;;;;;;AAeA,IAAa,4BAAb,cAA+C,MAAM;CAGnD,cAAc;AACZ,QAAM,yBAAyB;cAHjBA;AAId,OAAK,OAAO;;;;AAKhB,MAAa,kCAAkC;;;;;;;;;;;;;AAc/C,IAAa,0BAAb,cAA6C,MAAM;CAGjD,cAAc;AACZ,QAAM,uBAAuB;cAHf;AAId,OAAK,OAAO;;;;AAKhB,SAAgB,0BAA0B,OAAyB;AACjE,QACE,iBAAiB,SAChB,MAA6B,SAAS;;;;;;;;;;;;;AAe3C,MAAa,uBAAuB;;AAGpC,SAAgB,oBAAoB,SAAqC;AACvE,QAAO,WAAW;;AAgGpB,SAAgB,6BACd,QACqC;AACrC,QAAO,OAAO,kCAAkC;;;;;;;AAsBlD,SAAgB,wBACd,QACiC;AACjC,QAAO,OAAO,OAAO,uBAAuB;;AAG9C,IAAsB,cAAtB,MAAkC"}

package/dist/runtime/runner/agent-runner.d.cts

@@ -0,0 +1,151 @@
+import { AbstractAgent, BaseEvent, Message, RunAgentInput } from "@ag-ui/client";
+import { Observable } from "rxjs";
+
+//#region src/runtime/runner/agent-runner.d.ts
+/**
+ * Thrown by a runner when the thread already has a run in flight. The SSE
+ * handler sends it to the client as a `RUN_ERROR` with
+ * {@link THREAD_ALREADY_RUNNING_ERROR_CODE}, matched on `code` so a copy of
+ * this class from another package version still counts.
+ */
+declare class ThreadAlreadyRunningError extends Error {
+  readonly code = "THREAD_ALREADY_RUNNING";
+  constructor();
+}
+/** `code` of {@link ThreadAccessDeniedError}, also sent on the SSE `RUN_ERROR`. */
+declare const THREAD_ACCESS_DENIED_ERROR_CODE = "THREAD_ACCESS_DENIED";
+/**
+ * Thrown by a runner when a run targets a Thread that another identity owns.
+ *
+ * Defense in depth: the run handler checks `isThreadAccessible` first and
+ * refuses with an HTTP error, so the runner throws this only when another
+ * identity claims the Thread between that check and the run, or for direct
+ * runner callers. A synchronous throw from `run()` is still mapped to the
+ * HTTP error; a later one reaches the client as a `RUN_ERROR` with
+ * {@link THREAD_ACCESS_DENIED_ERROR_CODE}. Neither is reported as an agent
+ * failure. Matched on `code`, so a copy of this class from another package
+ * version still counts.
+ */
+declare class ThreadAccessDeniedError extends Error {
+  readonly code = "THREAD_ACCESS_DENIED";
+  constructor();
+}
+/** True for a {@link ThreadAccessDeniedError}, from any package version. */
+declare function isThreadAccessDeniedError(error: unknown): boolean;
+/**
+ * Owner of a Thread created, or reached, by a runner call that names no owner:
+ * a run, connect, stop or isRunning without `ownerId`, or a Thread endpoint call
+ * without a scope. Such calls come only from trusted server-side code (for
+ * example a Channel listener), and they act as this one server identity.
+ *
+ * No HTTP caller can act as it: request identities are `""` (anonymous) or an
+ * id that `identifyUser` returned, and a valid id cannot hold a NUL character.
+ * So an omitted owner never means "every Thread", and a Thread created
+ * server-side is never reachable by an anonymous caller.
+ */
+declare const ɵSERVER_THREAD_OWNER = "\0server";
+/** The owner a runner call acts as: `ownerId`, or the server owner when omitted. */
+declare function ɵresolveThreadOwner(ownerId: string | undefined): string;
+interface AgentRunnerRunRequest {
+  threadId: string;
+  /** Backend execution ID supplied by Intelligence for imported non-UUID sessions. */
+  backendThreadId?: string;
+  agent: AbstractAgent;
+  input: RunAgentInput;
+  persistedInputMessages?: Message[];
+  /** Short-lived token scoped to this runner invocation. */
+  authToken?: string;
+  /**
+   * Identity the run acts as. A runner that tracks owners records it on the
+   * Thread's first run and refuses a run from any other identity. `""` is the
+   * anonymous owner. When omitted, the run acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface AgentRunnerConnectRequest {
+  threadId: string;
+  agentId?: string;
+  headers?: Record<string, string>;
+  joinCode?: string;
+  /**
+   * Caller identity. A Thread owned by another identity is treated as unknown.
+   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface AgentRunnerIsRunningRequest {
+  threadId: string;
+  /**
+   * Caller identity. A Thread owned by another identity reports "not running".
+   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface AgentRunnerStopRequest {
+  threadId: string;
+  /** When present, stop only this exact run and never a newer run on the Thread. */
+  runId?: string;
+  /**
+   * Caller identity. A run on a Thread owned by another identity is not
+   * stopped. When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface LocalThreadEndpointRecord {
+  id: string;
+  name: string | null;
+  agentId: string;
+  organizationId: string;
+  createdById: string;
+  archived: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+/**
+ * Limits a local Thread endpoint call to the Threads of one owner. `""` is the
+ * anonymous owner. A call without a scope acts as
+ * {@link ɵSERVER_THREAD_OWNER}: it sees only Threads created server-side, never
+ * every Thread.
+ */
+interface LocalThreadEndpointScope {
+  ownerId: string;
+}
+interface LocalThreadEndpointRunner extends AgentRunner {
+  readonly ɵsupportsLocalThreadEndpoints: true;
+  listThreads(scope?: LocalThreadEndpointScope): LocalThreadEndpointRecord[];
+  getThreadMessages(threadId: string, scope?: LocalThreadEndpointScope): Message[];
+  getThreadEvents(threadId: string, scope?: LocalThreadEndpointScope): BaseEvent[];
+  getThreadState(threadId: string, scope?: LocalThreadEndpointScope): Record<string, unknown> | null;
+  clearThreads(scope?: LocalThreadEndpointScope): void;
+  /** See {@link ThreadOwnershipRunner.isThreadAccessible}. */
+  isThreadAccessible(threadId: string, scope: LocalThreadEndpointScope): boolean;
+}
+declare function supportsLocalThreadEndpoints(runner: AgentRunner): runner is LocalThreadEndpointRunner;
+/**
+ * A runner that records each Thread's owner and enforces it. Implementing
+ * `isThreadAccessible` is the promise that `run`, `connect`, `stop` and
+ * `isRunning` honor `ownerId` the same way: a call never reaches a Thread that
+ * another owner holds.
+ */
+interface ThreadOwnershipRunner extends AgentRunner {
+  /** False when the Thread id is held by an owner other than `scope`'s. */
+  isThreadAccessible(threadId: string, scope: LocalThreadEndpointScope): boolean | Promise<boolean>;
+}
+/**
+ * True when `runner` enforces Thread owners. Checks the method itself, so a
+ * runner built against an older interface (one that sets the endpoint flag
+ * but has no `isThreadAccessible`) is not taken to enforce them.
+ */
+declare function enforcesThreadOwnership(runner: AgentRunner): runner is ThreadOwnershipRunner;
+declare abstract class AgentRunner {
+  readonly ɵsupportsLocalThreadEndpoints?: boolean;
+  /** See {@link ThreadOwnershipRunner}. Optional: not every runner tracks owners. */
+  isThreadAccessible?(threadId: string, scope: LocalThreadEndpointScope): boolean | Promise<boolean>;
+  abstract run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+  abstract connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+  abstract isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+  abstract stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+}
+//#endregion
+export { AgentRunner, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerRunRequest, AgentRunnerStopRequest, LocalThreadEndpointRecord, LocalThreadEndpointRunner, LocalThreadEndpointScope, THREAD_ACCESS_DENIED_ERROR_CODE, ThreadAccessDeniedError, ThreadAlreadyRunningError, ThreadOwnershipRunner, enforcesThreadOwnership, isThreadAccessDeniedError, supportsLocalThreadEndpoints, ɵSERVER_THREAD_OWNER, ɵresolveThreadOwner };
+//# sourceMappingURL=agent-runner.d.cts.map

package/dist/runtime/runner/agent-runner.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner.d.cts","names":[],"sources":["../../../src/runtime/runner/agent-runner.ts"],"mappings":";;;;;;AAeA;;;;cAAa,yBAAA,SAAkC,KAAA;EAAA,SACpC,IAAA;;;;cASE,+BAAA;;;;;AAcb;;;;;;;;cAAa,uBAAA,SAAgC,KAAA;EAAA,SAClC,IAAA;;;;iBASK,yBAAA,CAA0B,KAAA;AAkB1C;;;;;AAGA;;;;;AAIA;AAPA,cAAa,oBAAA;;iBAGG,mBAAA,CAAoB,OAAA;AAAA,UAInB,qBAAA;EACf,QAAA;EAKgC;EAHhC,eAAA;EACA,KAAA,EAAO,aAAA;EACP,KAAA,EAAO,aAAA;EACP,sBAAA,GAAyB,OAAA;EAFlB;EAIP,SAAA;EAHO;;;;;EASP,OAAA;AAAA;AAAA,UAGe,yBAAA;EACf,QAAA;EACA,OAAA;EACA,OAAA,GAAU,MAAA;EACV,QAAA;EAFA;;;;EAOA,OAAA;AAAA;AAAA,UAGe,2BAAA;EACf,QAAA;EAD0C;;;;EAM1C,OAAA;AAAA;AAAA,UAGe,sBAAA;EACf,QAAA;EAAA;EAEA,KAAA;EAKA;;;AAGF;EAHE,OAAA;AAAA;AAAA,UAGe,yBAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;;AASF;;;;;UAAiB,wBAAA;EACf,OAAA;AAAA;AAAA,UAGe,yBAAA,SAAkC,WAAA;EAAA,SACxC,6BAAA;EACT,WAAA,CAAY,KAAA,GAAQ,wBAAA,GAA2B,yBAAA;EAC/C,iBAAA,CACE,QAAA,UACA,KAAA,GAAQ,wBAAA,GACP,OAAA;EACH,eAAA,CACE,QAAA,UACA,KAAA,GAAQ,wBAAA,GACP,SAAA;EACH,cAAA,CACE,QAAA,UACA,KAAA,GAAQ,wBAAA,GACP,MAAA;EACH,YAAA,CAAa,KAAA,GAAQ,wBAAA;EADlB;EAGH,kBAAA,CACE,QAAA,UACA,KAAA,EAAO,wBAAA;AAAA;AAAA,iBAIK,4BAAA,CACd,MAAA,EAAQ,WAAA,GACP,MAAA,IAAU,yBAAA;;;;;;;UAUI,qBAAA,SAA8B,WAAA;EAjCE;EAmC/C,kBAAA,CACE,QAAA,UACA,KAAA,EAAO,wBAAA,aACI,OAAA;AAAA;;;;;;iBAQC,uBAAA,CACd,MAAA,EAAQ,WAAA,GACP,MAAA,IAAU,qBAAA;AAAA,uBAIS,WAAA;EAAA,SACX,6BAAA;EA5CT;EA+CA,kBAAA,CAAA,CACE,QAAA,UACA,KAAA,EAAO,wBAAA,aACI,OAAA;EAAA,SAEJ,GAAA,CAAI,OAAA,EAAS,qBAAA,GAAwB,UAAA,CAAW,SAAA;EAAA,SAChD,OAAA,CAAQ,OAAA,EAAS,yBAAA,GAA4B,UAAA,CAAW,SAAA;EAAA,SACxD,SAAA,CAAU,OAAA,EAAS,2BAAA,GAA8B,OAAA;EAAA,SACjD,IAAA,CAAK,OAAA,EAAS,sBAAA,GAAyB,OAAA;AAAA"}

package/dist/runtime/runner/agent-runner.d.mts

@@ -0,0 +1,151 @@
+import { Observable } from "rxjs";
+import { AbstractAgent, BaseEvent, Message, RunAgentInput } from "@ag-ui/client";
+
+//#region src/runtime/runner/agent-runner.d.ts
+/**
+ * Thrown by a runner when the thread already has a run in flight. The SSE
+ * handler sends it to the client as a `RUN_ERROR` with
+ * {@link THREAD_ALREADY_RUNNING_ERROR_CODE}, matched on `code` so a copy of
+ * this class from another package version still counts.
+ */
+declare class ThreadAlreadyRunningError extends Error {
+  readonly code = "THREAD_ALREADY_RUNNING";
+  constructor();
+}
+/** `code` of {@link ThreadAccessDeniedError}, also sent on the SSE `RUN_ERROR`. */
+declare const THREAD_ACCESS_DENIED_ERROR_CODE = "THREAD_ACCESS_DENIED";
+/**
+ * Thrown by a runner when a run targets a Thread that another identity owns.
+ *
+ * Defense in depth: the run handler checks `isThreadAccessible` first and
+ * refuses with an HTTP error, so the runner throws this only when another
+ * identity claims the Thread between that check and the run, or for direct
+ * runner callers. A synchronous throw from `run()` is still mapped to the
+ * HTTP error; a later one reaches the client as a `RUN_ERROR` with
+ * {@link THREAD_ACCESS_DENIED_ERROR_CODE}. Neither is reported as an agent
+ * failure. Matched on `code`, so a copy of this class from another package
+ * version still counts.
+ */
+declare class ThreadAccessDeniedError extends Error {
+  readonly code = "THREAD_ACCESS_DENIED";
+  constructor();
+}
+/** True for a {@link ThreadAccessDeniedError}, from any package version. */
+declare function isThreadAccessDeniedError(error: unknown): boolean;
+/**
+ * Owner of a Thread created, or reached, by a runner call that names no owner:
+ * a run, connect, stop or isRunning without `ownerId`, or a Thread endpoint call
+ * without a scope. Such calls come only from trusted server-side code (for
+ * example a Channel listener), and they act as this one server identity.
+ *
+ * No HTTP caller can act as it: request identities are `""` (anonymous) or an
+ * id that `identifyUser` returned, and a valid id cannot hold a NUL character.
+ * So an omitted owner never means "every Thread", and a Thread created
+ * server-side is never reachable by an anonymous caller.
+ */
+declare const ɵSERVER_THREAD_OWNER = "\0server";
+/** The owner a runner call acts as: `ownerId`, or the server owner when omitted. */
+declare function ɵresolveThreadOwner(ownerId: string | undefined): string;
+interface AgentRunnerRunRequest {
+  threadId: string;
+  /** Backend execution ID supplied by Intelligence for imported non-UUID sessions. */
+  backendThreadId?: string;
+  agent: AbstractAgent;
+  input: RunAgentInput;
+  persistedInputMessages?: Message[];
+  /** Short-lived token scoped to this runner invocation. */
+  authToken?: string;
+  /**
+   * Identity the run acts as. A runner that tracks owners records it on the
+   * Thread's first run and refuses a run from any other identity. `""` is the
+   * anonymous owner. When omitted, the run acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface AgentRunnerConnectRequest {
+  threadId: string;
+  agentId?: string;
+  headers?: Record<string, string>;
+  joinCode?: string;
+  /**
+   * Caller identity. A Thread owned by another identity is treated as unknown.
+   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface AgentRunnerIsRunningRequest {
+  threadId: string;
+  /**
+   * Caller identity. A Thread owned by another identity reports "not running".
+   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface AgentRunnerStopRequest {
+  threadId: string;
+  /** When present, stop only this exact run and never a newer run on the Thread. */
+  runId?: string;
+  /**
+   * Caller identity. A run on a Thread owned by another identity is not
+   * stopped. When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.
+   */
+  ownerId?: string;
+}
+interface LocalThreadEndpointRecord {
+  id: string;
+  name: string | null;
+  agentId: string;
+  organizationId: string;
+  createdById: string;
+  archived: boolean;
+  createdAt: string;
+  updatedAt: string;
+}
+/**
+ * Limits a local Thread endpoint call to the Threads of one owner. `""` is the
+ * anonymous owner. A call without a scope acts as
+ * {@link ɵSERVER_THREAD_OWNER}: it sees only Threads created server-side, never
+ * every Thread.
+ */
+interface LocalThreadEndpointScope {
+  ownerId: string;
+}
+interface LocalThreadEndpointRunner extends AgentRunner {
+  readonly ɵsupportsLocalThreadEndpoints: true;
+  listThreads(scope?: LocalThreadEndpointScope): LocalThreadEndpointRecord[];
+  getThreadMessages(threadId: string, scope?: LocalThreadEndpointScope): Message[];
+  getThreadEvents(threadId: string, scope?: LocalThreadEndpointScope): BaseEvent[];
+  getThreadState(threadId: string, scope?: LocalThreadEndpointScope): Record<string, unknown> | null;
+  clearThreads(scope?: LocalThreadEndpointScope): void;
+  /** See {@link ThreadOwnershipRunner.isThreadAccessible}. */
+  isThreadAccessible(threadId: string, scope: LocalThreadEndpointScope): boolean;
+}
+declare function supportsLocalThreadEndpoints(runner: AgentRunner): runner is LocalThreadEndpointRunner;
+/**
+ * A runner that records each Thread's owner and enforces it. Implementing
+ * `isThreadAccessible` is the promise that `run`, `connect`, `stop` and
+ * `isRunning` honor `ownerId` the same way: a call never reaches a Thread that
+ * another owner holds.
+ */
+interface ThreadOwnershipRunner extends AgentRunner {
+  /** False when the Thread id is held by an owner other than `scope`'s. */
+  isThreadAccessible(threadId: string, scope: LocalThreadEndpointScope): boolean | Promise<boolean>;
+}
+/**
+ * True when `runner` enforces Thread owners. Checks the method itself, so a
+ * runner built against an older interface (one that sets the endpoint flag
+ * but has no `isThreadAccessible`) is not taken to enforce them.
+ */
+declare function enforcesThreadOwnership(runner: AgentRunner): runner is ThreadOwnershipRunner;
+declare abstract class AgentRunner {
+  readonly ɵsupportsLocalThreadEndpoints?: boolean;
+  /** See {@link ThreadOwnershipRunner}. Optional: not every runner tracks owners. */
+  isThreadAccessible?(threadId: string, scope: LocalThreadEndpointScope): boolean | Promise<boolean>;
+  abstract run(request: AgentRunnerRunRequest): Observable<BaseEvent>;
+  abstract connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;
+  abstract isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
+  abstract stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
+}
+//#endregion
+export { AgentRunner, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerRunRequest, AgentRunnerStopRequest, LocalThreadEndpointRecord, LocalThreadEndpointRunner, LocalThreadEndpointScope, THREAD_ACCESS_DENIED_ERROR_CODE, ThreadAccessDeniedError, ThreadAlreadyRunningError, ThreadOwnershipRunner, enforcesThreadOwnership, isThreadAccessDeniedError, supportsLocalThreadEndpoints, ɵSERVER_THREAD_OWNER, ɵresolveThreadOwner };
+//# sourceMappingURL=agent-runner.d.mts.map

package/dist/runtime/runner/agent-runner.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner.d.mts","names":[],"sources":["../../../src/runtime/runner/agent-runner.ts"],"mappings":";;;;;;AAeA;;;;cAAa,yBAAA,SAAkC,KAAA;EAAA,SACpC,IAAA;;;;cASE,+BAAA;;;;;AAcb;;;;;;;;cAAa,uBAAA,SAAgC,KAAA;EAAA,SAClC,IAAA;;;;iBASK,yBAAA,CAA0B,KAAA;AAkB1C;;;;;AAGA;;;;;AAIA;AAPA,cAAa,oBAAA;;iBAGG,mBAAA,CAAoB,OAAA;AAAA,UAInB,qBAAA;EACf,QAAA;EAKgC;EAHhC,eAAA;EACA,KAAA,EAAO,aAAA;EACP,KAAA,EAAO,aAAA;EACP,sBAAA,GAAyB,OAAA;EAFlB;EAIP,SAAA;EAHO;;;;;EASP,OAAA;AAAA;AAAA,UAGe,yBAAA;EACf,QAAA;EACA,OAAA;EACA,OAAA,GAAU,MAAA;EACV,QAAA;EAFA;;;;EAOA,OAAA;AAAA;AAAA,UAGe,2BAAA;EACf,QAAA;EAD0C;;;;EAM1C,OAAA;AAAA;AAAA,UAGe,sBAAA;EACf,QAAA;EAAA;EAEA,KAAA;EAKA;;;AAGF;EAHE,OAAA;AAAA;AAAA,UAGe,yBAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;;AASF;;;;;UAAiB,wBAAA;EACf,OAAA;AAAA;AAAA,UAGe,yBAAA,SAAkC,WAAA;EAAA,SACxC,6BAAA;EACT,WAAA,CAAY,KAAA,GAAQ,wBAAA,GAA2B,yBAAA;EAC/C,iBAAA,CACE,QAAA,UACA,KAAA,GAAQ,wBAAA,GACP,OAAA;EACH,eAAA,CACE,QAAA,UACA,KAAA,GAAQ,wBAAA,GACP,SAAA;EACH,cAAA,CACE,QAAA,UACA,KAAA,GAAQ,wBAAA,GACP,MAAA;EACH,YAAA,CAAa,KAAA,GAAQ,wBAAA;EADlB;EAGH,kBAAA,CACE,QAAA,UACA,KAAA,EAAO,wBAAA;AAAA;AAAA,iBAIK,4BAAA,CACd,MAAA,EAAQ,WAAA,GACP,MAAA,IAAU,yBAAA;;;;;;;UAUI,qBAAA,SAA8B,WAAA;EAjCE;EAmC/C,kBAAA,CACE,QAAA,UACA,KAAA,EAAO,wBAAA,aACI,OAAA;AAAA;;;;;;iBAQC,uBAAA,CACd,MAAA,EAAQ,WAAA,GACP,MAAA,IAAU,qBAAA;AAAA,uBAIS,WAAA;EAAA,SACX,6BAAA;EA5CT;EA+CA,kBAAA,CAAA,CACE,QAAA,UACA,KAAA,EAAO,wBAAA,aACI,OAAA;EAAA,SAEJ,GAAA,CAAI,OAAA,EAAS,qBAAA,GAAwB,UAAA,CAAW,SAAA;EAAA,SAChD,OAAA,CAAQ,OAAA,EAAS,yBAAA,GAA4B,UAAA,CAAW,SAAA;EAAA,SACxD,SAAA,CAAU,OAAA,EAAS,2BAAA,GAA8B,OAAA;EAAA,SACjD,IAAA,CAAK,OAAA,EAAS,sBAAA,GAAyB,OAAA;AAAA"}

package/dist/runtime/runner/agent-runner.mjs

@@ -0,0 +1,73 @@
+import { THREAD_ALREADY_RUNNING_ERROR_CODE } from "@copilotkit/shared";
+
+//#region src/runtime/runner/agent-runner.ts
+/**
+* Thrown by a runner when the thread already has a run in flight. The SSE
+* handler sends it to the client as a `RUN_ERROR` with
+* {@link THREAD_ALREADY_RUNNING_ERROR_CODE}, matched on `code` so a copy of
+* this class from another package version still counts.
+*/
+var ThreadAlreadyRunningError = class extends Error {
+	constructor() {
+		super("Thread already running");
+		this.code = THREAD_ALREADY_RUNNING_ERROR_CODE;
+		this.name = "ThreadAlreadyRunningError";
+	}
+};
+/** `code` of {@link ThreadAccessDeniedError}, also sent on the SSE `RUN_ERROR`. */
+const THREAD_ACCESS_DENIED_ERROR_CODE = "THREAD_ACCESS_DENIED";
+/**
+* Thrown by a runner when a run targets a Thread that another identity owns.
+*
+* Defense in depth: the run handler checks `isThreadAccessible` first and
+* refuses with an HTTP error, so the runner throws this only when another
+* identity claims the Thread between that check and the run, or for direct
+* runner callers. A synchronous throw from `run()` is still mapped to the
+* HTTP error; a later one reaches the client as a `RUN_ERROR` with
+* {@link THREAD_ACCESS_DENIED_ERROR_CODE}. Neither is reported as an agent
+* failure. Matched on `code`, so a copy of this class from another package
+* version still counts.
+*/
+var ThreadAccessDeniedError = class extends Error {
+	constructor() {
+		super("Thread access denied");
+		this.code = THREAD_ACCESS_DENIED_ERROR_CODE;
+		this.name = "ThreadAccessDeniedError";
+	}
+};
+/** True for a {@link ThreadAccessDeniedError}, from any package version. */
+function isThreadAccessDeniedError(error) {
+	return error instanceof Error && error.code === THREAD_ACCESS_DENIED_ERROR_CODE;
+}
+/**
+* Owner of a Thread created, or reached, by a runner call that names no owner:
+* a run, connect, stop or isRunning without `ownerId`, or a Thread endpoint call
+* without a scope. Such calls come only from trusted server-side code (for
+* example a Channel listener), and they act as this one server identity.
+*
+* No HTTP caller can act as it: request identities are `""` (anonymous) or an
+* id that `identifyUser` returned, and a valid id cannot hold a NUL character.
+* So an omitted owner never means "every Thread", and a Thread created
+* server-side is never reachable by an anonymous caller.
+*/
+const ɵSERVER_THREAD_OWNER = "\0server";
+/** The owner a runner call acts as: `ownerId`, or the server owner when omitted. */
+function ɵresolveThreadOwner(ownerId) {
+	return ownerId ?? ɵSERVER_THREAD_OWNER;
+}
+function supportsLocalThreadEndpoints(runner) {
+	return runner.ɵsupportsLocalThreadEndpoints === true;
+}
+/**
+* True when `runner` enforces Thread owners. Checks the method itself, so a
+* runner built against an older interface (one that sets the endpoint flag
+* but has no `isThreadAccessible`) is not taken to enforce them.
+*/
+function enforcesThreadOwnership(runner) {
+	return typeof runner.isThreadAccessible === "function";
+}
+var AgentRunner = class {};
+
+//#endregion
+export { AgentRunner, THREAD_ACCESS_DENIED_ERROR_CODE, ThreadAccessDeniedError, ThreadAlreadyRunningError, enforcesThreadOwnership, isThreadAccessDeniedError, supportsLocalThreadEndpoints, ɵSERVER_THREAD_OWNER, ɵresolveThreadOwner };
+//# sourceMappingURL=agent-runner.mjs.map

package/dist/runtime/runner/agent-runner.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-runner.mjs","names":[],"sources":["../../../src/runtime/runner/agent-runner.ts"],"sourcesContent":["import type {\n  AbstractAgent,\n  BaseEvent,\n  Message,\n  RunAgentInput,\n} from \"@ag-ui/client\";\nimport type { Observable } from \"rxjs\";\nimport { THREAD_ALREADY_RUNNING_ERROR_CODE } from \"@copilotkit/shared\";\n\n/**\n * Thrown by a runner when the thread already has a run in flight. The SSE\n * handler sends it to the client as a `RUN_ERROR` with\n * {@link THREAD_ALREADY_RUNNING_ERROR_CODE}, matched on `code` so a copy of\n * this class from another package version still counts.\n */\nexport class ThreadAlreadyRunningError extends Error {\n  readonly code = THREAD_ALREADY_RUNNING_ERROR_CODE;\n\n  constructor() {\n    super(\"Thread already running\");\n    this.name = \"ThreadAlreadyRunningError\";\n  }\n}\n\n/** `code` of {@link ThreadAccessDeniedError}, also sent on the SSE `RUN_ERROR`. */\nexport const THREAD_ACCESS_DENIED_ERROR_CODE = \"THREAD_ACCESS_DENIED\";\n\n/**\n * Thrown by a runner when a run targets a Thread that another identity owns.\n *\n * Defense in depth: the run handler checks `isThreadAccessible` first and\n * refuses with an HTTP error, so the runner throws this only when another\n * identity claims the Thread between that check and the run, or for direct\n * runner callers. A synchronous throw from `run()` is still mapped to the\n * HTTP error; a later one reaches the client as a `RUN_ERROR` with\n * {@link THREAD_ACCESS_DENIED_ERROR_CODE}. Neither is reported as an agent\n * failure. Matched on `code`, so a copy of this class from another package\n * version still counts.\n */\nexport class ThreadAccessDeniedError extends Error {\n  readonly code = THREAD_ACCESS_DENIED_ERROR_CODE;\n\n  constructor() {\n    super(\"Thread access denied\");\n    this.name = \"ThreadAccessDeniedError\";\n  }\n}\n\n/** True for a {@link ThreadAccessDeniedError}, from any package version. */\nexport function isThreadAccessDeniedError(error: unknown): boolean {\n  return (\n    error instanceof Error &&\n    (error as { code?: unknown }).code === THREAD_ACCESS_DENIED_ERROR_CODE\n  );\n}\n\n/**\n * Owner of a Thread created, or reached, by a runner call that names no owner:\n * a run, connect, stop or isRunning without `ownerId`, or a Thread endpoint call\n * without a scope. Such calls come only from trusted server-side code (for\n * example a Channel listener), and they act as this one server identity.\n *\n * No HTTP caller can act as it: request identities are `\"\"` (anonymous) or an\n * id that `identifyUser` returned, and a valid id cannot hold a NUL character.\n * So an omitted owner never means \"every Thread\", and a Thread created\n * server-side is never reachable by an anonymous caller.\n */\nexport const ɵSERVER_THREAD_OWNER = \"\\u0000server\";\n\n/** The owner a runner call acts as: `ownerId`, or the server owner when omitted. */\nexport function ɵresolveThreadOwner(ownerId: string | undefined): string {\n  return ownerId ?? ɵSERVER_THREAD_OWNER;\n}\n\nexport interface AgentRunnerRunRequest {\n  threadId: string;\n  /** Backend execution ID supplied by Intelligence for imported non-UUID sessions. */\n  backendThreadId?: string;\n  agent: AbstractAgent;\n  input: RunAgentInput;\n  persistedInputMessages?: Message[];\n  /** Short-lived token scoped to this runner invocation. */\n  authToken?: string;\n  /**\n   * Identity the run acts as. A runner that tracks owners records it on the\n   * Thread's first run and refuses a run from any other identity. `\"\"` is the\n   * anonymous owner. When omitted, the run acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface AgentRunnerConnectRequest {\n  threadId: string;\n  agentId?: string;\n  headers?: Record<string, string>;\n  joinCode?: string;\n  /**\n   * Caller identity. A Thread owned by another identity is treated as unknown.\n   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface AgentRunnerIsRunningRequest {\n  threadId: string;\n  /**\n   * Caller identity. A Thread owned by another identity reports \"not running\".\n   * When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface AgentRunnerStopRequest {\n  threadId: string;\n  /** When present, stop only this exact run and never a newer run on the Thread. */\n  runId?: string;\n  /**\n   * Caller identity. A run on a Thread owned by another identity is not\n   * stopped. When omitted, the call acts as {@link ɵSERVER_THREAD_OWNER}.\n   */\n  ownerId?: string;\n}\n\nexport interface LocalThreadEndpointRecord {\n  id: string;\n  name: string | null;\n  agentId: string;\n  organizationId: string;\n  createdById: string;\n  archived: boolean;\n  createdAt: string;\n  updatedAt: string;\n}\n\n/**\n * Limits a local Thread endpoint call to the Threads of one owner. `\"\"` is the\n * anonymous owner. A call without a scope acts as\n * {@link ɵSERVER_THREAD_OWNER}: it sees only Threads created server-side, never\n * every Thread.\n */\nexport interface LocalThreadEndpointScope {\n  ownerId: string;\n}\n\nexport interface LocalThreadEndpointRunner extends AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints: true;\n  listThreads(scope?: LocalThreadEndpointScope): LocalThreadEndpointRecord[];\n  getThreadMessages(\n    threadId: string,\n    scope?: LocalThreadEndpointScope,\n  ): Message[];\n  getThreadEvents(\n    threadId: string,\n    scope?: LocalThreadEndpointScope,\n  ): BaseEvent[];\n  getThreadState(\n    threadId: string,\n    scope?: LocalThreadEndpointScope,\n  ): Record<string, unknown> | null;\n  clearThreads(scope?: LocalThreadEndpointScope): void;\n  /** See {@link ThreadOwnershipRunner.isThreadAccessible}. */\n  isThreadAccessible(\n    threadId: string,\n    scope: LocalThreadEndpointScope,\n  ): boolean;\n}\n\nexport function supportsLocalThreadEndpoints(\n  runner: AgentRunner,\n): runner is LocalThreadEndpointRunner {\n  return runner.ɵsupportsLocalThreadEndpoints === true;\n}\n\n/**\n * A runner that records each Thread's owner and enforces it. Implementing\n * `isThreadAccessible` is the promise that `run`, `connect`, `stop` and\n * `isRunning` honor `ownerId` the same way: a call never reaches a Thread that\n * another owner holds.\n */\nexport interface ThreadOwnershipRunner extends AgentRunner {\n  /** False when the Thread id is held by an owner other than `scope`'s. */\n  isThreadAccessible(\n    threadId: string,\n    scope: LocalThreadEndpointScope,\n  ): boolean | Promise<boolean>;\n}\n\n/**\n * True when `runner` enforces Thread owners. Checks the method itself, so a\n * runner built against an older interface (one that sets the endpoint flag\n * but has no `isThreadAccessible`) is not taken to enforce them.\n */\nexport function enforcesThreadOwnership(\n  runner: AgentRunner,\n): runner is ThreadOwnershipRunner {\n  return typeof runner.isThreadAccessible === \"function\";\n}\n\nexport abstract class AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints?: boolean;\n\n  /** See {@link ThreadOwnershipRunner}. Optional: not every runner tracks owners. */\n  isThreadAccessible?(\n    threadId: string,\n    scope: LocalThreadEndpointScope,\n  ): boolean | Promise<boolean>;\n\n  abstract run(request: AgentRunnerRunRequest): Observable<BaseEvent>;\n  abstract connect(request: AgentRunnerConnectRequest): Observable<BaseEvent>;\n  abstract isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;\n  abstract stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;\n}\n"],"mappings":";;;;;;;;;AAeA,IAAa,4BAAb,cAA+C,MAAM;CAGnD,cAAc;AACZ,QAAM,yBAAyB;cAHjB;AAId,OAAK,OAAO;;;;AAKhB,MAAa,kCAAkC;;;;;;;;;;;;;AAc/C,IAAa,0BAAb,cAA6C,MAAM;CAGjD,cAAc;AACZ,QAAM,uBAAuB;cAHf;AAId,OAAK,OAAO;;;;AAKhB,SAAgB,0BAA0B,OAAyB;AACjE,QACE,iBAAiB,SAChB,MAA6B,SAAS;;;;;;;;;;;;;AAe3C,MAAa,uBAAuB;;AAGpC,SAAgB,oBAAoB,SAAqC;AACvE,QAAO,WAAW;;AAgGpB,SAAgB,6BACd,QACqC;AACrC,QAAO,OAAO,kCAAkC;;;;;;;AAsBlD,SAAgB,wBACd,QACiC;AACjC,QAAO,OAAO,OAAO,uBAAuB;;AAG9C,IAAsB,cAAtB,MAAkC"}