e2e 0.15.1 → 0.16.0

package/dist/agent/model/provider-hints.d.ts

@@ -43,4 +43,3 @@ export interface ProviderHints {
 export declare function providerHints(model: ProviderModelRef | undefined): ProviderHints;
 /** A stable key for one system prompt, so every call sharing the prefix routes alike. */
 export declare function promptCacheKey(system: string): string;
-//# sourceMappingURL=provider-hints.d.ts.map

package/dist/agent/model/provider-hints.js

@@ -85,4 +85,3 @@ function withoutBreakpoint(message) {
     }
     return { ...message, providerOptions };
 }
-//# sourceMappingURL=provider-hints.js.map

package/dist/agent/model/schema.d.ts

@@ -17,4 +17,3 @@ import type { JSONSchema7 } from 'ai';
 import type { StandardSchemaV1 } from '../../types.ts';
 /** The caller schema's shape as JSON Schema, or undefined when it has no usable projection. */
 export declare function deriveJsonSchema(schema: StandardSchemaV1): Promise<JSONSchema7 | undefined>;
-//# sourceMappingURL=schema.d.ts.map

package/dist/agent/model/schema.js

@@ -80,4 +80,3 @@ function refinesOnly(member, type) {
 function isSchemaObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-//# sourceMappingURL=schema.js.map

package/dist/agent/model/sdk.d.ts

@@ -72,4 +72,3 @@ export declare function failureHint(cause: unknown): string;
  * the SDK to be loaded, which every caller has done by the time a call failed.
  */
 export declare function isAbort(cause: unknown): boolean;
-//# sourceMappingURL=sdk.d.ts.map

package/dist/agent/model/sdk.js

@@ -303,4 +303,3 @@ export function isAbort(cause) {
         return true;
     return cause instanceof Error && (cause.name === 'AbortError' || cause.name === 'TimeoutError');
 }
-//# sourceMappingURL=sdk.js.map

package/dist/agent/model/stall.d.ts

@@ -8,4 +8,3 @@ import type { AiSdk, SdkLanguageModel } from '../ai-sdk.ts';
  * The caller's cancellation is not a stall and passes through as it was.
  */
 export declare function withStallGuard(ai: AiSdk, model: SdkLanguageModel, onStall?: (stallMs: number) => void, stallMs?: number): SdkLanguageModel;
-//# sourceMappingURL=stall.d.ts.map

package/dist/agent/model/stall.js

@@ -50,4 +50,3 @@ export function withStallGuard(ai, model, onStall = () => undefined, stallMs = M
         },
     });
 }
-//# sourceMappingURL=stall.js.map

package/dist/agent/model/tool-choice.d.ts

@@ -3,13 +3,36 @@
  * a tool call on every turn (`toolChoice: 'required'`) and names
  * `complete_step` on the final ones; some models reject that request shape
  * outright (Anthropic's Claude Fable 5.1 answers HTTP 400 with
- * `tool_choice: type "tool" and "any" are not supported for this model.`),
+ * `tool_choice: type "tool" and "any" are not supported for this model.`;
+ * DeepSeek's V4 models think by default and answer a forced choice with
+ * `Thinking mode does not support this tool_choice`),
  * and a gateway forwards the provider's words.
  *
  * The loop reacts to this refusal differently from any other provider
  * failure: the same request with `toolChoice: 'auto'` and an instruction to
  * answer with tool calls can still succeed, where a 5xx needs only time.
  */
+/**
+ * Whether a call warning says the provider sent `auto` in place of the
+ * forced choice it was asked for. The AI SDK's Anthropic provider does this
+ * itself for models it knows reject forced tool use (Claude Sonnet 5.5), so
+ * the request succeeds and no refusal ever reaches the loop.
+ */
+export declare function isForcedToolChoiceDowngraded(warning: {
+    readonly type: string;
+    readonly feature?: string;
+}): boolean;
+/**
+ * Whether a turn under a forced choice came back as a finished reply without
+ * a tool call. The AI SDK (7.0.88 and later) throws `AI_ToolChoiceViolationError`
+ * for that, which is how a downgrading provider's prose answer surfaces. It is
+ * matched by name, since earlier 7.x releases export no such class; a reply
+ * cut off by the token limit or a content filter says nothing about the
+ * provider and does not count.
+ */
+export declare function isForcedToolCallSkipped(error: unknown): error is {
+    readonly content?: readonly unknown[];
+};
 /**
  * Whether a provider failure says the model does not accept a forced tool
  * choice. Reads the message and the raw response body of the error and of
@@ -18,4 +41,3 @@
  * quoting the request never reads as a model limitation.
  */
 export declare function isForcedToolChoiceRejected(error: unknown): boolean;
