@agent-native/core 0.227.0 → 0.228.0-nightly-20261111004142

package/dist/action.d.ts

@@ -38,6 +38,8 @@ export declare function resolveToolMaxResultChars(action: {
 }): number;
 export interface ActionRunContext {
     send?: (event: AgentChatEvent) => void;
+    /** Request a clean empty final after this invocation succeeds. Available only to agent tool calls; does not stop the model or override errors, receipts, or later instructions. */
+    settle?: () => void;
     /**
      * Result cap the agent loop enforces on this call, from
      * `resolveToolMaxResultChars`. Absent outside the agent loop.
@@ -92,12 +94,14 @@ export interface ActionRunContext {
     approvedToolCallKey?: string;
     /**
      * The client behind a `caller: "mcp"` call. `name` and `version` are its
-     * self-reported `clientInfo`. `oauthClientId` is the OAuth client its
-     * credential was issued to.
+     * self-reported `clientInfo`, and `userAgent` its self-reported HTTP
+     * User-Agent. `oauthClientId` is the OAuth client its credential was issued
+     * to.
      */
     mcpClient?: {
         name?: string;
         version?: string;
+        userAgent?: string;
         oauthClientId?: string;
     };
 }

package/dist/agent/engine/builder-engine.js

@@ -194,7 +194,12 @@ class BuilderEngine {
         const toolNameMap = createProviderToolNameMap(opts.tools, opts.messages);
         const providerTools = limitProviderTools(opts.tools);
         const messages = engineMessagesToBuilderGatewayAnthropic(await inlineOwnedToolResultImages(opts.messages), toolNameMap);
-        const tools = engineToolsToAnthropic(providerTools, toolNameMap);
+        const anthropicTools = engineToolsToAnthropic(providerTools, toolNameMap);
+        // The gateway sends GPT tools in OpenAI strict mode unless told otherwise,
+        // and strict mode makes the model fill every optional action argument.
+        const tools = /^gpt-/i.test(model)
+            ? anthropicTools.map((tool) => ({ ...tool, strict: false }))
+            : anthropicTools;
         const thinkingBudget = opts.providerOptions?.anthropic?.thinking?.budgetTokens;
         const reasoningEffort = normalizeReasoningEffortForModel(model, opts.reasoningEffort ??
             (typeof thinkingBudget === "number"

package/dist/agent/engine/tool-call-journal-seed.d.ts

@@ -1,3 +1,4 @@
+import type { WriteReceipt } from "../../action.js";
 import { type ArtifactReceipt } from "../../artifacts/detect.js";
 import { type ToolCallJournal } from "../tool-call-journal.js";
 import type { AgentChatEvent } from "../types.js";
@@ -25,6 +26,7 @@ export interface PriorTurnToolResultSummary {
     content: string;
     isError: boolean;
     artifacts?: ArtifactReceipt[];
+    receipt?: WriteReceipt;
 }
 export type PriorTurnToolCallJournalRead = {
     status: "read";

package/dist/agent/engine/tool-call-journal-seed.js

@@ -1,6 +1,7 @@
 import { isArtifactReceipt, } from "../../artifacts/detect.js";
 import { AgentRunJournalUnreadableError, getCompletedAgentExecutionSteps, getCurrentTurnEventsForThread, } from "../run-store.js";
 import { classifyToolCallJournal, isConsistentToolCallInputFingerprint, toolCallInputFingerprint, } from "../tool-call-journal.js";
+import { readWriteReceipt } from "../write-receipts.js";
 const LEDGER_READ_RETRY_MS = 250;
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
@@ -75,6 +76,7 @@ function durableStepToolDone(event, row, unreadable) {
     const mcpApp = durableStepMcpApp(outcome.mcpApp);
     const chatUI = durableStepChatUI(outcome.chatUI);
     const fileMutation = durableStepFileMutation(outcome.fileMutation);
+    const receipt = readWriteReceipt({ _receipt: outcome.receipt });
     return {
         type: "tool_done",
         tool: event.tool,
@@ -95,6 +97,16 @@ function durableStepToolDone(event, row, unreadable) {
             ? { errorCode: outcome.errorCode }
             : {}),
         completedSideEffect: outcome.completedSideEffect,
+        ...(outcome.hasAgentWarnings === true
+            ? { hasAgentWarnings: true }
+            : {}),
+        ...(receipt ? { receipt } : {}),
+        ...(!outcome.isError &&
+            outcome.actionSettled === true &&
+            outcome.settledOnCleanToolStop === true &&
+            outcome.replayTruncated !== true
+            ? { actionSettled: true, settledOnCleanToolStop: true }
+            : {}),
         ...(outcome.replayed === true ? { replayed: true } : {}),
         argumentsHash: input.argumentsHash,
         ...(artifacts.length > 0 ? { artifacts } : {}),
@@ -351,11 +363,13 @@ export async function loadPriorTurnToolCallJournal(threadId, turnId, options = {
                 matchedStart: call !== undefined,
             });
             const artifacts = event.artifacts?.filter(isArtifactReceipt);
+            const receipt = readWriteReceipt({ _receipt: event.receipt });
             priorToolResults.push({
                 name: event.tool,
                 input: event.input ?? call?.input,
                 content: event.result,
                 isError: event.isError === true,
+                ...(receipt ? { receipt } : {}),
                 ...(artifacts && artifacts.length > 0 ? { artifacts } : {}),
             });
         }

package/dist/agent/harness/store.js

@@ -151,6 +151,20 @@ export const agentHarnessSessionsStore = defineStore({
             name: "agent-harness-sessions-run-policy",
             sql: "ALTER TABLE agent_harness_sessions ADD COLUMN IF NOT EXISTS run_policy TEXT",
         },
+        {
+            // Local runtimes skip legacy v6/v7 and never re-run a recorded baseline.
+            // The injected client keeps a rolled-back caller transaction's catalog
+            // view from marking this done without the columns.
+            name: "agent-harness-sessions-approval-and-expiry-columns",
+            run: async (exec) => {
+                for (const column of [
+                    "approval_resolution_id",
+                    "expiry_cleanup_id",
+                ]) {
+                    await ensureColumnExists("agent_harness_sessions", column, `ALTER TABLE agent_harness_sessions ADD COLUMN IF NOT EXISTS ${column} TEXT`, { injectedClient: exec });
+                }
+            },
+        },
     ],
 });
 export function ensureAgentHarnessSessionTables() {

package/dist/agent/production-agent.js

@@ -7,7 +7,7 @@ import { defineEventHandler, getHeader, setResponseHeader, setResponseStatus, ge
 import { parseA2AAgentActivityPart } from "../a2a/activity.js";
 import "../authorization/check-action.js";
 import { actionCallIsRetrySafe, actionChangeResource, classifyActionCall, } from "../action-call-classification.js";
-import { runOutsideActionInvocation, vouchedOutcome } from "../action-frame.js";
+import { actionExecutionStorage, runOutsideActionInvocation, vouchedOutcome, } from "../action-frame.js";
 import { ACTION_CHAT_UI_RECORD_CHANGE_RENDERER, normalizeActionChangeResult, } from "../action-ui.js";
 import { AgentConnectionRequiredError, describeToolParameterSignature, isActionContractError, isActionHiddenFromEveryAgentSurface, isAgentActionStopError, isAgentConnectionRequiredError, actionCallIntent, ActionInputValidationError, telemetryInvalidPaths, invocationEffect, runPreparedActionCall, boundActionCallIntent, preparedCallArguments, preparedCallNeedsApproval, recordInvalidActionCall, resolveToolMaxResultChars, stripUnsupportedSchemaKeywords, } from "../action.js";
 import { resolveAgentKitIntegrationReferences } from "../agentkit/capabilities.js";
@@ -109,7 +109,7 @@ import { getStrictToolInputValidator } from "./strict-tool-input.js";
 import { normalizeSubmissionDeadlineMetadata } from "./submission-deadline.js";
 import { consumeAgentToolApproval, createAgentToolApproval, ensureAgentToolApprovalTable, hasPendingCurrentTurnApproval, isAgentToolAlwaysAllowed, resolveAgentToolApprovalTurnId, } from "./tool-approval-store.js";
 import { toolCallInputSignature } from "./tool-call-input-signature.js";
-import { ambiguousLegacyCallEffectKey, findAmbiguousLegacyJournalEntryForCall, findUnresolvedJournalStepForCall, findInterruptedLegacyJournalEntryForCall, findReplayableJournalEntry, hasJournalStepForCall, isUnavailableToolCallInput, journalEntriesAmbiguousInHistory, journalEntriesRepresentedInHistory, journalCallEffects, journalCallIdentities, matchToolCallResultsInHistory, toolCallIdentityKey, toolCallInputFingerprint, unmatchedAmbiguousLegacyToolCallResultsInHistory, } from "./tool-call-journal.js";
+import { ambiguousLegacyCallEffectKey, buildResumeJournalNote, findAmbiguousLegacyJournalEntryForCall, findUnresolvedJournalStepForCall, findInterruptedLegacyJournalEntryForCall, findReplayableJournalEntry, hasJournalStepForCall, isUnavailableToolCallInput, journalEntriesAmbiguousInHistory, journalEntriesRepresentedInHistory, journalCallEffects, journalCallIdentities, matchToolCallResultsInHistory, toolCallIdentityKey, toolCallInputFingerprint, unmatchedAmbiguousLegacyToolCallResultsInHistory, } from "./tool-call-journal.js";
 import { redactSensitiveFields, sanitizeToolErrorText, sanitizeToolErrorValue, } from "./tool-error-redaction.js";
 import { formatToolIndex } from "./tool-index.js";
 import { describeToolResultImages, extractAgentImagesFromActionResult, } from "./tool-result-images.js";
@@ -2875,6 +2875,7 @@ function serializeDurableExecutionStepOutcome(outcome) {
         replayTruncated: true,
         replayOmittedFields: omittedFields,
         ...(outcome.errorCode ? { errorCode: outcome.errorCode } : {}),
+        ...(outcome.hasAgentWarnings ? { hasAgentWarnings: true } : {}),
         ...(outcome.receipt ? { receipt: outcome.receipt } : {}),
     };
     let serialized;
@@ -5028,6 +5029,9 @@ export async function runAgentLoop(opts) {
     if (followUpRunId)
         send({ type: "suggestions", suggestions: [] });
     let model = normalizeModelForEngine(engine, opts.model);
+    let settlementCandidate = false;
+    let settledEmptyFinal = false;
+    let turnHasActionWarnings = false;
     let outcomeReported = false;
     const reportOutcome = (outcome) => {
         if (outcomeReported)
@@ -5045,11 +5049,11 @@ export async function runAgentLoop(opts) {
     // provider reads alongside those results.
     const deliverSteeredMessagesAtToolBoundary = async (toolResultParts) => {
         if (signal.aborted)
-            return;
+            return 0;
         const threadId = opts.threadId;
         const runId = opts.runId;
         if (!threadId || !runId)
-            return;
+            return 0;
         const { claimSteeredQueuedMessages } = await import("../chat-threads/store.js");
         let delivered;
         try {
@@ -5059,7 +5063,7 @@ export async function runAgentLoop(opts) {
             // The claim is one transaction, so a failure leaves the message queued
             // and on screen; it sends at a later boundary or after this reply.
             console.warn("[agent-chat] Send now delivery skipped at a tool boundary:", error instanceof Error ? error.message : String(error));
-            return;
+            return 0;
         }
         for (const { queued, record } of delivered) {
             toolResultParts.push(...buildUserContentWithAttachments({
@@ -5073,6 +5077,7 @@ export async function runAgentLoop(opts) {
                 continuationMessageId: record.continuationMessageId,
             });
         }
+        return delivered.length;
     };
     const deferSteeredMessagesPastFinalResponse = async () => {
         if (!opts.threadId || !opts.runId)
@@ -5260,6 +5265,11 @@ export async function runAgentLoop(opts) {
         recoverCompletedExecutionSteps: opts.recoverCompletedExecutionSteps === true,
     });
     const toolCallJournal = journalRead.status === "read" ? journalRead.toolCallJournal : null;
+    turnHasActionWarnings =
+        journalRead.status === "read" &&
+            journalRead.events.some((event) => event.type === "tool_done" &&
+                (event.hasAgentWarnings === true ||
+                    event.result.includes("<agent-warning ")));
     const journalHistory = messages.slice(findCurrentTurnStartForContinuation(messages));
     const journalEntriesAlreadyRepresented = toolCallJournal
         ? journalEntriesRepresentedInHistory(toolCallJournal, journalHistory)
@@ -5308,6 +5318,111 @@ export async function runAgentLoop(opts) {
     };
     toolCallHistory.push(...journaledPriorToolCalls);
     toolResultHistory.push(...journaledPriorToolResults);
+    if ((internalContinuationTurn ||
+        opts.recoverCompletedExecutionSteps === true) &&
+        toolCallJournal &&
+        toolCallJournal.interrupted.length === 0) {
+        const tail = journalHistory.at(-1);
+        const continuationText = tail?.role === "user" &&
+            tail.content.length === 1 &&
+            tail.content[0]?.type === "text"
+            ? tail.content[0].text
+            : undefined;
+        const journalNote = buildResumeJournalNote(toolCallJournal);
+        const safeContinuation = continuationText !== undefined &&
+            [
+                "run_timeout",
+                "loop_limit",
+                "stream_ended",
+                "gateway_timeout",
+                "rate_limited",
+                "network_interrupted",
+                "no_progress",
+            ].some((reason) => [undefined, journalNote ?? undefined].some((note) => {
+                const expected = [];
+                appendAgentLoopContinuation(expected, reason, note ? { journalNote: note } : {});
+                return (expected[0]?.content[0]?.type === "text" &&
+                    expected[0].content[0].text === continuationText);
+            }));
+        const lastMessage = journalHistory.at(safeContinuation ? -2 : -1);
+        const previousMessage = journalHistory.at(safeContinuation ? -3 : -2);
+        const pairs = matchToolCallResultsInHistory(journalHistory);
+        const calls = previousMessage?.role === "assistant"
+            ? previousMessage.content.filter((part) => part.type === "tool-call")
+            : [];
+        const events = journalRead.status === "read" ? journalRead.events : [];
+        const batchIndex = events
+            .map((event) => event.type === "rich_event" &&
+            event.event.namespace === "agent-native.tool-batch" &&
+            event.event.name === "declared" &&
+            event.event.version === 1)
+            .lastIndexOf(true);
+        const batchEvent = batchIndex < 0 ? undefined : events.at(batchIndex);
+        const batchData = batchEvent?.type === "rich_event" ? batchEvent.event.data : undefined;
+        const batchCalls = isRecord(batchData) && Array.isArray(batchData.calls)
+            ? batchData.calls
+            : [];
+        const afterBatch = events.slice(batchIndex + 1);
+        const starts = afterBatch.filter((event) => event.type === "tool_start");
+        const dones = afterBatch.filter((event) => event.type === "tool_done");
+        if (batchIndex >= 0 &&
+            batchCalls.length > 0 &&
+            batchCalls.every((call) => isRecord(call) &&
+                typeof call.id === "string" &&
+                call.id.length > 0 &&
+                typeof call.name === "string" &&
+                call.name.length > 0) &&
+            new Set(batchCalls.map((call) => call.id)).size === batchCalls.length &&
+            starts.length === batchCalls.length &&
+            dones.length === batchCalls.length &&
+            !afterBatch.some((event) => event.type === "user_message" ||
+                event.type === "tool_input_start" ||
+                event.type === "tool_input_delta" ||
+                (event.type === "model_stream" &&
+                    event.status === "end" &&
+                    event.reason !== "end_turn")) &&
+            lastMessage?.role === "user" &&
+            lastMessage.content.length > 0 &&
+            lastMessage.content.every((part) => part.type === "tool-result" &&
+                !part.isError &&
+                part.outcome !== "unknown" &&
+                !part.approvalPause) &&
+            batchCalls.every((call) => {
+                if (!isRecord(call) ||
+                    typeof call.id !== "string" ||
+                    typeof call.name !== "string")
+                    return false;
+                const matchingStarts = starts.filter((start) => start.id === call.id && start.tool === call.name);
+                if (matchingStarts.length !== 1 || !matchingStarts[0]?.executionStepId)
+                    return false;
+                const stepId = matchingStarts[0].executionStepId;
+                const matchingDones = dones.filter((done) => done.executionStepId === stepId &&
+                    done.tool === call.name &&
+                    done.id === call.id);
+                const matchingPairs = pairs.filter((pair) => calls.includes(pair.call) &&
+                    lastMessage.content.includes(pair.result) &&
+                    pair.call.executionStepId === stepId &&
+                    pair.result.executionStepId === stepId &&
+                    pair.call.name === call.name &&
+                    pair.result.toolName === call.name);
+                const entries = toolCallJournal.completed.filter((entry) => entry.executionStepId === stepId && entry.tool === call.name);
+                return (matchingDones.length === 1 &&
+                    matchingDones[0]?.actionSettled === true &&
+                    matchingDones[0].settledOnCleanToolStop === true &&
+                    !matchingDones[0].isError &&
+                    matchingDones[0].outcomeUnknown !== true &&
+                    matchingPairs.length === 1 &&
+                    entries.length === 1 &&
+                    entries[0]?.actionSettled === true &&
+                    entries[0].settledOnCleanToolStop === true &&
+                    !entries[0].isError);
+            }) &&
+            !toolResultHistory.some((result) => result.isError) &&
+            !turnHasActionWarnings &&
+            !writeReceiptGuard(turnReceipts(), false)) {
+            settlementCandidate = true;
+        }
+    }
     const unreadableJournalStop = journalRead.status === "unreadable" &&
         (journalRead.code === "private_history_unrecoverable" ||
             internalContinuationTurn ||
@@ -6181,6 +6296,9 @@ export async function runAgentLoop(opts) {
             }
             if (followUpResults.length > 0)
                 messages.push({ role: "user", content: followUpResults });
+            if (terminalStopReason === "max_tokens" || followUpResults.length > 0) {
+                settlementCandidate = false;
+            }
             if (terminalStopReason === "max_tokens") {
                 if (hasEmptyFinalResponse) {
                     preserveReasoningEffortForEmptyResponseRetries = true;
@@ -6222,7 +6340,13 @@ export async function runAgentLoop(opts) {
                 flushUnstreamedAssistantText();
                 continue;
             }
-            if (hasEmptyFinalResponse) {
+            const canSettleEmptyFinal = hasEmptyFinalResponse &&
+                settlementCandidate &&
+                terminalStopReason === "end_turn" &&
+                followUpResults.length === 0 &&
+                !isSignalAborted(signal) &&
+                !writeReceiptGuard(turnReceipts(), receiptGuardRetried);
+            if (hasEmptyFinalResponse && !canSettleEmptyFinal) {
                 completedFollowUpSuggestions = undefined;
                 if (emptyFinalResponseRetries < EMPTY_FINAL_RESPONSE_RETRY_LIMIT) {
                     emptyFinalResponseRetries += 1;
@@ -6277,6 +6401,7 @@ export async function runAgentLoop(opts) {
                     : receiptGuard;
             }
             if (guard) {
+                settlementCandidate = false;
                 completedFollowUpSuggestions = undefined;
                 const retryMessage = typeof guard === "string" ? guard : guard.retryMessage;
                 const fallbackMessage = typeof guard === "string" ? guard : guard.fallbackMessage;
@@ -6318,7 +6443,8 @@ export async function runAgentLoop(opts) {
             }
             else {
                 flushUnstreamedAssistantText();
-                if (followUpRunId &&
+                if (!canSettleEmptyFinal &&
+                    followUpRunId &&
                     completedFollowUpSuggestions === undefined &&
                     (terminalStopReason === "end_turn" || followUpResults.length > 0)) {
                     completingFollowUpSuggestions = true;
@@ -6331,6 +6457,7 @@ export async function runAgentLoop(opts) {
                     continue;
                 }
             }
+            settledEmptyFinal = canSettleEmptyFinal && !guard;
             emptyFinalResponseRetries = 0;
             preserveReasoningEffortForEmptyResponseRetries = false;
             consecutiveMaxTokensContinuations = 0;
@@ -6346,6 +6473,7 @@ export async function runAgentLoop(opts) {
         preserveReasoningEffortForEmptyResponseRetries = false;
         consecutiveMaxTokensContinuations = 0;
         const toolCallTruncatedByOutputCap = terminalStopReason === "max_tokens";
+        const toolCallHasCleanStop = terminalStopReason === "tool_use";
         if (toolCallTruncatedByOutputCap) {
             if (truncatedToolCallRetries < TRUNCATED_TOOL_CALL_RETRY_LIMIT) {
                 truncatedToolCallRetries += 1;
@@ -6361,6 +6489,25 @@ export async function runAgentLoop(opts) {
             effectiveMaxOutputTokens = opts.maxOutputTokens;
         }
         flushUnstreamedAssistantText();
+        settlementCandidate = false;
+        const batchCallIds = toolCallParts.map((call) => call.id);
+        if (currentExecutionFence() &&
+            toolCallHasCleanStop &&
+            followUpResults.length === 0 &&
+            !send.isPrivateTurn() &&
+            batchCallIds.every(Boolean) &&
+            new Set(batchCallIds).size === batchCallIds.length) {
+            await send({
+                type: "rich_event",
+                event: {
+                    namespace: "agent-native.tool-batch",
+                    name: "declared",
+                    version: 1,
+                    data: { calls: toolCallParts.map(({ id, name }) => ({ id, name })) },
+                },
+            });
+        }
+        const settledToolCalls = new Set();
         let requestedActionStop = null;
         // Tool closures set the stop, so control flow still reads it as null here.
         const actionStopRequested = () => requestedActionStop !== null;
@@ -7103,6 +7250,8 @@ export async function runAgentLoop(opts) {
                     throw new Error(`Execution step ${toolCall.id} has no stored result text`);
                 }
                 const isError = outcome.isError === true;
+                if (outcome.hasAgentWarnings === true)
+                    turnHasActionWarnings = true;
                 const completedSideEffect = outcome.completedSideEffect === true;
                 const artifacts = Array.isArray(outcome.artifacts)
                     ? outcome.artifacts.filter(isArtifactReceipt)
@@ -7130,8 +7279,21 @@ export async function runAgentLoop(opts) {
                     ...(errorCode ? { errorCode } : {}),
                     completedSideEffect,
                     replayed: true,
+                    ...(outcome.hasAgentWarnings === true
+                        ? { hasAgentWarnings: true }
+                        : {}),
                     ...(artifacts.length > 0 ? { artifacts } : {}),
                     ...(receipt ? { receipt } : {}),
+                    ...(outcome.isError === false &&
+                        outcome.actionSettled === true &&
+                        outcome.settledOnCleanToolStop === true &&
+                        toolCallHasCleanStop &&
+                        outcome.replayTruncated !== true
+                        ? {
+                            actionSettled: true,
+                            settledOnCleanToolStop: true,
+                        }
+                        : {}),
                     ...(mcpApp ? { mcpApp } : {}),
                     ...(chatUI ? { chatUI } : {}),
                     ...(chatUI && outcome.chatUIResult !== undefined
@@ -7140,6 +7302,14 @@ export async function runAgentLoop(opts) {
                     ...(fileMutation ? { fileMutation } : {}),
                 });
                 recordToolResult(result, isError, artifacts, receipt, false);
+                if (!isError &&
+                    outcome.isError === false &&
+                    typeof outcome.completedSideEffect === "boolean" &&
+                    outcome.actionSettled === true &&
+                    outcome.settledOnCleanToolStop === true &&
+                    outcome.replayTruncated !== true) {
+                    settledToolCalls.add(originalToolCall);
+                }
                 if (!isError) {
                     noteToolCallSucceeded(actionEntry, toolCall.name, toolCall.input);
                 }
@@ -7251,6 +7421,16 @@ export async function runAgentLoop(opts) {
                         result,
                         ...(replayedFailure ? { isError: true } : {}),
                         ...(journaled.errorCode ? { errorCode: journaled.errorCode } : {}),
+                        ...(journaled.receipt ? { receipt: journaled.receipt } : {}),
+                        ...(!replayedFailure &&
+                            journaled.actionSettled &&
+                            journaled.settledOnCleanToolStop &&
+                            toolCallHasCleanStop
+                            ? {
+                                actionSettled: true,
+                                settledOnCleanToolStop: true,
+                            }
+                            : {}),
                         completedSideEffect: true,
                         replayed: true,
                         ...(journaled.artifacts?.length
@@ -7267,7 +7447,11 @@ export async function runAgentLoop(opts) {
                             }
                             : {}),
                     });
-                    recordToolResult(result, replayedFailure, journaled.artifacts, undefined, false);
+                    recordToolResult(result, replayedFailure, journaled.artifacts, journaled.receipt, false);
+                    if (!replayedFailure &&
+                        journaled.actionSettled &&
+                        journaled.settledOnCleanToolStop)
+                        settledToolCalls.add(originalToolCall);
                     if (!replayedFailure) {
                         noteToolCallSucceeded(actionEntry, toolCall.name, toolCall.input);
                     }
@@ -7548,6 +7732,10 @@ export async function runAgentLoop(opts) {
                 let toolArtifacts = [];
                 let fileMutation;
                 let receipt;
+                let requestedSettlement = false;
+                const settlementWasRequested = () => requestedSettlement;
+                let settlementOnReturn = false;
+                let requiresNextAction = false;
                 try {
                     // The run may have been aborted while we waited above for an
                     // interrupted tool's ledger result (the wait can poll for minutes).
@@ -7597,6 +7785,13 @@ export async function runAgentLoop(opts) {
                         }
                         const actionContext = {
                             send,
+                            settle: () => {
+                                if (actionExecutionOutcome.evidence &&
+                                    actionExecutionStorage?.getStore()?.frame ===
+                                        actionExecutionOutcome.evidence) {
+                                    requestedSettlement = true;
+                                }
+                            },
                             userEmail: actionUserEmail ?? undefined,
                             orgId: actionOrgId,
                             appId: opts.appId,
@@ -7750,8 +7945,12 @@ export async function runAgentLoop(opts) {
                             signal.addEventListener("abort", () => reject(new Error("Run aborted")), { once: true });
                         }),
                     ]);
+                    settlementOnReturn = settlementWasRequested();
                     const mcpResult = isMcpActionResult(raw) ? raw : null;
                     const rawForAgent = mcpResult ? mcpResult.text : raw;
+                    requiresNextAction =
+                        isRecord(rawForAgent) &&
+                            typeof rawForAgent.nextRequiredAction === "string";
                     if (mcpResult &&
                         mcpResult.raw &&
                         typeof mcpResult.raw === "object" &&
@@ -7942,8 +8141,18 @@ export async function runAgentLoop(opts) {
                 }
                 const agentWarnings = drainAgentWarnings();
                 if (agentWarnings.length > 0) {
+                    turnHasActionWarnings = true;
                     result = `${result}\n\n${formatAgentWarningsForToolResult(agentWarnings)}`;
                 }
+                const actionSettled = Boolean(!isError &&
+                    !toolResultLost &&
+                    !isSignalAborted(signal) &&
+                    settlementOnReturn &&
+                    !requiresNextAction &&
+                    callEffect !== "unknown" &&
+                    toolCallHasCleanStop &&
+                    agentWarnings.length === 0 &&
+                    !writeReceiptGuard(receipt ? [{ tool: toolCall.name, ...receipt }] : [], false));
                 const resolvedChatUI = actionChatUIForResult(toolCall.name, actionEntry, toolCall.input, chatUIResult, isError);
                 // A write refreshes other sessions, including one that failed after
                 // it ran: its changes are applied all the same.
@@ -7989,6 +8198,15 @@ export async function runAgentLoop(opts) {
                                 ? { errorCode: toolErrorCode }
                                 : {}),
                             completedSideEffect: callEffect === "committed",
+                            ...(!isPrivateCall() && actionSettled
+                                ? {
+                                    actionSettled: true,
+                                    settledOnCleanToolStop: true,
+                                }
+                                : {}),
+                            ...(agentWarnings.length > 0
+                                ? { hasAgentWarnings: true }
+                                : {}),
                             ...(isPrivateCall() ? {} : { artifacts: toolArtifacts }),
                             ...(!isPrivateCall() && receipt ? { receipt } : {}),
                             ...(!isPrivateCall() && mcpApp ? { mcpApp } : {}),
@@ -8033,9 +8251,21 @@ export async function runAgentLoop(opts) {
                     ...(fileMutation ? { fileMutation } : {}),
                     ...(toolArtifacts.length > 0 ? { artifacts: toolArtifacts } : {}),
                     ...(receipt ? { receipt } : {}),
+                    ...(actionSettled
+                        ? {
+                            actionSettled: true,
+                            settledOnCleanToolStop: true,
+                        }
+                        : {}),
+                    ...(agentWarnings.length > 0
+                        ? { hasAgentWarnings: true }
+                        : {}),
                 });
                 toolDonePersistenceFailed = false;
                 recordToolResult(result, isError, toolArtifacts, receipt);
+                if (actionSettled) {
+                    settledToolCalls.add(originalToolCall);
+                }
                 if (isError) {
                     if (callEffect === "committed") {
                         resetAfterSuccessfulWrite(toolCall.name, toolCall.input);
@@ -8222,7 +8452,15 @@ export async function runAgentLoop(opts) {
                 : toolResultParts,
         });
         if (!actionStopRequested()) {
-            await deliverSteeredMessagesAtToolBoundary(toolResultParts);
+            const delivered = await deliverSteeredMessagesAtToolBoundary(toolResultParts);
+            settlementCandidate =
+                delivered === 0 &&
+                    toolCallHasCleanStop &&
+                    followUpResults.length === 0 &&
+                    toolCallParts.length > 0 &&
+                    toolCallParts.every((call) => settledToolCalls.has(call)) &&
+                    !turnHasActionWarnings &&
+                    !toolResultHistory.some((result) => result.isError);
         }
         if (requestedActionStop) {
             const stop = requestedActionStop;
@@ -8294,14 +8532,16 @@ export async function runAgentLoop(opts) {
             send({ type: "suggestions", suggestions: completedFollowUpSuggestions });
         send({
             type: "done",
-            ...(loopBreakerStopped
-                ? {
-                    reason: "loop_breaker",
-                    ...(loopBreakerCloseout
-                        ? { message: loopBreakerCloseout.message }
-                        : {}),
-                }
-                : {}),
+            ...(settledEmptyFinal
+                ? { reason: "action_settled" }
+                : loopBreakerStopped
+                    ? {
+                        reason: "loop_breaker",
+                        ...(loopBreakerCloseout
+                            ? { message: loopBreakerCloseout.message }
+                            : {}),
+                    }
+                    : {}),
         });
         if (opts.threadId) {
             void retainRequestDbPoolScope(clearLedgerForThread(opts.threadId).catch(() => { }));

package/dist/agent/reaped-run-thread.js

@@ -87,6 +87,12 @@ export async function foldReapedRunIntoThread(runId, terminalError) {
         if (!thread)
             return "superseded";
         const repo = readThreadRepository(run.threadId, run.turnId, thread.threadData);
+        // A thread with no messages has no tail for the retry check below to wait
+        // on, so retrying would defer forever and fail every sweep.
+        if (repo.messages.length === 0) {
+            console.warn(`[agent-chat] dropping stopped run ${runId}: thread ${run.threadId} has no messages (turn ${run.turnId})`);
+            return "superseded";
+        }
         const folded = foldAssistantTurnWithSteers(repo, assistant, steered, {
             runId,
             turnId: run.turnId,

package/dist/agent/run-manager.js

@@ -320,6 +320,10 @@ function isBatchableRunEvent(event) {
 export function endsAfterToolResultWithoutAssistantFinal(run, privateCompletedUiTools = new Set()) {
     let toolResultAfterLastAssistantText = false;
     for (const { event, seq } of run.events) {
+        if (event.type === "done" && event.reason === "action_settled") {
+            toolResultAfterLastAssistantText = false;
+            continue;
+        }
         if (event.type === "text" && event.text.trim().length > 0) {
             toolResultAfterLastAssistantText = false;
             continue;
@@ -1907,6 +1911,8 @@ export function startRun(runId, threadId, runFn, onComplete, options) {
         const shouldAutoContinueAfterUnfinishedTurn = finalStatus === "completed" &&
             !checkpointStatusReadFailed &&
             checkpointUnknownStatus === null &&
+            !(terminalEventForCompletion?.event.type === "done" &&
+                terminalEventForCompletion.event.reason === "action_settled") &&
             (endsAfterToolResultWithoutAssistantFinal(runForCompletionChecks, privateCompletedUiTools) ||
                 endsDuringActionPreparation(runForCompletionChecks)) &&
             (!terminalEventForCompletion ||

package/dist/agent/tool-call-journal.d.ts

@@ -1,4 +1,5 @@
 import type { ActionChatUIConfig } from "../action-ui.js";
+import type { WriteReceipt } from "../action.js";
 import { type ArtifactReceipt } from "../artifacts/detect.js";
 import type { AgentMcpAppPayload } from "../mcp-client/app-result.js";
 import type { EngineMessage, EngineToolCallPart, EngineToolResultPart } from "./engine/types.js";
@@ -16,6 +17,9 @@ export interface ToolCallJournalEntry {
     /** The call failed after its side effect completed. */
     isError?: true;
     errorCode?: string;
+    receipt?: WriteReceipt;
+    actionSettled?: true;
+    settledOnCleanToolStop?: true;
     /** The call recorded a completed side effect, its own or a nested call's. */
     committed?: true;
     /** Exact identity of the arguments the call ran with, defaults applied. */