maka-agent 0.2.2-dev.92.20261019 → 0.2.2-dev.97.20261024

package/node_modules/@maka/eval/node_modules/undici/lib/web/websocket/receiver.js

@@ -16,6 +16,7 @@ const { failWebsocketConnection } = require('./connection')
 const { WebsocketFrameSend } = require('./frame')
 const { PerMessageDeflate } = require('./permessage-deflate')
 const { MessageSizeExceededError } = require('../../core/errors')
+const { defaultWebSocketMaxFragments, defaultWebSocketMaxPayloadSize } = require('../../core/constants')
 
 // This code was influenced by ws released under the MIT license.
 // Copyright (c) 2011 Einar Otto Stangvik <einaros@gmail.com>
@@ -48,18 +49,25 @@ class ByteParser extends Writable {
   /**
    * @param {import('./websocket').Handler} handler
    * @param {Map<string, string>|null} extensions
-   * @param {{ maxPayloadSize?: number }} [options]
+   * @param {{ maxFragments?: number, maxPayloadSize?: number }} [options]
+   *   A missing value uses the default limit; `0` disables the limit.
    */
   constructor (handler, extensions, options = {}) {
     super()
 
     this.#handler = handler
     this.#extensions = extensions == null ? new Map() : extensions
-    this.#maxFragments = options.maxFragments ?? 0
-    this.#maxPayloadSize = options.maxPayloadSize ?? 0
+    // Options come from the dispatcher's `webSocketOptions`, which only
+    // DispatcherBase provides. Fall back to the defaults rather than to no
+    // limit, so RetryAgent, MockAgent or a custom dispatcher can't turn off
+    // the payload and decompression limits by accident.
+    this.#maxFragments = options.maxFragments ?? defaultWebSocketMaxFragments
+    this.#maxPayloadSize = options.maxPayloadSize ?? defaultWebSocketMaxPayloadSize
 
     if (this.#extensions.has('permessage-deflate')) {
-      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, options))
+      this.#extensions.set('permessage-deflate', new PerMessageDeflate(extensions, {
+        maxPayloadSize: this.#maxPayloadSize
+      }))
     }
   }
 