-//# sourceMappingURL=tool-choice.d.ts.map

package/dist/agent/model/tool-choice.js

@@ -3,7 +3,9 @@
  * a tool call on every turn (`toolChoice: 'required'`) and names
  * `complete_step` on the final ones; some models reject that request shape
  * outright (Anthropic's Claude Fable 5.1 answers HTTP 400 with
- * `tool_choice: type "tool" and "any" are not supported for this model.`),
+ * `tool_choice: type "tool" and "any" are not supported for this model.`;
+ * DeepSeek's V4 models think by default and answer a forced choice with
+ * `Thinking mode does not support this tool_choice`),
  * and a gateway forwards the provider's words.
  *
  * The loop reacts to this refusal differently from any other provider
@@ -12,10 +14,34 @@
  */
 const FORCED_CHOICE_PATTERNS = [
     /tool_choice.*not supported/i, // Anthropic
+    /does not support (?:this |the )?tool_choice/i, // DeepSeek V4 in thinking mode (its default)
     /tool_choice.*(?:unsupported|is not allowed|cannot be)/i, // OpenAI-compatible proxies
     /(?:forced|required) tool (?:choice|call|use).*not supported/i, // generic
     /does not support (?:forced|required) tool/i, // generic
 ];
+/**
+ * Whether a call warning says the provider sent `auto` in place of the
+ * forced choice it was asked for. The AI SDK's Anthropic provider does this
+ * itself for models it knows reject forced tool use (Claude Sonnet 5.5), so
+ * the request succeeds and no refusal ever reaches the loop.
+ */
+export function isForcedToolChoiceDowngraded(warning) {
+    return warning.type === 'unsupported' && warning.feature === 'toolChoice';
+}
+/**
+ * Whether a turn under a forced choice came back as a finished reply without
+ * a tool call. The AI SDK (7.0.88 and later) throws `AI_ToolChoiceViolationError`
+ * for that, which is how a downgrading provider's prose answer surfaces. It is
+ * matched by name, since earlier 7.x releases export no such class; a reply
+ * cut off by the token limit or a content filter says nothing about the
+ * provider and does not count.
+ */
+export function isForcedToolCallSkipped(error) {
+    if (typeof error !== 'object' || error === null)
+        return false;
+    const record = error;
+    return record.name === 'AI_ToolChoiceViolationError' && record.finishReason === 'stop';
+}
 /** Longest cause chain walked; a wrapped error rarely nests deeper. */
 const MAX_CAUSE_DEPTH = 8;
 /**
@@ -46,4 +72,3 @@ function describesRejection(error) {
         return false;
     return [record.message, record.responseBody].some((text) => typeof text === 'string' && FORCED_CHOICE_PATTERNS.some((pattern) => pattern.test(text)));
 }
-//# sourceMappingURL=tool-choice.js.map

package/dist/agent/observation-budget.d.ts

@@ -24,4 +24,3 @@ export interface ObservationBudgetRequest {
  * than fail the adapter's pre-flight check.
  */
 export declare function observationByteBudget(limits: ObservationBudgetLimits, request: ObservationBudgetRequest): number;
-//# sourceMappingURL=observation-budget.d.ts.map

package/dist/agent/observation-budget.js

@@ -40,4 +40,3 @@ export function observationByteBudget(limits, request) {
     const withinTokenCeiling = Math.max(MIN_OBSERVATION_BYTES, limits.maxInputTokens - overhead);
     return Math.min(limits.maxObservationBytes, withinTokenCeiling);
 }
