@statelyai/agent 2.0.0-alpha.28 → 2.0.0-alpha.30

package/dist/{event-log-store-BIPOz-di.d.mts → event-log-store-CIIJohjj.d.mts}

@@ -1,6 +1,5 @@
-import { Z as AgentError, t as AgentCallUsage } from "./text-logic-D-czVPYp.mjs";
-import { AnyMachineSnapshot, AnyStateMachine, EventObject, Snapshot, SnapshotFrom } from "xstate";
-
+import { I as DecisionAttempt, Q as AgentError, t as AgentCallUsage } from "./text-logic-BRYOPWvY.mjs";
+import { Actor, AnyMachineSnapshot, AnyStateMachine, EventObject, Snapshot, SnapshotFrom } from "xstate";
 //#region src/event-log.d.ts
 /** The durable entry envelope version. */
 declare const AGENT_EVENT_SCHEMA_VERSION: 1;
@@ -46,6 +45,15 @@ interface AgentLogEntry {
   metadata?: Record<string, JsonValue>;
   /** Recorded projection hash used by replay verification. */
   verification?: AgentLogVerification;
+  /**
+   * The decision attempts the machine did NOT accept before this entry's
+   * event landed (guard rejections, non-offered options, unknown types,
+   * invalid payloads), in the order they were made, when a decider
+   * (`agent.decide`, or a host using `decideNext`) needed more than one try.
+   * Omitted when there are none. Replay-ignored: it explains the entry, it
+   * does not change the fold.
+   */
+  attempts?: DecisionAttempt[];
 }
 /** The payload of the reserved {@link AGENT_INIT_EVENT_TYPE} first entry. */
 interface AgentInitEvent extends EventObject {
@@ -134,6 +142,8 @@ interface CreateReplayEntryOptions {
   recordedAt?: string;
   causationId?: string;
   metadata?: Record<string, JsonValue>;
+  /** Rejected decision attempts that preceded `event`; omitted when empty. */
+  attempts?: DecisionAttempt[];
   /** Record `verification.stateHash` (default `true`). */
   verification?: boolean;
   /**
@@ -220,6 +230,29 @@ declare function agentCallOccurrence(history: readonly (EventObject | AgentLogEn
  * `undefined` until some entry reports it, and non-finite values are ignored.
  */
 declare function getUsageFromEvents(entries: readonly (EventObject | AgentLogEntry)[]): AgentCallUsage;
+/** One entry's rejected decision attempts, as {@link getDecisionAttempts} returns them. */
+interface AgentLogDecisionAttempts {
+  /** The entry's `index` in the log. */
+  index: number;
+  /**
+   * The entry's event type: the event the attempts preceded, or an
+   * `xstate.error.actor.*` type when the decision exhausted its retries.
+   */
+  eventType: string;
+  attempts: DecisionAttempt[];
+}
+/**
+ * The decision attempts a log recorded but the machine never accepted, in log
+ * order — the input for improving a decider from its traces. Two sources:
+ *
+ * - `entry.attempts`: the failed tries before the entry's event landed.
+ * - An `xstate.error.actor.*` entry whose `error` is a decision-exhausted
+ *   error (`code: "decision-exhausted"`) that kept its `attempts`: every try
+ *   failed. Another actor error's `attempts` field is not read.
+ *
+ * Entries with neither are skipped.
+ */
+declare function getDecisionAttempts(entries: readonly AgentLogEntry[]): AgentLogDecisionAttempts[];
 /**
  * Rewrites a journaled `xstate.done.actor`/`xstate.error.actor` event's
  * `sessionId` to the session the CURRENT fold minted for that `actorId`.
@@ -261,8 +294,51 @@ interface ReplayResult<TMachine extends AnyStateMachine> {
  * (`machine.restoreSnapshot`) and folds the rest of the log onto it.
  */
 declare function replay<TMachine extends AnyStateMachine>(machine: TMachine, entries: readonly AgentLogEntry[], options?: ReplayOptions): ReplayResult<TMachine>;
+/** A log being recorded from a plain actor. See {@link recordLog}. */
+interface LogRecorder {
+  /**
+   * The entries so far, init entry first, in the shape {@link replay} folds.
+   * Throws the recording's error if an event could not be journaled, and
+   * throws when there is no init entry yet (not started, or attached late).
+   */
+  readonly entries: AgentLogEntry[];
+  /** Stops recording. Entries recorded so far stay readable. */
+  stop(): void;
+}
+/**
+ * Records a plain `createActor` run as an event log, with no
+ * `createAgentRuntime`: the init entry (the actor's `input`, or the snapshot
+ * it was created from), then every event the root machine processed, invoke
+ * completions with their outputs inline. Attach it before `actor.start()`.
+ *
+ * @example
+ * ```ts no-check
+ * const actor = createActor(machine, { input });
+ * const log = recordLog(actor);
+ * actor.start();
+ * // ...later
+ * const { snapshot } = replay(machine, log.entries); // no actor runs
+ * ```
+ */
+declare function recordLog(actor: Actor<AnyStateMachine>): LogRecorder;
 //#endregion
 //#region src/event-log-store.d.ts
+/** Options for {@link AgentEventLogStore.listThreads}. */
+interface ListThreadsOptions {
+  /** Only thread ids that start with this string. */
+  prefix?: string;
+  /** At most this many ids per page (a positive integer). Omit for all. */
+  limit?: number;
+  /** The `cursor` of the previous page, to continue after it. */
+  cursor?: string;
+}
+/** One page of {@link AgentEventLogStore.listThreads}. */
+interface ListThreadsResult {
+  /** Thread ids in a stable store-defined order (the reference sorts them). */
+  threadIds: string[];
+  /** Present when more ids remain: pass it back as `options.cursor`. Opaque. */
+  cursor?: string;
+}
 /**
  * An append-only event log: the authoritative durability artifact of a thread.
  * The journal of external inputs IS the source of truth — deterministic
@@ -309,9 +385,18 @@ interface AgentEventLogStore {
    */
   fork(input: {
     threadId: string;
-    newThreadId: string; /** Exclusive index cutoff. */
+    newThreadId: string;
+    /** Exclusive index cutoff. */
     upToIndex?: number;
   }): Promise<void>;
+  /**
+   * Optional: list the threads that hold at least one entry, so a caller
+   * (an improver reading traces, a retention job) need not record thread ids
+   * itself. Pages with `limit` + `cursor`; the cursor is opaque and the order
+   * is stable across pages. Optional so existing stores keep compiling;
+   * `assertEventLogStoreConformance` checks it only when it is present.
+   */
+  listThreads?(options?: ListThreadsOptions): Promise<ListThreadsResult>;
 }
 /**
  * Rejection from {@link AgentEventLogStore.append} when the thread's stored
@@ -335,4 +420,4 @@ declare class AgentEventLogConflictError extends AgentError {
  */
 declare function createInMemoryEventLogStore(): AgentEventLogStore;
 //#endregion
-export { validateReplayEntries as A, forkEventLog as C, initEntry as D, getUsageFromEvents as E, rebindActorSession as O, createReplayEntry as S, getSnapshotStateHash as T, ReplayOptions as _, AGENT_INIT_EVENT_TYPE as a, assertAgentLogEntry as b, AgentLogEntry as c, AgentMachineVersionMismatchError as d, AgentPersistedSnapshot as f, NonSerializableAgentEventError as g, JsonValue as h, AGENT_EVENT_SCHEMA_VERSION as i, replay as k, AgentLogInit as l, CreateReplayEntryOptions as m, AgentEventLogStore as n, AgentEventLogError as o, AgentReplayDivergenceError as p, createInMemoryEventLogStore as r, AgentInitEvent as s, AgentEventLogConflictError as t, AgentLogVerification as u, ReplayResult as v, getLogExecutionId as w, assertJsonSerializable as x, agentCallOccurrence as y };
+export { rebindActorSession as A, createReplayEntry as C, getSnapshotStateHash as D, getLogExecutionId as E, replay as M, validateReplayEntries as N, getUsageFromEvents as O, assertJsonSerializable as S, getDecisionAttempts as T, NonSerializableAgentEventError as _, AGENT_INIT_EVENT_TYPE as a, agentCallOccurrence as b, AgentLogEntry as c, AgentMachineVersionMismatchError as d, AgentPersistedSnapshot as f, LogRecorder as g, JsonValue as h, AGENT_EVENT_SCHEMA_VERSION as i, recordLog as j, initEntry as k, AgentLogInit as l, CreateReplayEntryOptions as m, AgentEventLogStore as n, AgentEventLogError as o, AgentReplayDivergenceError as p, createInMemoryEventLogStore as r, AgentInitEvent as s, AgentEventLogConflictError as t, AgentLogVerification as u, ReplayOptions as v, forkEventLog as w, assertAgentLogEntry as x, ReplayResult as y };

package/dist/{event-log-store-2xzFmgr2.d.cts → event-log-store-CLAC9q2Y.d.cts}

@@ -1,6 +1,5 @@
-import { Z as AgentError, t as AgentCallUsage } from "./text-logic-IjfYy9DP.cjs";
-import { AnyMachineSnapshot, AnyStateMachine, EventObject, Snapshot, SnapshotFrom } from "xstate";
-
+import { I as DecisionAttempt, Q as AgentError, t as AgentCallUsage } from "./text-logic-DmciuVUQ.cjs";
+import { Actor, AnyMachineSnapshot, AnyStateMachine, EventObject, Snapshot, SnapshotFrom } from "xstate";
 //#region src/event-log.d.ts
 /** The durable entry envelope version. */
 declare const AGENT_EVENT_SCHEMA_VERSION: 1;
@@ -46,6 +45,15 @@ interface AgentLogEntry {
   metadata?: Record<string, JsonValue>;
   /** Recorded projection hash used by replay verification. */
   verification?: AgentLogVerification;
+  /**
+   * The decision attempts the machine did NOT accept before this entry's
+   * event landed (guard rejections, non-offered options, unknown types,
+   * invalid payloads), in the order they were made, when a decider
+   * (`agent.decide`, or a host using `decideNext`) needed more than one try.
+   * Omitted when there are none. Replay-ignored: it explains the entry, it
+   * does not change the fold.
+   */
+  attempts?: DecisionAttempt[];
 }
 /** The payload of the reserved {@link AGENT_INIT_EVENT_TYPE} first entry. */
 interface AgentInitEvent extends EventObject {
@@ -134,6 +142,8 @@ interface CreateReplayEntryOptions {
   recordedAt?: string;
   causationId?: string;
   metadata?: Record<string, JsonValue>;
+  /** Rejected decision attempts that preceded `event`; omitted when empty. */
+  attempts?: DecisionAttempt[];
   /** Record `verification.stateHash` (default `true`). */
   verification?: boolean;
   /**
@@ -220,6 +230,29 @@ declare function agentCallOccurrence(history: readonly (EventObject | AgentLogEn
  * `undefined` until some entry reports it, and non-finite values are ignored.
  */
 declare function getUsageFromEvents(entries: readonly (EventObject | AgentLogEntry)[]): AgentCallUsage;
+/** One entry's rejected decision attempts, as {@link getDecisionAttempts} returns them. */
+interface AgentLogDecisionAttempts {
+  /** The entry's `index` in the log. */
+  index: number;
+  /**
+   * The entry's event type: the event the attempts preceded, or an
+   * `xstate.error.actor.*` type when the decision exhausted its retries.
+   */
+  eventType: string;
+  attempts: DecisionAttempt[];
+}
+/**
+ * The decision attempts a log recorded but the machine never accepted, in log
+ * order — the input for improving a decider from its traces. Two sources:
+ *
+ * - `entry.attempts`: the failed tries before the entry's event landed.
+ * - An `xstate.error.actor.*` entry whose `error` is a decision-exhausted
+ *   error (`code: "decision-exhausted"`) that kept its `attempts`: every try
+ *   failed. Another actor error's `attempts` field is not read.
+ *
+ * Entries with neither are skipped.
+ */
+declare function getDecisionAttempts(entries: readonly AgentLogEntry[]): AgentLogDecisionAttempts[];
 /**
  * Rewrites a journaled `xstate.done.actor`/`xstate.error.actor` event's
  * `sessionId` to the session the CURRENT fold minted for that `actorId`.
@@ -261,8 +294,51 @@ interface ReplayResult<TMachine extends AnyStateMachine> {
  * (`machine.restoreSnapshot`) and folds the rest of the log onto it.
  */
 declare function replay<TMachine extends AnyStateMachine>(machine: TMachine, entries: readonly AgentLogEntry[], options?: ReplayOptions): ReplayResult<TMachine>;
+/** A log being recorded from a plain actor. See {@link recordLog}. */
+interface LogRecorder {
+  /**
+   * The entries so far, init entry first, in the shape {@link replay} folds.
+   * Throws the recording's error if an event could not be journaled, and
+   * throws when there is no init entry yet (not started, or attached late).
+   */
+  readonly entries: AgentLogEntry[];
+  /** Stops recording. Entries recorded so far stay readable. */
+  stop(): void;
+}
+/**
+ * Records a plain `createActor` run as an event log, with no
+ * `createAgentRuntime`: the init entry (the actor's `input`, or the snapshot
+ * it was created from), then every event the root machine processed, invoke
+ * completions with their outputs inline. Attach it before `actor.start()`.
+ *
+ * @example
+ * ```ts no-check
+ * const actor = createActor(machine, { input });
+ * const log = recordLog(actor);
+ * actor.start();
+ * // ...later
+ * const { snapshot } = replay(machine, log.entries); // no actor runs
+ * ```
+ */
+declare function recordLog(actor: Actor<AnyStateMachine>): LogRecorder;
 //#endregion
 //#region src/event-log-store.d.ts
+/** Options for {@link AgentEventLogStore.listThreads}. */
+interface ListThreadsOptions {
+  /** Only thread ids that start with this string. */
+  prefix?: string;
+  /** At most this many ids per page (a positive integer). Omit for all. */
+  limit?: number;
+  /** The `cursor` of the previous page, to continue after it. */
+  cursor?: string;
+}
+/** One page of {@link AgentEventLogStore.listThreads}. */
+interface ListThreadsResult {
+  /** Thread ids in a stable store-defined order (the reference sorts them). */
+  threadIds: string[];
+  /** Present when more ids remain: pass it back as `options.cursor`. Opaque. */
+  cursor?: string;
+}
 /**
  * An append-only event log: the authoritative durability artifact of a thread.
  * The journal of external inputs IS the source of truth — deterministic
@@ -309,9 +385,18 @@ interface AgentEventLogStore {
    */
   fork(input: {
     threadId: string;
-    newThreadId: string; /** Exclusive index cutoff. */
+    newThreadId: string;
+    /** Exclusive index cutoff. */
     upToIndex?: number;
   }): Promise<void>;
+  /**
+   * Optional: list the threads that hold at least one entry, so a caller
+   * (an improver reading traces, a retention job) need not record thread ids
+   * itself. Pages with `limit` + `cursor`; the cursor is opaque and the order
+   * is stable across pages. Optional so existing stores keep compiling;
+   * `assertEventLogStoreConformance` checks it only when it is present.
+   */
+  listThreads?(options?: ListThreadsOptions): Promise<ListThreadsResult>;
 }
 /**
  * Rejection from {@link AgentEventLogStore.append} when the thread's stored
@@ -335,4 +420,4 @@ declare class AgentEventLogConflictError extends AgentError {
  */
 declare function createInMemoryEventLogStore(): AgentEventLogStore;
 //#endregion
-export { validateReplayEntries as A, forkEventLog as C, initEntry as D, getUsageFromEvents as E, rebindActorSession as O, createReplayEntry as S, getSnapshotStateHash as T, ReplayOptions as _, AGENT_INIT_EVENT_TYPE as a, assertAgentLogEntry as b, AgentLogEntry as c, AgentMachineVersionMismatchError as d, AgentPersistedSnapshot as f, NonSerializableAgentEventError as g, JsonValue as h, AGENT_EVENT_SCHEMA_VERSION as i, replay as k, AgentLogInit as l, CreateReplayEntryOptions as m, AgentEventLogStore as n, AgentEventLogError as o, AgentReplayDivergenceError as p, createInMemoryEventLogStore as r, AgentInitEvent as s, AgentEventLogConflictError as t, AgentLogVerification as u, ReplayResult as v, getLogExecutionId as w, assertJsonSerializable as x, agentCallOccurrence as y };
+export { rebindActorSession as A, createReplayEntry as C, getSnapshotStateHash as D, getLogExecutionId as E, replay as M, validateReplayEntries as N, getUsageFromEvents as O, assertJsonSerializable as S, getDecisionAttempts as T, NonSerializableAgentEventError as _, AGENT_INIT_EVENT_TYPE as a, agentCallOccurrence as b, AgentLogEntry as c, AgentMachineVersionMismatchError as d, AgentPersistedSnapshot as f, LogRecorder as g, JsonValue as h, AGENT_EVENT_SCHEMA_VERSION as i, recordLog as j, initEntry as k, AgentLogInit as l, CreateReplayEntryOptions as m, AgentEventLogStore as n, AgentEventLogError as o, AgentReplayDivergenceError as p, createInMemoryEventLogStore as r, AgentInitEvent as s, AgentEventLogConflictError as t, AgentLogVerification as u, ReplayOptions as v, forkEventLog as w, assertAgentLogEntry as x, ReplayResult as y };

package/dist/event-log-store-DZR4IIWe.cjs

@@ -0,0 +1,95 @@
+const require_event_log = require("./event-log-BZRfBRd7.cjs");
+//#region src/event-log-store.ts
+/**
+* Durable storage for {@link AgentLogEntry} logs: the one interface a host
+* implements, plus the in-memory reference implementation the conformance
+* suite is written against.
+* @module
+*/
+/**
+* Rejection from {@link AgentEventLogStore.append} when the thread's stored
+* length is not the `expectedIndex` the writer held — a concurrent writer
+* appended first. `actualIndex` is the next index the store would accept.
+*/
+var AgentEventLogConflictError = class extends require_event_log.AgentError {
+	threadId;
+	expectedIndex;
+	actualIndex;
+	constructor(threadId, expectedIndex, actualIndex) {
+		super("event-log-conflict", `AgentEventLogStore.append: index conflict on thread "${threadId}": expected index ${expectedIndex} but found ${actualIndex} — a concurrent writer won.`);
+		this.name = "AgentEventLogConflictError";
+		this.threadId = threadId;
+		this.expectedIndex = expectedIndex;
+		this.actualIndex = actualIndex;
+	}
+};
+/**
+* In-memory reference store, and the baseline the conformance suite runs
+* against. Per-thread entries are held in a contiguous, index-ordered list;
+* append's check-and-push runs synchronously (no `await` between reading the
+* length and writing), so two appends racing on the same `expectedIndex`
+* resolve to exactly one winner. Every stored and returned entry is
+* `structuredClone`d, so a caller can neither mutate stored state through a
+* value it appended nor through a value it read.
+*/
+function createInMemoryEventLogStore() {
+	const threads = /* @__PURE__ */ new Map();
+	const clone = (value) => structuredClone(value);
+	return {
+		async append({ threadId, expectedIndex, entries }) {
+			for (const entry of entries) require_event_log.assertAgentLogEntry(entry);
+			for (let i = 0; i < entries.length; i++) if (entries[i].index !== expectedIndex + i) throw new Error(`AgentEventLogStore.append: entry.index (${entries[i].index}) must be contiguous from expectedIndex (${expectedIndex}); expected ${expectedIndex + i} at position ${i} on thread "${threadId}".`);
+			const list = threads.get(threadId);
+			const length = list ? list.length : 0;
+			if (length !== expectedIndex) throw new AgentEventLogConflictError(threadId, expectedIndex, length);
+			const ids = new Set((list ?? []).map((entry) => entry.id));
+			for (const entry of entries) {
+				if (ids.has(entry.id)) throw new Error(`AgentEventLogStore.append: duplicate event id "${entry.id}" in thread "${threadId}".`);
+				ids.add(entry.id);
+			}
+			const cloned = entries.map((entry) => clone(entry));
+			if (list) for (const entry of cloned) list.push(entry);
+			else threads.set(threadId, cloned);
+		},
+		async read(threadId, options) {
+			const list = threads.get(threadId) ?? [];
+			const from = options?.from ?? 0;
+			return list.slice(from).map((entry) => clone(entry));
+		},
+		async length(threadId) {
+			return threads.get(threadId)?.length ?? 0;
+		},
+		async fork({ threadId, newThreadId, upToIndex }) {
+			if ((threads.get(newThreadId)?.length ?? 0) > 0) throw new Error(`AgentEventLogStore.fork: newThreadId "${newThreadId}" already has entries.`);
+			const source = threads.get(threadId);
+			if (!source) throw new Error(`AgentEventLogStore.fork: unknown source thread "${threadId}".`);
+			const upTo = upToIndex ?? source.length;
+			if (!Number.isInteger(upTo) || upTo < 1 || upTo > source.length) throw new Error(`AgentEventLogStore.fork: upToIndex must be an integer in [1, ${source.length}] on thread "${threadId}"; got ${String(upTo)}.`);
+			threads.set(newThreadId, source.slice(0, upTo).map((entry) => clone(entry)));
+		},
+		async listThreads(options = {}) {
+			const { prefix = "", limit, cursor } = options;
+			if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1)) throw new Error(`AgentEventLogStore.listThreads: limit must be a positive integer; got ${String(limit)}.`);
+			const ids = [...threads].filter(([id, list]) => list.length > 0 && id.startsWith(prefix)).map(([id]) => id).filter((id) => cursor === void 0 || id > cursor).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+			if (limit === void 0 || ids.length <= limit) return { threadIds: ids };
+			const page = ids.slice(0, limit);
+			return {
+				threadIds: page,
+				cursor: page[page.length - 1]
+			};
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "AgentEventLogConflictError", {
+	enumerable: true,
+	get: function() {
+		return AgentEventLogConflictError;
+	}
+});
+Object.defineProperty(exports, "createInMemoryEventLogStore", {
+	enumerable: true,
+	get: function() {
+		return createInMemoryEventLogStore;
+	}
+});

package/dist/event-log-store-DsP6GCRh.mjs

@@ -0,0 +1,84 @@
+import { c as assertAgentLogEntry, st as AgentError } from "./event-log-DJCMHek_.mjs";
+//#region src/event-log-store.ts
+/**
+* Durable storage for {@link AgentLogEntry} logs: the one interface a host
+* implements, plus the in-memory reference implementation the conformance
+* suite is written against.
+* @module
+*/
+/**
+* Rejection from {@link AgentEventLogStore.append} when the thread's stored
+* length is not the `expectedIndex` the writer held — a concurrent writer
+* appended first. `actualIndex` is the next index the store would accept.
+*/
+var AgentEventLogConflictError = class extends AgentError {
+	threadId;
+	expectedIndex;
+	actualIndex;
+	constructor(threadId, expectedIndex, actualIndex) {
+		super("event-log-conflict", `AgentEventLogStore.append: index conflict on thread "${threadId}": expected index ${expectedIndex} but found ${actualIndex} — a concurrent writer won.`);
+		this.name = "AgentEventLogConflictError";
+		this.threadId = threadId;
+		this.expectedIndex = expectedIndex;
+		this.actualIndex = actualIndex;
+	}
+};
+/**
+* In-memory reference store, and the baseline the conformance suite runs
+* against. Per-thread entries are held in a contiguous, index-ordered list;
+* append's check-and-push runs synchronously (no `await` between reading the
+* length and writing), so two appends racing on the same `expectedIndex`
+* resolve to exactly one winner. Every stored and returned entry is
+* `structuredClone`d, so a caller can neither mutate stored state through a
+* value it appended nor through a value it read.
+*/
+function createInMemoryEventLogStore() {
+	const threads = /* @__PURE__ */ new Map();
+	const clone = (value) => structuredClone(value);
+	return {
+		async append({ threadId, expectedIndex, entries }) {
+			for (const entry of entries) assertAgentLogEntry(entry);
+			for (let i = 0; i < entries.length; i++) if (entries[i].index !== expectedIndex + i) throw new Error(`AgentEventLogStore.append: entry.index (${entries[i].index}) must be contiguous from expectedIndex (${expectedIndex}); expected ${expectedIndex + i} at position ${i} on thread "${threadId}".`);
+			const list = threads.get(threadId);
+			const length = list ? list.length : 0;
+			if (length !== expectedIndex) throw new AgentEventLogConflictError(threadId, expectedIndex, length);
+			const ids = new Set((list ?? []).map((entry) => entry.id));
+			for (const entry of entries) {
+				if (ids.has(entry.id)) throw new Error(`AgentEventLogStore.append: duplicate event id "${entry.id}" in thread "${threadId}".`);
+				ids.add(entry.id);
+			}
+			const cloned = entries.map((entry) => clone(entry));
+			if (list) for (const entry of cloned) list.push(entry);
+			else threads.set(threadId, cloned);
+		},
+		async read(threadId, options) {
+			const list = threads.get(threadId) ?? [];
+			const from = options?.from ?? 0;
+			return list.slice(from).map((entry) => clone(entry));
+		},
+		async length(threadId) {
+			return threads.get(threadId)?.length ?? 0;
+		},
+		async fork({ threadId, newThreadId, upToIndex }) {
+			if ((threads.get(newThreadId)?.length ?? 0) > 0) throw new Error(`AgentEventLogStore.fork: newThreadId "${newThreadId}" already has entries.`);
+			const source = threads.get(threadId);
+			if (!source) throw new Error(`AgentEventLogStore.fork: unknown source thread "${threadId}".`);
+			const upTo = upToIndex ?? source.length;
+			if (!Number.isInteger(upTo) || upTo < 1 || upTo > source.length) throw new Error(`AgentEventLogStore.fork: upToIndex must be an integer in [1, ${source.length}] on thread "${threadId}"; got ${String(upTo)}.`);
+			threads.set(newThreadId, source.slice(0, upTo).map((entry) => clone(entry)));
+		},
+		async listThreads(options = {}) {
+			const { prefix = "", limit, cursor } = options;
+			if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1)) throw new Error(`AgentEventLogStore.listThreads: limit must be a positive integer; got ${String(limit)}.`);
+			const ids = [...threads].filter(([id, list]) => list.length > 0 && id.startsWith(prefix)).map(([id]) => id).filter((id) => cursor === void 0 || id > cursor).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+			if (limit === void 0 || ids.length <= limit) return { threadIds: ids };
+			const page = ids.slice(0, limit);
+			return {
+				threadIds: page,
+				cursor: page[page.length - 1]
+			};
+		}
+	};
+}
+//#endregion
+export { createInMemoryEventLogStore as n, AgentEventLogConflictError as t };