@superdurable/dex-agents 0.2.0 → 0.4.0

package/dist/src/agent-session-step-options.js.map

@@ -1 +1 @@
-{"version":3,"file":"agent-session-step-options.js","sourceRoot":"","sources":["../../src/agent-session-step-options.ts"],"names":[],"mappings":"AAAA,yCAAyC;AACzC,EAAE;AACF,kDAAkD;AAClD,mEAAmE;AACnE,+CAA+C;AAC/C,EAAE;AACF,0DAA0D;AAE1D,OAAO,EAAE,cAAc,EAAE,OAAO,EAA6D,MAAM,mBAAmB,CAAC;AAGvH,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE,MAAM,CAAC,MAAM,QAAQ,GAAG,MAAM,CAAC;AAC/B,qFAAqF;AACrF,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,sBAAsB,EAAE,EAAE,GAAG,QAAQ;IACrC,kBAAkB,EAAE,CAAC,GAAG,QAAQ;IAChC,YAAY,EAAE,EAAE,eAAe,EAAE,CAAC,EAAE,eAAe,EAAE,EAAE,GAAG,QAAQ,EAAE;IACpE,cAAc,EAAE,cAAc,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC,qBAAqB,CAAC,iBAAiB,CAAC,CAAC;CAChE,CAAC;AACjC,qGAAqG;AACrG,MAAM,CAAC,MAAM,aAAa,GAAgB,EAAE,iBAAiB,EAAE,KAAK,EAAE,CAAC;AACvE,mGAAmG;AACnG,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,iBAAiB,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,EAAW,CAAC;AAWhG,sGAAsG;AACtG,MAAM,UAAU,kBAAkB,CAChC,WAAoC,EACpC,QAAgB,EAChB,UAA6B;IAE7B,MAAM,KAAK,GAAG;QACZ,wBAAwB,EAAE,UAAU,CAAC,UAAU;YAC7C,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,EAAE,WAAW,CAAC,cAAc,EAAE,WAAW,CAAC,kBAAkB,CAAC;YACzF,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,EAAE,WAAW,CAAC,cAAc,CAAC;QAC3D,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,gCAAgC,EAAE,UAAU,CAAC,SAAS,EAAE,CAAC;KACzG,CAAC;IACF,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,qBAAqB,CAAC,QAAQ;YACjC,OAAO,EAAE,GAAG,cAAc,EAAE,GAAG,oBAAoB,EAAE,GAAG,KAAK,EAAE,CAAC;QAClE,KAAK,qBAAqB,CAAC,gBAAgB;YACzC,OAAO,EAAE,GAAG,cAAc,EAAE,YAAY,EAAE,aAAa,EAAE,GAAG,KAAK,EAAE,CAAC;QACtE;YACE,MAAM,IAAI,SAAS,CAAC,aAAa,QAAQ,gCAAgC,CAAC,CAAC;IAC/E,CAAC;AACH,CAAC"}
+{"version":3,"file":"agent-session-step-options.js","sourceRoot":"","sources":["../../src/agent-session-step-options.ts"],"names":[],"mappings":"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"}

package/dist/src/agent-session-steps.d.ts

@@ -34,6 +34,8 @@ export declare class RunModelStep implements Step<void> {
     getStepType(): string;
     getStepOptions(): StepOptions;
     execute(context: AsyncContext): Promise<StepDecision>;
+    /** Starts the next queued write or skips the rest; `null` lets a cancelled turn end here. */
+    private continueOrderedWrites;
     /** Returns RunModel's move instead of a model call, or `null` to call the model. */
     private decideBeforeModelCall;
     private completeTurn;
@@ -140,6 +142,8 @@ export declare class RecordTurnFailureStep implements Step<CompactContextInput |
     getStepOptions(): StepOptions;
     execute(context: Context): StepDecision;
 }