-//# sourceMappingURL=observation-budget.js.map

package/dist/agent/observation-feed.d.ts

@@ -170,4 +170,3 @@ export declare class ObservationFeed {
 }
 /** The error for a target id the newest screen no longer lists. */
 export declare function nodeGone(id: string, latest: SemanticAgentObservation): AgentError;
-//# sourceMappingURL=observation-feed.d.ts.map

package/dist/agent/observation-feed.js

@@ -392,4 +392,3 @@ function echoesInput(node) {
 export function nodeGone(id, latest) {
     return new AgentError('LOCATOR_NOT_FOUND', `node #${id} is not on the current screen (observation ${latest.revision}); it was removed or never existed`);
 }
-//# sourceMappingURL=observation-feed.js.map

package/dist/agent/observation.d.ts

@@ -190,4 +190,3 @@ export declare function settleObservation<T>(capture: () => Promise<T>, shapeOf:
  */
 export declare function isTransitionalObservation(observation: AgentObservation): boolean;
 export {};
-//# sourceMappingURL=observation.d.ts.map

package/dist/agent/observation.js

@@ -474,4 +474,3 @@ function indexNodes(node, into, parents) {
         indexNodes(child, into, parents);
     }
 }
-//# sourceMappingURL=observation.js.map

package/dist/agent/operation-queue.d.ts

@@ -18,4 +18,3 @@ export declare class OperationQueue {
     /** Runs `body` after every operation queued before it, in call order. */
     run<T>(body: () => Promise<T>): Promise<T>;
 }
-//# sourceMappingURL=operation-queue.d.ts.map

package/dist/agent/operation-queue.js

@@ -24,4 +24,3 @@ export class OperationQueue {
         return run;
     }
 }
-//# sourceMappingURL=operation-queue.js.map

package/dist/agent/phases.d.ts

@@ -75,4 +75,3 @@ export declare function retryingObserve(options: {
     readonly signal: AbortSignal;
     readonly api: string;
 }): Promise<Observation>;
-//# sourceMappingURL=phases.d.ts.map

package/dist/agent/phases.js

@@ -140,4 +140,3 @@ function phaseErrorCode(cause) {
         return engineError.code;
     return cause instanceof Error ? cause.name : 'ERROR';
 }
-//# sourceMappingURL=phases.js.map

package/dist/agent/pixels.d.ts

@@ -18,4 +18,3 @@ export declare function sizeForModel<P extends ObservationPixels>(pixels: P): P;
  * the caller's pixels carry (a masked-region count) rides along unchanged.
  */
 export declare function downscalePixels<P extends ObservationPixels>(pixels: P, maxLongSide: number): P;
-//# sourceMappingURL=pixels.d.ts.map

package/dist/agent/pixels.js

@@ -82,4 +82,3 @@ function boxResample(source, sourceWidth, sourceHeight, target, targetWidth, tar
         }
     }
 }
-//# sourceMappingURL=pixels.js.map

package/dist/agent/point-tap.d.ts

@@ -63,4 +63,3 @@ export declare function describePointHit(input: PointProse & {
     readonly control: SemanticNode | undefined;
     readonly under: SemanticNode | undefined;
 }): string;
-//# sourceMappingURL=point-tap.d.ts.map

package/dist/agent/point-tap.js

