@statelyai/agent 2.0.0-alpha.29 → 2.0.0-alpha.31

package/dist/openai.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_event_log = require("./event-log-Dtb16p1p.cjs");
-const require_decision = require("./decision-oevZnkBe.cjs");
+const require_event_log = require("./event-log-Bdww2l1D.cjs");
+const require_decision = require("./decision-Iys2hzg3.cjs");
 //#region src/openai/index.ts
 /** Thrown for a message part Chat Completions cannot carry — dropping it would
 * silently change what the model sees. */
@@ -284,7 +284,7 @@ function toToolContent(output) {
 * ```ts
 * const executors = createOpenAiExecutors({
 *   client: new OpenAI(),
-*   resolveModel: () => 'gpt-5.4-mini',
+*   resolveModel: () => 'gpt-6-luna',
 * });
 * const result = await runToQuiescence(createAgentRuntime(machine, { executors }), { input });
 * ```

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-9fv1i9aK.cjs";
+import { N as AgentDecisionRequest, W as AgentEventDescriptor, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-j9hShB7d.cjs";
 import OpenAI from "openai";
 import { ChatCompletion, ChatCompletionCreateParamsNonStreaming, ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources/chat/completions/completions.js";
 //#region src/openai/index.d.ts
@@ -170,7 +170,7 @@ export declare function addAgentCallUsage(total: AgentCallUsage | undefined, nex
  * ```ts
  * const executors = createOpenAiExecutors({
  *   client: new OpenAI(),
- *   resolveModel: () => 'gpt-5.4-mini',
+ *   resolveModel: () => 'gpt-6-luna',
  * });
  * const result = await runToQuiescence(createAgentRuntime(machine, { executors }), { input });
  * ```

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-BDbGjYMh.mjs";
+import { N as AgentDecisionRequest, W as AgentEventDescriptor, c as AgentRequestExecutorInfo, f as AgentTextRequest, r as AgentFinishReason, t as AgentCallUsage } from "./text-logic-BwdrDpO9.mjs";
 import OpenAI from "openai";
 import { ChatCompletion, ChatCompletionCreateParamsNonStreaming, ChatCompletionMessageParam, ChatCompletionTool } from "openai/resources/chat/completions/completions.js";
 //#region src/openai/index.d.ts
@@ -170,7 +170,7 @@ export declare function addAgentCallUsage(total: AgentCallUsage | undefined, nex
  * ```ts
  * const executors = createOpenAiExecutors({
  *   client: new OpenAI(),
- *   resolveModel: () => 'gpt-5.4-mini',
+ *   resolveModel: () => 'gpt-6-luna',
  * });
  * const result = await runToQuiescence(createAgentRuntime(machine, { executors }), { input });
  * ```

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-GPZO9p7_.mjs";
-import { c as renderDecisionAttempts } from "./decision-Bl_rKQnU.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-DE430ZCa.mjs";
+import { c as renderDecisionAttempts } from "./decision-DqO018Tp.mjs";
 //#region src/openai/index.ts
 /** Thrown for a message part Chat Completions cannot carry — dropping it would
 * silently change what the model sees. */
@@ -283,7 +283,7 @@ function toToolContent(output) {
 * ```ts
 * const executors = createOpenAiExecutors({
 *   client: new OpenAI(),
-*   resolveModel: () => 'gpt-5.4-mini',
+*   resolveModel: () => 'gpt-6-luna',
 * });
 * const result = await runToQuiescence(createAgentRuntime(machine, { executors }), { input });
 * ```

package/dist/otel.d.cts

@@ -1,4 +1,4 @@
-import { g as AgentTraceEvent } from "./run-agent-C9ubX8Tx.cjs";
+import { g as AgentTraceEvent } from "./run-agent-B5opVUxx.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-CxSyZmIE.mjs";
+import { g as AgentTraceEvent } from "./run-agent-D4MwS5GY.mjs";
 import { Attributes, Tracer, TracerProvider } from "@opentelemetry/api";
 //#region src/otel/index.d.ts
 /** Options for {@link createOtelTraceHandler}. */

package/dist/{run-agent-C9ubX8Tx.d.cts → run-agent-B5opVUxx.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-9fv1i9aK.cjs";
-import { n as AgentUsageEvent } from "./usage-R1NTmLxY.cjs";
-import { c as AgentLogEntry, n as AgentEventLogStore } from "./event-log-store-CN9ygggF.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-j9hShB7d.cjs";
+import { n as AgentUsageEvent } from "./usage-BYqv7VBw.cjs";
+import { c as AgentLogEntry, h as JsonValue$1, n as AgentEventLogStore } from "./event-log-store-DTf_OzB-.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,11 +253,23 @@ 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;
+  /**
+   * Host-owned JSON stored on the log's `@agent.init` entry when this run
+   * starts a log: what produced the run, such as a policy version, the model
+   * ids, or the scenario. A resume keeps the stamp of the run that started
+   * the log; a version bridge, which opens a new log segment, takes this
+   * run's. `executionId` and `migratedFrom` are reserved and cannot be set here.
+   */
+  metadata?: Record<string, JsonValue$1>;
   /** Actor source implementations, merged onto the machine before binding — sugar for `machine.provide({ actors })` ahead of the run. */
   actors?: Record<string, AnyActorLogic>;
   /**

package/dist/{run-agent-CxSyZmIE.d.mts → run-agent-D4MwS5GY.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-BDbGjYMh.mjs";
-import { n as AgentUsageEvent } from "./usage-D8UphgEA.mjs";
-import { c as AgentLogEntry, n as AgentEventLogStore } from "./event-log-store-DS836wch.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-BwdrDpO9.mjs";
+import { n as AgentUsageEvent } from "./usage-Bl4nK8D-.mjs";
+import { c as AgentLogEntry, h as JsonValue$1, n as AgentEventLogStore } from "./event-log-store-RziIobdW.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,11 +253,23 @@ 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;
+  /**
+   * Host-owned JSON stored on the log's `@agent.init` entry when this run
+   * starts a log: what produced the run, such as a policy version, the model
+   * ids, or the scenario. A resume keeps the stamp of the run that started
+   * the log; a version bridge, which opens a new log segment, takes this
+   * run's. `executionId` and `migratedFrom` are reserved and cannot be set here.
+   */
+  metadata?: Record<string, JsonValue$1>;
   /** Actor source implementations, merged onto the machine before binding — sugar for `machine.provide({ actors })` ahead of the run. */
   actors?: Record<string, AnyActorLogic>;
   /**

package/dist/{run-agent-CuQT1xSS.mjs → run-agent-DWZ1uyBJ.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-GPZO9p7_.mjs";
-import { d as getAcceptedEvents, l as resolveDecision, n as acceptedDecisionOptions, s as isDecisionLogic, t as AgentDecisionExhaustedError } from "./decision-Bl_rKQnU.mjs";
-import { t as AgentEventLogConflictError } from "./event-log-store-yalq8C77.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-DE430ZCa.mjs";
+import { d as getAcceptedEvents, f as getHumanEventTypes, l as resolveDecision, n as acceptedDecisionOptions, s as isDecisionLogic, t as AgentDecisionExhaustedError } from "./decision-DqO018Tp.mjs";
+import { t as AgentEventLogConflictError } from "./event-log-store-CCWdTPEP.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);
@@ -918,6 +934,8 @@ function createAgentRuntime(machine, options = {}) {
 	let traceSeq = 0;
 	const machineId = machine.config.id ?? machine.id ?? "(machine)";
 	const machineVersion = resolveMachineVersion(machine);
+	if (options.metadata !== void 0) assertJsonSerializable(options.metadata, "metadata");
+	const initMetadata = options.metadata === void 0 ? void 0 : structuredClone(options.metadata);
 	const onTrace = createTraceDispatch({
 		onTrace: (payload) => {
 			options.onTrace?.({
@@ -998,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,
@@ -1016,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 = {}) => {
@@ -1191,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);
@@ -1246,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. */
@@ -1267,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 = () => {
@@ -1292,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 = () => {
@@ -1370,16 +1424,23 @@ function createAgentRuntime(machine, options = {}) {
 						logIndex: resumeEvents.length
 					};
 					seedInitEntry = () => appendInitEntry(snapshotInitCandidates(), {
+						...initMetadata,
 						...logExecutionId !== void 0 ? { executionId: logExecutionId } : {},
 						migratedFrom
 					});
 				}
 			} else if (init.snapshot !== void 0) {
 				logExecutionId = crypto.randomUUID();
-				seedInitEntry = () => appendInitEntry(snapshotInitCandidates(), { executionId: logExecutionId });
+				seedInitEntry = () => appendInitEntry(snapshotInitCandidates(), {
+					...initMetadata,
+					executionId: logExecutionId
+				});
 			} else {
 				logExecutionId = crypto.randomUUID();
-				seedInitEntry = () => appendInitEntry([resolvedInput !== void 0 ? { input: resolvedInput } : {}], { executionId: logExecutionId });
+				seedInitEntry = () => appendInitEntry([resolvedInput !== void 0 ? { input: resolvedInput } : {}], {
+					...initMetadata,
+					executionId: logExecutionId
+				});
 			}
 			const resumedHistory = [...logEntries];
 			const siteCallCounts = /* @__PURE__ */ new Map();
@@ -1447,9 +1508,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) {