zidane 6.4.3 → 6.4.4

package/dist/mcp.d.ts

@@ -1,2 +1,2 @@
-import { Cg as wrapDiscoveredMcpTools, Sg as resultToString, _g as expandEnvPlaceholders, bg as normalizeMcpBlocks, dg as McpConnection, fg as McpExecutionBinding, gg as deriveMcpToolMeta, hg as createStderrLineEmitter, im as McpServerConfig, mg as connectMcpServers, om as McpToolSchema, pg as attachStderrWarnPump, ug as ConnectMcpServersOptions, vg as expandMcpConfigEnv, xg as normalizeMcpServers, yg as nonOwningMcpView } from "./index-W_8010Lt.js";
+import { Ag as normalizeMcpServers, Cg as connectMcpServers, Dg as expandMcpConfigEnv, Eg as expandEnvPlaceholders, Mg as wrapDiscoveredMcpTools, Og as nonOwningMcpView, Sg as attachStderrWarnPump, Tg as deriveMcpToolMeta, bg as McpConnection, im as McpServerConfig, jg as resultToString, kg as normalizeMcpBlocks, om as McpToolSchema, wg as createStderrLineEmitter, xg as McpExecutionBinding, yg as ConnectMcpServersOptions } from "./index-C-Nd2ZbV.js";
 export { ConnectMcpServersOptions, McpConnection, McpExecutionBinding, type McpServerConfig, type McpToolSchema, attachStderrWarnPump, connectMcpServers, createStderrLineEmitter, deriveMcpToolMeta, expandEnvPlaceholders, expandMcpConfigEnv, nonOwningMcpView, normalizeMcpBlocks, normalizeMcpServers, resultToString, wrapDiscoveredMcpTools };

package/dist/mcp.js

@@ -1,2 +1,2 @@
-import { a as expandEnvPlaceholders, c as normalizeMcpBlocks, d as wrapDiscoveredMcpTools, i as deriveMcpToolMeta, l as normalizeMcpServers, n as connectMcpServers, o as expandMcpConfigEnv, r as createStderrLineEmitter, s as nonOwningMcpView, t as attachStderrWarnPump, u as resultToString } from "./mcp-CDN-m5lp.js";
+import { a as expandEnvPlaceholders, c as normalizeMcpBlocks, d as wrapDiscoveredMcpTools, i as deriveMcpToolMeta, l as normalizeMcpServers, n as connectMcpServers, o as expandMcpConfigEnv, r as createStderrLineEmitter, s as nonOwningMcpView, t as attachStderrWarnPump, u as resultToString } from "./mcp-3GXUBwur.js";
 export { attachStderrWarnPump, connectMcpServers, createStderrLineEmitter, deriveMcpToolMeta, expandEnvPlaceholders, expandMcpConfigEnv, nonOwningMcpView, normalizeMcpBlocks, normalizeMcpServers, resultToString, wrapDiscoveredMcpTools };

package/dist/output/stream-json.d.ts

@@ -1,4 +1,4 @@
-import { $n as HeadlessResult, Jn as FormattedHeadlessTurnEvent, Qn as HeadlessOutputFormat, Wi as Agent, Xn as HeadlessEvent, qn as FormattedHeadlessResult } from "../index-W_8010Lt.js";
+import { $n as HeadlessResult, Jn as FormattedHeadlessTurnEvent, Qn as HeadlessOutputFormat, Wi as Agent, Xn as HeadlessEvent, qn as FormattedHeadlessResult } from "../index-C-Nd2ZbV.js";
 
 //#region src/output/stream-json.d.ts
 type StreamJsonOutputFormat = HeadlessOutputFormat;

package/dist/output/terminal.d.ts

