@copilotkit/runtime 1.81.0 → 1.83.0

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

@@ -72,8 +72,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;
@@ -88,9 +94,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 require_agent_runner.ɵ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;
@@ -140,13 +168,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 = require_agent_runner.ɵ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;
@@ -184,9 +217,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;
@@ -224,6 +263,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;
@@ -235,17 +355,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()
@@ -253,8 +374,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;
 	}
@@ -296,7 +437,9 @@ var InMemoryAgentRunner = class extends require_agent_runner.AgentRunner {
 		}
 	}
 	run(request) {
-		const store = sharedStore.getOrCreate(request.threadId);
+		const owner = require_agent_runner.ɵresolveThreadOwner(request.ownerId);
+		if (!sharedStore.canClaim(request.threadId, owner)) throw new require_agent_runner.ThreadAccessDeniedError();
+		const store = sharedStore.getOrCreate(request.threadId, owner);
 		if (store.isRunning || store.stopRequested) {
 			if (this.onConcurrentRun !== "supersede") throw new require_agent_runner.ThreadAlreadyRunningError();
 			const priorAgent = store.agent;
@@ -361,7 +504,7 @@ var InMemoryAgentRunner = class extends require_agent_runner.AgentRunner {
 				const ownsThread = store.currentRunId === request.input.runId;
 				if (ownsThread && (!isError || preFinalizeEventCount > 0 || finalizeControl.stopRequested)) {
 					const compactedEvents = (0, _ag_ui_client.compactEvents)(currentRunEvents);
-					sharedStore.appendRun(request.threadId, {
+					sharedStore.appendRun(request.threadId, store, {
 						threadId: request.threadId,
 						runId: request.input.runId,
 						agentId: request.agent.agentId ?? "default",
@@ -417,11 +560,29 @@ var InMemoryAgentRunner = class extends require_agent_runner.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, require_agent_runner.ɵresolveThreadOwner(request.ownerId)) ? sharedStore.get(request.threadId, { touch: true }) : void 0;
 		const connectionSubject = new rxjs.ReplaySubject(Infinity);
 		if (!store) {
 			connectionSubject.complete();
@@ -448,11 +609,13 @@ var InMemoryAgentRunner = class extends require_agent_runner.AgentRunner {
 	}
 	isRunning(request) {
 		const store = sharedStore.peek(request.threadId);
-		return Promise.resolve(store?.isRunning ?? false);
+		if (!store || !isVisibleTo(store, require_agent_runner.ɵ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, require_agent_runner.ɵ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;
@@ -478,14 +641,16 @@ var InMemoryAgentRunner = class extends require_agent_runner.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
@@ -496,8 +661,8 @@ var InMemoryAgentRunner = class extends require_agent_runner.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];
 	}
@@ -509,8 +674,8 @@ var InMemoryAgentRunner = class extends require_agent_runner.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);
@@ -526,8 +691,8 @@ var InMemoryAgentRunner = class extends require_agent_runner.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 === _ag_ui_client.EventType.STATE_SNAPSHOT) {
@@ -539,7 +704,9 @@ var InMemoryAgentRunner = class extends require_agent_runner.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
@@ -547,8 +714,20 @@ var InMemoryAgentRunner = class extends require_agent_runner.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;
 	}
 };
 
@@ -557,6 +736,7 @@ exports.InMemoryAgentRunner = InMemoryAgentRunner;
 exports.ɵBoundedThreadStore = ɵBoundedThreadStore;
 exports.ɵGLOBAL_STORE = ɵGLOBAL_STORE;
 exports.ɵINMEMORY_DEFAULTS = ɵINMEMORY_DEFAULTS;
+exports.ɵOWNER_RETENTION_DEFAULTS = ɵOWNER_RETENTION_DEFAULTS;
 exports.ɵestimateBytes = ɵestimateBytes;
 exports.ɵnormalizeLimits = ɵnormalizeLimits;
 //# sourceMappingURL=in-memory.cjs.map