@qduc/term2 0.31.1 → 0.32.0

package/dist/services/agent-runtime/application-run-loop.js

@@ -1,4 +1,8 @@
+import { isOpenAICompaction, projectModelRequestHistory } from '../conversation/conversation-state-projector.js';
+import { getCatalogModel } from '../../providers/model-catalog/catalog.js';
+import { resolveRequestOutput } from './model-context-policy.js';
 import { z } from 'zod';
+import { enforceRequestInputLimit, RequestInputLimitError, ProviderContextOverflowError, isProviderContextOverflow, } from './request-input-limit.js';
 import { createContinuationHandle, unwrapContinuationHandle, } from '../../contracts/continuation-handle.js';
 import { createAgentStream } from '../agent-stream.js';
 import { ASSISTANT_TEXT_PART_SEPARATOR } from '../../contracts/streamed-model-turn.js';
@@ -280,6 +284,7 @@ export class ApplicationRunLoop {
                 ? options.providerId
                 : undefined,
             requestPreparation: options.requestPreparation,
+            requestInputLimit: options.requestInputLimit,
             disableChainingForAttempt: options.disableChainingForAttempt === true,
             sessionId: options.sessionId,
             turnId: options.turnId,
@@ -312,6 +317,7 @@ export class ApplicationRunLoop {
             }
             state.approvalDecision = 'approved';
             state.approvalDecisionCallId = getInterruptionCallId(interruption);
+            state.approvalDecisionInterruption = interruption;
         };
         state.reject = (interruption, approvalOptions) => {
             if (isRunBudgetInteraction(interruption)) {
@@ -320,6 +326,7 @@ export class ApplicationRunLoop {
             }
             state.approvalDecision = 'rejected';
             state.approvalDecisionCallId = getInterruptionCallId(interruption);
+            state.approvalDecisionInterruption = interruption;
             state.approvalMessage = approvalOptions?.message;
         };
         return this.#run(state, options);
@@ -387,6 +394,8 @@ export class ApplicationRunLoop {
         // root closure for callers that do not provide one again.
         if (options.requestPreparation)
             state.requestPreparation = options.requestPreparation;
+        if (options.requestInputLimit)
+            state.requestInputLimit = options.requestInputLimit;
         if (options.compactionHistory)
             state.compactionHistory = options.compactionHistory;
         if (options.disableChainingForAttempt === true) {
@@ -527,9 +536,10 @@ export class ApplicationRunLoop {
                 }
             }
             if (state.toolExecution.pendingApprovals.length > 0 && state.approvalDecision) {
-                state.toolExecution.resolveApproval(state.approvalDecisionCallId, state.approvalDecision, state.approvalMessage, state.approvals);
+                state.toolExecution.resolveApproval({ callId: state.approvalDecisionCallId, interruption: state.approvalDecisionInterruption }, state.approvalDecision, state.approvalMessage, state.approvals);
                 state.approvalDecision = undefined;
                 state.approvalDecisionCallId = undefined;
+                state.approvalDecisionInterruption = undefined;
                 state.approvalMessage = undefined;
                 await state.toolExecution.settle(this.#toolCallContext(state, stream, queue, toolContext));
                 stream.interruptions = state.toolExecution.pendingApprovals.map((item) => item.interruption);
@@ -577,24 +587,40 @@ export class ApplicationRunLoop {
                 const compactionHistory = compactionHistoryResult.kind === 'ready' ? compactionHistoryResult.history : undefined;
                 if (options.boundaryCompaction && compactionHistory && !boundaryDecision?.deferCompaction) {
                     const compactionStartedAt = Date.now();
+                    let costsRecordedLive = false;
                     const compaction = await options.boundaryCompaction.compact({
                         history: compactionHistory,
+                        instructions: state.agent.resolveInstructionsForRequest?.() ?? state.agent.instructions,
+                        tools: toModelTools(state.agent.tools),
+                        recordCostRecords: (records) => {
+                            if (records.length) {
+                                costsRecordedLive = true;
+                                state.costRecords ??= [];
+                                state.costRecords.push(...records);
+                                for (const record of records)
+                                    queue.push({ type: 'cost_update', record });
+                                this.#evaluateRunBudget(state, stream, queue);
+                            }
+                            return !state.pendingRunBudgetInteraction && !state.criticalWrapUpPending;
+                        },
                         automaticCompactionsThisRun: state.automaticCompactionsThisRun ?? 0,
                         lastCompletedInputTokens: state.lastCompletedInputTokens,
                         signal: options.signal,
                         onStarted: (provider) => outputPush(stream, queue, { type: 'context_compaction_started', provider, strategy: 'local' }),
                     });
+                    if (compaction.kind !== 'unchanged' && !costsRecordedLive && compaction.costRecords?.length) {
+                        state.costRecords ??= [];
+                        state.costRecords.push(...compaction.costRecords);
+                    }
                     if (compaction.kind === 'compacted') {
+                        state.inputUsageInvalidatedByCompaction = true;
+                        state.lastCompletedInputTokens = undefined;
                         state.compactedDuringRun = true;
                         state.history.splice(0, state.history.length, ...compaction.history);
                         state.input.splice(0, state.input.length, ...normalizeApplicationInput(compaction.modelInput));
                         state.responseId = undefined;
                         state.responseProviderId = undefined;
                         state.usesDeltaHistory = false;
-                        if (compaction.costRecords?.length) {
-                            state.costRecords ??= [];
-                            state.costRecords.push(...compaction.costRecords);
-                        }
                         state.automaticCompactionsThisRun = (state.automaticCompactionsThisRun ?? 0) + 1;
                         outputPush(stream, queue, {
                             type: 'context_compaction_completed',
@@ -610,6 +636,8 @@ export class ApplicationRunLoop {
                             strategy: 'local',
                             durationMs: Math.max(0, Date.now() - compactionStartedAt),
                         });
+                        if (compaction.error)
+                            throw compaction.error;
                     }
                     else if (compaction.notice && compaction.notice !== state.compactionNotice) {
                         state.compactionNotice = compaction.notice;
@@ -650,12 +678,14 @@ export class ApplicationRunLoop {
             let activeRequestId = '';
             let activeRequest;
             let pendingNativeReasoning;
+            let deferredNativeReasoning = [];
             let criticalWrapUp = false;
             while (true) {
                 streamedToolCalls = [];
                 completion = undefined;
                 sawToolCall = false;
                 pendingNativeReasoning = undefined;
+                deferredNativeReasoning = [];
                 // Stable process-unique request id, allocated immediately before dispatch
                 // so a cost record can be settled exactly once (success or failure).
                 activeRequestId = this.#nextRequestId();
@@ -688,6 +718,11 @@ export class ApplicationRunLoop {
                 else
                     options.signal?.addEventListener('abort', abortRequest, { once: true });
                 const requestInstructions = state.agent.resolveInstructionsForRequest?.() ?? state.agent.instructions;
+                // Same synchronous step as the instructions above, so the snapshot is
+                // exactly the state the model is shown in this request.
+                state.requestSnapshot = state.agent.resolveRequestSnapshot?.();
+                const requestCatalog = getCatalogModel(state.currentProviderId ?? 'openai', state.agent.model);
+                const effectiveOutput = resolveRequestOutput(requestCatalog, state.agent.modelSettings?.maxTokens);
                 const request = {
                     instructions: criticalWrapUp
                         ? `${requestInstructions}\n\nBudget containment is terminal. Do not call tools. In this one final response, summarize what you completed, the evidence you have, and what remains.`
@@ -700,16 +735,14 @@ export class ApplicationRunLoop {
                         ? { previousResponseId: state.responseId }
                         : {}),
                     ...(disableChaining ? { disableChaining: true } : {}),
-                    input: state.input,
+                    input: projectModelRequestHistory(state.input),
                     tools: toModelTools(criticalWrapUp ? [] : state.agent.tools),
                     applicationTools: criticalWrapUp ? [] : state.agent.tools,
                     ...(state.agent.modelSettings?.temperature !== undefined
                         ? { temperature: state.agent.modelSettings.temperature }
                         : {}),
                     ...(state.agent.modelSettings?.reasoning ? { reasoning: state.agent.modelSettings.reasoning } : {}),
-                    ...(state.agent.modelSettings?.maxTokens !== undefined
-                        ? { maxTokens: state.agent.modelSettings.maxTokens }
-                        : {}),
+                    ...(effectiveOutput !== undefined ? { maxTokens: effectiveOutput } : {}),
                     ...(state.agent.outputType !== undefined ? { outputType: state.agent.outputType } : {}),
                     ...(state.agent.modelSettings?.codex ? { codex: state.agent.modelSettings.codex } : {}),
                     ...(state.agent.modelSettings?.providerData
@@ -805,7 +838,11 @@ export class ApplicationRunLoop {
                             if (event.type === 'tool_call') {
                                 toolArgumentRunaway?.observeToolCallCompleted();
                                 generationGuard.observeToolCall(event.arguments);
-                                pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
+                                // The authoritative completion may introduce a native
+                                // replacement boundary before this call's reasoning.
+                                if (pendingNativeReasoning)
+                                    deferredNativeReasoning.push(pendingNativeReasoning);
+                                pendingNativeReasoning = undefined;
                                 sawToolCall = true;
                                 streamedToolCalls.push(event);
                             }
@@ -820,6 +857,31 @@ export class ApplicationRunLoop {
                 };
                 const dispatch = async () => {
                     state.requestPreparation?.prepare(request);
+                    // A response ID can be established after a self-contained request.
+                    // It does not make this run's full history a delta needing a snapshot.
+                    const needsChainedSnapshot = Boolean(request.previousResponseId && state.usesDeltaHistory);
+                    const fullContext = needsChainedSnapshot && state.compactionHistory
+                        ? mergeChainedCompactionHistory(state.compactionHistory, state.history)
+                        : undefined;
+                    const contextCatalog = getCatalogModel(state.currentProviderId ?? 'openai', state.agent.model);
+                    enforceRequestInputLimit({
+                        contextWindow: contextCatalog?.contextWindow,
+                        maxOutputTokens: request.maxTokens,
+                        limit: state.requestInputLimit
+                            ? state.requestInputLimit()
+                            : state.agent.modelSettings?.maxRequestInputTokens,
+                        history: fullContext?.kind === 'ready'
+                            ? fullContext.history
+                            : needsChainedSnapshot
+                                ? [...(state.compactionHistory ?? []), ...request.input]
+                                : request.input,
+                        instructions: request.instructions ?? '',
+                        tools: request.tools,
+                        lastCompletedInputTokens: state.inputUsageInvalidatedByCompaction
+                            ? undefined
+                            : state.lastCompletedInputTokens,
+                        chainedContextKnown: !needsChainedSnapshot || fullContext?.kind === 'ready',
+                    });
                     await consume();
                 };
                 try {
@@ -830,6 +892,33 @@ export class ApplicationRunLoop {
                     break;
                 }
                 catch (error) {
+                    if (error instanceof RequestInputLimitError) {
+                        this.#deps.logDiagnostic?.('Request input admission refused', {
+                            code: error.code,
+                            action: error.action,
+                            reason: error.reason,
+                            guardClass: 'admission',
+                            setting: 'agent.maxRequestInputTokens',
+                            executionScope: state.hookScope ?? 'root',
+                            recovery: 'retained_work',
+                            limit: error.limit,
+                            estimatedTokens: error.estimatedTokens,
+                            observedTokens: error.observedTokens,
+                            capacity: error.capacity,
+                            outputReserve: error.outputReserve,
+                            estimationReserve: error.estimationReserve,
+                        });
+                        throw error;
+                    }
+                    if (isProviderContextOverflow(error)) {
+                        this.#observeTerminalFailure(error, {
+                            requestId: activeRequestId,
+                            provider: state.currentProviderId,
+                            model: state.agent.model,
+                            tier: resolveServiceTier(request),
+                        });
+                        throw new ProviderContextOverflowError(error);
+                    }
                     const recoverOversizedToolArgument = isOversizedToolArgumentTrip(error) &&
                         (state.oversizedToolArgumentRecoveries ?? 0) < MAX_OVERSIZED_TOOL_ARGUMENT_RECOVERIES &&
                         !options.signal?.aborted;
@@ -946,6 +1035,9 @@ export class ApplicationRunLoop {
                 if (criticalWrapUp) {
                     return finish(stream, state, queue);
                 }
+                for (const reasoning of deferredNativeReasoning)
+                    commitPendingNativeReasoning(state, stream, queue, reasoning);
+                pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
                 await this.#dispatchToolCalls(state, stream, queue, streamedToolCalls, toolContext);
                 if (state.toolExecution.terminateAfterExecution)
                     return finish(stream, state, queue);
@@ -989,6 +1081,7 @@ export class ApplicationRunLoop {
                 if (normalizedCompletionUsage) {
                     if (normalizedCompletionUsage.prompt_tokens !== undefined) {
                         state.lastCompletedInputTokens = normalizedCompletionUsage.prompt_tokens;
+                        state.inputUsageInvalidatedByCompaction = false;
                     }
                     const accumulated = addTokenUsage(normalizeModelUsage(state.usage), normalizedCompletionUsage);
                     state.usage = {
@@ -1047,32 +1140,33 @@ export class ApplicationRunLoop {
             // completion rather than as separate stream events. Their reasoning may
             // likewise be terminal-only, so associate it before replaying calls.
             const toolCalls = [...streamedToolCalls];
-            if (!sawToolCall) {
-                for (const item of finalCompletion.output) {
-                    if (item.type === 'reasoning')
-                        pendingNativeReasoning = appendNativeReasoning(pendingNativeReasoning, item);
+            const hasTerminalReasoning = finalCompletion.output.some((item) => item.type === 'reasoning' && appendNativeReasoning(undefined, item) !== undefined);
+            if (hasTerminalReasoning) {
+                // Terminal output supplies native ordering and authoritative metadata.
+                // Streamed fragments have already been displayed, but are not history.
+                pendingNativeReasoning = undefined;
+            }
+            else {
+                for (const reasoning of deferredNativeReasoning)
+                    commitPendingNativeReasoning(state, stream, queue, reasoning);
+            }
+            for (const item of finalCompletion.output) {
+                if (item.type === 'reasoning') {
+                    // Each terminal native item is independently replayable; encrypted
+                    // reasoning cannot be concatenated or overwritten by its sibling.
+                    pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
+                    pendingNativeReasoning = appendNativeReasoning(undefined, item);
+                    continue;
                 }
-                for (const item of finalCompletion.output) {
-                    if (item.type !== 'tool_call')
-                        continue;
+                if (item.type === 'tool_call') {
                     pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
-                    sawToolCall = true;
-                    toolCalls.push(item);
+                    if (!sawToolCall)
+                        toolCalls.push(item);
+                    continue;
                 }
-            }
-            // A native reasoning item belongs to the completed assistant turn even
-            // when no tool call follows it. Commit it before assistant text so both
-            // stateless continuation and persisted canonical history retain the
-            // provider-specific metadata exactly once.
-            pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
-            // Provider-native completion items (notably OpenAI compaction items)
-            // must stay in the live provider history. The session layer later
-            // applies compaction's replacement rule; keeping the item here also
-            // makes it available to an in-flight tool continuation before that
-            // terminal history commit occurs.
-            for (const item of finalCompletion.output) {
                 if (item.type !== 'provider_opaque')
                     continue;
+                pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
                 const historyItem = {
                     ...item.item,
                     providerOpaque: {
@@ -1082,8 +1176,16 @@ export class ApplicationRunLoop {
                 };
                 state.history.push(historyItem);
                 state.input.push(item);
+                if (isOpenAICompaction(item)) {
+                    // Completion usage describes the request before native replacement.
+                    // Retain billed usage/costs; invalidate only the next admission hint.
+                    state.lastCompletedInputTokens = undefined;
+                    state.inputUsageInvalidatedByCompaction = true;
+                }
                 outputPush(stream, queue, { type: 'item', item });
             }
+            sawToolCall = toolCalls.length > 0;
+            pendingNativeReasoning = commitPendingNativeReasoning(state, stream, queue, pendingNativeReasoning);
             const assistantText = finalCompletion.output
                 .filter((item) => item.type === 'message')
                 .flatMap((item) => item.content)
@@ -1129,6 +1231,21 @@ export class ApplicationRunLoop {
                 return finish(stream, state, queue);
             }
             if (!sawToolCall) {
+                // The normal stop seam. A stop policy may keep the same run going; the
+                // reminder is admitted at the next request boundary, where pending
+                // budget evidence pauses first and turn accounting applies as usual.
+                const stopDecision = options.onNormalStop && !options.signal?.aborted && !state.criticalWrapUpPending
+                    ? options.onNormalStop(state.history, state.agent)
+                    : undefined;
+                if (stopDecision) {
+                    this.#deps.logDiagnostic?.('Normal stop policy decided', { action: stopDecision.action, turnCount: state.turnCount, ...stopDecision.diagnostics }, { severity: 'debug', eventType: 'run_loop.normal_stop_policy' });
+                }
+                if (stopDecision?.action === 'continue') {
+                    this.#queuePendingSystemNotice(stopDecision.reminder);
+                    continue;
+                }
+                if (stopDecision?.terminalCause)
+                    state.terminalCause = stopDecision.terminalCause;
                 // Evidence discovered when a response has already completed needs no
                 // human boundary: there is no later request or tool to block.
                 state.pendingRunBudgetInteraction = undefined;
@@ -1151,6 +1268,7 @@ export class ApplicationRunLoop {
             sessionId: state.sessionId,
             turnId: state.turnId,
             hookScope: state.hookScope,
+            ...(state.requestSnapshot ? { requestSnapshot: state.requestSnapshot } : {}),
             onCall: (event) => {
                 const callItem = {
                     type: event.toolType === 'custom' ? 'custom_tool_call' : 'function_call',
@@ -1248,8 +1366,9 @@ export class ApplicationRunLoop {
         }
         if (!state.wrapUpOnCriticalRunBudget &&
             !state.pendingRunBudgetInteraction &&
-            state.runBudgetEscalation !== 'warn' &&
-            this.#requiresHumanBudgetDecision(event)) {
+            (state.runBudgetEscalation === 'contain'
+                ? event.type === 'budget_stage' && event.stage === 'critical'
+                : state.runBudgetEscalation !== 'warn' && this.#requiresHumanBudgetDecision(event))) {
             state.pendingRunBudgetInteraction = { type: 'run_budget_interaction', event };
             state.runBudgetGrantConsumed = false;
         }
@@ -1439,6 +1558,28 @@ function normalizeHistory(input) {
 }
 function mergeChainedCompactionHistory(sessionHistory, deltaHistory) {
     const firstDeltaItem = deltaHistory[0];
+    const normalizedDelta = normalizeApplicationInput(deltaHistory);
+    if (normalizedDelta[0]?.type === 'tool_result') {
+        // A tool-only continuation needs a complete snapshot with still-open
+        // producing calls. Normalize supported legacy/custom forms for comparison,
+        // retain original provider items, and validate every later call/receipt.
+        const pending = new Map();
+        const seenCalls = new Set();
+        for (const item of [...normalizeApplicationInput(sessionHistory), ...normalizedDelta]) {
+            if (item.type === 'tool_call') {
+                if (!item.id || seenCalls.has(item.id))
+                    return { kind: 'skipped', reason: 'user_mismatch' };
+                seenCalls.add(item.id);
+                pending.set(item.id, item.toolType ?? 'function');
+            }
+            else if (item.type === 'tool_result') {
+                if (!item.id || pending.get(item.id) !== (item.toolType ?? 'function'))
+                    return { kind: 'skipped', reason: 'user_mismatch' };
+                pending.delete(item.id);
+            }
+        }
+        return { kind: 'ready', history: [...sessionHistory, ...deltaHistory] };
+    }
     if (!firstDeltaItem || firstDeltaItem.type !== 'message' || firstDeltaItem.role !== 'user') {
         return { kind: 'skipped', reason: 'user_mismatch' };
     }