@@ -1,4 +1,4 @@
-import { Ki as AgentHooks, Wi as Agent, t as Preset } from "../index-W_8010Lt.js";
+import { Ki as AgentHooks, Wi as Agent, t as Preset } from "../index-C-Nd2ZbV.js";
 
 //#region src/output/terminal.d.ts
 interface TerminalOutputOptions {

package/dist/presets.d.ts

@@ -1,2 +1,2 @@
-import { Gi as AgentHookMap, a as basicTools, i as _default, n as composePresets, r as definePreset, t as Preset } from "./index-W_8010Lt.js";
+import { Gi as AgentHookMap, a as basicTools, i as _default, n as composePresets, r as definePreset, t as Preset } from "./index-C-Nd2ZbV.js";
 export { type AgentHookMap, Preset, _default as basic, basicTools, composePresets, definePreset };

package/dist/presets.js

@@ -1,2 +1,2 @@
-import { ft as composePresets, ht as basic_default, mt as basicTools, pt as definePreset } from "./agent-CEvzc1Ao.js";
+import { ft as composePresets, ht as basic_default, mt as basicTools, pt as definePreset } from "./agent-8sUadp5M.js";
 export { basic_default as basic, basicTools, composePresets, definePreset };

package/dist/providers/anthropic.d.ts

@@ -1,2 +1,2 @@
-import { Cp as resolveAnthropicAuthShape, Sp as planAnthropicThinking, Tp as resolveAnthropicMaxOutput, _p as applyAnthropicCacheBreakpoints, bp as credentialIdentity, dp as AnthropicBedrockConfig, fp as AnthropicContextManagement, gp as anthropic, hp as EXTENDED_CACHE_TTL_BETA, mp as AnthropicThinkingPlan, pp as AnthropicParams, vp as buildAnthropicClientOptions, wp as resolveAnthropicBetas, xp as defaultAnthropicMaxTokens, yp as classifyAnthropicError } from "../index-W_8010Lt.js";
+import { Cp as resolveAnthropicAuthShape, Sp as planAnthropicThinking, Tp as resolveAnthropicMaxOutput, _p as applyAnthropicCacheBreakpoints, bp as credentialIdentity, dp as AnthropicBedrockConfig, fp as AnthropicContextManagement, gp as anthropic, hp as EXTENDED_CACHE_TTL_BETA, mp as AnthropicThinkingPlan, pp as AnthropicParams, vp as buildAnthropicClientOptions, wp as resolveAnthropicBetas, xp as defaultAnthropicMaxTokens, yp as classifyAnthropicError } from "../index-C-Nd2ZbV.js";
 export { AnthropicBedrockConfig, AnthropicContextManagement, AnthropicParams, AnthropicThinkingPlan, EXTENDED_CACHE_TTL_BETA, anthropic, applyAnthropicCacheBreakpoints, buildAnthropicClientOptions, classifyAnthropicError, credentialIdentity, defaultAnthropicMaxTokens, planAnthropicThinking, resolveAnthropicAuthShape, resolveAnthropicBetas, resolveAnthropicMaxOutput };

package/dist/providers/arcee.d.ts

@@ -1,2 +1,2 @@
-import { lp as ArceeParams, up as arcee } from "../index-W_8010Lt.js";
+import { lp as ArceeParams, up as arcee } from "../index-C-Nd2ZbV.js";
 export { ArceeParams, arcee };

package/dist/providers/baseten.d.ts

@@ -1,2 +1,2 @@
-import { cp as planBasetenReasoning, op as BasetenParams, sp as baseten } from "../index-W_8010Lt.js";
+import { cp as planBasetenReasoning, op as BasetenParams, sp as baseten } from "../index-C-Nd2ZbV.js";
 export { BasetenParams, baseten, planBasetenReasoning };

package/dist/providers/cerebras.d.ts

@@ -1,2 +1,2 @@
-import { ap as cerebras, ip as CerebrasParams } from "../index-W_8010Lt.js";
+import { ap as cerebras, ip as CerebrasParams } from "../index-C-Nd2ZbV.js";
 export { CerebrasParams, cerebras };

package/dist/providers/local.d.ts

@@ -1,2 +1,2 @@
-import { ep as LocalParams, tp as local } from "../index-W_8010Lt.js";
+import { ep as LocalParams, tp as local } from "../index-C-Nd2ZbV.js";
 export { LocalParams, local };

package/dist/providers/openai-compat.d.ts

@@ -1,2 +1,2 @@
-import { Af as OpenAICompatParams, Bf as mapOAIFinishReason, Df as OAITool, Ef as OAIMessage, Ff as assistantMessage, Gf as userMessage, Hf as openaiCompat, If as buildAssistantContent, Lf as classifyOpenAICompatError, Mf as TOOL_RESULTS_TAG, Nf as applyOAICacheBreakpoints, Of as OpenAICompatAuthHeader, Pf as applyOAIToolCacheBreakpoint, Rf as consumeSSE, Tf as ASSISTANT_TOOL_CALLS_TAG, Uf as toOAIMessages, Vf as openAICompatPromptMessage, Wf as toolResultsMessage, jf as OpenAICompatStreamError, kf as OpenAICompatHttpError, zf as formatTools } from "../index-W_8010Lt.js";
+import { Af as OpenAICompatParams, Bf as mapOAIFinishReason, Df as OAITool, Ef as OAIMessage, Ff as assistantMessage, Gf as userMessage, Hf as openaiCompat, If as buildAssistantContent, Lf as classifyOpenAICompatError, Mf as TOOL_RESULTS_TAG, Nf as applyOAICacheBreakpoints, Of as OpenAICompatAuthHeader, Pf as applyOAIToolCacheBreakpoint, Rf as consumeSSE, Tf as ASSISTANT_TOOL_CALLS_TAG, Uf as toOAIMessages, Vf as openAICompatPromptMessage, Wf as toolResultsMessage, jf as OpenAICompatStreamError, kf as OpenAICompatHttpError, zf as formatTools } from "../index-C-Nd2ZbV.js";
 export { ASSISTANT_TOOL_CALLS_TAG, OAIMessage, OAITool, OpenAICompatAuthHeader, OpenAICompatHttpError, OpenAICompatParams, OpenAICompatStreamError, TOOL_RESULTS_TAG, applyOAICacheBreakpoints, applyOAIToolCacheBreakpoint, assistantMessage, buildAssistantContent, classifyOpenAICompatError, consumeSSE, formatTools, mapOAIFinishReason, openAICompatPromptMessage, openaiCompat, toOAIMessages, toolResultsMessage, userMessage };

package/dist/providers/openai.d.ts

@@ -1,2 +1,2 @@
-import { Jf as mapCodexStopReason, Kf as OpenAIParams, Xf as toPiMessages, Yf as openai, qf as classifyOpenAIError } from "../index-W_8010Lt.js";
+import { Jf as mapCodexStopReason, Kf as OpenAIParams, Xf as toPiMessages, Yf as openai, qf as classifyOpenAIError } from "../index-C-Nd2ZbV.js";
 export { OpenAIParams, classifyOpenAIError, mapCodexStopReason, openai, toPiMessages };

package/dist/providers/openrouter.d.ts

@@ -1,2 +1,2 @@
-import { Cf as normalizeOpenRouterModelId, Sf as OpenRouterParams, wf as openrouter } from "../index-W_8010Lt.js";
+import { Cf as normalizeOpenRouterModelId, Sf as OpenRouterParams, wf as openrouter } from "../index-C-Nd2ZbV.js";
 export { OpenRouterParams, normalizeOpenRouterModelId, openrouter };

package/dist/providers/xai.d.ts

@@ -1,2 +1,2 @@
-import { gf as xai, hf as XaiParams } from "../index-W_8010Lt.js";
+import { gf as xai, hf as XaiParams } from "../index-C-Nd2ZbV.js";
 export { XaiParams, xai };

package/dist/providers.d.ts

@@ -1,2 +1,2 @@
-import { $f as planMistralReasoning, Af as OpenAICompatParams, Ap as OAuthParams, Bf as mapOAIFinishReason, Bp as OAuthProviderInterface, Dg as getModelCatalog, Dp as PromptCacheKeyOption, Eg as ModelCatalogSource, Ep as PromptCacheKeyContext, Fp as isOAuthAccessToken, Hf as openaiCompat, Ip as readOAuthCredentials, Kf as OpenAIParams, Lf as classifyOpenAICompatError, Lp as registerCustomOAuthProvider, Mp as credentialsFilePath, Np as credentialsFromParams, Of as OpenAICompatAuthHeader, Og as setModelCatalog, Op as derivePromptCacheKey, Pp as extractRuntimeCredentials, Qf as mistral, Rp as resolveOAuthApiKey, Sf as OpenRouterParams, Tg as ModelCatalogEntry, Yf as openai, Zf as MistralParams, _f as SchemaSanitizeOptions, _p as applyAnthropicCacheBreakpoints, af as StreamCallbacks, ap as cerebras, bf as sanitizeToolSchema, cf as ToolCall, cp as planBasetenReasoning, df as TurnResult, ep as LocalParams, ff as ZaiParams, gf as xai, gp as anthropic, hf as XaiParams, if as ProviderCapabilities, ip as CerebrasParams, jp as ResolveOAuthApiKeyOptions, kf as OpenAICompatHttpError, kp as resolvePromptCacheKey, lf as ToolResult, lp as ArceeParams, mf as zai, nf as HistoryRepair, np as CursorParams, of as StreamOptions, op as BasetenParams, pf as planZaiReasoning, pp as AnthropicParams, rf as Provider, rp as cursor, sf as TokenCountPayload, sp as baseten, tp as local, uf as ToolSpec, up as arcee, vf as SchemaSanitizeProfile, wf as openrouter, wg as ModelCatalog, xf as sanitizeToolSpecs, yf as SchemaSanitizeResult, zp as writeOAuthCredentials } from "./index-W_8010Lt.js";
+import { $f as planMistralReasoning, Af as OpenAICompatParams, Ap as OAuthParams, Bf as mapOAIFinishReason, Bp as OAuthProviderInterface, Dp as PromptCacheKeyOption, Ep as PromptCacheKeyContext, Fg as ModelCatalogSource, Fp as isOAuthAccessToken, Hf as openaiCompat, Ig as getModelCatalog, Ip as readOAuthCredentials, Kf as OpenAIParams, Lf as classifyOpenAICompatError, Lg as setModelCatalog, Lp as registerCustomOAuthProvider, Mp as credentialsFilePath, Ng as ModelCatalog, Np as credentialsFromParams, Of as OpenAICompatAuthHeader, Op as derivePromptCacheKey, Pg as ModelCatalogEntry, Pp as extractRuntimeCredentials, Qf as mistral, Rp as resolveOAuthApiKey, Sf as OpenRouterParams, Yf as openai, Zf as MistralParams, _f as SchemaSanitizeOptions, _p as applyAnthropicCacheBreakpoints, af as StreamCallbacks, ap as cerebras, bf as sanitizeToolSchema, cf as ToolCall, cp as planBasetenReasoning, df as TurnResult, ep as LocalParams, ff as ZaiParams, gf as xai, gp as anthropic, hf as XaiParams, if as ProviderCapabilities, ip as CerebrasParams, jp as ResolveOAuthApiKeyOptions, kf as OpenAICompatHttpError, kp as resolvePromptCacheKey, lf as ToolResult, lp as ArceeParams, mf as zai, nf as HistoryRepair, np as CursorParams, of as StreamOptions, op as BasetenParams, pf as planZaiReasoning, pp as AnthropicParams, rf as Provider, rp as cursor, sf as TokenCountPayload, sp as baseten, tp as local, uf as ToolSpec, up as arcee, vf as SchemaSanitizeProfile, wf as openrouter, xf as sanitizeToolSpecs, yf as SchemaSanitizeResult, zp as writeOAuthCredentials } from "./index-C-Nd2ZbV.js";
 export { type AnthropicParams, type ArceeParams, type BasetenParams, type CerebrasParams, type CursorParams, HistoryRepair, type LocalParams, type MistralParams, type ModelCatalog, type ModelCatalogEntry, type ModelCatalogSource, type OAuthParams, type OAuthProviderInterface, type OpenAICompatAuthHeader, OpenAICompatHttpError, type OpenAICompatParams, type OpenAIParams, type OpenRouterParams, type PromptCacheKeyContext, type PromptCacheKeyOption, Provider, ProviderCapabilities, type ResolveOAuthApiKeyOptions, type SchemaSanitizeOptions, type SchemaSanitizeProfile, type SchemaSanitizeResult, StreamCallbacks, StreamOptions, TokenCountPayload, ToolCall, ToolResult, ToolSpec, TurnResult, type XaiParams, type ZaiParams, anthropic, applyAnthropicCacheBreakpoints, arcee, baseten, cerebras, classifyOpenAICompatError, credentialsFilePath, credentialsFromParams, cursor, derivePromptCacheKey, extractRuntimeCredentials, getModelCatalog, isOAuthAccessToken, local, mapOAIFinishReason, mistral, openai, openaiCompat, openrouter, planBasetenReasoning, planMistralReasoning, planZaiReasoning, readOAuthCredentials, registerCustomOAuthProvider, resolveOAuthApiKey, resolvePromptCacheKey, sanitizeToolSchema, sanitizeToolSpecs, setModelCatalog, writeOAuthCredentials, xai, zai };

package/dist/restate.d.ts

@@ -1,4 +1,4 @@
-import { $m as ToolDef, Fm as ToolBatchExecutor, Hp as AgentClock, Qm as ToolContext, Sh as SessionStore, Vp as AgentBehavior, Xi as McpToolWrap, Yi as McpToolMeta, of as StreamOptions, rf as Provider, zm as ToolResultContent } from "./index-W_8010Lt.js";
+import { $m as ToolDef, Fm as ToolBatchExecutor, Hp as AgentClock, Qm as ToolContext, Vp as AgentBehavior, Xi as McpToolWrap, Yi as McpToolMeta, jh as SessionStore, mh as ToolStateStore, of as StreamOptions, rf as Provider, zm as ToolResultContent } from "./index-C-Nd2ZbV.js";
 import { g as TaskExitInfo, h as TaskEntry, l as ExecutionHandle, o as DetachedTasksCapability } from "./types-M2DauK2D.js";
 
 //#region src/restate/types.d.ts
@@ -838,6 +838,56 @@ declare function wrapAgentTools(tools: Record<string, ToolDef>, ctx: RestateCont
   exclude?: readonly string[];
 }): Record<string, ToolDef>;
 //#endregion
