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

package/dist/log.mjs

@@ -1,5 +1,5 @@
-import { S as validateReplayEntries, _ as getUsageFromEvents, a as AgentReplayDivergenceError, b as recordLog, c as assertAgentLogEntry, d as createReplayEntry, g as getSnapshotStateHash, h as getLogExecutionId, i as AgentMachineVersionMismatchError, l as assertJsonSerializable, m as getDecisionAttempts, n as AGENT_INIT_EVENT_TYPE, o as NonSerializableAgentEventError, p as forkEventLog, r as AgentEventLogError, s as agentCallOccurrence, t as AGENT_EVENT_SCHEMA_VERSION, v as initEntry, x as replay, y as rebindActorSession } from "./event-log-DJCMHek_.mjs";
-import { n as createInMemoryEventLogStore, t as AgentEventLogConflictError } from "./event-log-store-DsP6GCRh.mjs";
+import { S as validateReplayEntries, _ as getUsageFromEvents, a as AgentReplayDivergenceError, b as recordLog, c as assertAgentLogEntry, d as createReplayEntry, g as getSnapshotStateHash, h as getLogExecutionId, i as AgentMachineVersionMismatchError, l as assertJsonSerializable, m as getDecisionAttempts, n as AGENT_INIT_EVENT_TYPE, o as NonSerializableAgentEventError, p as forkEventLog, r as AgentEventLogError, s as agentCallOccurrence, t as AGENT_EVENT_SCHEMA_VERSION, v as initEntry, x as replay, y as rebindActorSession } from "./event-log-DAqsalT1.mjs";
+import { n as createInMemoryEventLogStore, t as AgentEventLogConflictError } from "./event-log-store-BGehvVTb.mjs";
 //#region src/event-log-store-conformance.ts
 /**
 * The runner-agnostic conformance suite for {@link AgentEventLogStore}
@@ -29,8 +29,11 @@ function entry(index, type, metadata) {
 		...metadata !== void 0 ? { metadata } : {}
 	};
 }
+function initFixture(executionId = "exec-src") {
+	return entry(0, AGENT_INIT_EVENT_TYPE, { executionId });
+}
 function entriesFrom(start, count) {
-	return Array.from({ length: count }, (_unused, i) => entry(start + i, `e${start + i}`));
+	return Array.from({ length: count }, (_unused, i) => start + i === 0 ? initFixture() : entry(start + i, `e${start + i}`));
 }
 function assertJsonEqual(actual, expected, message) {
 	const a = JSON.stringify(actual);
@@ -280,10 +283,42 @@ const cases = [
 				expectedIndex: 1,
 				entries: [entry(1, "branch")]
 			});
-			assertJsonEqual((await store.read("fork-1")).map((e) => e.event.type), ["e0", "branch"], "a forked thread must append independently from its copied length");
+			assertJsonEqual((await store.read("fork-1")).map((e) => e.event.type), [AGENT_INIT_EVENT_TYPE, "branch"], "a forked thread must append independently from its copied length");
 			if (await store.length("src") !== 3) fail("appending to a fork must not touch the source thread");
 		}
 	},
+	{
+		name: "a fork is its own lineage: a fresh executionId, and forkedFrom naming the parent",
+		async run(create) {
+			const store = await create();
+			const source = entriesFrom(0, 3);
+			await store.append({
+				threadId: "src",
+				expectedIndex: 0,
+				entries: source
+			});
+			await store.fork({
+				threadId: "src",
+				newThreadId: "fork-a",
+				upToIndex: 2
+			});
+			await store.fork({
+				threadId: "src",
+				newThreadId: "fork-b",
+				upToIndex: 2
+			});
+			const [a, b] = [await store.read("fork-a"), await store.read("fork-b")];
+			const ids = [getLogExecutionId(a), getLogExecutionId(b)];
+			if (typeof ids[0] !== "string" || typeof ids[1] !== "string") fail("a fork's init entry must carry a string metadata.executionId");
+			if (ids.includes("exec-src") || ids[0] === ids[1]) fail("every fork must mint its own executionId, not reuse the parent's or a sibling's");
+			assertJsonEqual(a[0].metadata?.forkedFrom, {
+				executionId: "exec-src",
+				logIndex: 2
+			}, "a fork's init entry must record forkedFrom: { executionId, logIndex }");
+			assertJsonEqual(a.slice(1), source.slice(1, 2), "a fork must copy every entry after the init entry unchanged");
+			assertJsonEqual(await store.read("src"), source, "forking must not touch the source thread");
+		}
+	},
 	{
 		name: "fork rejects a non-empty target, an unknown source, and an out-of-range cutoff (0 included)",
 		async run(create) {
@@ -356,7 +391,7 @@ const cases = [
 			]) await store.append({
 				threadId,
 				expectedIndex: 0,
-				entries: [entry(0, "start")]
+				entries: [initFixture()]
 			});
 			await store.fork({
 				threadId: "user:a",

package/dist/machines.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_setup_agent = require("./setup-agent-DoUk7EdC.cjs");
+const require_setup_agent = require("./setup-agent-CwUJyqKB.cjs");
 //#region src/machines/internal.ts
 /** The builtin inline text request every preset lowers a request entry to. */
 const GENERATE_TEXT_SRC = "agent.generateText";

