@qduc/term2 0.20.0 → 0.22.0

package/dist/lib/agent-client.js

@@ -12,15 +12,31 @@ import { randomUUID } from 'node:crypto';
 import { fetchModels } from '../services/model-service.js';
 import { prepareOpenAIRequestPrefixBinding, runWithOpenAIRequestPrefixBindingScope, } from '../providers/openai-request-prefix-binding.js';
 import { isDeepStrictEqual } from 'node:util';
+import { MIN_CHECK_IN_INTERVAL_SECONDS, MIN_NEXT_CHECK_IN_SECONDS } from '../tools/agent/configure-task-check-in.js';
 import { ContextCompactionHardFitError, LocalContextCompactor, } from '../services/agent-runtime/context-compaction/local-context-compactor.js';
 import { CONTEXT_COMPACTION_INSTRUCTIONS } from '../prompts/context-compaction.js';
 import { getCatalogModel } from '../providers/model-catalog/catalog.js';
 import { supportsContextCompactionModel } from '../providers/openai-responses-model.js';
+import { isCodexCompactionIncompatible } from '../providers/codex-compact.js';
 import { estimateContext, resolveCompactionThreshold, shouldDeferAutomaticCompaction, } from '../services/agent-runtime/context-compaction/index.js';
 import { projectConversationMessage } from '../services/conversation/conversation-message-projection.js';
 import { isLocalContextSummary } from '../contracts/provider-input.js';
 import { classifyProviderFailure } from '../services/retry/provider-failure-classification.js';
 import { ContextMilestoneReminder } from '../services/agent-runtime/context-compaction/context-milestone-reminder.js';