+//#region src/restate/tool-state.d.ts
+/** Default virtual-object state key holding the tool-state map. */
+declare const DEFAULT_TOOL_STATE_KEY = "zidane_tool_state";
+interface RestateToolStateStoreOptions {
+  /** Override the state key. Defaults to {@link DEFAULT_TOOL_STATE_KEY}. */
+  key?: string;
+  /**
+   * Per-value size budget enforced when a tool stages a write. Defaults to
+   * the library's `DEFAULT_MAX_VALUE_BYTES` (64 KiB), which is far below
+   * Restate's own journal-entry ceiling on purpose: an oversized state value
+   * doesn't fail politely there — the invocation fails with `RT0003`
+   * (MessageSizeLimit) and is retried under the configured policy, i.e. a fat
+   * write becomes a poison pill rather than a dropped one.
+   */
+  maxValueBytes?: number;
+}
+/**
+ * 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.
+ */
+declare function restateToolStateStore(ctx: RestateObjectContextLike, options?: RestateToolStateStoreOptions): ToolStateStore;
+//#endregion
 //#region src/restate/wait-background.d.ts
 interface RestateWaitBackgroundOptions {
   /** The Restate context the awakeable + journal entries bind to. */
@@ -891,5 +941,5 @@ declare function restateWaitBackground(options: RestateWaitBackgroundOptions): (
   signal?: AbortSignal;
 }) => Promise<TaskExitInfo | null>;
 //#endregion