+/** Reports whether a Step failed because its commit would exceed the Flow's state limit. */
+export declare function isStateLimitFailure(recoveryError: RecoveryErrorInfo | undefined): boolean;
 /** `last_turn_error` of a turn whose runner stored messages incrementally without the builder. */
 export declare const missingUnfinishedTurnMessageBuilder = "a runner that sets ToolCallsRequested.newMessages must implement buildUnfinishedTurnMessages";
 /**
@@ -148,6 +152,11 @@ export declare const missingUnfinishedTurnMessageBuilder = "a runner that sets T
  */
 export declare function toolStepOptions(persistence: AgentSessionPersistence, stepType: string, toolCallId?: string): StepOptions;
 export declare function toolStepMovement(persistence: AgentSessionPersistence, stepType: string, toolCallId: string): StepMovement<string>;
+/**
+ * Returns the movement that starts an approved call's tool Step, with the runner's timeout and retry policy.
+ * Only `CallTool` takes the retry policy; `CallSingleAttemptTool` keeps one attempt.
+ */
+export declare function toolCallMovement(transitions: AgentSessionTransitions, toolCall: AgentToolCallRecord): StepMovement<string>;
 /** Moves to `PollToolTask`; a poll that keeps failing leaves the task running, so the call is recorded by effect. */
 export declare function toolTaskPollMovement(persistence: AgentSessionPersistence, toolCall: AgentToolCallRecord): StepMovement<string>;
 /** Returns the record of a tool's question: `awaiting_answer`, or `failed` when it is blank. */

package/dist/src/agent-session-steps.js

@@ -8,14 +8,14 @@
 import { ExecuteFailure, StepMovement, int64Codec, StepRef, StepAttemptProgress, Timer, Wait, deadEnd, forceFail, goTo, goToMany, stringCodec, voidCodec, } from "@superdurable/dex";
 import { buildPlanClearedOutput, buildPlanUpdatedOutput, isBlankText, validateAskUserArguments, validateDurableWaitArguments, validateWriteTodosArguments, writeTodosCalledMoreThanOnce, } from "./agent-built-in-tools.js";
 import { isCompactionTriggered, isContextCompactionRunner, readRetainedTokenBudget, } from "./agent-context-compaction.js";
-import { ToolExecutionError, } from "./agent-framework-runner.js";
+import { ToolExecutionError, ToolOutcomeUnknownError, } from "./agent-framework-runner.js";
 import { buildPlanExecutionMessage, planningTurnToolRejection, planStatusAfterWrite } from "./agent-plans.js";
 import { agentSessionStartInputCodec, turnFailureRouteInputCodec } from "./agent-session-codecs.js";
 import { messageStepOptions, minuteMs, modelCallStepOptions, recoveryRetry, syncDurability, } from "./agent-session-step-options.js";
 import { agentSessionStepTypes, allPendingMessages, cancelledToolCall, isAbandonedToolTask, isCancellableByTurnControl, readRecoveryDetail, recoveryErrorDetail, toRunnerToolCall, toolStepTypeForEffect, ToolStepHeartbeats, writePlanUpdated, } from "./agent-session-transitions.js";
 import { messageSequenceKey, planExecutionKey, } from "./agent-session-persistence.js";
 import { checkStoredSessionSettings } from "./agent-session-settings.js";
-import { approvalDeadlinePassed, blankToolTaskId, buildTurnFailureNote, emptyAgentUsage, invalidToolTaskPollInterval, isFinalToolCallStatus, missingToolTaskPoller, toolCallNotRunErrorPrefix, toolTaskAbandonedError, } from "./agent-session-values.js";
+import { approvalDeadlinePassed, blankToolTaskId, buildTurnFailureNote, emptyAgentUsage, invalidToolTaskPollInterval, isFinalToolCallStatus, missingToolTaskPoller, toolCallNotRunErrorPrefix, toolCallSkippedAfterWriteDetail, toolTaskAbandonedError, } from "./agent-session-values.js";
 /** Longest wait between two polls of a tool task, as in the Python core; a longer interval is shortened. */
 const maximumToolTaskPollIntervalSeconds = 86_400;
 // An int64 Value, as the Python core's Step[int] encodes it.