@@ -112,4 +112,3 @@ export function describePointHit(input) {
 function describeNode(prose, node) {
     return nodeLine(prose.observation, node.ref.id);
 }
-//# sourceMappingURL=point-tap.js.map

package/dist/agent/primitives.d.ts

@@ -46,6 +46,12 @@ export interface GrammarToolOptions {
      * otherwise.
      */
     readonly screen?: ScreenPresenter;
+    /**
+     * Told the cause of every action that failed into a result rather than a
+     * throw, before it becomes the result's text: the one place its runner
+     * code is still structured.
+     */
+    readonly onActionFailed?: ((cause: unknown) => void) | undefined;
 }
 /**
  * AI SDK tools over the harness action grammar, limited to the verbs the
@@ -78,4 +84,3 @@ export declare function trackModelCalls(context: StepExecutorContext, model?: {
     readonly provider?: string;
     readonly modelId?: string;
 }): ModelCallTracker;
-//# sourceMappingURL=primitives.d.ts.map

package/dist/agent/primitives.js

@@ -666,7 +666,10 @@ function verbKit(context, options) {
         catch (cause) {
             if (isRuntimeHardStop(cause))
                 throw cause;
-            return present(failureLead(label, cause));
+            const failed = await present(failureLead(label, cause));
+            // After the look, so a look that throws fails the call once, as itself.
+            options.onActionFailed?.(cause);
+            return failed;
         }
         return present(outcome.lead, { expectChange: outcome.expectChange, ...update });
     });
@@ -717,4 +720,3 @@ export function trackModelCalls(context, model) {
         },
     };
 }
-//# sourceMappingURL=primitives.js.map

package/dist/agent/prompts.d.ts

@@ -49,4 +49,3 @@ export declare const JUDGMENT_REQUEST: string;
 export declare const EXTRACT_REQUEST: string;
 /** The extraction's answer to a rejection the screen cannot satisfy: say so rather than change the data. */
 export declare const EXTRACT_REPAIR_OUTLET = "Correct a misread or a wrong shape. When the data the observation shows cannot satisfy the errors, respond with \"found\": false and say why in \"missing\" rather than change a value to fit.";
-//# sourceMappingURL=prompts.d.ts.map

package/dist/agent/prompts.js

@@ -118,4 +118,3 @@ export const EXTRACT_REQUEST = [
 ].join('\n');
 /** The extraction's answer to a rejection the screen cannot satisfy: say so rather than change the data. */
 export const EXTRACT_REPAIR_OUTLET = 'Correct a misread or a wrong shape. When the data the observation shows cannot satisfy the errors, respond with "found": false and say why in "missing" rather than change a value to fit.';
-//# sourceMappingURL=prompts.js.map

package/dist/agent/protocol.d.ts

@@ -65,4 +65,3 @@ export declare function extractSchema(shape: JSONSchema7): JSONSchema7;
  */
 export declare function validateExtractResponse(value: unknown): ProtocolValidation<ExtractResponse>;
 export {};
-//# sourceMappingURL=protocol.d.ts.map

package/dist/agent/protocol.js

@@ -163,4 +163,3 @@ function asBoundedString(value, min, max) {
 function codePointLength(value) {
     return [...value].length;
 }
-//# sourceMappingURL=protocol.js.map

package/dist/agent/public.d.ts

@@ -11,4 +11,3 @@
 export { createToolLoopExecutor, type ToolLoopExecutorOptions, type PreparedTurn, type PreparedMessages, type ToolLoopHelpers, } from './tool-loop.ts';
 export { defineTool, getToolContext, type DefinedTool, type ToolAnnotations } from './tool.ts';
 export { AgentError, isAgentError } from './error.ts';
-//# sourceMappingURL=public.d.ts.map

package/dist/agent/public.js

@@ -11,4 +11,3 @@
 export { createToolLoopExecutor, } from './tool-loop.js';
 export { defineTool, getToolContext } from './tool.js';
 export { AgentError, isAgentError } from './error.js';
-//# sourceMappingURL=public.js.map

package/dist/agent/reading.d.ts

@@ -24,4 +24,3 @@ export declare function nodeReading(observation: Pick<SemanticAgentObservation,
  * list moving.
  */
 export declare function readingShape(observation: Pick<SemanticAgentObservation, 'nodes'>): string;
-//# sourceMappingURL=reading.d.ts.map

package/dist/agent/reading.js

@@ -80,4 +80,3 @@ export function readingShape(observation) {
     }
     return lines.join('\n');
 }
-//# sourceMappingURL=reading.js.map

package/dist/agent/replay.d.ts

@@ -84,4 +84,3 @@ export declare function verifyAnchors(host: ReplayHost, anchors: readonly TraceT
     readonly waitMs?: number;
     readonly initial?: SemanticScreen;
 }): Promise<boolean>;
-//# sourceMappingURL=replay.d.ts.map

package/dist/agent/replay.js

@@ -438,4 +438,3 @@ function isUncertainCommit(cause) {
 function isReplayFatal(cause, signal) {
     return signal.aborted || isRuntimeHardStop(cause);
 }
-//# sourceMappingURL=replay.js.map

package/dist/agent/screen-update.d.ts

@@ -121,4 +121,3 @@ export declare class ScreenPresenter {
      */
     private withScreenshot;
 }
-//# sourceMappingURL=screen-update.d.ts.map

package/dist/agent/screen-update.js

@@ -312,4 +312,3 @@ function diffScreens(previous, next) {
     }
     return lines;
 }
-//# sourceMappingURL=screen-update.js.map

package/dist/agent/scroll-target.d.ts

@@ -23,4 +23,3 @@ import type { SemanticAgentObservation } from './observation.ts';
 export declare function resolveScrollTarget(feed: ObservationFeed, target: ExecutorTarget): Resolved | undefined;
 /** The listed node of the role whose box overlaps `box` most, when it overlaps enough. */
 export declare function samePlace(observation: SemanticAgentObservation, role: string | undefined, box: Box): SemanticNode | undefined;
-//# sourceMappingURL=scroll-target.d.ts.map

package/dist/agent/scroll-target.js

@@ -51,4 +51,3 @@ export function samePlace(observation, role, box) {
     }
     return best?.node;
 }
