@copilotkit/runtime 1.83.0 → 2.0.0-rc.0

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

@@ -1,735 +0,0 @@
-import "reflect-metadata";
-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";
-
-//#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 {
-	/**
-	* @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;
-		this.historicRuns = [];
-		this.agent = null;
-		this.runSubject = null;
-		this.stopRequested = false;
-		this.activeFinalize = null;
-		this.currentEvents = null;
-		this.messagesSnapshot = [];
-		this.approxMessagesSnapshotBytes = 0;
-		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;
-		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);
-	}
-	/**
-	* 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, ownerId);
-		this.forgetOwner(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;
-	}
-	/**
-	* 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 || store !== writer) 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);
-		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;
-	}
-	noteEviction() {
-		if (this.warned) return;
-		this.warned = true;
-		try {
-			console.warn(EVICTION_GUIDANCE);
-		} catch {}
-	}
-	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: store.ownerId,
-				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());
-	}
-	/**
-	* 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;
-	}
-};
-/**
-* 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;
-		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) {
-		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;
-			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.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;
-		const historicMessageIds = /* @__PURE__ */ new Set();
-		for (const run of store.historicRuns) for (const event of run.events) {
-			if ("messageId" in event && typeof event.messageId === "string") historicMessageIds.add(event.messageId);
-			if (event.type === EventType.RUN_STARTED) {
-				const messages = event.input?.messages ?? [];
-				for (const message of messages) historicMessageIds.add(message.id);
-			}
-		}
-		const nextSubject = new ReplaySubject(Infinity);
-		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;
-				if (finalizeControl.stopRequested && !currentRunEvents.some((event) => event.type === EventType.RUN_STARTED)) {
-					const started = {
-						type: EventType.RUN_STARTED,
-						threadId: request.threadId,
-						runId: request.input.runId,
-						input: {
-							...request.input,
-							messages: request.input.messages.filter((message) => !historicMessageIds.has(message.id))
-						}
-					};
-					currentRunEvents.unshift(started);
-					runSubject.next(started);
-					nextSubject.next(started);
-				}
-				const appendedEvents = finalizeRunEvents(currentRunEvents, {
-					stopRequested: finalizeControl.stopRequested,
-					protocolVersion: request.input.protocolVersion,
-					...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 || finalizeControl.stopRequested)) {
-					const compactedEvents = compactEvents(currentRunEvents);
-					sharedStore.appendRun(request.threadId, store, {
-						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 }) => {
-						let processedEvent = event;
-						if (event.type === EventType.RUN_STARTED) {
-							const runStartedEvent = event;
-							if (!runStartedEvent.input) {
-								const sanitizedMessages = request.input.messages ? request.input.messages.filter((message) => !historicMessageIds.has(message.id)) : void 0;
-								runStartedEvent.input = {
-									...request.input,
-									...sanitizedMessages !== void 0 ? { messages: sanitizedMessages } : {}
-								};
-								processedEvent = runStartedEvent;
-							}
-						}
-						runSubject.next(processedEvent);
-						nextSubject.next(processedEvent);
-						currentRunEvents.push(processedEvent);
-					},
-					onNewMessage: ({ message }) => {
-						if (!seenMessageIds.has(message.id)) seenMessageIds.add(message.id);
-					},
-					onRunStartedEvent: () => {
-						if (request.input.messages) {
-							for (const message of request.input.messages) if (!seenMessageIds.has(message.id)) seenMessageIds.add(message.id);
-						}
-					}
-				});
-				finalizeRun({});
-			} catch (error) {
-				finalizeRun({ interruptionMessage: error instanceof Error ? error.message : String(error) });
-			}
-		};
-		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 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();
-			return connectionSubject.asObservable();
-		}
-		const allHistoricEvents = [];
-		for (const run of store.historicRuns) allHistoricEvents.push(...run.events);
-		const compactedEvents = compactEvents(allHistoricEvents);
-		const emittedMessageIds = /* @__PURE__ */ new Set();
-		for (const event of compactedEvents) {
-			connectionSubject.next(event);
-			if ("messageId" in event && typeof event.messageId === "string") emittedMessageIds.add(event.messageId);
-		}
-		if (store.subject && (store.isRunning || store.stopRequested)) store.subject.subscribe({
-			next: (event) => {
-				if ("messageId" in event && typeof event.messageId === "string" && emittedMessageIds.has(event.messageId)) return;
-				connectionSubject.next(event);
-			},
-			complete: () => connectionSubject.complete(),
-			error: (err) => connectionSubject.error(err)
-		});
-		else connectionSubject.complete();
-		return connectionSubject.asObservable();
-	}
-	isRunning(request) {
-		const store = sharedStore.peek(request.threadId);
-		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;
-		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 {
-			agent.abortRun();
-			return Promise.resolve(true);
-		} catch (error) {
-			console.error("Failed to abort agent run", error);
-			store.stopRequested = false;
-			store.isRunning = true;
-			if (finalizeControl) finalizeControl.stopRequested = false;
-			return Promise.resolve(false);
-		}
-	}
-	/**
-	* 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(scope) {
-		return sharedStore.listThreads(scope);
-	}
-	/**
-	* Returns all messages for a thread, using the snapshot captured at the end
-	* of the most recent run.
-	*
-	* This powers the local-dev fallback for `GET /threads/:threadId/messages`
-	* when CopilotKit Intelligence is not configured. The returned `Message[]`
-	* objects come directly from the ag-ui agent, so their shape is compatible
-	* with CopilotKit Intelligence's `ThreadMessage` type.
-	*/
-	getThreadMessages(threadId, scope) {
-		const store = this.peekVisible(threadId, scope);
-		if (!store) return [];
-		return [...store.messagesSnapshot];
-	}
-	/**
-	* Returns all AG-UI events for a thread, compacted across historic runs.
-	*
-	* Powers the local-dev fallback for `GET /threads/:threadId/events` when the
-	* CopilotKit Intelligence is not configured. The compaction logic matches
-	* the connection-replay path in {@link connect}, so the stream a
-	* late-joining inspector sees matches what this method returns.
-	*/
-	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);
-		return compactEvents(all);
-	}
-	/**
-	* Returns the agent state snapshot for a thread.
-	*
-	* Derived from the last `STATE_SNAPSHOT` in the compacted event stream. The
-	* AG-UI `compactEvents` helper consolidates STATE_DELTA events and produces
-	* a single trailing STATE_SNAPSHOT when state changes exist, so this is a
-	* faithful view of state at the end of the most recent run.
-	*
-	* Returns `null` when the thread has never emitted a STATE_SNAPSHOT.
-	*/
-	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) {
-				const snapshot = event.snapshot;
-				if (snapshot && typeof snapshot === "object" && !Array.isArray(snapshot)) return { ...snapshot };
-				return null;
-			}
-		}
-		return null;
-	}
-	/**
-	* 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
-	* restarting the runtime. Intentionally not exposed on the Intelligence
-	* platform path: there, thread history lives in a real database and must
-	* not be wiped this way.
-	*/
-	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, ɵOWNER_RETENTION_DEFAULTS, ɵestimateBytes, ɵnormalizeLimits };
-//# sourceMappingURL=in-memory.mjs.map