@@ -159,7 +159,7 @@ export class RunModelStep {
     }
     getStepOptions() {
         // Each movement into RunModel adds the archive chunks of the model input.
-        return messageStepOptions(this.transitions.persistence, this.getStepType(), staticMessageChunkLoads(this.transitions));
+        return messageStepOptions(this.transitions.persistence, this.getStepType(), staticMessageChunkLoads(this.transitions), this.transitions.config.runModelLimit);
     }
     async execute(context) {
         const transitions = this.transitions;
@@ -168,7 +168,14 @@ export class RunModelStep {
         if (turnId === null) {
             throw new Error(`the agent session ${context.flowId} has no active turn`);
         }
-        const toolCalls = transitions.readTurnToolCalls(context, turnId);
+        let toolCalls = transitions.readTurnToolCalls(context, turnId);
+        if (toolCalls.some((toolCall) => toolCall.writeQueued === true)) {
+            const writeDecision = this.continueOrderedWrites(context, state, turnId, toolCalls);
+            if (writeDecision !== null) {
+                return writeDecision;
+            }
+            toolCalls = transitions.readTurnToolCalls(context, turnId);
+        }
         const openToolCall = toolCalls.find((toolCall) => !isFinalToolCallStatus(toolCall.status));
         if (openToolCall !== undefined) {
             throw new Error(`RunModel for ${turnId} started before tool call ${openToolCall.toolCallId} finished`);
@@ -184,8 +191,18 @@ export class RunModelStep {
             if (throughSequence !== null) {
                 return this.startCompaction(context, state, turnContext.contextSummary ?? null, throughSequence);
             }
+            const refusal = await transitions.checkSpendLimit(context, state, turnId, this.getStepType());
+            if (refusal !== null) {
+                return refusal;
+            }
             return await transitions.tracer.traceModelCall(context, this.getStepType(), turnContext, async (modelCallSpan) => {
-                const outcome = await transitions.runWithHeartbeats(context, () => transitions.runner.runModelStep(turnContext));
+                const outcome = await transitions.runWithHeartbeats(context, async () => {
+                    const result = await transitions.runner.runModelStep(turnContext);
+                    if (result?.kind === "completed" || result?.kind === "tool_calls_requested") {
+                        await transitions.reportModelUsage(context, turnId, this.getStepType(), result.usage);
+                    }
+                    return result;
+                });
                 switch (outcome?.kind) {
                     case "completed": {
                         modelCallSpan.recordOutcome(outcome, appendedMessageKeys(state, outcome.newMessages));
@@ -211,6 +228,61 @@ export class RunModelStep {
             events.close();
         }
     }
+    /** Starts the next queued write or skips the rest; `null` lets a cancelled turn end here. */
+    continueOrderedWrites(context, state, turnId, toolCalls) {
+        const transitions = this.transitions;
+        const queued = toolCalls.filter((toolCall) => toolCall.writeQueued === true);
+        const reason = transitions.readTurnControlReason(context, turnId);
+        if (reason !== null) {
+            transitions.writeEvents(context, turnId, (events) => {
+                for (const toolCall of queued) {
+                    transitions.finishUnscheduledToolCall(context, { ...cancelledToolCall(toolCall, reason), writeQueued: false }, events);
+                }
+            });
+            return null;
+        }
+        const openToolCall = toolCalls.find((toolCall) => toolCall.writeQueued !== true && !isFinalToolCallStatus(toolCall.status));
+        if (openToolCall !== undefined) {
+            throw new Error(`RunModel for ${turnId} started before tool call ${openToolCall.toolCallId} finished`);
+        }
+        const nextWrite = queued[0];
+        const previousWrite = toolCalls
+            .filter((toolCall) => toolCall.orderedWrite === true &&
+            toolCall.writeQueued !== true &&
+            toolCall.deferralOrder < nextWrite.deferralOrder)
+            .at(-1);
+        if (previousWrite !== undefined && previousWrite.status !== "succeeded") {
+            transitions.writeEvents(context, turnId, (events) => {
+                for (const toolCall of queued) {
+                    transitions.finishUnscheduledToolCall(context, skippedToolCall(toolCall), events);
+                }
+            });
+            // The skips commit before the model call, so readers see them while the model runs.
+            return transitions.goToRunModel(context);
+        }
+        const createdAt = new Date();
+        const traceContext = transitions.tracer.readActivationTraceparent(context);
+        const { traceContext: _queuedTraceContext, ...queuedWrite } = nextWrite;
+        const started = {
+            ...queuedWrite,
+            writeQueued: false,
+            status: nextWrite.requiresApproval ? "awaiting_approval" : "approved",
+            ...(traceContext === null ? {} : { traceContext }),
+        };
+        transitions.writeToolCall(context, started);
+        let movement;
+        if (started.requiresApproval) {
+            const interrupt = toolApprovalInterrupt(started, createdAt.toISOString(), interruptDeadline(transitions, createdAt));
+            transitions.persistence.pendingInterrupts.set(context, [...transitions.readPendingInterrupts(context), interrupt]);
+            transitions.writeEvents(context, turnId, (events) => transitions.writeInterruptRaised(events, interrupt));
+            movement = toolStepMovement(transitions.persistence, agentSessionStepTypes.awaitToolApproval, started.toolCallId);
+        }
+        else {
+            movement = toolCallMovement(transitions, started);
+        }
+        transitions.writeAgentState(context, { ...state, status: "running_tools" });
+        return goToMany(movement, StepMovement.of(new StepRef(agentSessionStepTypes.resumeTurn), 1));
+    }
     /** Returns RunModel's move instead of a model call, or `null` to call the model. */
     decideBeforeModelCall(context, turnId) {
         // Execute state is fixed at the first attempt, so this and the compaction check are RunModel's decision points.
@@ -290,15 +362,15 @@ export class RunModelStep {
             context,
             turnId,
             createdAt: createdAt.toISOString(),
-            interruptDeadline: transitions.config.interruptDeadlineMs === undefined
-                ? null
-                : new Date(createdAt.getTime() + transitions.config.interruptDeadlineMs).toISOString(),
+            interruptDeadline: interruptDeadline(transitions, createdAt),
             interrupts: [],
             traceContext: transitions.tracer.readActivationTraceparent(context),
             movements: [],
             events,
             interactionMode: state.interactionMode ?? "chat",
             writeTodosCallCount: outcome.toolCalls.filter((toolCall) => toolCall.toolName === "write_todos" && transitions.isEnabledBuiltInTool(toolCall.toolName)).length,
+            hasStartedOrderedWrite: false,
+            queuedCount: 0,
         };
         for (const [index, requestedToolCall] of outcome.toolCalls.entries()) {
             const deferralOrder = toolCalls.length + index;
@@ -316,7 +388,7 @@ export class RunModelStep {
         transitions.persistence.pendingInterrupts.set(context, batch.interrupts);
         transitions.recordUsage(context, outcome.usage, events);
         transitions.writeAgentState(context, { ...stateWithMessages, status: "running_tools" });
-        batch.movements.push(StepMovement.of(new StepRef(agentSessionStepTypes.resumeTurn), outcome.toolCalls.length));
+        batch.movements.push(StepMovement.of(new StepRef(agentSessionStepTypes.resumeTurn), outcome.toolCalls.length - batch.queuedCount));
         return goToMany(...batch.movements);
     }
     /** A planning turn hides executable tools; a call to one never runs. */
@@ -330,31 +402,27 @@ export class RunModelStep {
         const transitions = this.transitions;
         const requiresApproval = requestedToolCall.policy.requiresApproval;
         const effect = requestedToolCall.policy.effect;
-        const record = createToolCallRecord(batch, requestedToolCall, effect, requiresApproval, deferralOrder);
-        transitions.writeToolCall(batch.context, {
-            ...record,
-            status: requiresApproval ? "awaiting_approval" : "approved",
-        });
+        const isOrderedWrite = requestedToolCall.ordered === true && effect !== "read";
+        const record = {
+            ...createToolCallRecord(batch, requestedToolCall, effect, requiresApproval, deferralOrder),
+            orderedWrite: isOrderedWrite,
+        };
         writeToolCallDeferred(batch.events, record);
-        const nextStepType = requiresApproval
-            ? agentSessionStepTypes.awaitToolApproval
-            : toolStepTypeForEffect(effect);
-        batch.movements.push(toolStepMovement(transitions.persistence, nextStepType, requestedToolCall.toolCallId));
+        if (isOrderedWrite && batch.hasStartedOrderedWrite) {
+            // Started by RunModel once every earlier ordered write of the turn succeeded.
+            transitions.writeToolCall(batch.context, { ...record, status: "approved", writeQueued: true });
+            batch.queuedCount += 1;
+            return;
+        }
+        batch.hasStartedOrderedWrite ||= isOrderedWrite;
+        const deferred = { ...record, status: requiresApproval ? "awaiting_approval" : "approved" };
+        transitions.writeToolCall(batch.context, deferred);
         if (!requiresApproval) {
+            batch.movements.push(toolCallMovement(transitions, deferred));
             return;
         }
-        const interrupt = {
-            interruptId: requestedToolCall.toolCallId,
-            kind: "tool_approval",
-            toolCallId: requestedToolCall.toolCallId,
-            toolName: requestedToolCall.toolName,
-            arguments: requestedToolCall.arguments,
-            createdAt: batch.createdAt,
-            deadline: batch.interruptDeadline,
-            question: null,
-            choices: [],
-            allowsFreeText: true,
-        };
+        batch.movements.push(toolStepMovement(transitions.persistence, agentSessionStepTypes.awaitToolApproval, requestedToolCall.toolCallId));
+        const interrupt = toolApprovalInterrupt(record, batch.createdAt, batch.interruptDeadline);
         batch.interrupts.push(interrupt);
         transitions.writeInterruptRaised(batch.events, interrupt);
     }
@@ -477,6 +545,10 @@ export class CompactContextStep {
         if (!isContextCompactionRunner(runner)) {
             throw new TypeError("CompactContext needs a runner that implements the compaction methods");
         }
+        const refusal = await transitions.checkSpendLimit(context, state, turnId, this.getStepType());
+        if (refusal !== null) {
+            return refusal;
+        }
         const events = transitions.createEventWriter(context, turnId);
         try {
             events.writeEvent("compaction_started", { through_sequence: throughSequence });
@@ -511,21 +583,27 @@ export class CompactContextStep {
         const messages = transitions.readMessages(context, firstSequence, throughSequence + 1);
         const policy = transitions.config.compaction;
         return transitions.tracer.traceContextSummary(context, this.getStepType(), turnId, throughSequence, messages, async (summarySpan) => {
-            const result = await transitions.runWithHeartbeats(context, () => runner.summarizeContext({
-                flowId: context.flowId,
-                turnId,
-                attempt: context.attempt,
-                stepExecutionId: context.stepExecutionId,
-                previousSummary,
-                messages,
-                throughSequence,
-                events,
-                cancellationSignal: context.cancellationSignal,
-                deadline: context.deadline,
-                ...(policy === undefined ? {} : { inputTokenBudget: policy.contextWindowTokens }),
-                sessionSettings: transitions.readTurnSessionSettings(context),
-                heartbeat: () => transitions.recordHeartbeat(context),
-            }));
+            const result = await transitions.runWithHeartbeats(context, async () => {
+                const summaryResult = await runner.summarizeContext({
+                    flowId: context.flowId,
+                    turnId,
+                    attempt: context.attempt,
+                    stepExecutionId: context.stepExecutionId,
+                    previousSummary,
+                    messages,
+                    throughSequence,
+                    events,
+                    cancellationSignal: context.cancellationSignal,
+                    deadline: context.deadline,
+                    ...(policy === undefined ? {} : { inputTokenBudget: policy.contextWindowTokens }),
+                    sessionSettings: transitions.readTurnSessionSettings(context),
+                    heartbeat: () => transitions.recordHeartbeat(context),
+                });
+                if (typeof summaryResult?.usage === "object") {
+                    await transitions.reportModelUsage(context, turnId, this.getStepType(), summaryResult.usage);
+                }
+                return summaryResult;
+            });
             if (typeof result?.text !== "string" || result.text.trim() === "" || typeof result.usage !== "object") {
                 throw new TypeError("summarizeContext must return summary text and usage");
             }
@@ -610,7 +688,7 @@ export class AwaitToolApprovalStep {
                 isAnswered: false,
                 rejectionMessage: null,
             });
-            return goToMany(toolStepMovement(this.transitions.persistence, toolStepTypeForEffect(toolCall.effect), toolCall.toolCallId));
+            return goToMany(toolCallMovement(this.transitions, { ...toolCall, status: "approved" }));
         });
     }
     rejectToolCall(context, toolCall, rejectionMessage) {
@@ -680,12 +758,19 @@ export class ToolCallStep {
                     heartbeat: () => heartbeats.record(),
                     ...(heartbeats.previousCheckpoint === undefined ? {} : { heartbeatCheckpoint: heartbeats.previousCheckpoint }),
                     saveHeartbeatCheckpoint: (checkpoint) => heartbeats.saveCheckpoint(checkpoint),
+                    context,
                 };
                 let outcome;
                 try {
                     outcome = await transitions.runWithHeartbeats(context, () => transitions.runner.executeDeferredToolCall(execution), () => heartbeats.record());
                 }
                 catch (error) {
+                    if (error instanceof ToolOutcomeUnknownError) {
+                        const unknown = { ...toolCall, status: "outcome_unknown", error: error.message };
+                        toolCallSpan.recordFinished(unknown);
+                        transitions.finishToolCall(context, unknown, events);
+                        return deadEnd();
+                    }
                     if (!(error instanceof ToolExecutionError)) {
                         throw error;
                     }
@@ -703,7 +788,12 @@ export class ToolCallStep {
                 if (typeof outcome?.output !== "string") {
                     throw new TypeError(`executeDeferredToolCall returned no output for ${toolCallId}`);
                 }
-                const succeeded = { ...toolCall, status: "succeeded", output: outcome.output };
+                const succeeded = {
+                    ...toolCall,
+                    status: "succeeded",
+                    output: outcome.output,
+                    truncatedOutputBytes: outcome.truncatedOutputBytes ?? null,
+                };
                 toolCallSpan.recordFinished(succeeded);
                 transitions.finishToolCall(context, succeeded, events);
                 return deadEnd();
@@ -786,6 +876,9 @@ export class ToolCallFailureRecordingStep {
     }
     execute(context, toolCallId) {
         const transitions = this.transitions;
+        if (isStateLimitFailure(context.recoveryError)) {
+            return recordFailedSession(transitions, context, readRecoveryDetail(context));
+        }
         const toolCall = transitions.readToolCall(context, toolCallId);
         if (isFinalToolCallStatus(toolCall.status)) {
             return deadEnd();
@@ -855,12 +948,17 @@ export class ResumeTurnStep {
             // The results did not all arrive, so wait again for the same count.
             return goTo(new StepRef(agentSessionStepTypes.resumeTurn), expectedResultCount);
         }
-        const unfinishedCount = toolCalls.filter((toolCall) => !isFinalToolCallStatus(toolCall.status)).length;
+        const unfinishedCount = toolCalls.filter((toolCall) => !isFinalToolCallStatus(toolCall.status) && toolCall.writeQueued !== true).length;
         if (unfinishedCount > 0) {
             // A consumed result from an earlier turn must not resume this one early.
             return goTo(new StepRef(agentSessionStepTypes.resumeTurn), unfinishedCount);
         }
         if (reason !== null) {
+            transitions.writeEvents(context, turnId, (events) => {
+                for (const toolCall of toolCalls.filter((queued) => queued.writeQueued === true)) {
+                    transitions.finishUnscheduledToolCall(context, { ...cancelledToolCall(toolCall, reason), writeQueued: false }, events);
+                }
+            });
             return transitions.goToApplyTurnControl(context);
         }
         transitions.writeAgentState(context, { ...state, status: "running_model" });
@@ -912,7 +1010,7 @@ export class ApplyTurnControlStep {
         // Each movement into ApplyTurnControl adds the archive chunks of the model input.
         // The lock keeps a turn from starting while cancel_turn decides about the last one.
         return {
-            ...messageStepOptions(this.transitions.persistence, this.getStepType(), staticMessageChunkLoads(this.transitions)),
+            ...messageStepOptions(this.transitions.persistence, this.getStepType(), staticMessageChunkLoads(this.transitions), this.transitions.config.runModelLimit),
             executeLockAttributes: [this.transitions.persistence.turnCancellationRequest.lock()],
         };
     }
@@ -935,6 +1033,11 @@ export class ApplyTurnControlStep {
         return transitions.beginTurn(context, state, steeredMessages, this.getStepType(), transitions.decideInteractionMode(context, steeredMessages));
     }
 }
+// server-zd reports a Step whose commit would pass limits.maxFlowStateBytes with this type and text:
+// "run state of <X> bytes exceeds the maximum of <Y> bytes", or "active run state of ..." since the limit
+// counts only active state.
+const stateLimitErrorType = "ValueTooLarge";
+const stateLimitErrorText = "run state of ";
 /** Ends a failed turn; it is the failure route of `RunModel` and `CompactContext`, so it takes either's input. */
 export class RecordTurnFailureStep {
     transitions;
@@ -959,15 +1062,48 @@ export class RecordTurnFailureStep {
     }
     execute(context) {
         const transitions = this.transitions;
+        if (isStateLimitFailure(context.recoveryError)) {
+            return recordFailedSession(transitions, context, readRecoveryDetail(context));
+        }
         const state = transitions.readAgentState(context);
         const toolCalls = transitions.readTurnToolCalls(context, state.activeTurnId);
         const finalToolCalls = toolCalls.filter((toolCall) => isFinalToolCallStatus(toolCall.status));
         const unfinishedTurnMessages = state.activeTurnId === null
             ? null
             : transitions.buildUnfinishedTurnMessages(context, state, state.activeTurnId, finalToolCalls);
-        return recordFailedTurn(transitions, context, state, toolCalls, unfinishedTurnMessages ?? [], readRecoveryDetail(context));
+        // A refused model call moves here on purpose, with its reason already in the state.
+        const error = context.recoveryError === undefined && state.lastTurnError ? state.lastTurnError : readRecoveryDetail(context);
+        return recordFailedTurn(transitions, context, state, toolCalls, unfinishedTurnMessages ?? [], error);
     }
 }
+/** Reports whether a Step failed because its commit would exceed the Flow's state limit. */
+export function isStateLimitFailure(recoveryError) {
+    // The Server gives this failure no code of its own; a value over its own limit shares the type.
+    return recoveryError?.errorType === stateLimitErrorType && recoveryError.detail.includes(stateLimitErrorText);
+}
+/**
+ * Ends a session whose Flow reached the state limit, in one commit with the Flow's close. This commit is checked
+ * against the same limit, so it stores no turn messages and keeps the turn's tool call records. When it does not
+ * fit, Dex fails the Flow with the same text and `AgentState` stays as it was; see `agent-session-failure.ts`.
+ */
+function recordFailedSession(transitions, context, error) {
+    const persistence = transitions.persistence;
+    const state = transitions.readAgentState(context);
+    persistence.frameworkRunState.delete(context);
+    if (transitions.readPendingInterrupts(context).length > 0) {
+        persistence.pendingInterrupts.set(context, []);
+    }
+    transitions.writeAgentState(context, {
+        ...state,
+        status: "failed",
+        turnCount: state.turnCount + (state.activeTurnId === null ? 0 : 1),
+        activeTurnId: null,
+        lastTurnError: error,
+        acceptsTurnControl: false,
+    });
+    transitions.writeEvents(context, state.activeTurnId, (events) => events.writeEvent("turn_failed", { error }));
+    return forceFail(error);
+}
 /**
  * Ends the active turn as failed in the current commit: appends the unfinished-turn messages, then the
  * turn-failure note when the turn has final records, and clears the turn.
@@ -1106,6 +1242,63 @@ export function toolStepOptions(persistence, stepType, toolCallId) {
 export function toolStepMovement(persistence, stepType, toolCallId) {
     return StepMovement.of(new StepRef(stepType), toolCallId, toolStepOptions(persistence, stepType, toolCallId));
 }
+/**
+ * Returns the movement that starts an approved call's tool Step, with the runner's timeout and retry policy.
+ * Only `CallTool` takes the retry policy; `CallSingleAttemptTool` keeps one attempt.
+ */
+export function toolCallMovement(transitions, toolCall) {
+    const stepType = toolStepTypeForEffect(toolCall.effect);
+    const options = toolStepOptions(transitions.persistence, stepType, toolCall.toolCallId);
+    const overrides = readToolCallStepOptions(transitions, toolCall);
+    return StepMovement.of(new StepRef(stepType), toolCall.toolCallId, {
+        ...options,
+        ...(overrides?.executeMethodTimeout === undefined ? {} : { executeMethodTimeoutMs: overrides.executeMethodTimeout }),
+        ...(overrides?.executeRetry === undefined || stepType !== agentSessionStepTypes.callTool
+            ? {}
+            : { executeRetry: overrides.executeRetry }),
+    });
+}
+function readToolCallStepOptions(transitions, toolCall) {
+    const provide = transitions.runner.toolCallStepOptions;
+    if (provide === undefined) {
+        return undefined;
+    }
+    try {
+        return provide.call(transitions.runner, toRunnerToolCall(toolCall));
+    }
+    catch (error) {
+        // The call then runs with the defaults; a missing tool fails by its effect class.
+        console.warn(`dex-agents: toolCallStepOptions failed for ${toolCall.toolName}:`, error);
+        return undefined;
+    }
+}
+function toolApprovalInterrupt(toolCall, createdAt, deadline) {
+    return {
+        interruptId: toolCall.toolCallId,
+        kind: "tool_approval",
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        arguments: toolCall.arguments,
+        createdAt,
+        deadline,
+        question: null,
+        choices: [],
+        allowsFreeText: true,
+    };
+}
+function interruptDeadline(transitions, createdAt) {
+    const deadlineMs = transitions.config.interruptDeadlineMs;
+    return deadlineMs === undefined ? null : new Date(createdAt.getTime() + deadlineMs).toISOString();
+}
+function skippedToolCall(toolCall) {
+    return {
+        ...toolCall,
+        status: "failed",
+        writeQueued: false,
+        skipped: true,
+        error: `${toolCallNotRunErrorPrefix}: ${toolCallSkippedAfterWriteDetail}`,
+    };
+}
 /**
  * Returns the options of `PollToolTask`. It takes no lock and never waits on a cancellation: it owns the
  * record, and a started task runs on.
@@ -1193,6 +1386,10 @@ function createToolCallRecord(batch, requestedToolCall, effect, requiresApproval
         taskId: null,
         taskPollIntervalSeconds: null,
         taskAnswerPending: false,
+        orderedWrite: false,
+        writeQueued: false,
+        skipped: false,
+        truncatedOutputBytes: null,
     };
 }
 function writeToolCallDeferred(events, record) {