@copilotkit/runtime 1.81.0 → 1.83.0

package/dist/v2/runtime/runner/in-memory.d.mts

@@ -1,5 +1,5 @@
 
-import { AgentRunner, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerRunRequest, AgentRunnerStopRequest } from "./agent-runner.mjs";
+import { AgentRunner, AgentRunnerConnectRequest, AgentRunnerIsRunningRequest, AgentRunnerRunRequest, AgentRunnerStopRequest, LocalThreadEndpointScope } from "./agent-runner.mjs";
 import { Observable, ReplaySubject } from "rxjs";
 import { AbstractAgent, BaseEvent, Message } from "@ag-ui/client";
 
@@ -114,14 +114,21 @@ interface InMemoryThread {
   name: string | null;
   agentId: string;
   organizationId: "";
-  createdById: "";
+  /** Identity that owns the thread; `""` for a thread created without identity. */
+  createdById: string;
   archived: false;
   createdAt: string;
   updatedAt: string;
 }
 declare class InMemoryEventStore {
   threadId: string;
-  constructor(threadId: string);
+  readonly ownerId: string;
+  /**
+   * @param ownerId Identity that owns this thread, recorded when the thread is
+   * created by its first run. `""` is the anonymous owner;
+   * {@link ɵSERVER_THREAD_OWNER} is the owner of a thread created server-side.
+   */
+  constructor(threadId: string, ownerId: string);
   /** The subject that current consumers subscribe to. */
   subject: ReplaySubject<BaseEvent> | null;
   /** True while a run is actively producing events. */
@@ -172,8 +179,44 @@ declare class InMemoryEventStore {
    */
   createdAt: number | null;
 }
+/**
+ * How long, and how many, owner records the store keeps for threads that left
+ * it through LRU eviction or a scoped clear. See
+ * {@link ɵBoundedThreadStore.ownerOf}.
+ *
+ * When a record is added over a limit, expired records go first; then, when
+ * the record's owner holds more than `maxEntriesPerOwner`, that owner's
+ * oldest record; then, over `maxEntries`, the oldest record of any owner. So
+ * one identity that churns threads (anonymous callers share one identity)
+ * only displaces its own records. Residual risk: many distinct identities
+ * together can still exceed `maxEntries` and push out another identity's
+ * live record. That frees the id for a new owner but leaks nothing, since
+ * the removed thread's history is already gone, and it needs the victim's
+ * thread id.
+ */
+interface ɵOwnerRetention {
+  /** Milliseconds an owner record is kept after its thread was removed. */
+  ttlMs: number;
+  /** Most owner records kept in all. */
+  maxEntries: number;
+  /** Most owner records kept for one owner. */
+  maxEntriesPerOwner: number;
+  /** Clock, replaceable in tests. */
+  now: () => number;
+}
+declare const ɵOWNER_RETENTION_DEFAULTS: ɵOwnerRetention;
 declare class ɵBoundedThreadStore {
   private readonly map;
+  /**
+   * Owners of threads that were removed from `map`, oldest first. A removed
+   * thread's history is gone, but its id stays reserved for its owner until
+   * the record expires, so another identity cannot claim the id and receive
+   * the owner's next runs or later replays.
+   */
+  private readonly removedOwners;
+  /** The ids in `removedOwners`, per owner, oldest first. */
+  private readonly removedOwnersByOwner;
+  private ownerRetention;
   private totalBytes;
   private warned;
   /** True once limits have been EXPLICITLY set (via setLimits), not just the constructor default. */
@@ -206,7 +249,11 @@ declare class ɵBoundedThreadStore {
   get size(): number;
   /** Re-insert at the tail so Map iteration order stays LRU-first. */
   private touchOrder;
-  getOrCreate(threadId: string): InMemoryEventStore;
+  /**
+   * The thread's store, created and owned by `ownerId` when it does not exist
+   * yet. An existing store keeps its owner; callers check access first.
+   */
+  getOrCreate(threadId: string, ownerId?: string): InMemoryEventStore;
   get(threadId: string, opts: {
     touch: boolean;
   }): InMemoryEventStore | undefined;
@@ -227,7 +274,13 @@ declare class ɵBoundedThreadStore {
    * finalization completes.
    */
   private evictOneLru;
-  appendRun(threadId: string, run: HistoricRun): void;
+  /**
+   * Append a finished run to `writer`, the store its run started on. Nothing is
+   * written when `writer` is no longer the live store for `threadId` (the thread
+   * was removed, or removed and claimed again): a run must never write into a
+   * thread it did not start on, which may now belong to another owner.
+   */
+  appendRun(threadId: string, writer: InMemoryEventStore | undefined, run: HistoricRun): void;
   private enforceRunCap;
   /**
    * Trim the store back under the byte ceiling by evicting LRU non-running
@@ -236,10 +289,43 @@ declare class ɵBoundedThreadStore {
    */
   private evictByBytesIfNeeded;
   private removeThread;
+  /**
+   * Keep the owner of a removed thread, within the retention bounds. See
+   * {@link ɵOwnerRetention} for which records go first over a limit.
+   */
+  private rememberOwner;
+  /** Remove the owner record of `threadId`, if any. */
+  private forgetOwner;
+  /** Drop expired owner records. They are oldest first, so stop at the first live one. */
+  private pruneRemovedOwners;
+  /**
+   * Owner of `threadId`: the live thread's owner, or the retained owner of a
+   * thread that was evicted or cleared. `undefined` when nobody owns the id, so
+   * the next run may claim it.
+   */
+  ownerOf(threadId: string): string | undefined;
+  /** True when a caller acting as `owner` may run on, or claim, `threadId`. */
+  canClaim(threadId: string, owner: string): boolean;
+  /**
+   * Replace the owner-record retention. Omitted fields fall back to
+   * {@link ɵOWNER_RETENTION_DEFAULTS}. Internal: for tests.
+   */
+  ɵsetOwnerRetention(retention: Partial<ɵOwnerRetention>): void;
   private evictThreadsIfNeeded;
   private noteEviction;
-  listThreads(): InMemoryThread[];
-  clear(): void;
+  listThreads(scope?: LocalThreadEndpointScope): InMemoryThread[];
+  /**
+   * Removes every thread visible to `scope`, except threads that are running
+   * or still finalizing: removing one would drop its owner record while its
+   * run still writes, so another identity could claim the id. Those threads
+   * stay, as in `evictOneLru`. A scoped clear leaves other owners' threads
+   * untouched.
+   *
+   * Without a scope the whole store is reset, running threads included. That
+   * is an internal reset for tests; `appendRun` keeps an orphaned run from
+   * writing into a thread created after the reset.
+   */
+  clear(scope?: LocalThreadEndpointScope): void;
 }
 /**
  * Process-wide singleton backing every {@link InMemoryAgentRunner}. Exported
@@ -278,13 +364,15 @@ declare class InMemoryAgentRunner extends AgentRunner {
   isRunning(request: AgentRunnerIsRunningRequest): Promise<boolean>;
   stop(request: AgentRunnerStopRequest): Promise<boolean | undefined>;
   /**
-   * Returns a summary of every thread that has been run through this runner.
+   * Returns a summary of every thread that `scope`'s owner holds in the
+   * process-wide store, which every InMemoryAgentRunner shares. Without a
+   * scope, the server owner's threads ({@link ɵSERVER_THREAD_OWNER}).
    *
    * This powers the local-dev fallback for `GET /threads` when the Intelligence
    * platform is not configured. Each entry mirrors the shape of a platform
    * `ThreadRecord` so the HTTP handler can use the same response envelope.
    */
-  listThreads(): InMemoryThread[];
+  listThreads(scope?: LocalThreadEndpointScope): InMemoryThread[];
   /**
    * Returns all messages for a thread, using the snapshot captured at the end
    * of the most recent run.
@@ -294,7 +382,7 @@ declare class InMemoryAgentRunner extends AgentRunner {
    * objects come directly from the ag-ui agent, so their shape is compatible
    * with CopilotKit Intelligence's `ThreadMessage` type.
    */
-  getThreadMessages(threadId: string): Message[];
+  getThreadMessages(threadId: string, scope?: LocalThreadEndpointScope): Message[];
   /**
    * Returns all AG-UI events for a thread, compacted across historic runs.
    *
@@ -303,7 +391,7 @@ declare class InMemoryAgentRunner extends AgentRunner {
    * the connection-replay path in {@link connect}, so the stream a
    * late-joining inspector sees matches what this method returns.
    */
-  getThreadEvents(threadId: string): BaseEvent[];
+  getThreadEvents(threadId: string, scope?: LocalThreadEndpointScope): BaseEvent[];
   /**
    * Returns the agent state snapshot for a thread.
    *
@@ -314,9 +402,11 @@ declare class InMemoryAgentRunner extends AgentRunner {
    *
    * Returns `null` when the thread has never emitted a STATE_SNAPSHOT.
    */
-  getThreadState(threadId: string): Record<string, unknown> | null;
+  getThreadState(threadId: string, scope?: LocalThreadEndpointScope): Record<string, unknown> | null;
   /**
-   * Clears all in-memory thread history.
+   * Clears the in-memory history of `scope`'s threads (without a scope, the
+   * server owner's). A thread with a run still active or finalizing is kept;
+   * see {@link ɵBoundedThreadStore.clear}.
    *
    * Powers the local-dev fallback for `POST /threads/clear`, letting consumers
    * (e.g. the demo's Clear button) reset to an empty thread list without
@@ -324,8 +414,15 @@ declare class InMemoryAgentRunner extends AgentRunner {
    * platform path: there, thread history lives in a real database and must
    * not be wiped this way.
    */
-  clearThreads(): void;
+  clearThreads(scope?: LocalThreadEndpointScope): void;
+  /**
+   * False when the thread id is held by an owner other than `scope`'s: a
+   * live thread, or the retained owner of an evicted or cleared one.
+   */
+  isThreadAccessible(threadId: string, scope: LocalThreadEndpointScope): boolean;
+  /** The thread's store, or `undefined` when unknown or not visible to `scope`. */
+  private peekVisible;
 }
 //#endregion
-export { InMemoryAgentRunner, InMemoryAgentRunnerOptions, InMemoryLimits, InMemoryThread, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵestimateBytes, ɵnormalizeLimits };
+export { InMemoryAgentRunner, InMemoryAgentRunnerOptions, InMemoryLimits, InMemoryThread, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵOWNER_RETENTION_DEFAULTS, ɵOwnerRetention, ɵestimateBytes, ɵnormalizeLimits };
 //# sourceMappingURL=in-memory.d.mts.map

package/dist/v2/runtime/runner/in-memory.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"in-memory.d.mts","names":[],"sources":["../../../../src/v2/runtime/runner/in-memory.ts"],"mappings":"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"}
+{"version":3,"file":"in-memory.d.mts","names":[],"sources":["../../../../src/v2/runtime/runner/in-memory.ts"],"mappings":"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"}

package/dist/v2/runtime/runner/in-memory.mjs

@@ -1,5 +1,5 @@
 import "reflect-metadata";
-import { AgentRunner, ThreadAlreadyRunningError } from "./agent-runner.mjs";
+import { AgentRunner, ThreadAccessDeniedError, ThreadAlreadyRunningError, ɵSERVER_THREAD_OWNER, ɵresolveThreadOwner } from "./agent-runner.mjs";
 import { finalizeRunEvents } from "@copilotkit/shared";
 import { ReplaySubject } from "rxjs";
 import { EventType, compactEvents } from "@ag-ui/client";
@@ -71,8 +71,14 @@ function ɵestimateBytes(value) {
 	}
 }
 var InMemoryEventStore = class {
-	constructor(threadId) {
+	/**
+	* @param ownerId Identity that owns this thread, recorded when the thread is
+	* created by its first run. `""` is the anonymous owner;
+	* {@link ɵSERVER_THREAD_OWNER} is the owner of a thread created server-side.
+	*/
+	constructor(threadId, ownerId) {
 		this.threadId = threadId;
+		this.ownerId = ownerId;
 		this.subject = null;
 		this.isRunning = false;
 		this.currentRunId = null;
@@ -87,9 +93,31 @@ var InMemoryEventStore = class {
 		this.createdAt = null;
 	}
 };
+/**
+* True when a caller acting as `owner` may reach `store`: only the thread's
+* own owner may. Resolve an optional owner or scope with
+* {@link ɵresolveThreadOwner} first; an omitted one is the server owner, never
+* "every thread".
+*/
+function isVisibleTo(store, owner) {
+	return store.ownerId === owner;
+}
+/** The owner a Thread endpoint call acts as. */
+function scopeOwner(scope) {
+	return ɵresolveThreadOwner(scope?.ownerId);
+}
+const ɵOWNER_RETENTION_DEFAULTS = {
+	ttlMs: 1440 * 60 * 1e3,
+	maxEntries: 1e5,
+	maxEntriesPerOwner: 1e4,
+	now: () => Date.now()
+};
 var ɵBoundedThreadStore = class {
 	constructor(limits) {
 		this.map = /* @__PURE__ */ new Map();
+		this.removedOwners = /* @__PURE__ */ new Map();
+		this.removedOwnersByOwner = /* @__PURE__ */ new Map();
+		this.ownerRetention = ɵOWNER_RETENTION_DEFAULTS;
 		this.totalBytes = 0;
 		this.warned = false;
 		this.limitsExplicitlySet = false;
@@ -139,13 +167,18 @@ var ɵBoundedThreadStore = class {
 		this.map.delete(threadId);
 		this.map.set(threadId, store);
 	}
-	getOrCreate(threadId) {
+	/**
+	* The thread's store, created and owned by `ownerId` when it does not exist
+	* yet. An existing store keeps its owner; callers check access first.
+	*/
+	getOrCreate(threadId, ownerId = ɵSERVER_THREAD_OWNER) {
 		const existing = this.map.get(threadId);
 		if (existing) {
 			this.touchOrder(threadId, existing);
 			return existing;
 		}
-		const store = new InMemoryEventStore(threadId);
+		const store = new InMemoryEventStore(threadId, ownerId);
+		this.forgetOwner(threadId);
 		this.map.set(threadId, store);
 		this.evictThreadsIfNeeded(threadId);
 		return store;
@@ -183,9 +216,15 @@ var ɵBoundedThreadStore = class {
 		}
 		return false;
 	}
-	appendRun(threadId, run) {
+	/**
+	* Append a finished run to `writer`, the store its run started on. Nothing is
+	* written when `writer` is no longer the live store for `threadId` (the thread
+	* was removed, or removed and claimed again): a run must never write into a
+	* thread it did not start on, which may now belong to another owner.
+	*/
+	appendRun(threadId, writer, run) {
 		const store = this.map.get(threadId);
-		if (!store) return;
+		if (!store || store !== writer) return;
 		if (store.createdAt === null) store.createdAt = run.createdAt;
 		if (run.messages.length > 0) {
 			this.totalBytes -= store.approxMessagesSnapshotBytes;
@@ -223,6 +262,87 @@ var ɵBoundedThreadStore = class {
 		for (const run of store.historicRuns) this.totalBytes -= run.approxEventBytes ?? 0;
 		this.totalBytes -= store.approxMessagesSnapshotBytes;
 		this.map.delete(threadId);
+		this.rememberOwner(threadId, store.ownerId);
+	}
+	/**
+	* Keep the owner of a removed thread, within the retention bounds. See
+	* {@link ɵOwnerRetention} for which records go first over a limit.
+	*/
+	rememberOwner(threadId, ownerId) {
+		const { maxEntries, maxEntriesPerOwner, now } = this.ownerRetention;
+		this.forgetOwner(threadId);
+		this.removedOwners.set(threadId, {
+			ownerId,
+			removedAt: now()
+		});
+		let owned = this.removedOwnersByOwner.get(ownerId);
+		if (!owned) {
+			owned = /* @__PURE__ */ new Set();
+			this.removedOwnersByOwner.set(ownerId, owned);
+		}
+		owned.add(threadId);
+		this.pruneRemovedOwners();
+		while (owned.size > maxEntriesPerOwner) {
+			const oldest = owned.values().next().value;
+			if (oldest === void 0) break;
+			this.forgetOwner(oldest);
+		}
+		while (this.removedOwners.size > maxEntries) {
+			const oldest = this.removedOwners.keys().next().value;
+			if (oldest === void 0) break;
+			this.forgetOwner(oldest);
+		}
+	}
+	/** Remove the owner record of `threadId`, if any. */
+	forgetOwner(threadId) {
+		const record = this.removedOwners.get(threadId);
+		if (!record) return;
+		this.removedOwners.delete(threadId);
+		const owned = this.removedOwnersByOwner.get(record.ownerId);
+		owned?.delete(threadId);
+		if (owned?.size === 0) this.removedOwnersByOwner.delete(record.ownerId);
+	}
+	/** Drop expired owner records. They are oldest first, so stop at the first live one. */
+	pruneRemovedOwners() {
+		const { ttlMs, now } = this.ownerRetention;
+		const cutoff = now() - ttlMs;
+		for (const [threadId, record] of this.removedOwners) {
+			if (record.removedAt >= cutoff) break;
+			this.forgetOwner(threadId);
+		}
+	}
+	/**
+	* Owner of `threadId`: the live thread's owner, or the retained owner of a
+	* thread that was evicted or cleared. `undefined` when nobody owns the id, so
+	* the next run may claim it.
+	*/
+	ownerOf(threadId) {
+		const store = this.map.get(threadId);
+		if (store) return store.ownerId;
+		this.pruneRemovedOwners();
+		const record = this.removedOwners.get(threadId);
+		if (!record) return void 0;
+		const { ttlMs, now } = this.ownerRetention;
+		if (record.removedAt < now() - ttlMs) {
+			this.forgetOwner(threadId);
+			return;
+		}
+		return record.ownerId;
+	}
+	/** True when a caller acting as `owner` may run on, or claim, `threadId`. */
+	canClaim(threadId, owner) {
+		const current = this.ownerOf(threadId);
+		return current === void 0 || current === owner;
+	}
+	/**
+	* Replace the owner-record retention. Omitted fields fall back to
+	* {@link ɵOWNER_RETENTION_DEFAULTS}. Internal: for tests.
+	*/
+	ɵsetOwnerRetention(retention) {
+		this.ownerRetention = {
+			...ɵOWNER_RETENTION_DEFAULTS,
+			...retention
+		};
 	}
 	evictThreadsIfNeeded(protect) {
 		while (this.map.size > this.limits.maxThreads) if (!this.evictOneLru(protect)) break;
@@ -234,17 +354,18 @@ var ɵBoundedThreadStore = class {
 			console.warn(EVICTION_GUIDANCE);
 		} catch {}
 	}
-	listThreads() {
+	listThreads(scope) {
 		const threads = [];
 		for (const [threadId, store] of this.map) {
 			if (store.historicRuns.length === 0) continue;
+			if (!isVisibleTo(store, scopeOwner(scope))) continue;
 			const lastRun = store.historicRuns[store.historicRuns.length - 1];
 			threads.push({
 				id: threadId,
 				name: null,
 				agentId: lastRun.agentId,
 				organizationId: "",
-				createdById: "",
+				createdById: store.ownerId,
 				archived: false,
 				createdAt: new Date(store.createdAt ?? lastRun.createdAt).toISOString(),
 				updatedAt: new Date(lastRun.createdAt).toISOString()
@@ -252,8 +373,28 @@ var ɵBoundedThreadStore = class {
 		}
 		return threads.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
 	}
-	clear() {
+	/**
+	* Removes every thread visible to `scope`, except threads that are running
+	* or still finalizing: removing one would drop its owner record while its
+	* run still writes, so another identity could claim the id. Those threads
+	* stay, as in `evictOneLru`. A scoped clear leaves other owners' threads
+	* untouched.
+	*
+	* Without a scope the whole store is reset, running threads included. That
+	* is an internal reset for tests; `appendRun` keeps an orphaned run from
+	* writing into a thread created after the reset.
+	*/
+	clear(scope) {
+		if (scope !== void 0) {
+			for (const [threadId, store] of this.map) {
+				if (store.isRunning || store.stopRequested) continue;
+				if (isVisibleTo(store, scopeOwner(scope))) this.removeThread(threadId, store);
+			}
+			return;
+		}
 		this.map.clear();
+		this.removedOwners.clear();
+		this.removedOwnersByOwner.clear();
 		this.totalBytes = 0;
 		this.warned = false;
 	}
@@ -295,7 +436,9 @@ var InMemoryAgentRunner = class extends AgentRunner {
 		}
 	}
 	run(request) {
-		const store = sharedStore.getOrCreate(request.threadId);
+		const owner = ɵresolveThreadOwner(request.ownerId);
+		if (!sharedStore.canClaim(request.threadId, owner)) throw new ThreadAccessDeniedError();
+		const store = sharedStore.getOrCreate(request.threadId, owner);
 		if (store.isRunning || store.stopRequested) {
 			if (this.onConcurrentRun !== "supersede") throw new ThreadAlreadyRunningError();
 			const priorAgent = store.agent;
@@ -360,7 +503,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
 				const ownsThread = store.currentRunId === request.input.runId;
 				if (ownsThread && (!isError || preFinalizeEventCount > 0 || finalizeControl.stopRequested)) {
 					const compactedEvents = compactEvents(currentRunEvents);
-					sharedStore.appendRun(request.threadId, {
+					sharedStore.appendRun(request.threadId, store, {
 						threadId: request.threadId,
 						runId: request.input.runId,
 						agentId: request.agent.agentId ?? "default",
@@ -416,11 +559,29 @@ var InMemoryAgentRunner = class extends AgentRunner {
 				finalizeRun({ interruptionMessage: error instanceof Error ? error.message : String(error) });
 			}
 		};
-		runAgent();
+		runAgent().catch((error) => {
+			console.error("Failed to finish agent run", {
+				threadId: request.threadId,
+				runId: request.input.runId
+			}, error);
+			if (store.currentRunId === request.input.runId) {
+				store.currentEvents = null;
+				store.currentRunId = null;
+				store.agent = null;
+				store.runSubject = null;
+				store.stopRequested = false;
+				store.isRunning = false;
+				store.activeFinalize = null;
+			}
+			runSubject.complete();
+			nextSubject.complete();
+			if (store.subject === nextSubject) store.subject = null;
+		});
 		return runSubject.asObservable();
 	}
 	connect(request) {
-		const store = sharedStore.get(request.threadId, { touch: true });
+		const found = sharedStore.peek(request.threadId);
+		const store = found && isVisibleTo(found, ɵresolveThreadOwner(request.ownerId)) ? sharedStore.get(request.threadId, { touch: true }) : void 0;
 		const connectionSubject = new ReplaySubject(Infinity);
 		if (!store) {
 			connectionSubject.complete();
@@ -447,11 +608,13 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	}
 	isRunning(request) {
 		const store = sharedStore.peek(request.threadId);
-		return Promise.resolve(store?.isRunning ?? false);
+		if (!store || !isVisibleTo(store, ɵresolveThreadOwner(request.ownerId))) return Promise.resolve(false);
+		return Promise.resolve(store.isRunning);
 	}
 	stop(request) {
 		const store = sharedStore.peek(request.threadId);
 		if (!store || !store.isRunning) return Promise.resolve(false);
+		if (!isVisibleTo(store, ɵresolveThreadOwner(request.ownerId))) return Promise.resolve(false);
 		if (request.runId !== void 0 && store.currentRunId !== request.runId) return Promise.resolve(false);
 		if (store.stopRequested) return Promise.resolve(false);
 		store.stopRequested = true;
@@ -477,14 +640,16 @@ var InMemoryAgentRunner = class extends AgentRunner {
 		}
 	}
 	/**
-	* Returns a summary of every thread that has been run through this runner.
+	* Returns a summary of every thread that `scope`'s owner holds in the
+	* process-wide store, which every InMemoryAgentRunner shares. Without a
+	* scope, the server owner's threads ({@link ɵSERVER_THREAD_OWNER}).
 	*
 	* This powers the local-dev fallback for `GET /threads` when the Intelligence
 	* platform is not configured. Each entry mirrors the shape of a platform
 	* `ThreadRecord` so the HTTP handler can use the same response envelope.
 	*/
-	listThreads() {
-		return sharedStore.listThreads();
+	listThreads(scope) {
+		return sharedStore.listThreads(scope);
 	}
 	/**
 	* Returns all messages for a thread, using the snapshot captured at the end
@@ -495,8 +660,8 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	* objects come directly from the ag-ui agent, so their shape is compatible
 	* with CopilotKit Intelligence's `ThreadMessage` type.
 	*/
-	getThreadMessages(threadId) {
-		const store = sharedStore.peek(threadId);
+	getThreadMessages(threadId, scope) {
+		const store = this.peekVisible(threadId, scope);
 		if (!store) return [];
 		return [...store.messagesSnapshot];
 	}
@@ -508,8 +673,8 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	* the connection-replay path in {@link connect}, so the stream a
 	* late-joining inspector sees matches what this method returns.
 	*/
-	getThreadEvents(threadId) {
-		const store = sharedStore.peek(threadId);
+	getThreadEvents(threadId, scope) {
+		const store = this.peekVisible(threadId, scope);
 		if (!store || store.historicRuns.length === 0) return [];
 		const all = [];
 		for (const run of store.historicRuns) all.push(...run.events);
@@ -525,8 +690,8 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	*
 	* Returns `null` when the thread has never emitted a STATE_SNAPSHOT.
 	*/
-	getThreadState(threadId) {
-		const events = this.getThreadEvents(threadId);
+	getThreadState(threadId, scope) {
+		const events = this.getThreadEvents(threadId, scope);
 		for (let i = events.length - 1; i >= 0; i--) {
 			const event = events[i];
 			if (event.type === EventType.STATE_SNAPSHOT) {
@@ -538,7 +703,9 @@ var InMemoryAgentRunner = class extends AgentRunner {
 		return null;
 	}
 	/**
-	* Clears all in-memory thread history.
+	* Clears the in-memory history of `scope`'s threads (without a scope, the
+	* server owner's). A thread with a run still active or finalizing is kept;
+	* see {@link ɵBoundedThreadStore.clear}.
 	*
 	* Powers the local-dev fallback for `POST /threads/clear`, letting consumers
 	* (e.g. the demo's Clear button) reset to an empty thread list without
@@ -546,11 +713,23 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	* platform path: there, thread history lives in a real database and must
 	* not be wiped this way.
 	*/
-	clearThreads() {
-		sharedStore.clear();
+	clearThreads(scope) {
+		sharedStore.clear({ ownerId: scopeOwner(scope) });
+	}
+	/**
+	* False when the thread id is held by an owner other than `scope`'s: a
+	* live thread, or the retained owner of an evicted or cleared one.
+	*/
+	isThreadAccessible(threadId, scope) {
+		return sharedStore.canClaim(threadId, scopeOwner(scope));
+	}
+	/** The thread's store, or `undefined` when unknown or not visible to `scope`. */
+	peekVisible(threadId, scope) {
+		const store = sharedStore.peek(threadId);
+		return store && isVisibleTo(store, scopeOwner(scope)) ? store : void 0;
 	}
 };
 
 //#endregion
-export { InMemoryAgentRunner, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵestimateBytes, ɵnormalizeLimits };
+export { InMemoryAgentRunner, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵOWNER_RETENTION_DEFAULTS, ɵestimateBytes, ɵnormalizeLimits };
 //# sourceMappingURL=in-memory.mjs.map