@@ -244,6 +252,19 @@ class ByteParser extends Writable {
         if (isControlFrame(this.#info.opcode)) {
           this.#loop = this.parseControlFrame(body)
           this.#state = parserStates.INFO
+
+          // If the automatic PONG/CLOSE reply filled the socket's write buffer,
+          // stop parsing and resume on drain so a PING flood cannot grow the
+          // outbound queue without bound.
+          if (this.#loop && this.#handler.socket.writableNeedDrain) {
+            this.#loop = false
+            this.#handler.socket.once('drain', () => {
+              if (this.destroyed) return
+              this.#loop = true
+              this.run(callback)
+            })
+            return
+          }
         } else {
           if (!this.#info.compressed) {
             if (!this.writeFragments(body)) {

package/node_modules/@maka/eval/node_modules/undici/package.json

@@ -1,6 +1,6 @@
 {
   "name": "undici",
-  "version": "8.11.2",
+  "version": "8.12.3",
   "description": "An HTTP/1.1 client, written from scratch for Node.js",
   "homepage": "https://undici.nodejs.org",
   "bugs": {
@@ -63,13 +63,15 @@
   "types": "index.d.ts",
   "scripts": {
     "build:node": "esbuild index-fetch.js --bundle --platform=node --outfile=undici-fetch.js --define:esbuildDetection=1 --keep-names && node scripts/strip-comments.js",
-    "build:wasm": "node build/wasm.js --docker",
+    "build:milo": "node build/milo.js",
+    "build:llhttp": "node build/llhttp.js --docker",
+    "build:wasm": "node build/llhttp.js --docker",
     "generate-pem": "node scripts/generate-pem.js",
     "lint": "eslint --cache",
     "lint:fix": "eslint --fix --cache",
     "test": "npm run test:javascript && cross-env NODE_V8_COVERAGE= npm run test:typescript",
     "test:javascript": "npm run test:javascript:no-jest && npm run test:jest",
-    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:wpt && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
+    "test:javascript:no-jest": "npm run generate-pem && npm run test:unit && npm run test:fetch && npm run test:node-fetch && npm run test:infra && npm run test:cache && npm run test:cache-interceptor && npm run test:interceptors && npm run test:cookies && npm run test:eventsource && npm run test:subresource-integrity && npm run test:websocket && npm run test:node-test && npm run test:cache-tests",
     "test:javascript:without-intl": "npm run test:javascript:no-jest",
     "test:busboy": "borp --timeout 180000 -p \"test/busboy/*.js\"",
     "test:cache": "borp --timeout 180000 -p \"test/cache/*.js\"",
@@ -97,7 +99,7 @@
     "test:websocket:autobahn": "node test/autobahn/client.js",
     "test:websocket:autobahn:report": "node test/autobahn/report.js",
     "test:wpt:setup": "node test/web-platform-tests/wpt-runner.mjs setup",
-    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource",
+    "test:wpt": "npm run test:wpt:setup && node test/web-platform-tests/wpt-runner.mjs run /fetch /mimesniff /xhr /websockets /eventsource /service-workers",
     "test:cache-tests": "node test/cache-interceptor/cache-tests.mjs --ci",
     "coverage": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report",
     "coverage:ci": "npm run coverage:clean && cross-env NODE_V8_COVERAGE=./coverage/tmp npm run test:javascript && npm run coverage:report:ci",
@@ -109,7 +111,7 @@
     "prepare": "husky && node ./scripts/platform-shell.js"
   },
   "devDependencies": {
-    "@fastify/busboy": "3.2.2",
+    "@fastify/busboy": "3.2.3",
     "@matteo.collina/tspl": "^0.2.0",
     "@metcoder95/https-pem": "^1.0.0",
     "@sinonjs/fake-timers": "^12.0.0",
@@ -120,12 +122,12 @@
     "cross-env": "^10.0.0",
     "dns-packet": "^5.4.0",
     "esbuild": "^0.28.0",
-    "eslint": "^9.9.0",
+    "eslint": "^10.12.0",
     "fast-check": "^4.1.1",
     "husky": "^9.0.7",
     "jest": "^30.0.5",
     "jsondiffpatch": "^0.7.3",
-    "neostandard": "^0.13.0",
+    "neostandard": "^0.14.0",
     "node-forge": "^1.3.1",
     "proxy": "^4.0.0",
     "tsd": "^0.33.0",

package/node_modules/@maka/mcp/package.json

@@ -10,6 +10,6 @@
   },
   "dependencies": {
     "@maka/core": "0.1.0",
-    "@modelcontextprotocol/client": "2.2.0"
+    "@modelcontextprotocol/client": "2.3.0"
   }
 }

package/node_modules/@maka/runtime/dist/ai-sdk-compaction.js

@@ -884,10 +884,10 @@ export class AiSdkCompaction {
     /**
      * Reactive overflow recovery (issue #882 PR 2): the second line of defense.
      * When a provider rejects a request with a context-length error, fold the
-     * durable turn ledger and resend — once per step: a step that a fold or an
-     * image omission has already reshaped gets no second recovery, so the
-     * resend's own rejection is terminal, while a step the provider has since
-     * accepted earns a fresh attempt. Returns the compacted messages to resend,
+     * durable turn ledger and resend. Each step may omit historical images once,
+     * then fold once; a rejection after the fold is terminal. A step the
+     * provider has since accepted earns a fresh recovery sequence. Returns the
+     * compacted messages to resend,
      * or undefined when recovery is impossible or already spent, in which case
      * the caller surfaces the real provider error rather than a fabricated
      * success or a locally synthesized verdict (the provider — not the runtime —
@@ -897,12 +897,14 @@ export class AiSdkCompaction {
      */
     async recoverFromOverflowError(input) {
         const state = input.midTurnState;
-        if (!state || state.stepShaping.has('fold') || state.stepShaping.has('omit_images')) {
+        if (!state || state.stepShaping.has('fold')) {
             return undefined;
         }
         const eligibleImages = collectHistoricalImageToolResults(state.priorContentEvents);
-        const imageOmission = omitHistoricalImageToolResults(input.currentMessages, eligibleImages);
-        if (imageOmission.omittedParts > 0) {
+        const imageOmission = state.stepShaping.has('omit_images')
+            ? undefined
+            : omitHistoricalImageToolResults(input.currentMessages, eligibleImages);
+        if (imageOmission && imageOmission.omittedParts > 0) {
             state.stepShaping.add('omit_images');
             for (const toolCallId of imageOmission.omittedToolCallIds) {
                 const image = eligibleImages.get(toolCallId);
@@ -912,6 +914,15 @@ export class AiSdkCompaction {
                 if (image)
                     state.omittedImageToolResults.set(toolCallId, image);
             }
+            input.onDiagnosticPatch(compactionDecisionDiagnosticPatch({
+                stage: 'activeStep',
+                sourceKind: 'providerMessages',
+                decision: 'replaced',
+                phase: state.compactionPhase(input.stepNumber),
+                boundaryKind: 'imageOmission',
+                coverage: { toolCallIds: [...imageOmission.omittedToolCallIds] },
+                reason: 'overflow',
+            }));
             state.baselineTokens = undefined;
             return { messages: imageOmission.messages };
         }
@@ -962,7 +973,9 @@ export class AiSdkCompaction {
         // The fold replaced the request; the baseline described the rejected one.
         state.stepShaping.add('fold');
         state.baselineTokens = undefined;
-        return { messages: outcome.replacementMessages };
+        return {
+            messages: projectHistoricalImageOmissions(outcome.replacementMessages, state.omittedImageToolResults) ?? outcome.replacementMessages,
+        };
     }
 }
 function projectHistoricalImageOmissions(messages, omittedImageToolResults) {
@@ -1048,7 +1061,7 @@ export class MidTurnCapacityCompactState {
     /**
      * What has reshaped the request since the last one a provider accepted. The
      * turn clears it at that acceptance; overflow recovery reads it so a request
-     * that was already folded or stripped of images is not reshaped again.
+     * is folded at most once, after an optional image omission.
      */
     stepShaping = new Set();
     /**

package/node_modules/@maka/runtime/dist/ai-sdk-message-projection.js

@@ -19,8 +19,9 @@
 import { MAX_PROVIDER_IMAGE_REQUEST_BYTES, PROVIDER_IMAGE_BUDGET_EXCEEDED_MESSAGE, } from '@maka/core/attachments';
 import { applyPatchReplayFactText, normalizeApplyPatchReplayInput, } from './apply-patch-profile.js';
 import { durableProjectionToToolResultOutput } from './durable-tool-result-projection.js';
+import { runtimeContextMessage } from './runtime-context.js';
 import { historyCompactCheckpointToModelMessage, isProviderHistoryCompactCheckpoint, } from './history-compact-checkpoint.js';
-import { admitProviderReasoningReplayItems, buildRuntimeEventReplayTimeline, formatTextWithInlineRefs, steeringProviderOptions, } from './model-history.js';
+import { admitProviderReasoningReplayItems, buildRuntimeEventReplayTimeline, formatTextWithInlineRefs, steeringProviderOptions, runtimeContextProviderOptions, } from './model-history.js';
 import { openAiChatReasoningFieldFromProviderOptions } from './openai-chat-reasoning-transport.js';
 import { decodePlaintextResponsesReasoningState, replayPlaintextResponsesProviderOptions, } from './responses-reasoning-state.js';
 import { toolResultOutput } from './tool-result-output.js';
@@ -464,6 +465,11 @@ export class AiSdkMessageProjection {
         messages.push(message);
         this.memoryReplayMessageEvents.set(message, [...new Set(eventIds)]);
     }
+    materializeRuntimeContext(context, eventId) {
+        const message = runtimeContextMessage(context);
+        this.memoryReplayMessageEvents.set(message, [eventId]);
+        return message;
+    }
     memoryEventMessagePositions(messages) {
         const positions = {};
         for (const [position, message] of messages.entries()) {
@@ -492,6 +498,9 @@ export class AiSdkMessageProjection {
             return {
                 role: 'user',
                 content,
+                ...(item.runtimeContextName !== undefined
+                    ? { providerOptions: runtimeContextProviderOptions(item.runtimeContextName) }
+                    : {}),
             };
         }
         return {

package/node_modules/@maka/runtime/dist/ai-sdk-turn.js

@@ -45,6 +45,7 @@ import { portableApplyPatchTool } from './apply-patch-profile.js';
 import { RunTrace } from './run-trace.js';
 import { REQUEST_SANDBOX_BOUNDARY_TOOL_NAME, SANDBOX_BOUNDARY_DENIED_FOR_TURN, SANDBOX_BOUNDARY_FINALIZATION_PROMPT, requiredSandboxBoundaryToolNames, } from './sandbox-boundary-tool.js';
 import { buildRuntimeEventModelReplayPlan, appendPriorUnknownToolResponses, buildSteeringEnvelope, collectToolActivityTurnIds, compatibleProviderReasoningReplayEventIds, formatTextWithInlineRefs, inspectPriorUnknownToolOutcomes, steeringMessagesMissingFromBase, steeringModelMessage, } from './model-history.js';
+import { changedRuntimeContexts } from './runtime-context.js';
 import { toolSchemaCharsForDiagnostics, requestCompositionToolSchemas, stableHash, toolCatalogHash, } from './request-shape.js';
 import { toolAvailabilityHash } from './tool-availability.js';
 import { hasFinalizedReasoning } from './ai-sdk-message-projection.js';
@@ -389,8 +390,8 @@ export class AiSdkTurn {
     abortController = new AbortController();
     activeTools;
     aborted = false;
-    loopStopRequested = false;
-    loopStopReason;
+    stopRequested = false;
+    turnYield;
     handoffPaused = false;
     watchdog = null;
     runTrace = null;
@@ -430,8 +431,8 @@ export class AiSdkTurn {
         await this.toolRuntime.endTurn(this.aborted ? 'aborted' : 'completed');
     }
     requestStop(reason, mode) {
+        this.stopRequested = true;
         if (mode === 'after_step') {
-            this.loopStopRequested = true;
             this.runTrace?.abortRequested(reason);
             return;
         }
@@ -439,6 +440,9 @@ export class AiSdkTurn {
         this.abortController.abort();
         this.runTrace?.abortRequested(reason);
     }
+    get loopStopReason() {
+        return this.stopRequested ? 'user_stop' : this.turnYield;
+    }
     async endAbortedTools() {
         await this.toolRuntime.endTurn('aborted');
     }
@@ -1092,6 +1096,24 @@ export class AiSdkTurn {
                         ? currentTurnMessages
                         : [...priorReplay.messages, ...currentTurnMessages];
                 };
+                const appendRuntimeContexts = async (history, contexts) => {
+                    const additions = changedRuntimeContexts(contexts, history).map((context) => ({
+                        context,
+                        id: this.deps.newId(),
+                    }));
+                    for (const { context, id } of additions) {
+                        queue.push({ type: 'runtime_context', id, turnId, ts: this.deps.now(), ...context });
+                    }
+                    if (additions.length === 0)
+                        return history;
+                    // Persist before dispatch; retries reuse the same snapshot. Context
+                    // removed by compaction is refreshed after that fold, not lost in it.
+                    await queue.waitUntilConsumedThroughCurrent();
+                    return [
+                        ...history,
+                        ...additions.map(({ context, id }) => this.deps.messageProjection.materializeRuntimeContext(context, id)),
+                    ];
+                };
                 // Tool Availability describes the provider-visible (active) subset. A
                 // group loaded this turn expands that subset on later requests, so the
                 // terminal trace is refined against the final active set below.
@@ -1126,7 +1148,7 @@ export class AiSdkTurn {
                 let finishFeedback;
                 let result;
                 let providerOutcome;
-                let finishReason = 'stop';
+                let terminalStopReason;
                 let terminalProviderError;
                 agentLoop: for (;;) {
                     ({ plan, providerTools, modelTools, nestedTools } = snapshotStepTools());
@@ -1188,7 +1210,6 @@ export class AiSdkTurn {
                             activeTools,
                         };
                     };
-                    const dynamicContextMessages = (resolvedSystemPrompt.contexts ?? []).map(({ text }) => ({ role: 'user', content: text }));
                     const shaped = requestProjection
                         ? await requestProjection({
                             completedSteps: completedProviderSteps,
@@ -1220,9 +1241,10 @@ export class AiSdkTurn {
                         })
                         : undefined;
                     providerRequestTracker?.setStep(runtimeSteps, requestCompositionId);
-                    let attemptMessages = projectedMessages;
+                    let attemptMessages = await appendRuntimeContexts(projectedMessages, resolvedSystemPrompt.contexts ?? []);
                     let overflowRecoveryMaxOutputTokens;
                     let providerAttempt = 0;
+                    let pendingRetryReason;
                     const returnedToolCalls = [];
                     const providerToolInputs = new Map();
                     let providerStepUsage;
@@ -1243,8 +1265,7 @@ export class AiSdkTurn {
                         let attemptSawReplayBarrier = false;
                         const attemptHasNoObservableOutput = () => !attemptSawVisibleContent && !attemptSawToolActivity && !attemptSawReplayBarrier;
                         const attemptCanReplay = () => !attemptSawToolActivity && !attemptSawReplayBarrier;
-                        // Request-only facts must survive history replacement and overflow recovery.
-                        const dispatchMessages = [...attemptMessages, ...dynamicContextMessages];
+                        const dispatchMessages = attemptMessages;
                         this.memorySourceMessages = dispatchMessages;
                         this.memorySourceEventMessagePositions =
                             this.deps.messageProjection.memoryEventMessagePositions(dispatchMessages);
@@ -1267,6 +1288,24 @@ export class AiSdkTurn {
                         // rebuilt in place by overflow recovery, and the boundary it folded
                         // under must travel with that rebuild, not with the step.
                         const historyCompactBoundary = requestHistoryCompactBoundary();
+                        // Stop can arrive during handoff, retry backoff, or overflow recovery.
+                        if (this.loopStopReason) {
+                            terminalStopReason = this.loopStopReason;
+                            break agentLoop;
+                        }
+                        if (pendingRetryReason) {
+                            queue.push({
+                                type: 'provider_retry',
+                                id: this.deps.newId(),
+                                turnId,
+                                ts: this.deps.now(),
+                                phase: 'started',
+                                attempt: providerAttempt,
+                                maxAttempts: MAX_PROVIDER_ATTEMPTS_PER_STEP,
+                                reason: pendingRetryReason,
+                            });
+                            pendingRetryReason = undefined;
+                        }
                         result = await this.deps.modelAdapter.startStream({
                             model,
                             messages: dispatchMessages,
@@ -1596,7 +1635,7 @@ export class AiSdkTurn {
                                     !attemptSawToolInput &&
                                     returnedToolCalls.length === 0))
                                 sawUnusableStepUsage = true;
-                            if (this.loopStopRequested) {
+                            if (this.loopStopReason) {
                                 terminalProviderError = failure;
                                 terminalProviderErrorReason =
                                     lastCompletedStepHadToolResult && failure.kind === 'timeout'
@@ -1633,7 +1672,7 @@ export class AiSdkTurn {
                                 })
                                 : undefined;
                             if (recovered) {
-                                attemptMessages = recovered.messages;
+                                attemptMessages = await appendRuntimeContexts(recovered.messages, resolvedSystemPrompt.contexts ?? []);
                                 overflowRecoveryMaxOutputTokens = Math.min(this.deps.modelAdapter.maxOutputTokens() ?? CONTEXT_RECOVERY_MAX_OUTPUT_TOKENS, CONTEXT_RECOVERY_MAX_OUTPUT_TOKENS);
                                 continue;
                             }
@@ -1716,16 +1755,7 @@ export class AiSdkTurn {
                                     reason,
                                 });
                                 await this.deps.providerRetrySleep(delayMs, turnAbortController.signal);
-                                queue.push({
-                                    type: 'provider_retry',
-                                    id: this.deps.newId(),
-                                    turnId,
-                                    ts: this.deps.now(),
-                                    phase: 'started',
-                                    attempt: nextAttempt,
-                                    maxAttempts,
-                                    reason,
-                                });
+                                pendingRetryReason = reason;
                                 continue;
                             }
                             // Unrecoverable (not context-length, this step's attempt spent,
@@ -1752,7 +1782,7 @@ export class AiSdkTurn {
                     const providerStepId = currentStepMessageId;
                     if (providerOutcome.kind !== 'completed')
                         throw providerOutcome.failure;
-                    finishReason = providerOutcome.finishReason;
+                    const finishReason = providerOutcome.finishReason;
                     await queue.waitUntilConsumedThroughCurrent();
                     let toolRequestedFinish = false;
                     if (returnedToolCalls.length > 0) {
@@ -1843,8 +1873,7 @@ export class AiSdkTurn {
                             if (returnedToolCalls.length === 1 &&
                                 !settlement.providerError &&
                                 isEventWaitYieldReceipt(settlement.result)) {
-                                this.loopStopReason = 'event_wait';
-                                this.loopStopRequested = true;
+                                this.turnYield = 'event_wait';
                             }
                             if (isPlanToolResult(settlement.result)) {
                                 this.handlePlanToolResult(settlement.result, queue);
@@ -1859,9 +1888,7 @@ export class AiSdkTurn {
                         // an entire completed batch across the next provider request.
                         settlementOutcomes.length = 0;
                         await queue.waitUntilConsumedThroughCurrent();
-                        const continuationWillRun = (maxSteps === undefined || runtimeSteps < maxSteps) &&
-                            !this.loopStopRequested &&
-                            !this.aborted;
+                        const continuationWillRun = (maxSteps === undefined || runtimeSteps < maxSteps) && !this.loopStopReason;
                         if (continuationWillRun && providerOutcome.continuation === 'pending') {
                             const persistedProjection = await loadDurableTurnProjection();
                             const responseMessages = persistedOpenAiResponsesStepMessages(attemptMessages, persistedProjection, returnedToolCalls.map((toolCall) => toolCall.toolCallId));
@@ -1878,119 +1905,72 @@ export class AiSdkTurn {
                         ...(providerStepUsage ? { usage: providerStepUsage } : {}),
                     });
                     lastCompletedStepHadToolResult = returnedToolCalls.length > 0;
-                    // Finish only after the tool result is durably consumed. The Host can
-                    // veto completion (for example, new Inbox input raced with Sleep).
-                    if (toolRequestedFinish && !this.aborted && !this.loopStopRequested) {
-                        const decision = await this.deps.backend.beforeTurnFinish?.({
-                            sessionId: this.deps.backend.sessionId,
-                            turnId,
-                            signal: turnAbortController.signal,
-                        });
-                        if (!decision || decision.allow) {
-                            finishReason = 'stop';
-                            this.deps.modelAdapter.clearContinuation(this.turnId);
-                            break agentLoop;
-                        }
-                        finishFeedback = decision.feedback;
-                    }
                     const stepLimitReached = maxSteps !== undefined && runtimeSteps >= maxSteps;
                     if (sandboxBoundaryFinalizationStep ||
                         (stepLimitReached &&
                             (toolRuntime.shouldFinalizeSandboxBoundary() ||
                                 toolRuntime.hasSandboxBoundaryDenial()))) {
-                        this.loopStopReason = 'permission_handoff';
-                        this.loopStopRequested = true;
-                    }
-                    const mayTakeAnotherStep = !stepLimitReached && !this.loopStopRequested && !this.aborted;
-                    if (returnedToolCalls.length > 0 && mayTakeAnotherStep) {
-                        if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                            this.handoffPaused = true;
-                            break agentLoop;
-                        }
-                        if (this.aborted || this.loopStopRequested)
-                            break agentLoop;
-                        currentStepMessageId = this.deps.newId();
-                        continue agentLoop;
+                        this.turnYield = 'permission_handoff';
                     }
+                    let finishCandidateReason = returnedToolCalls.length > 0 && !toolRequestedFinish
+                        ? undefined
+                        : toolRequestedFinish
+                            ? 'end_turn'
+                            : this.deps.modelAdapter.mapFinishReason(finishReason);
                     // Enforce Host prerequisites locally: some providers reject required
                     // tool_choice in thinking mode. Never silently complete without the
                     // receipt; replay the draft and per-step reminder for bounded repair.
                     if (returnedToolCalls.length === 0 &&
                         resolvedSystemPrompt.requireToolCall &&
-                        !this.loopStopRequested &&
-                        !this.aborted) {
-                        if (!mayTakeAnotherStep ||
+                        !this.loopStopReason) {
+                        if (stepLimitReached ||
                             !this.deps.backend.loadTurnRuntimeEvents ||
                             ++missingPrerequisiteAttempts > 2) {
                             throw new Error('Required turn prerequisite was not recorded; cannot complete this response.');
                         }
-                        await queue.waitUntilConsumedThroughCurrent();
-                        if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                            this.handoffPaused = true;
-                            break agentLoop;
-                        }
-                        if (this.aborted || this.loopStopRequested)
-                            break agentLoop;
-                        currentStepMessageId = this.deps.newId();
-                        continue agentLoop;
+                        finishCandidateReason = undefined;
                     }
-                    // Continuing the turn needs the durable current-run reader, for the
-                    // same reason the tool-call edge above demands it: the next request
-                    // has to carry the assistant output this step just produced, and only
-                    // the ledger projection has it. The no-reader fallback at the top of
-                    // the loop appends steering alone, which would ask the model to
-                    // redirect work it cannot see. Without a reader this edge is skipped
-                    // rather than throwing — the turn still completes and the Host folds
-                    // the message into the next Turn, which is today's behaviour.
-                    if (mayTakeAnotherStep && this.deps.backend.loadTurnRuntimeEvents) {
-                        // Last chance for a steer that landed after this turn's final
-                        // tool-call boundary — including the only boundary a tool-free
-                        // turn has, which precedes the model's first token. Without it the
-                        // message is never pulled at all, and whether Steer works would
-                        // depend on the model happening to call a tool afterwards (#3529).
-                        // A step-limited turn deliberately skips this: its budget is spent,
-                        // and the Host folds the message into the next Turn instead.
+                    // The Host carries steering left unconsumed here into the next Turn.
+                    if (finishCandidateReason !== undefined &&
+                        !toolRequestedFinish &&
+                        !stepLimitReached &&
+                        !this.loopStopReason &&
+                        this.deps.backend.loadTurnRuntimeEvents) {
                         const injectedBefore = this.injectedSteeringMessages.length;
                         await this.drainSteeringInto(input, queue);
-                        // Re-read the stop flags: the drain awaits a durable push, so an
-                        // `after_step` stop or an abort can land while it is in flight, and
-                        // `mayTakeAnotherStep` is stale by now. Stop wins — the message is
-                        // already durable, so the Host folds it into the next Turn.
-                        if (this.injectedSteeringMessages.length > injectedBefore &&
-                            !this.loopStopRequested &&
-                            !this.aborted) {
-                            await queue.waitUntilConsumedThroughCurrent();
-                            if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                                this.handoffPaused = true;
-                                break agentLoop;
-                            }
-                            if (this.aborted || this.loopStopRequested)
-                                break agentLoop;
-                            currentStepMessageId = this.deps.newId();
-                            continue agentLoop;
-                        }
+                        if (this.injectedSteeringMessages.length > injectedBefore)
+                            finishCandidateReason = undefined;
                     }
-                    if (mayTakeAnotherStep &&
-                        returnedToolCalls.length === 0 &&
-                        this.deps.backend.beforeTurnFinish &&
-                        this.deps.backend.loadTurnRuntimeEvents &&
-                        this.deps.modelAdapter.mapFinishReason(finishReason) === 'end_turn') {
-                        const decision = await this.deps.backend.beforeTurnFinish({
+                    // Finishing needs Host approval even when no continuation is possible.
+                    if (finishCandidateReason === 'end_turn' && !this.loopStopReason) {
+                        const finishDecision = await this.deps.backend.beforeTurnFinish?.({
                             sessionId: this.deps.backend.sessionId,
                             turnId,
                             signal: turnAbortController.signal,
                         });
-                        if (!decision.allow && !this.aborted && !this.loopStopRequested) {
-                            if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
-                                this.handoffPaused = true;
-                                break agentLoop;
-                            }
-                            finishFeedback = decision.feedback;
-                            currentStepMessageId = this.deps.newId();
-                            continue agentLoop;
+                        if (finishDecision && !finishDecision.allow) {
+                            finishFeedback = finishDecision.feedback;
+                            finishCandidateReason = undefined;
                         }
+                        else if (toolRequestedFinish) {
+                            this.deps.modelAdapter.clearContinuation(this.turnId);
+                        }
+                    }
+                    terminalStopReason =
+                        this.loopStopReason ??
+                            finishCandidateReason ??
+                            (stepLimitReached ? 'step_limit' : undefined);
+                    if (terminalStopReason)
+                        break agentLoop;
+                    if (!this.deps.backend.loadTurnRuntimeEvents) {
+                        throw new Error('durable current-run reader is required for turn continuation');
                     }
-                    break agentLoop;
+                    await queue.waitUntilConsumedThroughCurrent();
+                    if ((await input.handoffBoundary?.(turnAbortController.signal, maxSteps === undefined ? null : maxSteps - runtimeSteps)) === 'pause') {
+                        this.handoffPaused = true;
+                        break agentLoop;
+                    }
+                    currentStepMessageId = this.deps.newId();
                 }
                 // Refine Tool Availability against the final active set. Deferred
                 // loading may add tools, while boundary convergence may remove them;
@@ -2006,7 +1986,7 @@ export class AiSdkTurn {
                 // silently drop prior requests. An unusable sample in ANY request fails
                 // the whole record closed (#972).
                 try {
-                    const attemptTotalUsage = providerOutcome.usage;
+                    const attemptTotalUsage = providerOutcome?.usage;
                     tokenUsage = sawUnusableStepUsage ? undefined : (completedStepUsage ?? attemptTotalUsage);
                     if (tokenUsage) {
                         tokenUsageCostUsd = this.deps.providerTelemetry.normalizedUsageCostUsd(tokenUsage);
@@ -2110,10 +2090,9 @@ export class AiSdkTurn {
                 // seals the drained stream; no complete/abort event ends the logical Turn.
                 if (this.handoffPaused)
                     return;
-                const stopReason = this.loopStopReason ??
-                    (maxSteps !== undefined && finishReason === 'tool-calls'
-                        ? 'step_limit'
-                        : this.mapFinishReason(finishReason));
+                const stopReason = this.loopStopReason ?? terminalStopReason;
+                if (!stopReason)
+                    throw new Error('Turn ended without a terminal decision');
                 trace.modelStreamCompleted(stopReason);
                 const completeEvent = {
                     type: 'complete',
@@ -2281,7 +2260,7 @@ export class AiSdkTurn {
                 })),
                 isFatalToolError: isRuntimeCommitBoundaryError,
                 callTool: async (name, input, signal) => {
-                    if (this.loopStopRequested)
+                    if (this.loopStopReason)
                         throw new Error('The turn has yielded; no further tools may run.');
                     const tool = snapshot.get(name);
                     if (!tool)
@@ -2343,8 +2322,7 @@ export class AiSdkTurn {
                 revision: proposal.revision,
                 storeVersion: result.storeVersion,
             });
-            this.loopStopReason = 'plan_handoff';
-            this.loopStopRequested = true;
+            this.turnYield = 'plan_handoff';
             return;
         }
         const traceType = result.kind;
@@ -2365,11 +2343,7 @@ export class AiSdkTurn {
             liveOperatorCount: result.liveOperatorCount,
             reason: result.reason,
         });
-        this.loopStopReason = 'graph_yield';
-        this.loopStopRequested = true;
-    }
-    mapFinishReason(reason) {
-        return this.deps.modelAdapter.mapFinishReason(reason);
+        this.turnYield = 'graph_yield';
     }
     makeErrorEvent(turnId, err, reasonOverride) {
         return this.deps.modelAdapter.makeErrorEvent(turnId, err, reasonOverride);