-//# sourceMappingURL=scroll-target.js.map

package/dist/agent/secrets.d.ts

@@ -17,4 +17,3 @@ interface SecretFillHost {
  */
 export declare function authorizeSecretFill(host: SecretFillHost, runtime: AgentContext, secret: Secret, node: SemanticNode): Promise<string>;
 export {};
-//# sourceMappingURL=secrets.d.ts.map

package/dist/agent/secrets.js

@@ -38,4 +38,3 @@ export async function authorizeSecretFill(host, runtime, secret, node) {
         throw toAgentError(cause);
     }
 }
-//# sourceMappingURL=secrets.js.map

package/dist/agent/settle-policy.d.ts

@@ -53,4 +53,3 @@ interface SettleAfter {
  */
 export declare const SETTLE_AFTER: Record<RecordedAction['name'], SettleAfter>;
 export {};
-//# sourceMappingURL=settle-policy.d.ts.map

package/dist/agent/settle-policy.js

@@ -66,4 +66,3 @@ export const SETTLE_AFTER = {
     dismissKeyboard: { changeWaitMs: FULL_CHANGE_WAIT_MS, look: 'held-still' },
     tool: { changeWaitMs: BRIEF_CHANGE_WAIT_MS, look: 'held-still' },
 };
-//# sourceMappingURL=settle-policy.js.map

package/dist/agent/step-accounting.d.ts

@@ -108,4 +108,3 @@ export declare class StepAccounting {
      */
     modelInfo(executor: Pick<StepExecutor, 'name' | 'version'>): StepModelInfo | undefined;
 }
-//# sourceMappingURL=step-accounting.d.ts.map

package/dist/agent/step-accounting.js

@@ -220,4 +220,3 @@ export class StepAccounting {
         }, calls);
     }
 }
-//# sourceMappingURL=step-accounting.js.map

package/dist/agent/step-cache.d.ts

@@ -47,8 +47,15 @@ export interface StepCacheOptions {
     /** Timeline index of the step being dispatched. */
     readonly stepIndex: number;
 }
