@copilotkit/runtime 1.81.0 → 1.83.0

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

@@ -16,13 +16,68 @@ var ThreadAlreadyRunningError = class extends Error {
 		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/v2/runtime/runner/agent-runner.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"agent-runner.cjs","names":["THREAD_ALREADY_RUNNING_ERROR_CODE"],"sources":["../../../../src/v2/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\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\nexport interface AgentRunnerConnectRequest {\n  threadId: string;\n  agentId?: string;\n  headers?: Record<string, string>;\n  joinCode?: string;\n}\n\nexport interface AgentRunnerIsRunningRequest {\n  threadId: 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\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\nexport interface LocalThreadEndpointRunner extends AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints: true;\n  listThreads(): LocalThreadEndpointRecord[];\n  getThreadMessages(threadId: string): Message[];\n  getThreadEvents(threadId: string): BaseEvent[];\n  getThreadState(threadId: string): Record<string, unknown> | null;\n  clearThreads(): void;\n}\n\nexport function supportsLocalThreadEndpoints(\n  runner: AgentRunner,\n): runner is LocalThreadEndpointRunner {\n  return runner.ɵsupportsLocalThreadEndpoints === true;\n}\n\nexport abstract class AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints?: 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;;;AAoDhB,SAAgB,6BACd,QACqC;AACrC,QAAO,OAAO,kCAAkC;;AAGlD,IAAsB,cAAtB,MAAkC"}
+{"version":3,"file":"agent-runner.cjs","names":["THREAD_ALREADY_RUNNING_ERROR_CODE"],"sources":["../../../../src/v2/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/v2/runtime/runner/agent-runner.d.cts

@@ -13,6 +13,40 @@ 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. */
@@ -22,20 +56,41 @@ interface AgentRunnerRunRequest {
   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;
@@ -47,22 +102,51 @@ interface LocalThreadEndpointRecord {
   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(): LocalThreadEndpointRecord[];
-  getThreadMessages(threadId: string): Message[];
-  getThreadEvents(threadId: string): BaseEvent[];
-  getThreadState(threadId: string): Record<string, unknown> | null;
-  clearThreads(): void;
+  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, ThreadAlreadyRunningError, supportsLocalThreadEndpoints };
+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/v2/runtime/runner/agent-runner.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-runner.d.cts","names":[],"sources":["../../../../src/v2/runtime/runner/agent-runner.ts"],"mappings":";;;;;;;AAeA;;;;cAAa,yBAAA,SAAkC,KAAA;EAAA,SACpC,IAAA;;;UAQM,qBAAA;EACf,QAAA;EADoC;EAGpC,eAAA;EACA,KAAA,EAAO,aAAA;EACP,KAAA,EAAO,aAAA;EACP,sBAAA,GAAyB,OAAA;EAAO;EAEhC,SAAA;AAAA;AAAA,UAGe,yBAAA;EACf,QAAA;EACA,OAAA;EACA,OAAA,GAAU,MAAA;EACV,QAAA;AAAA;AAAA,UAGe,2BAAA;EACf,QAAA;AAAA;AAAA,UAGe,sBAAA;EACf,QAAA;EAZwC;EAcxC,KAAA;AAAA;AAAA,UAGe,yBAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,UAGe,yBAAA,SAAkC,WAAA;EAAA,SACxC,6BAAA;EACT,WAAA,IAAe,yBAAA;EACf,iBAAA,CAAkB,QAAA,WAAmB,OAAA;EACrC,eAAA,CAAgB,QAAA,WAAmB,SAAA;EACnC,cAAA,CAAe,QAAA,WAAmB,MAAA;EAClC,YAAA;AAAA;AAAA,iBAGc,4BAAA,CACd,MAAA,EAAQ,WAAA,GACP,MAAA,IAAU,yBAAA;AAAA,uBAIS,WAAA;EAAA,SACX,6BAAA;EAAA,SAEA,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"}
+{"version":3,"file":"agent-runner.d.cts","names":[],"sources":["../../../../src/v2/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/v2/runtime/runner/agent-runner.d.mts

@@ -13,6 +13,40 @@ 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. */
@@ -22,20 +56,41 @@ interface AgentRunnerRunRequest {
   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;
@@ -47,22 +102,51 @@ interface LocalThreadEndpointRecord {
   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(): LocalThreadEndpointRecord[];
-  getThreadMessages(threadId: string): Message[];
-  getThreadEvents(threadId: string): BaseEvent[];
-  getThreadState(threadId: string): Record<string, unknown> | null;
-  clearThreads(): void;
+  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, ThreadAlreadyRunningError, supportsLocalThreadEndpoints };
+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/v2/runtime/runner/agent-runner.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"agent-runner.d.mts","names":[],"sources":["../../../../src/v2/runtime/runner/agent-runner.ts"],"mappings":";;;;;;;AAeA;;;;cAAa,yBAAA,SAAkC,KAAA;EAAA,SACpC,IAAA;;;UAQM,qBAAA;EACf,QAAA;EADoC;EAGpC,eAAA;EACA,KAAA,EAAO,aAAA;EACP,KAAA,EAAO,aAAA;EACP,sBAAA,GAAyB,OAAA;EAAO;EAEhC,SAAA;AAAA;AAAA,UAGe,yBAAA;EACf,QAAA;EACA,OAAA;EACA,OAAA,GAAU,MAAA;EACV,QAAA;AAAA;AAAA,UAGe,2BAAA;EACf,QAAA;AAAA;AAAA,UAGe,sBAAA;EACf,QAAA;EAZwC;EAcxC,KAAA;AAAA;AAAA,UAGe,yBAAA;EACf,EAAA;EACA,IAAA;EACA,OAAA;EACA,cAAA;EACA,WAAA;EACA,QAAA;EACA,SAAA;EACA,SAAA;AAAA;AAAA,UAGe,yBAAA,SAAkC,WAAA;EAAA,SACxC,6BAAA;EACT,WAAA,IAAe,yBAAA;EACf,iBAAA,CAAkB,QAAA,WAAmB,OAAA;EACrC,eAAA,CAAgB,QAAA,WAAmB,SAAA;EACnC,cAAA,CAAe,QAAA,WAAmB,MAAA;EAClC,YAAA;AAAA;AAAA,iBAGc,4BAAA,CACd,MAAA,EAAQ,WAAA,GACP,MAAA,IAAU,yBAAA;AAAA,uBAIS,WAAA;EAAA,SACX,6BAAA;EAAA,SAEA,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"}
+{"version":3,"file":"agent-runner.d.mts","names":[],"sources":["../../../../src/v2/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/v2/runtime/runner/agent-runner.mjs

@@ -15,11 +15,60 @@ var ThreadAlreadyRunningError = class extends Error {
 		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, ThreadAlreadyRunningError, supportsLocalThreadEndpoints };
+export { AgentRunner, THREAD_ACCESS_DENIED_ERROR_CODE, ThreadAccessDeniedError, ThreadAlreadyRunningError, enforcesThreadOwnership, isThreadAccessDeniedError, supportsLocalThreadEndpoints, ɵSERVER_THREAD_OWNER, ɵresolveThreadOwner };
 //# sourceMappingURL=agent-runner.mjs.map

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

@@ -1 +1 @@
-{"version":3,"file":"agent-runner.mjs","names":[],"sources":["../../../../src/v2/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\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\nexport interface AgentRunnerConnectRequest {\n  threadId: string;\n  agentId?: string;\n  headers?: Record<string, string>;\n  joinCode?: string;\n}\n\nexport interface AgentRunnerIsRunningRequest {\n  threadId: 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\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\nexport interface LocalThreadEndpointRunner extends AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints: true;\n  listThreads(): LocalThreadEndpointRecord[];\n  getThreadMessages(threadId: string): Message[];\n  getThreadEvents(threadId: string): BaseEvent[];\n  getThreadState(threadId: string): Record<string, unknown> | null;\n  clearThreads(): void;\n}\n\nexport function supportsLocalThreadEndpoints(\n  runner: AgentRunner,\n): runner is LocalThreadEndpointRunner {\n  return runner.ɵsupportsLocalThreadEndpoints === true;\n}\n\nexport abstract class AgentRunner {\n  readonly ɵsupportsLocalThreadEndpoints?: 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;;;AAoDhB,SAAgB,6BACd,QACqC;AACrC,QAAO,OAAO,kCAAkC;;AAGlD,IAAsB,cAAtB,MAAkC"}
+{"version":3,"file":"agent-runner.mjs","names":[],"sources":["../../../../src/v2/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"}