-export { type AwakeableWithTimeoutOptions, type ReplayDoneHooks, type ReplayTracker, type ReplayTrackerOptions, type RestateAwakeable, type RestateAwakeableToolOptions, type RestateClockOptions, type RestateContextLike, type RestateDurableStart, type RestateDurableWait, type RestateMcpToolWrapOptions, type RestateObjectContextLike, type RestatePromiseAllLike, type RestatePromiseLike, type RestatePromiseRaceLike, type RestateProviderOptions, type RestateRunOptions, type RestateSessionStoreOptions, type RestateToolBatchExecutorOptions, type RestateToolOptions, type RestateWaitBackgroundOptions, awakeableWithTimeout, createReplayTracker, deterministicUuid, replayAwareAbort, restateAwakeableTool, restateBehavior, restateClock, restateMcpToolWrap, restateProvider, restateSessionStore, restateTool, restateToolBatchExecutor, restateWaitBackground, shouldRethrowRestateControlError, wrapAgentTools };
+export { type AwakeableWithTimeoutOptions, DEFAULT_TOOL_STATE_KEY, type ReplayDoneHooks, type ReplayTracker, type ReplayTrackerOptions, type RestateAwakeable, type RestateAwakeableToolOptions, type RestateClockOptions, type RestateContextLike, type RestateDurableStart, type RestateDurableWait, type RestateMcpToolWrapOptions, type RestateObjectContextLike, type RestatePromiseAllLike, type RestatePromiseLike, type RestatePromiseRaceLike, type RestateProviderOptions, type RestateRunOptions, type RestateSessionStoreOptions, type RestateToolBatchExecutorOptions, type RestateToolOptions, type RestateToolStateStoreOptions, type RestateWaitBackgroundOptions, awakeableWithTimeout, createReplayTracker, deterministicUuid, replayAwareAbort, restateAwakeableTool, restateBehavior, restateClock, restateMcpToolWrap, restateProvider, restateSessionStore, restateTool, restateToolBatchExecutor, restateToolStateStore, restateWaitBackground, shouldRethrowRestateControlError, wrapAgentTools };
 //# sourceMappingURL=restate.d.ts.map

package/dist/restate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"restate.d.ts","names":[],"sources":["../src/restate/types.ts","../src/restate/awakeable.ts","../src/restate/awakeable-tool.ts","../src/restate/behavior.ts","../src/restate/clock.ts","../src/restate/errors.ts","../src/restate/replay.ts","../src/restate/mcp.ts","../src/restate/parallel.ts","../src/restate/provider.ts","../src/restate/session.ts","../src/restate/tool.ts","../src/restate/wait-background.ts"],"mappings":"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"}
+{"version":3,"file":"restate.d.ts","names":[],"sources":["../src/restate/types.ts","../src/restate/awakeable.ts","../src/restate/awakeable-tool.ts","../src/restate/behavior.ts","../src/restate/clock.ts","../src/restate/errors.ts","../src/restate/replay.ts","../src/restate/mcp.ts","../src/restate/parallel.ts","../src/restate/provider.ts","../src/restate/session.ts","../src/restate/tool.ts","../src/restate/tool-state.ts","../src/restate/wait-background.ts"],"mappings":"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"}

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
 /**
@@ -318,26 +318,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 +382,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 +412,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 +430,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 +454,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;
 	});
 }
 /**
@@ -903,6 +965,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 +1099,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