@copilotkit/runtime 1.66.2 → 1.66.4

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

@@ -5,6 +5,71 @@ import { ReplaySubject } from "rxjs";
 import { EventType, compactEvents } from "@ag-ui/client";
 
 //#region src/v2/runtime/runner/in-memory.ts
+const ɵINMEMORY_DEFAULTS = {
+	maxThreads: 1e3,
+	maxRunsPerThread: 100,
+	maxBytes: 512 * 1024 ** 2
+};
+/**
+* A limit value is well-formed iff it is a non-negative integer OR `+Infinity`.
+* `+Infinity` is the documented "disabled/unbounded" sentinel and `0` is the
+* documented run-cap disable sentinel; both are non-negative and pass. Every
+* enforcement site (`evictThreadsIfNeeded`, `enforceRunCap`,
+* `evictByBytesIfNeeded`) compares its counter against the limit with `>` in a
+* `while`/`if` guard, so only these shapes keep those loops finite and correct.
+* Rejected: negatives (drive `count > -1` true on an empty collection, so
+* `enforceRunCap` `shift()!`s `undefined` and throws), `-Infinity` (loops never
+* terminate their intent — always "over"), `NaN` (every `>` is false, silently
+* disabling the bound), and non-integer finites (fractional caps are nonsense).
+*/
+function ɵisValidLimit(value) {
+	return value === Infinity || Number.isInteger(value) && value >= 0;
+}
+/**
+* Normalize a fully-resolved limits bag so every field is well-formed before it
+* can reach an enforcement loop. Each field is validated independently against
+* {@link ɵisValidLimit}; an invalid value is CLAMPED to its
+* {@link ɵINMEMORY_DEFAULTS} floor and a single `console.warn` naming the field
+* and the received value is emitted.
+*
+* Clamp-and-warn (rather than throw) is deliberate and matches this file's
+* established posture toward bad input: `ɵestimateBytes` swallows serialization
+* failures and returns 0, the limits-clobber path warns rather than throwing,
+* and both the eviction and clobber logs are wrapped so "logging must never
+* break construction/a run". Constructing a bounded in-memory runner is a
+* best-effort, non-durable convenience; a typo'd bound must degrade to a safe
+* default, never abort construction or (worse) surface later as an unhandled
+* rejection from the fire-and-forget finalize path.
+*/
+function ɵnormalizeLimits(limits) {
+	const normalized = { ...limits };
+	for (const field of Object.keys(ɵINMEMORY_DEFAULTS)) {
+		const value = limits[field];
+		if (!ɵisValidLimit(value)) {
+			const fallback = ɵINMEMORY_DEFAULTS[field];
+			normalized[field] = fallback;
+			try {
+				console.warn(`[CopilotKit] InMemoryAgentRunner: invalid ${field} value ${String(value)} (expected a non-negative integer or Infinity); falling back to ${String(fallback)}.`);
+			} catch {}
+		}
+	}
+	return normalized;
+}
+const EVICTION_GUIDANCE = "[CopilotKit] InMemoryAgentRunner evicted in-memory thread history to stay under memory limits. This runner is bounded and non-durable by design. For durable or production threads, configure an Intelligence backend.";
+const LIMITS_CLOBBER_GUIDANCE = "[CopilotKit] InMemoryAgentRunner was constructed with in-memory limits that differ from the already-configured process-global store; the last-constructed runner's limits apply to ALL in-memory threads (the store is shared per-process). Configure a single consistent set of limits, or use an Intelligence backend for isolated bounds.";
+/**
+* Best-effort approximate byte size of a value, via serialized length.
+* Never throws — returns 0 when the value cannot be serialized. This is an
+* approximation (UTF-16 length, not exact heap bytes), used only for relative
+* accounting against `maxBytes`.
+*/
+function ɵestimateBytes(value) {
+	try {
+		return JSON.stringify(value)?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
 var InMemoryEventStore = class {
 	constructor(threadId) {
 		this.threadId = threadId;
@@ -15,39 +80,240 @@ var InMemoryEventStore = class {
 		this.agent = null;
 		this.runSubject = null;
 		this.stopRequested = false;
+		this.activeFinalize = null;
 		this.currentEvents = null;
+		this.messagesSnapshot = [];
+		this.approxMessagesSnapshotBytes = 0;
+		this.createdAt = null;
+	}
+};
+var ɵBoundedThreadStore = class {
+	constructor(limits) {
+		this.map = /* @__PURE__ */ new Map();
+		this.totalBytes = 0;
+		this.warned = false;
+		this.limitsExplicitlySet = false;
+		this.clobberWarned = false;
+		this.limits = ɵnormalizeLimits(limits);
+	}
+	get byteTotal() {
+		return this.totalBytes;
+	}
+	/**
+	* The store's CURRENT effective bounds. Exposed (with the `ɵ` internal-API
+	* prefix) so a partial `setLimits` can coalesce unspecified fields against the
+	* live config rather than the hardcoded {@link ɵINMEMORY_DEFAULTS} — a partial
+	* update must be a partial update, never a silent reset of the fields the
+	* caller did not mention. Returns a copy so callers cannot mutate the store's
+	* bounds through it.
+	*/
+	get ɵlimits() {
+		return { ...this.limits };
+	}
+	/**
+	* Reconfigure the process-global store's bounds. Called by the
+	* {@link InMemoryAgentRunner} constructor when limits are passed. Because the
+	* store is a per-process singleton, this replaces the bounds for ALL in-memory
+	* threads. Emits {@link LIMITS_CLOBBER_GUIDANCE} at most ONCE per store when a
+	* SECOND (or later) explicit set arrives whose resolved values differ from the
+	* prior explicit set — i.e. a genuine clobber of an already-customized config.
+	* The first explicit customization (defaults → custom) is the intended
+	* override and never warns; identical re-sets never warn.
+	*/
+	setLimits(limits) {
+		const normalized = ɵnormalizeLimits(limits);
+		if (this.limitsExplicitlySet && !this.clobberWarned && (normalized.maxThreads !== this.limits.maxThreads || normalized.maxRunsPerThread !== this.limits.maxRunsPerThread || normalized.maxBytes !== this.limits.maxBytes)) {
+			this.clobberWarned = true;
+			try {
+				console.warn(LIMITS_CLOBBER_GUIDANCE);
+			} catch {}
+		}
+		this.limitsExplicitlySet = true;
+		this.limits = normalized;
+	}
+	get size() {
+		return this.map.size;
+	}
+	/** Re-insert at the tail so Map iteration order stays LRU-first. */
+	touchOrder(threadId, store) {
+		this.map.delete(threadId);
+		this.map.set(threadId, store);
+	}
+	getOrCreate(threadId) {
+		const existing = this.map.get(threadId);
+		if (existing) {
+			this.touchOrder(threadId, existing);
+			return existing;
+		}
+		const store = new InMemoryEventStore(threadId);
+		this.map.set(threadId, store);
+		this.evictThreadsIfNeeded(threadId);
+		return store;
+	}
+	get(threadId, opts) {
+		const store = this.map.get(threadId);
+		if (store && opts.touch) this.touchOrder(threadId, store);
+		return store;
+	}
+	peek(threadId) {
+		return this.map.get(threadId);
+	}
+	/**
+	* Evict the least-recently-used thread that is neither running NOR
+	* mid-finalization. Returns false if none evictable. The `protect` thread
+	* (typically the one just created) is never evicted, so a fresh thread is not
+	* immediately dropped when it is the only non-running candidate.
+	*
+	* A thread is skipped while `isRunning` OR `stopRequested` is set.
+	* `stop()` flips `isRunning` to false the moment it aborts the agent, but the
+	* run keeps finalizing asynchronously (the abort trips the `catch` in
+	* `runAgent`, which later calls `appendRun`). During that window
+	* `stopRequested` stays true; evicting the thread then would make the pending
+	* `appendRun` hit `if (!store) return` and silently drop the aborted run's
+	* history. Guarding on `stopRequested` keeps the thread alive until
+	* finalization completes.
+	*/
+	evictOneLru(protect) {
+		for (const [threadId, store] of this.map) {
+			if (threadId === protect) continue;
+			if (store.isRunning || store.stopRequested) continue;
+			this.removeThread(threadId, store);
+			this.noteEviction();
+			return true;
+		}
+		return false;
+	}
+	appendRun(threadId, run) {
+		const store = this.map.get(threadId);
+		if (!store) return;
+		if (store.createdAt === null) store.createdAt = run.createdAt;
+		if (run.messages.length > 0) {
+			this.totalBytes -= store.approxMessagesSnapshotBytes;
+			store.messagesSnapshot = run.messages;
+			store.approxMessagesSnapshotBytes = ɵestimateBytes(run.messages);
+			this.totalBytes += store.approxMessagesSnapshotBytes;
+		}
+		run.messages = [];
+		run.approxMessageBytes = 0;
+		run.approxEventBytes = ɵestimateBytes(run.events);
+		store.historicRuns.push(run);
+		this.totalBytes += run.approxEventBytes;
+		this.touchOrder(threadId, store);
+		this.enforceRunCap(store);
+		this.evictByBytesIfNeeded(threadId);
+	}
+	enforceRunCap(store) {
+		const cap = this.limits.maxRunsPerThread;
+		if (!cap || cap === Infinity) return;
+		while (store.historicRuns.length > cap) {
+			const dropped = store.historicRuns.shift();
+			this.totalBytes -= dropped.approxEventBytes ?? 0;
+			this.noteEviction();
+		}
+	}
+	/**
+	* Trim the store back under the byte ceiling by evicting LRU non-running
+	* threads. `protect` (the just-appended thread) is never self-evicted, so a
+	* fresh run pushes OTHER threads out rather than dropping itself.
+	*/
+	evictByBytesIfNeeded(protect) {
+		while (this.totalBytes > this.limits.maxBytes) if (!this.evictOneLru(protect)) break;
+	}
+	removeThread(threadId, store) {
+		for (const run of store.historicRuns) this.totalBytes -= run.approxEventBytes ?? 0;
+		this.totalBytes -= store.approxMessagesSnapshotBytes;
+		this.map.delete(threadId);
+	}
+	evictThreadsIfNeeded(protect) {
+		while (this.map.size > this.limits.maxThreads) if (!this.evictOneLru(protect)) break;
+	}
+	noteEviction() {
+		if (this.warned) return;
+		this.warned = true;
+		try {
+			console.warn(EVICTION_GUIDANCE);
+		} catch {}
+	}
+	listThreads() {
+		const threads = [];
+		for (const [threadId, store] of this.map) {
+			if (store.historicRuns.length === 0) continue;
+			const lastRun = store.historicRuns[store.historicRuns.length - 1];
+			threads.push({
+				id: threadId,
+				name: null,
+				agentId: lastRun.agentId,
+				organizationId: "",
+				createdById: "",
+				archived: false,
+				createdAt: new Date(store.createdAt ?? lastRun.createdAt).toISOString(),
+				updatedAt: new Date(lastRun.createdAt).toISOString()
+			});
+		}
+		return threads.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+	}
+	clear() {
+		this.map.clear();
+		this.totalBytes = 0;
+		this.warned = false;
 	}
 };
-const GLOBAL_STORE = /* @__PURE__ */ new Map();
+/**
+* Process-wide singleton backing every {@link InMemoryAgentRunner}. Exported
+* (with the `ɵ` internal-API prefix) so tests can inspect the exact store the
+* runner writes to; not part of the public API.
+*/
+const ɵGLOBAL_STORE = new ɵBoundedThreadStore(ɵINMEMORY_DEFAULTS);
+const sharedStore = ɵGLOBAL_STORE;
 var InMemoryAgentRunner = class extends AgentRunner {
+	/**
+	* @param options Per-runner behavior (`onConcurrentRun`) plus optional bounds
+	* for the in-memory store ({@link InMemoryLimits}).
+	*
+	* Note the differing scopes: `onConcurrentRun` is per-runner instance, while
+	* the limits reconfigure the PROCESS-GLOBAL store shared by every
+	* `InMemoryAgentRunner`. Omit the limits for safe defaults
+	* ({@link ɵINMEMORY_DEFAULTS}); passing none leaves the store untouched. When
+	* multiple runners are constructed with differing limits, the last-constructed
+	* wins — in practice the OSS/SSE default construction passes nothing. If a
+	* second (or later) runner is constructed with limits that DIFFER from an
+	* already-customized store, a one-time `console.warn` is emitted to signal that
+	* the shared store's bounds are being clobbered for ALL in-memory threads.
+	*/
 	constructor(options) {
 		super();
 		this.ɵsupportsLocalThreadEndpoints = true;
-		this.onConcurrentRun = options?.onConcurrentRun ?? "throw";
+		const { onConcurrentRun, ...limits } = options ?? {};
+		this.onConcurrentRun = onConcurrentRun ?? "throw";
+		if (limits.maxThreads !== void 0 || limits.maxRunsPerThread !== void 0 || limits.maxBytes !== void 0) {
+			const current = sharedStore.ɵlimits;
+			sharedStore.setLimits({
+				maxThreads: limits.maxThreads ?? current.maxThreads,
+				maxRunsPerThread: limits.maxRunsPerThread ?? current.maxRunsPerThread,
+				maxBytes: limits.maxBytes ?? current.maxBytes
+			});
+		}
 	}
 	run(request) {
-		let existingStore = GLOBAL_STORE.get(request.threadId);
-		if (!existingStore) {
-			existingStore = new InMemoryEventStore(request.threadId);
-			GLOBAL_STORE.set(request.threadId, existingStore);
-		}
-		const store = existingStore;
-		if (store.isRunning) {
+		const store = sharedStore.getOrCreate(request.threadId);
+		if (store.isRunning || store.stopRequested) {
 			if (this.onConcurrentRun !== "supersede") throw new Error("Thread already running");
 			const priorAgent = store.agent;
-			store.stopRequested = true;
+			const priorFinalize = store.activeFinalize;
+			if (priorFinalize) priorFinalize.stopRequested = true;
 			store.isRunning = false;
 			if (priorAgent) try {
 				priorAgent.abortRun();
 			} catch (error) {
 				console.error("Failed to abort superseded run", error);
 			}
-			store.stopRequested = false;
 		}
 		store.isRunning = true;
 		store.currentRunId = request.input.runId;
 		store.agent = request.agent;
 		store.stopRequested = false;
+		const finalizeControl = { stopRequested: false };
+		store.activeFinalize = finalizeControl;
 		const seenMessageIds = /* @__PURE__ */ new Set();
 		const currentRunEvents = [];
 		store.currentEvents = currentRunEvents;
@@ -60,12 +326,48 @@ var InMemoryAgentRunner = class extends AgentRunner {
 			}
 		}
 		const nextSubject = new ReplaySubject(Infinity);
-		const prevSubject = store.subject;
 		store.subject = nextSubject;
 		const runSubject = new ReplaySubject(Infinity);
 		store.runSubject = runSubject;
 		const runAgent = async () => {
 			const parentRunId = store.historicRuns[store.historicRuns.length - 1]?.runId ?? null;
+			const finalizeRun = (opts) => {
+				const isError = opts.interruptionMessage !== void 0;
+				const preFinalizeEventCount = currentRunEvents.length;
+				const appendedEvents = finalizeRunEvents(currentRunEvents, {
+					stopRequested: finalizeControl.stopRequested,
+					...isError ? { interruptionMessage: opts.interruptionMessage } : {}
+				});
+				for (const event of appendedEvents) {
+					runSubject.next(event);
+					nextSubject.next(event);
+				}
+				const ownsThread = store.currentRunId === request.input.runId;
+				if (ownsThread && (!isError || preFinalizeEventCount > 0)) {
+					const compactedEvents = compactEvents(currentRunEvents);
+					sharedStore.appendRun(request.threadId, {
+						threadId: request.threadId,
+						runId: request.input.runId,
+						agentId: request.agent.agentId ?? "default",
+						parentRunId,
+						events: compactedEvents,
+						messages: Array.isArray(request.agent.messages) ? [...request.agent.messages] : [],
+						createdAt: Date.now()
+					});
+				}
+				if (ownsThread) {
+					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;
+			};
 			try {
 				await request.agent.runAgent(request.input, {
 					onEvent: ({ event }) => {
@@ -94,77 +396,16 @@ var InMemoryAgentRunner = class extends AgentRunner {
 						}
 					}
 				});
-				const appendedEvents = finalizeRunEvents(currentRunEvents, { stopRequested: store.stopRequested });
-				for (const event of appendedEvents) {
-					runSubject.next(event);
-					nextSubject.next(event);
-				}
-				if (store.currentRunId === request.input.runId) {
-					const compactedEvents = compactEvents(currentRunEvents);
-					store.historicRuns.push({
-						threadId: request.threadId,
-						runId: request.input.runId,
-						agentId: request.agent.agentId ?? "default",
-						parentRunId,
-						events: compactedEvents,
-						messages: Array.isArray(request.agent.messages) ? [...request.agent.messages] : [],
-						createdAt: Date.now()
-					});
-				}
-				if (store.currentRunId === request.input.runId) {
-					store.currentEvents = null;
-					store.currentRunId = null;
-					store.agent = null;
-					store.runSubject = null;
-					store.stopRequested = false;
-					store.isRunning = false;
-				}
-				runSubject.complete();
-				nextSubject.complete();
+				finalizeRun({});
 			} catch (error) {
-				const interruptionMessage = error instanceof Error ? error.message : String(error);
-				const appendedEvents = finalizeRunEvents(currentRunEvents, {
-					stopRequested: store.stopRequested,
-					interruptionMessage
-				});
-				for (const event of appendedEvents) {
-					runSubject.next(event);
-					nextSubject.next(event);
-				}
-				if (store.currentRunId === request.input.runId && currentRunEvents.length > 0) {
-					const compactedEvents = compactEvents(currentRunEvents);
-					store.historicRuns.push({
-						threadId: request.threadId,
-						runId: request.input.runId,
-						agentId: request.agent.agentId ?? "default",
-						parentRunId,
-						events: compactedEvents,
-						messages: Array.isArray(request.agent.messages) ? [...request.agent.messages] : [],
-						createdAt: Date.now()
-					});
-				}
-				if (store.currentRunId === request.input.runId) {
-					store.currentEvents = null;
-					store.currentRunId = null;
-					store.agent = null;
-					store.runSubject = null;
-					store.stopRequested = false;
-					store.isRunning = false;
-				}
-				runSubject.complete();
-				nextSubject.complete();
+				finalizeRun({ interruptionMessage: error instanceof Error ? error.message : String(error) });
 			}
 		};
-		if (prevSubject) prevSubject.subscribe({
-			next: (e) => nextSubject.next(e),
-			error: (err) => nextSubject.error(err),
-			complete: () => {}
-		});
 		runAgent();
 		return runSubject.asObservable();
 	}
 	connect(request) {
-		const store = GLOBAL_STORE.get(request.threadId);
+		const store = sharedStore.get(request.threadId, { touch: true });
 		const connectionSubject = new ReplaySubject(Infinity);
 		if (!store) {
 			connectionSubject.complete();
@@ -190,20 +431,23 @@ var InMemoryAgentRunner = class extends AgentRunner {
 		return connectionSubject.asObservable();
 	}
 	isRunning(request) {
-		const store = GLOBAL_STORE.get(request.threadId);
+		const store = sharedStore.peek(request.threadId);
 		return Promise.resolve(store?.isRunning ?? false);
 	}
 	stop(request) {
-		const store = GLOBAL_STORE.get(request.threadId);
+		const store = sharedStore.peek(request.threadId);
 		if (!store || !store.isRunning) 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;
 		store.isRunning = false;
+		const finalizeControl = store.activeFinalize;
+		if (finalizeControl) finalizeControl.stopRequested = true;
 		const agent = store.agent;
 		if (!agent) {
 			store.stopRequested = false;
 			store.isRunning = false;
+			if (finalizeControl) finalizeControl.stopRequested = false;
 			return Promise.resolve(false);
 		}
 		try {
@@ -213,6 +457,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
 			console.error("Failed to abort agent run", error);
 			store.stopRequested = false;
 			store.isRunning = true;
+			if (finalizeControl) finalizeControl.stopRequested = false;
 			return Promise.resolve(false);
 		}
 	}
@@ -224,23 +469,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	* `ThreadRecord` so the HTTP handler can use the same response envelope.
 	*/
 	listThreads() {
-		const threads = [];
-		for (const [threadId, store] of GLOBAL_STORE) {
-			if (store.historicRuns.length === 0) continue;
-			const firstRun = store.historicRuns[0];
-			const lastRun = store.historicRuns[store.historicRuns.length - 1];
-			threads.push({
-				id: threadId,
-				name: null,
-				agentId: lastRun.agentId,
-				organizationId: "",
-				createdById: "",
-				archived: false,
-				createdAt: new Date(firstRun.createdAt).toISOString(),
-				updatedAt: new Date(lastRun.createdAt).toISOString()
-			});
-		}
-		return threads.sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+		return sharedStore.listThreads();
 	}
 	/**
 	* Returns all messages for a thread, using the snapshot captured at the end
@@ -252,9 +481,9 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	* with the Intelligence platform's `ThreadMessage` type.
 	*/
 	getThreadMessages(threadId) {
-		const store = GLOBAL_STORE.get(threadId);
-		if (!store || store.historicRuns.length === 0) return [];
-		return store.historicRuns[store.historicRuns.length - 1].messages;
+		const store = sharedStore.peek(threadId);
+		if (!store) return [];
+		return [...store.messagesSnapshot];
 	}
 	/**
 	* Returns all AG-UI events for a thread, compacted across historic runs.
@@ -265,7 +494,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	* late-joining inspector sees matches what this method returns.
 	*/
 	getThreadEvents(threadId) {
-		const store = GLOBAL_STORE.get(threadId);
+		const store = sharedStore.peek(threadId);
 		if (!store || store.historicRuns.length === 0) return [];
 		const all = [];
 		for (const run of store.historicRuns) all.push(...run.events);
@@ -287,7 +516,7 @@ var InMemoryAgentRunner = class extends AgentRunner {
 			const event = events[i];
 			if (event.type === EventType.STATE_SNAPSHOT) {
 				const snapshot = event.snapshot;
-				if (snapshot && typeof snapshot === "object") return snapshot;
+				if (snapshot && typeof snapshot === "object" && !Array.isArray(snapshot)) return { ...snapshot };
 				return null;
 			}
 		}
@@ -303,10 +532,10 @@ var InMemoryAgentRunner = class extends AgentRunner {
 	* not be wiped this way.
 	*/
 	clearThreads() {
-		GLOBAL_STORE.clear();
+		sharedStore.clear();
 	}
 };
 
 //#endregion
-export { InMemoryAgentRunner };
+export { InMemoryAgentRunner, ɵBoundedThreadStore, ɵGLOBAL_STORE, ɵINMEMORY_DEFAULTS, ɵestimateBytes, ɵnormalizeLimits };
 //# sourceMappingURL=in-memory.mjs.map