zidane 6.4.3 → 6.5.0

package/dist/restate.js

@@ -1,6 +1,6 @@
 import { n as buildAliasMaps } from "./aliasing-lVFbm81n.js";
 import { r as coerceToolResultContent } from "./types-BIarq1qE.js";
-import { a as hydrateReadStateFromSessionAsync } from "./read-state-Dt7UbVsd.js";
+import { i as stagedToolState, l as hydrateReadStateFromSessionAsync, r as isToolStateOps } from "./tool-state-DTs-3ZHH.js";
 import { createHash } from "node:crypto";
 //#region src/restate/awakeable.ts
 /**
@@ -182,7 +182,8 @@ function restateClock(ctx, options = {}) {
 	const randomUUID = () => deterministicUuid(`${idSeed}:uuid:${idSeq++}`);
 	if (!coalesce) return {
 		now: () => ctx.date.now(),
-		randomUUID
+		randomUUID,
+		journaled: true
 	};
 	const requested = typeof coalesce === "object" ? coalesce.reanchorEvery : void 0;
 	const reanchorEvery = typeof requested === "number" && Number.isFinite(requested) && requested >= 1 ? Math.floor(requested) : DEFAULT_REANCHOR_EVERY;
@@ -201,7 +202,8 @@ function restateClock(ctx, options = {}) {
 			lastReturned = value;
 			return value;
 		},
-		randomUUID
+		randomUUID,
+		journaled: true
 	};
 }
 //#endregion
@@ -318,26 +320,52 @@ function restateTool(inner, ctx, options = {}) {
 		return ctx.run(nameFor(seq, canonicalName, input, toolCtx.callId), async () => {
 			options.replayTracker?.markLive();
 			await hydrateOnce(toolCtx);
+			const staged = stagedToolState(toolCtx.state);
+			staged?.clear();
 			if (shellBackgroundDisabled && input.run_in_background === true) return SHELL_BACKGROUND_DISABLED_MESSAGE;
 			if (!softErrors) {
 				const out = await inner.execute(input, toolCtx);
-				return coerceBlocks ? coerceToolResultContent(out) : out;
+				return attachToolState(coerceBlocks ? coerceToolResultContent(out) : out, staged);
 			}
 			try {
 				const out = await inner.execute(input, toolCtx);
-				return coerceBlocks ? coerceToolResultContent(out) : out;
+				return attachToolState(coerceBlocks ? coerceToolResultContent(out) : out, staged);
 			} catch (err) {
 				if (isRestateControlOrAbort(err, toolCtx.signal)) throw err;
-				return makeSoftToolError(err);
+				return attachToolState(makeSoftToolError(err), staged);
 			}
 		}, runOpts);
 	};
-	const executeDurably = softErrors ? async (input, toolCtx) => rethrowSoftToolError(await runJournaled(input, toolCtx)) : runJournaled;
-	const durableExecuteImpl = softErrors ? (input, toolCtx) => unwrapDurableSoftError(runJournaled(input, toolCtx)) : runJournaled;
-	const executeTwoPhase = async (input, toolCtx) => {
+	const finishJournaled = async (journaled, staged) => {
+		let value;
+		try {
+			value = await journaled;
+		} catch (err) {
+			staged?.clear();
+			throw err;
+		}
+		const output = applyToolState(value, staged);
+		return softErrors ? rethrowSoftToolError(output) : output;
+	};
+	const executeDurably = (input, toolCtx) => {
+		const staged = stagedToolState(toolCtx.state);
+		if (!softErrors && !staged) return runJournaled(input, toolCtx);
+		return finishJournaled(runJournaled(input, toolCtx), staged);
+	};
+	const durableExecuteImpl = (input, toolCtx) => {
+		const staged = stagedToolState(toolCtx.state);
+		if (!softErrors && !staged) return runJournaled(input, toolCtx);
+		return unwrapDurableToolValue(runJournaled(input, toolCtx), staged, softErrors);
+	};
+	const executeTwoPhaseInner = async (input, toolCtx) => {
 		const start = durableStart;
+		const staged = stagedToolState(toolCtx.state);
 		seq += 1;
 		const entry = nameFor(seq, canonicalName, input, toolCtx.callId);
+		const runFinal = async (body) => applyToolState(await ctx.run(entry, async () => {
+			options.replayTracker?.markLive();
+			return attachToolState(await body(), staged);
+		}, runOpts), staged);
 		const token = await ctx.run(`${entry}-start`, async () => {
 			options.replayTracker?.markLive();
 			await hydrateOnce(toolCtx);
@@ -356,17 +384,11 @@ function restateTool(inner, ctx, options = {}) {
 		const wait = start.wait;
 		if (wait) {
 			if (wait.inline?.(token, input, toolCtx)) {
-				if (!onAbort || !signal) return await ctx.run(entry, () => {
-					options.replayTracker?.markLive();
-					return wait.result(token, null, input, toolCtx);
-				}, runOpts);
+				if (!onAbort || !signal) return await runFinal(() => wait.result(token, null, input, toolCtx));
 				if (signal.aborted) fireAbortCleanup();
 				else signal.addEventListener("abort", fireAbortCleanup, { once: true });
 				try {
-					return await ctx.run(entry, () => {
-						options.replayTracker?.markLive();
-						return wait.result(token, null, input, toolCtx);
-					}, runOpts);
+					return await runFinal(() => wait.result(token, null, input, toolCtx));
 				} finally {
 					signal.removeEventListener("abort", fireAbortCleanup);
 				}
@@ -392,18 +414,12 @@ function restateTool(inner, ctx, options = {}) {
 				}, runOpts);
 				if (marker.awakeableId !== awakeable.id) throw new Error(`restateTool(${canonicalName}): journal drift — registration marker carries awakeable "${marker.awakeableId}" but this replay minted "${awakeable.id}". Refusing to park on an unreachable awakeable.`);
 				const resumed = await parkWithSignal(awakeable.promise, signal, canonicalName);
-				return await ctx.run(entry, () => {
-					options.replayTracker?.markLive();
-					return wait.result(token, resumed, input, toolCtx);
-				}, runOpts);
+				return await runFinal(() => wait.result(token, resumed, input, toolCtx));
 			} finally {
 				signal?.removeEventListener("abort", fireAbortCleanup);
 			}
 		}
-		const attach = () => ctx.run(entry, () => {
-			options.replayTracker?.markLive();
-			return start.attach(token, input, toolCtx);
-		}, runOpts);
+		const attach = () => runFinal(() => start.attach(token, input, toolCtx));
 		if (!onAbort || !signal) return attach();
 		if (signal.aborted) {
 			fireAbortCleanup();
@@ -416,6 +432,15 @@ function restateTool(inner, ctx, options = {}) {
 			signal.removeEventListener("abort", fireAbortCleanup);
 		}
 	};
+	const executeTwoPhase = async (input, toolCtx) => {
+		const staged = stagedToolState(toolCtx.state);
+		try {
+			return await executeTwoPhaseInner(input, toolCtx);
+		} catch (err) {
+			staged?.clear();
+			throw err;
+		}
+	};
 	if (durableStart) {
 		const { durableExecute: _dropped, ...rest } = inner;
 		return {
@@ -431,20 +456,59 @@ function restateTool(inner, ctx, options = {}) {
 		durableExecute: durableExecuteImpl
 	};
 }
+function isToolStateEnvelope(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const candidate = value;
+	return candidate.__zidaneToolState === 1 && Array.isArray(candidate.ops) && "output" in candidate;
+}
+/**
+* Wrap the output with the staged ops so they cross the journal as DATA.
+* Returns the output untouched when nothing was staged — the no-state path
+* must not change the journaled shape.
+*/
+function attachToolState(output, staged) {
+	const ops = staged?.pending() ?? [];
+	return ops.length === 0 ? output : {
+		__zidaneToolState: 1,
+		ops,
+		output
+	};
+}
 /**
-* Compose the soft-error unwrap into the runtime's mappable durable promise.
-* A journaled sentinel becomes a thrown (rejected) value so the Restate batch
-* scheduler classifies it as a tool failure → `tool_result { isError }`; a real
-* action failure (control error) is rethrown verbatim. Non-mappable promises
-* (a ctx without the SDK's `RestatePromise`) pass through so the loop's durable
-* guard surfaces the "not a mappable durable promise" error instead.
+* Inverse of {@link attachToolState}, run OUTSIDE the journal: re-seed the
+* staging view from the journaled ops so the loop's commit writes the same
+* thing on a live attempt and on every replay. A value with no envelope
+* clears the view — whatever it holds was staged by an attempt no journal
+* entry records, and committing that would be a write replay can't reproduce.
 */