-/** How the step settled, as the write-side decision sees it. */
-export type StepOutcome = 'passed' | 'failed' | 'cancelled';
+/**
+ * How the step settled, as the write-side decision sees it. `no-verdict` is a
+ * step that ended without anything judging the app: it was cancelled, or no
+ * model answered (`isModelUnreachable`). Neither says the recorded flow is
+ * wrong, so neither implicates its entry.
+ */
+export type StepOutcome = 'passed' | 'failed' | 'no-verdict';
+/** The outcome of a step that threw `cause`. */
+export declare function failedStepOutcome(cause: unknown): Exclude<StepOutcome, 'passed'>;
 export declare class StepTraceSession {
     private readonly host;
     private readonly cache;
@@ -132,7 +139,11 @@ export declare class StepTraceSession {
      * - failed after consuming a replay: evict. Without this, a diverged replay
      *   whose step then fails stages nothing — and the poisoned entry would
      *   replay its bad prefix on every future first attempt.
-     * - cancelled: nothing, exactly like an interrupted attempt.
+     * - no verdict (cancelled, or no model answered): nothing, exactly like an
+     *   interrupted attempt. A replay that stopped at a gap and handed off to a
+     *   model that never answered proved nothing against the recording, and one
+     *   that diverged hands off again next run, where a model that answers
+     *   re-records it.
      */
     conclude(outcome: StepOutcome, verdictSummary: string | undefined): Promise<void>;
     /**
@@ -213,4 +224,3 @@ export declare class StepTraceSession {
  * drift apart; a summary not written by it is returned as is.
  */
 export declare function recordedVerdictOf(summary: string): string;
-//# sourceMappingURL=step-cache.d.ts.map

package/dist/agent/step-cache.js

@@ -19,9 +19,15 @@ import { TraceRecorder } from '../cache/recorder.js';
 import { expandTrace, templateParams, templatesCollide, templateTrace } from '../cache/template.js';
 import { readTraceEntry } from '../cache/trace.js';
 import { sleep } from '../internal/time.js';
-import { AgentError } from './error.js';
+import { AgentError, isAgentError, isModelUnreachable } from './error.js';
 import { isRuntimeHardStop } from './executor.js';
 import { replayTrace, verifyAnchors, } from './replay.js';
+/** The outcome of a step that threw `cause`. */
+export function failedStepOutcome(cause) {
+    if (isModelUnreachable(cause))
+        return 'no-verdict';
+    return isAgentError(cause) && cause.code === 'CANCELLED' ? 'no-verdict' : 'failed';
+}
 /**
  * The reasons a recording that exists no longer replays: the app or the
  * entry changed under it. The others describe the step (a value read off
@@ -189,14 +195,18 @@ export class StepTraceSession {
      * - failed after consuming a replay: evict. Without this, a diverged replay
      *   whose step then fails stages nothing — and the poisoned entry would
      *   replay its bad prefix on every future first attempt.
-     * - cancelled: nothing, exactly like an interrupted attempt.
+     * - no verdict (cancelled, or no model answered): nothing, exactly like an
+     *   interrupted attempt. A replay that stopped at a gap and handed off to a
+     *   model that never answered proved nothing against the recording, and one
+     *   that diverged hands off again next run, where a model that answers
+     *   re-records it.
      */
     async conclude(outcome, verdictSummary) {
         const recorder = this.recorder;
         if (recorder === undefined)
             return;
         switch (outcome) {
-            case 'cancelled':
+            case 'no-verdict':
                 return;
             case 'failed':
                 // A stale recording `cache.strict` failed on stays for the next strict
@@ -501,4 +511,3 @@ export function recordedVerdictOf(summary) {
     const at = summary.indexOf(RECORDED_VERDICT_SEPARATOR);
     return at === -1 ? summary : summary.slice(at + RECORDED_VERDICT_SEPARATOR.length);
 }
-//# sourceMappingURL=step-cache.js.map

package/dist/agent/tool-loop.d.ts

@@ -80,4 +80,3 @@ export interface PreparedTurn {
  * Its model turns per step are the agent's `maxModelCalls`.
  */
 export declare function createToolLoopExecutor(options: ToolLoopExecutorOptions): StepExecutor;
-//# sourceMappingURL=tool-loop.d.ts.map

package/dist/agent/tool-loop.js

@@ -14,7 +14,7 @@ import { asSdkLanguageModel, loadAiSdk } from './ai-sdk.js';
 import { ConfigurationError, withHint } from '../internal/errors.js';
 import { failureHint, isAbort, TRANSPORT_RETRIES } from './model/sdk.js';
 import { isContextOverflow } from './model/overflow.js';
-import { isForcedToolChoiceRejected } from './model/tool-choice.js';
+import { isForcedToolCallSkipped, isForcedToolChoiceDowngraded, isForcedToolChoiceRejected } from './model/tool-choice.js';
 import { withStallGuard } from './model/stall.js';
 import { providerHints } from './model/provider-hints.js';
 import { isScreenOutput, toolResultTexts } from './screen-update.js';
@@ -61,6 +61,14 @@ const MAX_REPORTED_NOTES_CHARS = 1_000;
 const FREE_TOOL_CHOICE_MODELS = new WeakSet();
 /** Appended to the instructions when the model cannot be forced to call tools. */
 const TOOL_CALLS_ONLY_RULE = 'Reply with tool calls only. A reply without a tool call does nothing and spends a turn; the step ends only through complete_step.';
+/** The usage of a turn the SDK threw on: the provider answered, but the SDK reports no usage for it. */
+const UNREPORTED_USAGE = {
+    inputTokens: undefined,
+    inputTokenDetails: { noCacheTokens: undefined, cacheReadTokens: undefined, cacheWriteTokens: undefined },
+    outputTokens: undefined,
+    outputTokenDetails: { textTokens: undefined, reasoningTokens: undefined },
+    totalTokens: undefined,
+};
 /** Sent when a turn came back as text without a tool call. */
 const TEXT_REPLY_NOTICE = '[SYSTEM] Your last reply had no tool call, so nothing happened. Continue with a tool call, or call complete_step with your verdict.';
 /**
@@ -125,6 +133,8 @@ class LoopRun {
     overflowNote;
     /** How this step asks for tool calls; flips to `auto` when the model rejects a forced choice. */
     toolChoice;
+    /** The tool-choice mode the running generate call's instructions were written for. */
+    instructedFor = 'required';
     /** The last turn that ran, for continuing after a reply without tool calls. */
     lastStep;
     /** `model` as the loop sends requests to it: each one bounded, so a stalled response is sent again. */
@@ -166,6 +176,7 @@ class LoopRun {
                         this.lastStep = step;
                         this.recordTurn(step);
                         tracker.onStepEnd(step);
+                        this.noticeToolChoiceDowngrade(step);
                     },
                 });
                 const continued = this.continueAfterTextReply(result.responseMessages);
@@ -181,7 +192,7 @@ class LoopRun {
                     prompt = shrunk;
                     continue;
                 }
-                const freed = this.freeToolChoiceRetry(cause);
+                const freed = this.freeToolChoiceRetry(cause, tracker);
                 if (freed !== undefined) {
                     prompt = freed;
                     continue;
@@ -221,6 +232,7 @@ class LoopRun {
     }
     buildLoop(tools) {
         const system = this.instructions();
+        this.instructedFor = this.toolChoice;
         const providerOptions = this.hints.providerOptions(this.options.providerOptions ?? this.context.providerOptions, system);
         return new this.ai.ToolLoopAgent({
             model: this.requestModel,
@@ -241,8 +253,8 @@ class LoopRun {
     /**
      * A generate call that returned without a verdict and without a hard stop
      * ended on a turn that made no tool call: the SDK loop stops when there is
-     * nothing to execute. Under `required` that cannot happen; under `auto` the
-     * model may answer in prose. While turns remain, the reply is kept in the
+     * nothing to execute. Under `required` the SDK throws instead (see
+     * `freeToolChoiceRetry`); under `auto` the model may answer in prose. While turns remain, the reply is kept in the
      * history and the model is told to act, on the same turn budget.
      */
     continueAfterTextReply(responseMessages) {
@@ -264,21 +276,49 @@ class LoopRun {
     /**
      * A model that refuses a forced tool choice (HTTP 400 naming
      * `tool_choice`) is asked again with `auto` and a tool-calls-only rule in
-     * its instructions, on the same turn budget. The refusal is remembered per
-     * model instance, so later steps start in that mode.
+     * its instructions, on the same turn budget. So is one whose reply had no
+     * tool call under a forced choice: the SDK throws `ToolChoiceViolationError`
+     * for it, which happens when the provider downgraded the choice to `auto`
+     * and the model answered in prose. Either way the model is remembered, so
+     * later steps start in that mode.
      */
-    freeToolChoiceRetry(cause) {
+    freeToolChoiceRetry(cause, tracker) {
         if (this.toolChoice === 'auto' || this.lastRequest === undefined)
             return undefined;
-        if (this.context.signal.aborted || this.hardStop !== undefined || !isForcedToolChoiceRejected(cause)) {
+        if (this.context.signal.aborted || this.hardStop !== undefined)
+            return undefined;
+        if (isForcedToolCallSkipped(cause)) {
+            // The provider answered, and billed, before the SDK threw: the turn counts.
+            tracker.onStepEnd({ usage: UNREPORTED_USAGE, providerMetadata: undefined, reasoningText: undefined });
+            this.turnsUsed += 1;
+            this.turns.push({ index: this.turnsUsed, calls: [], outcome: skippedReplyText(cause.content), notes: [] });
+            this.note(`turn ${String(this.turnsUsed)} answered without the forced tool call: retrying with auto`);
+        }
+        else if (isForcedToolChoiceRejected(cause)) {
+            this.note(`the model rejected a forced tool choice before turn ${String(this.turnsUsed + 1)}: retrying with auto`);
+        }
+        else {
             return undefined;
         }
         this.toolChoice = 'auto';
         FREE_TOOL_CHOICE_MODELS.add(this.model);
         this.turnOffset = this.turnsUsed;
-        this.note(`the model rejected a forced tool choice before turn ${String(this.turnsUsed + 1)}: retrying with auto`);
         return this.lastRequest;
     }
+    /**
+     * A provider that downgraded a forced choice to `auto` on its own (a
+     * `toolChoice` warning on a turn that otherwise succeeded) is treated like
+     * one that refused it: the rest of the step asks with `auto` under the
+     * tool-calls-only rule, and the model is remembered, so later steps start
+     * in that mode.
+     */
+    noticeToolChoiceDowngrade(step) {
+        if (this.toolChoice === 'auto' || step.warnings?.some(isForcedToolChoiceDowngraded) !== true)
+            return;
+        this.toolChoice = 'auto';
+        FREE_TOOL_CHOICE_MODELS.add(this.model);
+        this.note(`the provider sent auto in place of a forced tool choice on turn ${String(this.turnsUsed)}: continuing with auto`);
+    }
     /**
      * The one recovery the loop attempts on its own: a request the provider
      * refused as too large is sent again with the history shrunk — superseded
@@ -409,6 +449,8 @@ class LoopRun {
         // alone under `auto`; the notices above already tell it to call it.
         return {
             ...(outgoing === messages ? {} : { messages: outgoing }),
+            // A switch to `auto` inside this generate call: the remaining turns get the tool-calls-only rule too.
+            ...(this.toolChoice === this.instructedFor ? {} : { instructions: this.hints.instructions(this.instructions()) }),
             ...(forced
                 ? {
                     activeTools: ['complete_step'],
@@ -564,6 +606,17 @@ function truncate(text, max) {
     return text.length <= max ? text : `${text.slice(0, max)}…[truncated]`;
 }
 /** A tool result for the transcript: a screenshot-carrying result reads as its text plus the image size, never the bytes. */
+/** The prose of a reply the SDK refused for lacking the forced tool call, as a turn outcome. */
+function skippedReplyText(content) {
+    const text = (content ?? [])
+        .flatMap((part) => {
+        const record = part;
+        return record.type === 'text' && typeof record.text === 'string' ? [record.text] : [];
+    })
+        .join('')
+        .trim();
+    return text === '' ? '' : `assistant: ${truncate(text, MAX_TURN_TEXT_CHARS)}`;
+}
 function describeOutput(output) {
     if (isScreenOutput(output))
         return `${output.text}\n[screenshot, ${String(output.pixels.data.byteLength)} bytes]`;
@@ -579,4 +632,3 @@ function safeJson(value) {
         return String(value);
     }
 }
-//# sourceMappingURL=tool-loop.js.map