package/dist/machines.mjs

@@ -1,4 +1,4 @@
-import { r as setupAgent } from "./setup-agent-7rV_cujV.mjs";
+import { r as setupAgent } from "./setup-agent-CmhB-U5P.mjs";
 //#region src/machines/internal.ts
 /** The builtin inline text request every preset lowers a request entry to. */
 const GENERATE_TEXT_SRC = "agent.generateText";

package/dist/{model-source-BCKg4qJ1.cjs → model-source-BQ97_l1-.cjs}

@@ -1,8 +1,7 @@
-const require_event_log = require("./event-log-BZRfBRd7.cjs");
-const require_decision = require("./decision-CIb7ddIv.cjs");
+const require_event_log = require("./event-log-CKWeC7H-.cjs");
 //#region src/internal/model-source.ts
 function hasEntries(value) {
-	return require_decision.isRecord(value) && Object.keys(value).length > 0;
+	return require_event_log.isRecord(value) && Object.keys(value).length > 0;
 }
 function isMachineLike(value) {
 	return "config" in value && typeof value.transition === "function";
@@ -25,13 +24,13 @@ function describeValue(value) {
 * model values are. Throws, naming what it got, for anything else. @internal
 */
 function resolveModelSource(adapter, source) {
-	if (require_decision.isRecord(source)) {
+	if (require_event_log.isRecord(source)) {
 		if (typeof source.createMachine === "function") {
 			if (hasEntries(source.models)) return { models: source.models };
 		} else if (isMachineLike(source)) {
 			const models = require_event_log.getAgentExecutionOptions(source)?.models;
 			if (hasEntries(models)) return { models };
-		} else if (require_decision.isRecord(source.models) || typeof source.resolveModel === "function") return source;
+		} else if (require_event_log.isRecord(source.models) || typeof source.resolveModel === "function") return source;
 	}
 	throw new TypeError(`${adapter}: expected { models }, { resolveModel }, a setupAgent(...) result with models, or a machine from its createMachine; got ${describeValue(source)}.`);
 }

package/dist/{model-source-BaHwJ1wK.mjs → model-source-BilDEyqk.mjs}

@@ -1,5 +1,4 @@
-import { H as getAgentExecutionOptions } from "./event-log-DJCMHek_.mjs";
-import { m as isRecord } from "./decision-BHkvuImD.mjs";
+import { H as getAgentExecutionOptions, lt as isRecord } from "./event-log-DAqsalT1.mjs";
 //#region src/internal/model-source.ts
 function hasEntries(value) {
 	return isRecord(value) && Object.keys(value).length > 0;

package/dist/openai.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_log = require("./event-log-BZRfBRd7.cjs");
-const require_decision = require("./decision-CIb7ddIv.cjs");
+const require_event_log = require("./event-log-CKWeC7H-.cjs");
+const require_decision = require("./decision-BPdEaxPf.cjs");
 //#region src/openai/index.ts
 /** Thrown for a message part Chat Completions cannot carry — dropping it would
 * silently change what the model sees. */

package/dist/openai.d.cts

@@ -1,5 +1,5 @@
 import { i as AgentToolChoice, n as AgentMessage, s as AgentTools, u as ChosenEvent } from "./types-Dp5_Ru4R.cjs";
-import { N as AgentDecisionRequest, W as AgentEventDescriptor, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-DmciuVUQ.cjs";
+import { N as AgentDecisionRequest, W as AgentEventDescriptor, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-CYP502VT.cjs";
 import OpenAI from "openai";
 import { ChatCompletion, ChatCompletionCreateParamsNonStreaming, ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources/chat/completions/completions.js";
 //#region src/openai/index.d.ts

package/dist/openai.d.mts

@@ -1,5 +1,5 @@
 import { i as AgentToolChoice, n as AgentMessage, s as AgentTools, u as ChosenEvent } from "./types-Dp5_Ru4R.mjs";
-import { N as AgentDecisionRequest, W as AgentEventDescriptor, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-BRYOPWvY.mjs";
+import { N as AgentDecisionRequest, W as AgentEventDescriptor, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-DuK9HIFM.mjs";
 import OpenAI from "openai";
 import { ChatCompletion, ChatCompletionCreateParamsNonStreaming, ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources/chat/completions/completions.js";
 //#region src/openai/index.d.ts

package/dist/openai.mjs

@@ -1,5 +1,5 @@
-import { L as parseProviderOutput, R as providerOutputSchema, X as getJsonSchemaSync, Y as getJsonSchema, ct as AgentTruncatedError, j as getAgentOutputMode, tt as isStandardSchema, w as AGENT_USAGE_TOKEN_FIELDS } from "./event-log-DJCMHek_.mjs";
-import { c as renderDecisionAttempts } from "./decision-BHkvuImD.mjs";
+import { L as parseProviderOutput, R as providerOutputSchema, X as getJsonSchemaSync, Y as getJsonSchema, dt as AgentTruncatedError, j as getAgentOutputMode, tt as isStandardSchema, w as AGENT_USAGE_TOKEN_FIELDS } from "./event-log-DAqsalT1.mjs";
+import { c as renderDecisionAttempts } from "./decision-CV7WiV5C.mjs";
 //#region src/openai/index.ts
 /** Thrown for a message part Chat Completions cannot carry — dropping it would
 * silently change what the model sees. */

package/dist/otel.d.cts

@@ -1,4 +1,4 @@
-import { g as AgentTraceEvent } from "./run-agent-CTlMc3Jb.cjs";
+import { g as AgentTraceEvent } from "./run-agent-B5QhabdY.cjs";
 import { Attributes, Tracer, TracerProvider } from "@opentelemetry/api";
 //#region src/otel/index.d.ts
 /** Options for {@link createOtelTraceHandler}. */

package/dist/otel.d.mts

@@ -1,4 +1,4 @@
-import { g as AgentTraceEvent } from "./run-agent-CAVt5R-r.mjs";
+import { g as AgentTraceEvent } from "./run-agent-Atu-wEk7.mjs";
 import { Attributes, Tracer, TracerProvider } from "@opentelemetry/api";
 //#region src/otel/index.d.ts
 /** Options for {@link createOtelTraceHandler}. */

package/dist/{run-agent-BpHqkaZw.mjs → run-agent-2UnSUhDb.mjs}

@@ -1,6 +1,6 @@
-import { B as responseMessagesOf, C as AGENT_USAGE_EVENT_TYPE, F as normalizeGeneratorResult, J as findNonSerializableContextPaths, M as getCallFinishReason, N as getCallUsage, P as isTextLogic, S as validateReplayEntries, U as getRegisteredAgentExecutionOptions, V as executorBoundLogics, W as isUnboundPlaceholder, _ as getUsageFromEvents, d as createReplayEntry, f as foldLog, g as getSnapshotStateHash, h as getLogExecutionId, i as AgentMachineVersionMismatchError, l as assertJsonSerializable, nt as resolveMachineVersion, ot as validateSchemaSync, s as agentCallOccurrence, st as AgentError, tt as isStandardSchema, u as canonicalEventJson, v as initEntry, x as replay } from "./event-log-DJCMHek_.mjs";
-import { d as getAcceptedEvents, l as resolveDecision, n as acceptedDecisionOptions, s as isDecisionLogic, t as AgentDecisionExhaustedError } from "./decision-BHkvuImD.mjs";
-import { t as AgentEventLogConflictError } from "./event-log-store-DsP6GCRh.mjs";
+import { B as responseMessagesOf, C as AGENT_USAGE_EVENT_TYPE, F as normalizeGeneratorResult, J as findNonSerializableContextPaths, M as getCallFinishReason, N as getCallUsage, P as isTextLogic, S as validateReplayEntries, U as getRegisteredAgentExecutionOptions, V as executorBoundLogics, W as isUnboundPlaceholder, _ as getUsageFromEvents, d as createReplayEntry, f as foldLog, g as getSnapshotStateHash, h as getLogExecutionId, i as AgentMachineVersionMismatchError, l as assertJsonSerializable, nt as resolveMachineVersion, ot as validateSchemaSync, s as agentCallOccurrence, st as canonicalJson, tt as isStandardSchema, u as canonicalEventJson, ut as AgentError, v as initEntry, x as replay } from "./event-log-DAqsalT1.mjs";
+import { d as getAcceptedEvents, f as getHumanEventTypes, l as resolveDecision, n as acceptedDecisionOptions, s as isDecisionLogic, t as AgentDecisionExhaustedError } from "./decision-CV7WiV5C.mjs";
+import { t as AgentEventLogConflictError } from "./event-log-store-BGehvVTb.mjs";
 import { createAsyncLogic, getNextTransitions, isMachineSnapshot, stopActor } from "xstate";
 import { createDurable } from "xstate/durable";
 //#region src/run-agent.ts
@@ -290,6 +290,13 @@ function unrebindableChildRequestError(childPath, stateName, requestSrc, kind) {
 function declaresUsageTransition(snapshot) {
 	return getNextTransitions(snapshot).some((transition) => transition.eventType === "@agent.usage" || transition.eventType === "*");
 }
+function observe(name, call) {
+	try {
+		call();
+	} catch (error) {
+		console.error(`@statelyai/agent: ${name} threw; the run continues.`, error);
+	}
+}
 /**
 * Builds the ONE place a trace payload is emitted: it hands the payload to the
 * envelope-stamping trace sink and, from that same payload, invokes the sugar
@@ -306,21 +313,21 @@ function createTraceDispatch(sinks) {
 	return (payload, self) => {
 		switch (payload.type) {
 			case "stream.chunk":
-				sinks.onTrace?.(payload, self);
-				sinks.onChunk?.(payload.chunk, { request: payload.request });
+				observe("onTrace", () => sinks.onTrace?.(payload, self));
+				observe("onChunk", () => sinks.onChunk?.(payload.chunk, { request: payload.request }));
 				return;
 			case "request.end":
-				sinks.onResult?.(payload.request, {
+				observe("onResult", () => sinks.onResult?.(payload.request, {
 					result: payload.output,
 					raw: payload.raw
-				});
-				sinks.onTrace?.(payload, self);
+				}));
+				observe("onTrace", () => sinks.onTrace?.(payload, self));
 				return;
 			case "machine.transition":
-				sinks.onTrace?.(payload, self);
-				sinks.onTransition?.(payload.snapshot, payload.event);
+				observe("onTrace", () => sinks.onTrace?.(payload, self));
+				observe("onTransition", () => sinks.onTransition?.(payload.snapshot, payload.event));
 				return;
-			default: sinks.onTrace?.(payload, self);
+			default: observe("onTrace", () => sinks.onTrace?.(payload, self));
 		}
 	};
 }
@@ -509,6 +516,11 @@ function bindDecisionLogic(logic, runCtx) {
 			schemas: runCtx.schemas,
 			eventTypes: declaredEventTypes
 		}) : [];
+		const agentCan = (event) => {
+			if (!actorRef) return true;
+			const snapshot = actorRef.getSnapshot();
+			return !getHumanEventTypes(snapshot).has(event.type) && snapshot.can(event);
+		};
 		const lowered = logic.request(input);
 		const request = {
 			...lowered,
@@ -521,7 +533,7 @@ function bindDecisionLogic(logic, runCtx) {
 		const options = acceptedDecisionOptions(request, (event) => {
 			let accepted;
 			try {
-				accepted = actorRef ? actorRef.getSnapshot().can(event) : true;
+				accepted = agentCan(event);
 			} catch {
 				accepted = false;
 			}
@@ -532,6 +544,10 @@ function bindDecisionLogic(logic, runCtx) {
 			request.options = options;
 			request.withheld = withheld;
 		}
+		if (actorRef) {
+			const humanEventTypes = getHumanEventTypes(actorRef.getSnapshot());
+			request.events = events.filter((event) => !humanEventTypes.has(event.type));
+		}
 		if (options?.length === 0) {
 			const error = new AgentDecisionExhaustedError([]);
 			error.message = `Decision '${request.name}' has no offered option the current snapshot accepts; no model call was made.`;
@@ -554,7 +570,7 @@ function bindDecisionLogic(logic, runCtx) {
 		} }, {
 			maxRetries: lowered.maxRetries ?? logic.maxRetries,
 			signal,
-			canTake: (event) => actorRef ? actorRef.getSnapshot().can(event) : true
+			canTake: agentCan
 		});
 		if (priorAttempts.length > 0) runCtx.noteDecision?.(chosen, priorAttempts);
 		actorRef?.send(chosen);
@@ -870,7 +886,7 @@ function assertThreadMatchesEvents(threadId, stored, events) {
 		const givenEntry = events[index];
 		const storedHash = storedEntry.verification?.stateHash;
 		const givenHash = givenEntry.verification?.stateHash;
-		if (!(storedEntry.id === givenEntry.id && storedEntry.index === givenEntry.index && canonicalEventJson(storedEntry.event) === canonicalEventJson(givenEntry.event) && (storedHash === void 0 || givenHash === void 0 || storedHash === givenHash))) throw new AgentError("event-log-conflict", `createAgentRuntime: the given \`events\` diverge from thread "${threadId}" at index ${index} (stored entry '${storedEntry.id}', given '${givenEntry.id}') — the log passed in is not this thread's log.`);
+		if (!(storedEntry.id === givenEntry.id && storedEntry.index === givenEntry.index && canonicalEventJson(storedEntry.event) === canonicalEventJson(givenEntry.event) && (storedHash === void 0 || givenHash === void 0 || storedHash === givenHash) && (index > 0 || getLogExecutionId([storedEntry]) === getLogExecutionId([givenEntry])))) throw new AgentError("event-log-conflict", `createAgentRuntime: the given \`events\` diverge from thread "${threadId}" at index ${index} (stored entry '${storedEntry.id}', given '${givenEntry.id}') — the log passed in is not this thread's log.`);
 	}
 }
 const QUIESCENT = Symbol("quiescent");
@@ -1000,13 +1016,32 @@ function createAgentRuntime(machine, options = {}) {
 	let loggingEnabled = true;
 	const attemptsByEvent = /* @__PURE__ */ new WeakMap();
 	let logFold;
+	const stopLogging = (error) => {
+		if (!loggingEnabled) return;
+		loggingEnabled = false;
+		if (store !== void 0) {
+			journalError ??= error;
+			stopRun({
+				cause: "journal",
+				error
+			});
+			return;
+		}
+		console.warn(`@statelyai/agent: this run's log stopped at entry ${logEntries.length}, so result.events is incomplete: ${error instanceof Error ? error.message : String(error)}. Pass input and events that JSON can hold.`);
+	};
 	const appendLogEntry = (event, attempts) => {
 		if (!loggingEnabled) return;
-		const entry = createReplayEntry(logMachine, logEntries, event, {
-			machineVersion,
-			verification: false,
-			...attempts !== void 0 ? { attempts } : {}
-		});
+		let entry;
+		try {
+			entry = createReplayEntry(logMachine, logEntries, event, {
+				machineVersion,
+				verification: false,
+				...attempts !== void 0 ? { attempts } : {}
+			});
+		} catch (error) {
+			stopLogging(error);
+			return;
+		}
 		if (verificationEnabled && logFold !== null) try {
 			logFold ??= foldLog(logMachine, logEntries, {
 				machineVersion,
@@ -1018,7 +1053,7 @@ function createAgentRuntime(machine, options = {}) {
 		}
 		logEntries.push(entry);
 		journalEntry(entry);
-		options.onEvent?.(entry);
+		observe("onEvent", () => options.onEvent?.(entry));
 		return entry;
 	};
 	const recordUsage = (usage, source = {}) => {
@@ -1193,8 +1228,8 @@ function createAgentRuntime(machine, options = {}) {
 			event
 		});
 		const on = options.on ?? {};
-		on[event.type]?.(event);
-		if (event.type !== "*") on["*"]?.(event);
+		observe(`on['${event.type}']`, () => on[event.type]?.(event));
+		if (event.type !== "*") observe("on['*']", () => on["*"]?.(event));
 	};
 	const inspect = options.inspect === void 0 ? void 0 : (event) => {
 		if (typeof options.inspect === "function") options.inspect(event);
@@ -1248,14 +1283,15 @@ function createAgentRuntime(machine, options = {}) {
 		}
 	}, inspect ? { inspect } : void 0);
 	const runErrorCause = (error) => budgetExceeded ? "max-model-calls" : wrapsDecisionExhausted(error) ? "decision-exhausted" : "machine";
-	const commit = (snapshot, event) => {
+	const commit = (snapshot, event, ignored = false) => {
 		const from = { value: (current ?? snapshot).value };
 		current = snapshot;
 		onTrace({
 			type: "machine.transition",
 			from,
 			snapshot,
-			event
+			event,
+			...ignored ? { ignored: true } : {}
 		});
 	};
 	/** True for a child completion/failure whose child is no longer running under the current state. */
@@ -1269,14 +1305,23 @@ function createAgentRuntime(machine, options = {}) {
 			if (started) throw new AgentError("runtime-started", "createAgentRuntime: `start` was already called.");
 			started = true;
 			let resumeEvents = init.events;
+			let resumedFromStore = false;
 			if (store !== void 0) {
 				const storedThread = await store.read(threadId);
 				if (resumeEvents !== void 0) {
 					if (storedThread.length !== resumeEvents.length) throw new AgentEventLogConflictError(threadId, resumeEvents.length, storedThread.length);
 					assertThreadMatchesEvents(threadId, storedThread, resumeEvents);
-				} else if (storedThread.length > 0) resumeEvents = storedThread;
+					resumedFromStore = storedThread.length > 0;
+				} else if (storedThread.length > 0) {
+					resumeEvents = storedThread;
+					resumedFromStore = true;
+				}
 			}
 			const resolvedInput = resolveMachineInput(machine, init.input);
+			const threadInit = resumeEvents?.[0]?.event;
+			if (resumedFromStore && init.input !== void 0 && threadInit !== void 0 && Object.hasOwn(threadInit, "input")) {
+				if (canonicalJson(threadInit.input) !== canonicalJson(resolvedInput)) throw new AgentError("thread-input-mismatch", `createAgentRuntime: thread '${threadId}' was started with different input. A thread that already has entries is resumed, not restarted; give a new run a new threadId.`);
+			}
 			let effectiveSnapshot = init.snapshot;
 			let seedInitEntry;
 			const restoredPersistedSnapshot = () => {
@@ -1294,18 +1339,25 @@ function createAgentRuntime(machine, options = {}) {
 			* run WITHOUT a log rather than failing it.
 			*/
 			const appendInitEntry = (candidates, metadata) => {
-				for (const candidate of candidates) for (const verification of verificationEnabled ? [true, false] : [false]) try {
-					const entry = initEntry(logMachine, candidate, {
-						machineVersion,
-						verification,
-						metadata
-					});
+				let lastError;
+				for (const candidate of candidates) for (const verification of verificationEnabled ? [true, false] : [false]) {
+					let entry;
+					try {
+						entry = initEntry(logMachine, candidate, {
+							machineVersion,
+							verification,
+							metadata
+						});
+					} catch (error) {
+						lastError = error;
+						continue;
+					}
 					logEntries.push(entry);
 					journalEntry(entry);
-					options.onEvent?.(entry);
+					observe("onEvent", () => options.onEvent?.(entry));
 					return;
-				} catch {}
-				loggingEnabled = false;
+				}
+				stopLogging(lastError);
 			};
 			/** Init forms for a snapshot resume, most faithful first. */
 			const snapshotInitCandidates = () => {
@@ -1355,7 +1407,9 @@ function createAgentRuntime(machine, options = {}) {
 						machineVersion: tail.machineVersion
 					});
 					const bridgeMeta = readAgentMeta(init.snapshot);
-					if (inheritedExecutionId === void 0 || bridgeMeta?.logId !== inheritedExecutionId) throw new AgentMachineVersionMismatchError(tail.id, tail.index, {
+					const forkedFrom = resumeEvents[0].metadata?.forkedFrom;
+					const parentCache = forkedFrom?.executionId !== void 0 && bridgeMeta?.logId === forkedFrom.executionId && forkedFrom.logIndex === resumeEvents.length;
+					if (inheritedExecutionId === void 0 || bridgeMeta?.logId !== inheritedExecutionId && !parentCache) throw new AgentMachineVersionMismatchError(tail.id, tail.index, {
 						machineId,
 						machineVersion
 					}, {
@@ -1456,9 +1510,11 @@ function createAgentRuntime(machine, options = {}) {
 			const attempts = transitionOptions?.attempts ?? attemptsByEvent.get(event);
 			if (transitionOptions?.attempts !== void 0) assertJsonSerializable(transitionOptions.attempts, "attempts");
 			const [next, effects] = execution.transition(state, event);
-			if (!fromMailbox.has(event) && next === state && effects.length === 0) ignoredEvent = event;
+			const ignored = !fromMailbox.has(event) && next === state && effects.length === 0;
+			if (ignored) ignoredEvent = event;
 			appendLogEntry(event, attempts);
-			commit(next, event);
+			if (stopReason !== void 0) return [state, []];
+			commit(next, event, ignored);
 			return [next, effects];
 		},
 		async execute(effects) {

package/dist/{run-agent-CAVt5R-r.d.mts → run-agent-Atu-wEk7.d.mts}

@@ -1,7 +1,7 @@
 import { _ as StandardSchemaV1, m as InferInput, s as AgentTools, w as WithAgentInputSchema } from "./types-Dp5_Ru4R.mjs";
-import { I as DecisionAttempt, N as AgentDecisionRequest, Q as AgentError, W as AgentEventDescriptor, d as AgentRequestMode, f as AgentTextRequest, m as AgentUsage, q as AgentRequestSource, r as AgentFinishReason, t as AgentCallUsage, u as AgentRequestExecutors } from "./text-logic-BRYOPWvY.mjs";
-import { n as AgentUsageEvent } from "./usage-BkM3z02Y.mjs";
-import { c as AgentLogEntry, h as JsonValue$1, n as AgentEventLogStore } from "./event-log-store-CIIJohjj.mjs";
+import { I as DecisionAttempt, N as AgentDecisionRequest, Q as AgentError, W as AgentEventDescriptor, d as AgentRequestMode, f as AgentTextRequest, m as AgentUsage, q as AgentRequestSource, r as AgentFinishReason, t as AgentCallUsage, u as AgentRequestExecutors } from "./text-logic-DuK9HIFM.mjs";
+import { n as AgentUsageEvent } from "./usage-D7JKAxLc.mjs";
+import { c as AgentLogEntry, h as JsonValue$1, n as AgentEventLogStore } from "./event-log-store-C2NjVlWU.mjs";
 import { AnyActorLogic, AnyActorRef, AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EmittedFrom, EventFromLogic, EventObject, InputFrom, InspectionEvent, OutputFrom, Snapshot, SnapshotFrom, StateValue } from "xstate";
 import { DurableExecution } from "xstate/durable";
 //#region src/steps.d.ts
@@ -121,6 +121,13 @@ type AgentTraceEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
   };
   snapshot: SnapshotFrom<TMachine>;
   event: EventFromLogic<TMachine>;
+  /**
+   * `true` when the host's own event (the run's opening `event`, or one
+   * sent with `runtime.transition`) had no transition in this state, so
+   * nothing changed: the same event {@link AgentRunResult.ignored}
+   * reports. Absent otherwise.
+   */
+  ignored?: true;
 } | {
   type: "emit";
   event: EmittedFrom<TMachine>;
@@ -246,9 +253,13 @@ interface AgentRuntimeOptions<TMachine extends AnyStateMachine> {
   onEvent?: (entry: AgentLogEntry) => void;
   /**
    * Record a `verification.stateHash` on every appended entry (default `true`).
-   * The hash is taken O(1) from the live actor's persisted snapshot right after
-   * that entry's transition, so `replay(machine, events)` can prove it lands on
-   * the same state. Set `false` for a smaller, unverifiable log.
+   * The hash is of the state the log folds to after that entry, the same fold
+   * `replay` runs, so `replay(machine, events)` can check each entry against
+   * the fold before it. It does not show the log is complete (a dropped last
+   * entry leaves the rest intact), nor compare against the live snapshot: a
+   * machine that reads something the log does not keep (an error's class, a
+   * non-JSON field) can replay to a different state. Set `false` for a
+   * smaller, unverifiable log.
    */
   verification?: boolean;
   /**

package/dist/{run-agent-CTlMc3Jb.d.cts → run-agent-B5QhabdY.d.cts}

@@ -1,7 +1,7 @@
 import { _ as StandardSchemaV1, m as InferInput, s as AgentTools, w as WithAgentInputSchema } from "./types-Dp5_Ru4R.cjs";
-import { I as DecisionAttempt, N as AgentDecisionRequest, Q as AgentError, W as AgentEventDescriptor, d as AgentRequestMode, f as AgentTextRequest, m as AgentUsage, q as AgentRequestSource, r as AgentFinishReason, t as AgentCallUsage, u as AgentRequestExecutors } from "./text-logic-DmciuVUQ.cjs";
-import { n as AgentUsageEvent } from "./usage-Cm_ovz9V.cjs";
-import { c as AgentLogEntry, h as JsonValue$1, n as AgentEventLogStore } from "./event-log-store-CLAC9q2Y.cjs";
+import { I as DecisionAttempt, N as AgentDecisionRequest, Q as AgentError, W as AgentEventDescriptor, d as AgentRequestMode, f as AgentTextRequest, m as AgentUsage, q as AgentRequestSource, r as AgentFinishReason, t as AgentCallUsage, u as AgentRequestExecutors } from "./text-logic-CYP502VT.cjs";
+import { n as AgentUsageEvent } from "./usage-DVw-646x.cjs";
+import { c as AgentLogEntry, h as JsonValue$1, n as AgentEventLogStore } from "./event-log-store-s73r1Hxf.cjs";
 import { AnyActorLogic, AnyActorRef, AnyMachineSnapshot, AnyStateMachine, AsyncActorLogic, EmittedFrom, EventFromLogic, EventObject, InputFrom, InspectionEvent, OutputFrom, Snapshot, SnapshotFrom, StateValue } from "xstate";
 import { DurableExecution } from "xstate/durable";
 //#region src/steps.d.ts
@@ -121,6 +121,13 @@ type AgentTraceEvent<TMachine extends AnyStateMachine = AnyStateMachine> = {
   };
   snapshot: SnapshotFrom<TMachine>;
   event: EventFromLogic<TMachine>;
+  /**
+   * `true` when the host's own event (the run's opening `event`, or one
+   * sent with `runtime.transition`) had no transition in this state, so
+   * nothing changed: the same event {@link AgentRunResult.ignored}
+   * reports. Absent otherwise.
+   */
+  ignored?: true;
 } | {
   type: "emit";
   event: EmittedFrom<TMachine>;
@@ -246,9 +253,13 @@ interface AgentRuntimeOptions<TMachine extends AnyStateMachine> {
   onEvent?: (entry: AgentLogEntry) => void;
   /**
    * Record a `verification.stateHash` on every appended entry (default `true`).
-   * The hash is taken O(1) from the live actor's persisted snapshot right after
-   * that entry's transition, so `replay(machine, events)` can prove it lands on
-   * the same state. Set `false` for a smaller, unverifiable log.
+   * The hash is of the state the log folds to after that entry, the same fold
+   * `replay` runs, so `replay(machine, events)` can check each entry against
+   * the fold before it. It does not show the log is complete (a dropped last
+   * entry leaves the rest intact), nor compare against the live snapshot: a
+   * machine that reads something the log does not keep (an error's class, a
+   * non-JSON field) can replay to a different state. Set `false` for a
+   * smaller, unverifiable log.
    */
   verification?: boolean;
   /**