-function unwrapDurableSoftError(promise) {
+function applyToolState(value, staged) {
+	if (isToolStateEnvelope(value)) {
+		if (isToolStateOps(value.ops)) staged?.restore(value.ops);
+		else staged?.clear();
+		return value.output;
+	}
+	staged?.clear();
+	return value;
+}
+/**
+* Compose the state unwrap + soft-error unwrap into the runtime's mappable
+* durable promise. A journaled sentinel becomes a thrown (rejected) value so
+* the Restate batch scheduler classifies it as a tool failure →
+* `tool_result { isError }`; a real action failure (control error) is rethrown
+* verbatim. Non-mappable promises (a ctx without the SDK's `RestatePromise`)
+* pass through so the loop's durable guard surfaces the "not a mappable
+* durable promise" error instead.
+*/
+function unwrapDurableToolValue(promise, staged, softErrors) {
 	const mappable = promise;
 	if (typeof mappable.map !== "function") return promise;
 	return mappable.map((value, failure) => {
-		if (failure !== void 0) throw failure instanceof Error ? failure : new Error(String(failure));
-		return rethrowSoftToolError(value);
+		if (failure !== void 0) {
+			staged?.clear();
+			throw failure instanceof Error ? failure : new Error(String(failure));
+		}
+		const output = applyToolState(value, staged);
+		return softErrors ? rethrowSoftToolError(output) : output;
 	});
 }
 /**
@@ -505,7 +569,7 @@ function wrapAgentTools(tools, ctx, opts = {}) {
 	const excludeSet = new Set(opts.exclude ?? []);
 	const skipWaitTask = opts.detachedTasks === "durable";
 	const wrapped = {};
-	for (const [name, def] of Object.entries(tools)) wrapped[name] = excludeSet.has(name) || skipWaitTask && def.spec.name === "wait_task" ? def : restateTool(def, ctx, opts);
+	for (const [name, def] of Object.entries(tools)) wrapped[name] = excludeSet.has(name) || def.runsNestedAgent === true || skipWaitTask && def.spec.name === "wait_task" ? def : restateTool(def, ctx, opts);
 	return wrapped;
 }
 //#endregion
@@ -903,6 +967,62 @@ function maxDefined(values) {
 	return max;
 }
 //#endregion
+//#region src/restate/tool-state.ts
+/** Default virtual-object state key holding the tool-state map. */
+const DEFAULT_TOOL_STATE_KEY = "zidane_tool_state";
+/**
+* Build a {@link ToolStateStore} over the bound virtual object's state.
+*
+* ```ts
+* const agent = createAgent({
+*   provider,
+*   tools: wrapAgentTools({ shell }, ctx),
+*   session: createSession({ id: ctx.key, store: restateSessionStore(ctx) }),
+*   toolState: restateToolStateStore(ctx),
+* })
+* ```
+*
+* Single-writer like the session store: the state belongs to the object key,
+* so bind one key per conversation and one agent per invocation.
+*
+* Build it INSIDE the handler. The returned store closes over this `ctx`, so
+* an agent constructed once at module scope and reused across invocations
+* would commit through a context that is already finished, and would never
+* re-hydrate (the controller memoizes the load for the life of the agent).
+* Same rule as `restateSessionStore` / `restateProvider` / `restateClock` —
+* but easier to get wrong here, because `toolState` looks like
+* agent-lifetime configuration rather than a per-invocation binding.
+*
+* The map is a schema you own: one JSON object, no versioning, no migration.
+* A value written by an earlier deploy is still there after you change its
+* shape, so either read tolerantly or move to a fresh `key`.
+*
+* Enabling this adds a `ctx.get` at run start, which changes the journal
+* shape for NEW invocations. Existing in-flight invocations replay against
+* the old shape — drain them (or accept the failed attempts) before rolling
+* it out.
+*/
+function restateToolStateStore(ctx, options = {}) {
+	const key = options.key ?? "zidane_tool_state";
+	const maxValueBytes = options.maxValueBytes;
+	let cache;
+	return {
+		...maxValueBytes !== void 0 ? { maxValueBytes } : {},
+		load: async () => {
+			cache = await ctx.get(key) ?? {};
+			return { ...cache };
+		},
+		commit: (ops) => {
+			if (ops.length === 0) return;
+			const next = { ...cache ?? {} };
+			for (const op of ops) if (op.delete === true) delete next[op.key];
+			else next[op.key] = op.value;
+			cache = next;
+			ctx.set(key, next);
+		}
+	};
+}
+//#endregion
 //#region src/restate/wait-background.ts
 function entryToExit(entry) {
 	return {
@@ -981,6 +1101,6 @@ function restateWaitBackground(options) {
 	};
 }
 //#endregion
-export { awakeableWithTimeout, createReplayTracker, deterministicUuid, replayAwareAbort, restateAwakeableTool, restateBehavior, restateClock, restateMcpToolWrap, restateProvider, restateSessionStore, restateTool, restateToolBatchExecutor, restateWaitBackground, shouldRethrowRestateControlError, wrapAgentTools };
+export { DEFAULT_TOOL_STATE_KEY, awakeableWithTimeout, createReplayTracker, deterministicUuid, replayAwareAbort, restateAwakeableTool, restateBehavior, restateClock, restateMcpToolWrap, restateProvider, restateSessionStore, restateTool, restateToolBatchExecutor, restateToolStateStore, restateWaitBackground, shouldRethrowRestateControlError, wrapAgentTools };
 
 //# sourceMappingURL=restate.js.map