+function findConversationResetModel(model) {
+    const visited = new Set();
+    let current = model;
+    while (current && typeof current === 'object' && !visited.has(current)) {
+        visited.add(current);
+        const wrapped = current.wrappedModel;
+        if (wrapped && typeof wrapped === 'object' && typeof wrapped.stream === 'function') {
+            current = wrapped;
+            continue;
+        }
+        return typeof current.resetConversationState === 'function' ? current : undefined;
+    }
+    return undefined;
+}
 function createScopedToolLifecycle(lifecycle, scope) {
     const withScope = (context) => ({
         ...context,
@@ -41,6 +57,7 @@ export class AgentClient {
     #toolInterceptorRegistry;
     #applicationRunLoop;
     #contextCompactionSessionState = { disabled: false };
+    #unavailableCodexCompaction = new WeakSet();
     #maxTurns;
     #retryAttempts;
     #retryCallback = null;
@@ -66,6 +83,10 @@ export class AgentClient {
     #streamedModelCache = new Map();
     #contextMilestoneReminder = new ContextMilestoneReminder();
     #sessionRolloverRequest = null;
+    #lastCompletedProviderInputTokens;
+    #blockedCompactionRearmAtEstimatedTokens;
+    #blockedCompactionUserTurnCount;
+    #lastLogicalSessionId;
     #clearStreamedModelCache() {
         for (const cached of this.#streamedModelCache.values()) {
             if (cached.ownership !== 'owned')
@@ -76,6 +97,16 @@ export class AgentClient {
         }
         this.#streamedModelCache.clear();
     }
+    #discardStreamedModel(cacheKey, cached) {
+        if (this.#streamedModelCache.get(cacheKey) !== cached)
+            return;
+        this.#streamedModelCache.delete(cacheKey);
+        if (cached.ownership !== 'owned')
+            return;
+        void Promise.resolve(cached.model)
+            .then((model) => model.close?.())
+            .catch(() => undefined);
+    }
     #resolveStreamedModel(selectedModel) {
         const providerId = this.#agentConfig.getProvider();
         const provider = getProvider(providerId);
@@ -135,11 +166,14 @@ export class AgentClient {
                 return { kind: 'unchanged' };
         }
         const streamed = await this.#resolveStreamedModel(input.model);
+        if (!input.manual && this.#unavailableCodexCompaction.has(streamed)) {
+            return { kind: 'unchanged', nativeUnavailable: true };
+        }
         if (!streamed.compactHistory) {
             this.#logger.warn('Codex compact endpoint is unavailable; continuing with uncompacted history', {
                 model: input.model,
             });
-            return { kind: 'unchanged' };
+            return { kind: 'unchanged', nativeUnavailable: true };
         }
         input.onStarted('codex');
         try {
@@ -151,14 +185,23 @@ export class AgentClient {
             if (history.length === 0) {
                 throw new Error('Codex compact endpoint returned an empty history');
             }
+            this.#unavailableCodexCompaction.delete(streamed);
             return { kind: 'compacted', history, modelInput: history };
         }
         catch (error) {
+            if (input.signal?.aborted)
+                throw error;
+            const nativeUnavailable = isCodexCompactionIncompatible(error);
+            if (nativeUnavailable)
+                this.#unavailableCodexCompaction.add(streamed);
             this.#logger.warn('Codex compact endpoint failed; continuing with uncompacted history', {
+                eventType: 'context_compaction.native_failed',
                 model: input.model,
                 error: error instanceof Error ? error.message : String(error),
+                automaticRetry: nativeUnavailable ? 'disabled_for_model_instance' : 'eligible',
+                recovery: nativeUnavailable ? 'Manual /compact retries; auto mode can use local compaction.' : 'unchanged',
             });
-            return { kind: 'failed', provider: 'codex' };
+            return { kind: 'failed', provider: 'codex', nativeUnavailable };
         }
     }
     #boundaryCompaction() {
@@ -166,7 +209,7 @@ export class AgentClient {
         if (!enabled)
             return undefined;
         return {
-            compact: async ({ history, automaticCompactionsThisRun, signal, onStarted, }) => {
+            compact: async ({ history, automaticCompactionsThisRun, lastCompletedInputTokens, signal, onStarted, }) => {
                 const mode = this.#settings.get('agent.contextCompaction.mode') ?? 'native';
                 const provider = this.#agentConfig.getProvider();
                 const model = this.#agentConfig.getModel();
@@ -176,7 +219,7 @@ export class AgentClient {
                     supportsContextCompactionModel(model) &&
                     !this.#contextCompactionSessionState.disabled;
                 if (provider === 'codex' && mode !== 'local') {
-                    return this.#compactCodexHistory({
+                    const native = await this.#compactCodexHistory({
                         history,
                         model,
                         automaticCompactionsThisRun,
@@ -184,6 +227,10 @@ export class AgentClient {
                         onStarted,
                         manual: false,
                     });
+                    if (mode !== 'auto' || !('nativeUnavailable' in native && native.nativeUnavailable))
+                        return native;
+                    // Auto was explicitly selected. Keep the existing local safe-cut and
+                    // opaque-history checks; a rejected native call never discards history.
                 }
                 if (mode === 'native' || (mode === 'auto' && openaiInlineNative))
                     return { kind: 'unchanged' };
@@ -212,6 +259,19 @@ export class AgentClient {
                     },
                 });
                 const checkpoint = history.find(isLocalContextSummary)?.contextSummary;
+                const genuineUserTurns = history.filter((item) => {
+                    const message = projectConversationMessage(item);
+                    return message?.role === 'user' && !message.isSynthetic;
+                }).length;
+                const checkpointIndex = history.findIndex(isLocalContextSummary);
+                const hasCompleteNewUserTurn = this.#blockedCompactionUserTurnCount !== undefined
+                    ? genuineUserTurns > this.#blockedCompactionUserTurnCount
+                    : checkpointIndex >= 0
+                        ? history.slice(checkpointIndex + 1).some((item) => {
+                            const message = projectConversationMessage(item);
+                            return message?.role === 'user' && !message.isSynthetic;
+                        })
+                        : true;
                 let outcome;
                 try {
                     outcome = await compactor.compactAtBoundary({
@@ -227,8 +287,10 @@ export class AgentClient {
                         compactThresholdTokens: this.#settings.get('agent.contextCompaction.compactThresholdTokens') ?? null,
                         manual: false,
                         automaticCompactionsThisRun,
-                        hasCompleteNewUserTurn: true,
+                        hasCompleteNewUserTurn,
                         checkpoint: checkpoint ? { rearmAtEstimatedTokens: checkpoint.rearmAtEstimatedTokens } : undefined,
+                        rearmAtEstimatedTokens: this.#blockedCompactionRearmAtEstimatedTokens,
+                        lastCompletedInputTokens,
                         signal,
                     });
                 }
@@ -248,15 +310,29 @@ export class AgentClient {
                     // A blocked outcome leaves context growing, so it must be visible in
                     // the log even though it is not a failure the user can act on.
                     if (outcome.kind === 'blocked') {
+                        if (outcome.rearmAtTokens !== undefined) {
+                            this.#blockedCompactionRearmAtEstimatedTokens = outcome.rearmAtTokens;
+                            this.#blockedCompactionUserTurnCount = genuineUserTurns;
+                        }
                         this.#logger.warn('Local context compaction blocked; continuing with uncompacted history', {
                             provider,
                             model,
                             reason: outcome.reason,
                             renderedInputTokens: outcome.estimate.renderedInputTokens,
+                            ...(outcome.rearmAtTokens !== undefined ? { rearmAtEstimatedTokens: outcome.rearmAtTokens } : {}),
                         });
+                        if (outcome.reason === 'no_complete_cold_turn') {
+                            return {
+                                kind: 'unchanged',
+                                notice: 'Local compaction cannot shorten this history yet: it preserves the newest two user turns and needs an older completed turn. ' +
+                                    'Continue the current work; keep outputs concise and save durable progress. If session_rollover is available, consider it at a safe idle boundary; live background work survives rollover, so do not wait for it solely to rotate. Do not repeat completed work or manufacture user turns to force compaction.',
+                            };
+                        }
                     }
                     return { kind: 'unchanged' };
                 }
+                this.#blockedCompactionRearmAtEstimatedTokens = undefined;
+                this.#blockedCompactionUserTurnCount = undefined;
                 if (outcome.droppedOpaqueItems > 0) {
                     this.#logger.debug('Local context compaction dropped provider-opaque items with their cold turns', {
                         provider,
@@ -282,16 +358,11 @@ export class AgentClient {
             },
         };
     }
-    #observeContextMilestones(history, onReminder) {
+    #observeContextMilestones(history, onReminder, lastCompletedInputTokens) {
         const provider = this.#agentConfig.getProvider();
         const model = this.#agentConfig.getModel();
         const catalog = getCatalogModel(provider, model);
         const agent = this.#agentConfig.getApplicationAgent();
-        const threshold = resolveCompactionThreshold({
-            contextWindow: catalog?.contextWindow,
-            compactThreshold: this.#settings.get('agent.contextCompaction.compactThreshold') ?? 0.8,
-            compactThresholdTokens: this.#settings.get('agent.contextCompaction.compactThresholdTokens') ?? null,
-        });
         const estimate = estimateContext({
             history,
             instructions: agent.instructions,
@@ -305,9 +376,7 @@ export class AgentClient {
             milestones: this.#settings.get('agent.sessionRollover.milestones') ?? [],
             autoBrief: this.#settings.get('agent.sessionRollover.autoBrief') ?? true,
         };
-        const reminders = this.#contextMilestoneReminder.observe(estimate, config, canSafelyDeferCompaction && this.#settings.get('agent.contextCompaction.enabled') && threshold.available
-            ? threshold.effectiveThreshold
-            : undefined);
+        const reminders = this.#contextMilestoneReminder.observe(lastCompletedInputTokens, config);
         for (const reminder of reminders) {
             onReminder(reminder);
         }
@@ -336,42 +405,25 @@ export class AgentClient {
         this.#subagentBridge?.setBackgroundApprovalPauseSink(sink);
     }
     requestSessionRollover(request) {
-        const active = this.#liveBackgroundWork();
-        if (active.subagent > 0 || active.shell > 0) {
-            return {
-                ok: false,
-                status: 'rollover_blocked',
-                error: 'Session rollover is blocked while background work is live.',
-                active,
-            };
-        }
-        this.#sessionRolloverRequest ??= request;
-        return { ok: true, status: 'rollover_requested' };
+        const rolloverId = randomUUID();
+        const pending = {
+            ...request,
+            rolloverId,
+            requestedAt: Date.now(),
+            ...(this.#lastCompletedProviderInputTokens !== undefined
+                ? { providerInputTokens: this.#lastCompletedProviderInputTokens }
+                : {}),
+        };
+        this.#sessionRolloverRequest ??= pending;
+        return { ok: true, status: 'rollover_requested', rolloverId: this.#sessionRolloverRequest.rolloverId };
     }
     consumeSessionRolloverRequest() {
         const request = this.#sessionRolloverRequest;
         this.#sessionRolloverRequest = null;
         if (!request)
             return { status: 'none' };
-        const active = this.#liveBackgroundWork();
-        if (active.subagent > 0 || active.shell > 0) {
-            return {
-                status: 'blocked',
-                blocker: 'background_work',
-                error: 'Session rollover was not performed because background work became live before turn settlement.',
-                active,
-            };
-        }
         return { status: 'ready', request };
     }
-    #liveBackgroundWork() {
-        const subagent = this.listBackgroundSubagentStatuses().filter(({ status }) => status === 'running' ||
-            status === 'awaiting_approval' ||
-            status === 'waiting_for_answer' ||
-            status === 'cancelling').length;
-        const shell = this.listBackgroundShellJobs().filter(({ status }) => status === 'running' || status === 'cancelling').length;
-        return { shell, subagent };
-    }
     /** Exact nested-tool state shared with the subagent runtime's tool factory. */
     getNestedToolCompatibilityState() {
         return this.#subagentBridge?.getNestedToolCompatibilityState();
@@ -405,7 +457,7 @@ export class AgentClient {
     #resetMentorState() {
         this.#subagentBridge?.clearSubagentCache();
     }
-    constructor({ model, reasoningEffort, maxTurns, retryAttempts, agentOverride, providerOverride, deps, subagentBridge, toolOwnership, postExecutePauseCapability, sessionAccess, toolLifecycle, hookScope, backgroundShellRegistry, backgroundShellOutput, allowBackgroundShell = true, // Retained for session-factory compatibility; direct execution no longer
+    constructor({ model, reasoningEffort, maxTurns, retryAttempts, agentOverride, providerOverride, approvalPolicyRegistry, deps, subagentBridge, toolOwnership, postExecutePauseCapability, sessionAccess, toolLifecycle, hookScope, backgroundShellRegistry, backgroundShellOutput, allowBackgroundShell = true, // Retained for session-factory compatibility; direct execution no longer
     allowAskUser = true, wrapUpOnCriticalRunBudget = false, 
     // projects chained input through the legacy mode.
     continuationProjectionMode: _continuationProjectionMode = 'legacy', }) {
@@ -420,7 +472,7 @@ export class AgentClient {
         this.#wrapUpOnCriticalRunBudget = wrapUpOnCriticalRunBudget;
         this.#askUserAnswerStore = new AskUserAnswerStore();
         // Create AgentConfiguration (handles editor, model, provider, reasoning, etc.)
-        this.#agentConfig = new AgentConfiguration({ model, reasoningEffort, providerOverride, agentOverride }, {
+        this.#agentConfig = new AgentConfiguration({ model, reasoningEffort, providerOverride, agentOverride, approvalPolicyRegistry }, {
             logger: deps.logger,
             settings: deps.settings,
             sessionContextService: deps.sessionContextService,
@@ -459,7 +511,14 @@ export class AgentClient {
             getOnToolDispatch: () => this.#onToolDispatch,
             contextCompactionSessionState: this.#contextCompactionSessionState,
             resolveMaxParallelToolCalls: () => deps.settings.get('agent.maxParallelToolCalls'),
-            logDiagnostic: (message, meta) => deps.logger.info(message, meta),
+            logDiagnostic: (message, meta, options = {}) => {
+                const metadata = options.eventType ? { ...meta, eventType: options.eventType } : meta;
+                if (options.severity === 'debug') {
+                    deps.logger.debug(message, metadata);
+                    return;
+                }
+                deps.logger.info(message, metadata);
+            },
             resolveModel: (selectedModel) => this.#resolveStreamedModel(selectedModel),
         });
         this.#chatService = new AgentChatService({
@@ -481,10 +540,11 @@ export class AgentClient {
                 // Factory lives here (not in SubagentBridge) so each subagent gets a
                 // lightweight transient client that shares logger/settings/executionContext
                 // with the parent but skips agent-rebuild and SubagentManager initialisation.
-                createClient: ({ agent, provider, maxTurns, retryAttempts, agentId, role, }) => new AgentClient({
+                createClient: ({ agent, provider, maxTurns, retryAttempts, agentId, role, approvalPolicyRegistry, }) => new AgentClient({
                     model: agent.model,
                     maxTurns,
                     retryAttempts,
+                    approvalPolicyRegistry,
                     deps: {
                         logger: deps.logger,
                         settings: deps.settings,
@@ -665,6 +725,12 @@ export class AgentClient {
             toolCounts: {},
         });
     }
+    getApprovalPolicyRegistry() {
+        return this.#agentConfig.approvalPolicyRegistry;
+    }
+    setNestedApprovalOwner(owner) {
+        this.#agentConfig.setNestedApprovalOwner(owner);
+    }
     listBackgroundSubagentStatuses() {
         return this.#subagentBridge?.listBackgroundSubagentStatuses() ?? [];
     }
@@ -711,6 +777,18 @@ export class AgentClient {
         if (!this.#backgroundCheckInScheduler) {
             return { ok: false, error: 'Background check-in scheduler is not active.' };
         }
+        if (params.interval_seconds !== undefined && params.interval_seconds < MIN_CHECK_IN_INTERVAL_SECONDS) {
+            return {
+                ok: false,
+                error: `interval_seconds must be at least ${MIN_CHECK_IN_INTERVAL_SECONDS} seconds (5 minutes).`,
+            };
+        }
+        if (params.next_check_in_seconds !== undefined && params.next_check_in_seconds < MIN_NEXT_CHECK_IN_SECONDS) {
+            return {
+                ok: false,
+                error: `next_check_in_seconds must be at least ${MIN_NEXT_CHECK_IN_SECONDS} seconds.`,
+            };
+        }
         return this.#backgroundCheckInScheduler.configureTaskCheckIn(params.target, {
             enabled: params.enabled,
             intervalMs: params.interval_seconds !== undefined ? params.interval_seconds * 1000 : undefined,
@@ -742,13 +820,66 @@ export class AgentClient {
         this.#chatService.clearModelCache();
         this.#subagentBridge?.dispose();
         this.#agentConfig.dispose();
+        this.#blockedCompactionRearmAtEstimatedTokens = undefined;
+        this.#blockedCompactionUserTurnCount = undefined;
     }
     clearConversations() {
         this.#applicationRunLoop.abort();
+        this.#blockedCompactionRearmAtEstimatedTokens = undefined;
+        this.#blockedCompactionUserTurnCount = undefined;
         getProvider(this.#agentConfig.getProvider())?.clearConversations?.();
         this.#agentConfig.refreshAgent();
         this.#logger.debug('Conversation and agent refreshed');
     }
+    /**
+     * Rollover deliberately does not use clearConversations(): that public
+     * operation refreshes the whole client and is allowed to tear down normal
+     * conversation resources. Only the root request lane is reset here; nested
+     * clients and their live background work remain owned by the bridge.
+     */
+    rolloverRootContext() {
+        this.#applicationRunLoop.abort();
+        this.#clearCorrelationId();
+        // Keep the state object captured by an already-created provider model.
+        // Replacing it would leave the retained model bound to an obsolete
+        // compaction state object.
+        this.#contextCompactionSessionState.disabled = false;
+        this.#contextMilestoneReminder = new ContextMilestoneReminder();
+        this.#sessionRolloverRequest = null;
+        this.#lastCompletedProviderInputTokens = undefined;
+        this.#askUserAnswerStore.clear();
+        const resetOptions = this.#lastLogicalSessionId
+            ? { providerHistoryKey: this.#lastLogicalSessionId }
+            : undefined;
+        for (const [cacheKey, cached] of this.#streamedModelCache) {
+            // A retained root reset must never reach a transient client's borrowed
+            // model. Its provider state may be shared with a live nested sibling,
+            // while the root reset is scoped only to the root history key.
+            if (cached.ownership !== 'owned')
+                continue;
+            const reset = (model) => {
+                const resetModel = findConversationResetModel(model);
+                if (resetModel) {
+                    if (!resetOptions)
+                        return;
+                    resetModel.resetConversationState(resetOptions);
+                    this.#unavailableCodexCompaction.delete(model);
+                    return;
+                }
+                // A provider without the reset seam has not proved that its cached
+                // state is safe to carry into a new logical session. Recreate it rather
+                // than silently retaining unknown conversation state.
+                this.#discardStreamedModel(cacheKey, cached);
+            };
+            if (cached.model instanceof Promise) {
+                void cached.model.then(reset).catch(() => undefined);
+            }
+            else {
+                reset(cached.model);
+            }
+        }
+        this.#chatService.clearModelCache();
+    }
     #clearCorrelationId() {
         if (this.#currentCorrelationId) {
             this.#logger.clearCorrelationId();
@@ -800,12 +931,17 @@ export class AgentClient {
             if (this.#currentCorrelationId === correlationId)
                 this.#clearCorrelationId();
         };
-        void stream.completed.then(() => cleanup(), (error) => {
+        void stream.completed.then(() => {
+            if (stream.latestProviderInputTokens !== undefined) {
+                this.#lastCompletedProviderInputTokens = stream.latestProviderInputTokens;
+                if (this.#sessionRolloverRequest) {
+                    this.#sessionRolloverRequest.providerInputTokens = stream.latestProviderInputTokens;
+                }
+            }
+            cleanup();
+        }, (error) => {
             const failure = classifyProviderFailure(error);
-            this.#logger.error('Agent stream failed', {
-                eventType: 'provider.response.failed',
-                category: 'provider',
-                phase: 'provider_response',
+            const metadata = {
                 traceId: correlationId ?? undefined,
                 provider,
                 model,
@@ -818,7 +954,23 @@ export class AgentClient {
                 inputType: Array.isArray(input) ? 'array' : typeof input,
                 inputLength: typeof input === 'string' ? input.length : undefined,
                 inputItems: Array.isArray(input) ? input.length : undefined,
-            });
+            };
+            if (failure.errorKind === 'cancelled') {
+                this.#logger.debug('Agent stream cancelled', {
+                    ...metadata,
+                    eventType: 'stream.aborted',
+                    category: 'stream',
+                    phase: 'abort',
+                });
+            }
+            else {
+                this.#logger.error('Agent stream failed', {
+                    ...metadata,
+                    eventType: 'provider.response.failed',
+                    category: 'provider',
+                    phase: 'provider_response',
+                });
+            }
             cleanup();
         });
     }
@@ -870,6 +1022,8 @@ export class AgentClient {
         this.#abortActiveWork(() => this.#applicationRunLoop.abortSegment());
         const startController = new AbortController();
         this.#activeStartController = startController;
+        if (options.sessionId)
+            this.#lastLogicalSessionId = options.sessionId;
         try {
             await this.#prepareStart(userInput, options, startController.signal);
             if (startController.signal.aborted) {
@@ -877,7 +1031,7 @@ export class AgentClient {
             }
             const provider = this.#agentConfig.getProvider();
             const supportsChaining = this.supportsConversationChaining();
-            const agent = this.#agentConfig.getApplicationAgent(options.sessionId);
+            const agent = this.#agentConfig.getApplicationAgent(options.sessionId, options.promptCacheKey);
             const requestPreparation = this.#openAIRequestPreparation(options);
             const boundaryCompaction = this.#boundaryCompaction();
             const runBudget = this.#runBudgetPolicy();
@@ -900,7 +1054,7 @@ export class AgentClient {
                     runBudget,
                     ...(this.#wrapUpOnCriticalRunBudget ? { wrapUpOnCriticalRunBudget: true } : {}),
                     ...(options.onRunBudgetEvent ? { onRunBudgetEvent: options.onRunBudgetEvent } : {}),
-                    onRequestBoundary: (history, onReminder) => this.#observeContextMilestones(history, onReminder),
+                    onRequestBoundary: (history, onReminder, observation) => this.#observeContextMilestones(history, onReminder, observation.lastCompletedInputTokens),
                 });
             };
             const stream = run();
@@ -919,6 +1073,8 @@ export class AgentClient {
         // The turn is resuming, not ending: keep anything waiting for this segment.
         this.#abortActiveWork(() => this.#applicationRunLoop.abortSegment());
         const provider = this.#agentConfig.getProvider();
+        if (options.sessionId)
+            this.#lastLogicalSessionId = options.sessionId;
         const supportsChaining = this.supportsConversationChaining();
         const requestPreparation = this.#openAIRequestPreparation(options);
         const boundaryCompaction = this.#boundaryCompaction();
@@ -940,7 +1096,7 @@ export class AgentClient {
             runBudget,
             ...(this.#wrapUpOnCriticalRunBudget ? { wrapUpOnCriticalRunBudget: true } : {}),
             ...(options.onRunBudgetEvent ? { onRunBudgetEvent: options.onRunBudgetEvent } : {}),
-            onRequestBoundary: (history, onReminder) => this.#observeContextMilestones(history, onReminder),
+            onRequestBoundary: (history, onReminder, observation) => this.#observeContextMilestones(history, onReminder, observation.lastCompletedInputTokens),
             ...(options.stopAfterApprovalResolution ? { stopAfterApprovalResolution: true } : {}),
         });
         this.#observeCompletion(stream, state, provider, this.#agentConfig.getModel());