e2e 0.16.0 → 0.18.0

package/dist/agent/step-cache.js

@@ -11,17 +11,17 @@
  * for the route precondition. The initial capture can also serve the executor
  * when replay performed no action.
  */
-import { anchorsPresent, describeAnchors } from '../cache/anchors.js';
+import { deltaEvidenced, deltaHolds, describeDelta } from '../cache/anchors.js';
 import { decideTraceReplay, opensWithNavigate } from '../cache/decide.js';
-import { compareRoutes, routeOf } from '../cache/route.js';
-import { instructionDigest } from '../cache/identity.js';
-import { TraceRecorder } from '../cache/recorder.js';
+import { sameRoute } from '../cache/route.js';
+import { recordedProvenance, 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, isAgentError, isModelUnreachable } from './error.js';
 import { isRuntimeHardStop } from './executor.js';
-import { replayTrace, verifyAnchors, } from './replay.js';
+import { replayTrace, verifyEndState, } from './replay.js';
+import { redactNodesAgain } from './observation.js';
 /** The outcome of a step that threw `cause`. */
 export function failedStepOutcome(cause) {
     if (isModelUnreachable(cause))
@@ -48,9 +48,8 @@ const STALE_REASONS = new Set([
 const END_WAIT_MARGIN_MS = 10_000;
 /**
  * How long a replay waits for a recorded destination path to be the current
- * one. A step that moved records no anchors: the path is its whole
- * postcondition, and the replayed tap that starts the navigation returns
- * before the new document commits. Reading the path once, right after the
+ * one. The replayed tap that starts a navigation returns before the new
+ * document commits. Reading the path once, right after the
  * tap, hands every navigation off as an end-mismatch; polling with the
  * settling backoff lets the destination arrive. Bounded like anchor polling.
  */
@@ -60,8 +59,11 @@ export class StepTraceSession {
     host;
     cache;
     keyHash;
+    /** The claimed key and the step it names, which an entry records as its provenance. */
+    claim;
     recorder;
     options;
+    redaction;
     info;
     prefix;
     startPath;
@@ -85,6 +87,8 @@ export class StepTraceSession {
     replayedWhole = false;
     /** True once a cached entry's actions were run this step, fully or partly. */
     consumedReplay = false;
+    /** True once the store returned an entry for this step, whether or not it replayed. */
+    readEntryHit = false;
     /** True once `cache.strict` failed the step on its recording, which is then kept for review rather than evicted. */
     failedStale = false;
     /** Grammar actions recorded so far when an end-mismatch hand-off happened. */
@@ -92,13 +96,15 @@ export class StepTraceSession {
     constructor(host, options) {
         this.host = host;
         this.options = options;
+        this.redaction = { redact: options.redact, redactCut: options.redactCut };
         this.cache = options.cache;
         // The key digests the params as the recording spells them, a placeholder
         // where each `unique()` value was, so every run's value finds one entry.
-        this.keyHash = options.cache.claimKeyHash('act', options.instruction, templateParams(options.params, options.templates));
+        this.claim = options.cache.claimKey('act', options.instruction, templateParams(options.params, options.templates), options.agent);
+        this.keyHash = this.claim.keyHash;
         if (options.cache.mode === 'read-write') {
             this.recorder = new TraceRecorder({
-                redact: options.redact,
+                ...this.redaction,
                 maxActions: options.maxActions,
             });
         }
@@ -130,7 +136,8 @@ export class StepTraceSession {
      * self-finalized verdict on a full replay whose postcondition holds;
      * undefined dispatches the executor — after a miss from the top, after a
      * divergence mid-step with `replayedPrefix` set. Every failure to replay is
-     * a miss, never an error; only runtime hard stops propagate.
+     * a miss, never an error; only runtime hard stops and a policy denial on
+     * the opening look propagate.
      */
     async begin() {
         this.startedMs = Date.now();
@@ -144,6 +151,8 @@ export class StepTraceSession {
             this.info = this.missed(read.reason, 0);
             if (read.unavailable !== true)
                 this.failIfStale();
+            if (read.reason === 'no-entry')
+                await this.failIfRekeyed();
             return undefined;
         }
         // With an entry in hand the step is the cache's from its first moment: the
@@ -151,6 +160,7 @@ export class StepTraceSession {
         // replay finishes stays the cache's through its verdict and the re-stage,
         // so a reporter never shows a model turn that is not coming. Only a replay
         // that cannot finish the step hands it to the model.
+        this.readEntryHit = true;
         this.host.replaying(true);
         const verdict = await this.replayEntry(read.entry);
         if (verdict === undefined) {
@@ -173,6 +183,23 @@ export class StepTraceSession {
         this.failedStale = true;
         throw new AgentError('REPLAY_STALE', `the recording of this step no longer replays (${reason}), and cache.strict hands no step to the agent; ${strict.advice}`);
     }
+    /**
+     * Under `cache.strict`, ends a step whose key found no entry while the
+     * store holds a recording made for the same step under another key: the
+     * runner, the engine, the app, or the agent's context changed since, and
+     * the recording no longer replays as surely as one that diverged. A step
+     * whose instruction or params changed is a new step and still runs live.
+     */
+    async failIfRekeyed() {
+        const { strict } = this.cache;
+        if (strict === false || strict.recordings === undefined)
+            return;
+        const previous = await strict.recordings.underAnotherKey(this.keyHash, recordedProvenance(this.claim.step, this.options.redact));
+        if (previous === undefined)
+            return;
+        this.failedStale = true;
+        throw new AgentError('REPLAY_STALE', `the recording of this step no longer replays: the store holds it under another cache key (${previous}.json), since the runner, the engine, the app, or the agent's context changed after it was recorded, and cache.strict hands no step to the agent; ${strict.advice}`);
+    }
     /**
      * Closes the session once the step has settled. The whole write-side
      * decision lives here, in read-write mode only:
@@ -192,6 +219,10 @@ export class StepTraceSession {
      *   anchor, or end wait, so drift is repaired only once a relocation fails
      *   and the hand-off that follows re-records.
      * - passed otherwise: stage the recorded trace for attempt-end settlement.
+     *   When this pass leaves nothing to stage (it changed nothing a replay
+     *   could check) and an entry was read for the step, evict that entry: it
+     *   did not serve this pass, and nothing recorded will replace it, so
+     *   keeping it would hand every later run off the same way.
      * - 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.
@@ -219,10 +250,15 @@ export class StepTraceSession {
                 if (this.repairedAfterEndMismatch(recorder))
                     await this.evict();
                 else if (this.replayedWhole) {
-                    this.cache.staged.push({ kind: 'keep', keyHash: this.keyHash, stepIndex: this.options.stepIndex });
+                    this.cache.staged.push({
+                        kind: 'keep',
+                        keyHash: this.keyHash,
+                        stepIndex: this.options.stepIndex,
+                        recordedFor: recordedProvenance(this.claim.step, this.options.redact),
+                    });
                 }
-                else
-                    await this.stage(recorder, verdictSummary);
+                else if (!(await this.stage(recorder, verdictSummary)) && this.readEntryHit)
+                    await this.evict();
                 return;
         }
     }
@@ -262,7 +298,7 @@ export class StepTraceSession {
      * when this step may write. Settled as far as the capture's purpose asks.
      */
     async captureStart(purpose) {
-        const observation = await probeScreen(this.host, purpose === 'path-only' ? 'raw' : 'held-still');
+        const observation = await probeScreen(this.host, purpose === 'path-only' ? 'raw' : 'held-still', true);
         this.startPath = observation?.path;
         if (this.recorder !== undefined && observation?.kind === 'semantic')
             this.startNodes = observation.nodes;
@@ -289,10 +325,33 @@ export class StepTraceSession {
             this.info = this.missed(decision.reason, trace.actions.length);
             return undefined;
         }
-        const outcome = await replayTrace(this.host, trace, start?.kind === 'semantic' ? { initial: start } : {});
+        // Every screen the replay looks at, in order, from the start: the end
+        // check measures the recorded delta from the first of them on the route
+        // the replay ends on, so a free action is preceded by a look until one
+        // on the recorded end route has been seen.
+        const screens = start === undefined ? [] : [start];
+        const onEndRoute = (screen) => screen !== undefined && (trace.endPath === undefined || (screen.path !== undefined && sameRoute(screen.path, trace.endPath)));
+        const host = this.host;
+        const watched = {
+            get traceEligible() {
+                return host.traceEligible;
+            },
+            observe: async (mode) => {
+                const screen = await host.observe(mode);
+                screens.push(screen);
+                return screen;
+            },
+            actions: host.actions,
+            signal: host.signal,
+            remainingMs: () => host.remainingMs(),
+        };
+        const outcome = await replayTrace(watched, trace, {
+            ...(start?.kind === 'semantic' ? { initial: start } : {}),
+            looksBeforeFree: () => !onEndRoute(screens.at(-1)),
+        });
         this.consumedReplay = true;
         const stopReason = outcome.completed
-            ? (await this.endStateMatches(trace))
+            ? start?.kind === 'semantic' && (await this.endStateMatches(trace, start, screens))
                 ? undefined
                 : 'end-mismatch'
             : (outcome.stopReason ?? 'action-failed');
@@ -309,57 +368,59 @@ export class StepTraceSession {
     }
     /**
      * The trace's postcondition against the live screen: the recorded end
-     * route (when the live location is known) and every recorded end anchor
-     * present again. A route the path leaves undecided is the recorded screen
-     * only if the anchors are already on it, which then needs no second look.
+     * route when the live location is known, the recorded delta on the
+     * screen (`deltaHolds`), and evidence that the replay produced it rather
+     * than finding it there (`deltaEvidenced`). The evidence is measured from
+     * the first screen the replay saw on the route it ended on (`screens`, in
+     * order): the start for a step that stays on one screen, the page a
+     * recorded navigate opened before the switch on it was tapped. An outcome
+     * already showing there proves nothing, and neither does a recording with
+     * no delta at all.
      */
-    async endStateMatches(trace) {
+    async endStateMatches(trace, start, screens) {
         if (!this.host.traceEligible)
             return false;
         const arrived = await this.endScreen(trace);
         if (arrived === undefined)
             return false;
-        if (arrived.anchorsSeen)
-            return true;
-        return (await verifyAnchors(this.host, trace.endAnchors ?? [], {
-            initial: arrived.screen,
+        // Both captures may predate a secret the replay resolved; read with the
+        // ledger as it is now, an unchanged node is no change.
+        const baseline = baselineScreen(screens, arrived.path);
+        const baselineNodes = baseline === undefined ? undefined : redactNodesAgain(baseline.nodes, this.redaction);
+        if (!deltaEvidenced(trace, baselineNodes, inputTargets(trace)))
+            return false;
+        const beforeNodes = baselineNodes ?? redactNodesAgain(start.nodes, this.redaction);
+        // Every look the wait takes must still be on the recorded end route: a
+        // screen that moved on after the route first matched is another screen.
+        const holds = (screen) => (trace.endPath === undefined || screen.path === undefined || sameRoute(screen.path, trace.endPath)) &&
+            deltaHolds(trace, screen.nodes, beforeNodes);
+        return (await verifyEndState(this.host, holds, {
+            initial: arrived,
             ...(trace.endWaitMs === undefined ? {} : { waitMs: trace.endWaitMs }),
         })) && this.host.traceEligible;
     }
     /**
      * Captures the semantic end state once its route matches the recording,
-     * polling while a navigation the last action started commits. Reports
-     * whether the anchors were what settled the route, so the caller does not
-     * verify them again. A route still undecided when the poll runs out is
-     * handed on with the anchors unseen: the caller's anchor wait, sized by
-     * the recording, is the one that decides it, as for a route that matched.
+     * polling while a navigation the last action started commits. A route
+     * that never matches is another screen, whatever it shows: a link that
+     * now lands on a page sharing the recorded one's layout is exactly the
+     * flow that went wrong.
      */
     async endScreen(trace) {
         const startedMs = Date.now();
-        const recorded = trace.endPath === undefined ? undefined : routeOf(trace.endPath);
-        const anchors = trace.endAnchors ?? [];
+        const recorded = trace.endPath;
         for (let attempt = 0;; attempt += 1) {
             const observation = await probeScreen(this.host, 'raw');
             if (observation?.kind !== 'semantic' || !this.host.traceEligible)
                 return undefined;
-            if (recorded === undefined || observation.path === undefined)
-                return { screen: observation, anchorsSeen: false };
-            const verdict = compareRoutes(recorded, routeOf(observation.path));
-            if (verdict === 'same')
-                return { screen: observation, anchorsSeen: false };
-            // A path the runner cannot recognize as the recorded route is the
-            // recorded screen only if the recorded effect is visibly on it; with
-            // no anchors recorded there is nothing to see, and it is another screen.
-            const undecided = verdict === 'undecided' && anchors.length > 0;
-            if (undecided && anchorsPresent(anchors, observation.nodes, { redact: this.options.redact })) {
-                return { screen: observation, anchorsSeen: true };
-            }
+            if (recorded === undefined || observation.path === undefined || sameRoute(recorded, observation.path))
+                return observation;
             const delay = END_PATH_DELAYS_MS[attempt];
             if (delay === undefined ||
                 Date.now() - startedMs + delay > END_PATH_TIMEOUT_MS ||
                 this.host.remainingMs() <= delay ||
                 this.host.signal.aborted) {
-                return undecided ? { screen: observation, anchorsSeen: false } : undefined;
+                return undefined;
             }
             await sleep(delay, this.host.signal);
         }
@@ -401,32 +462,36 @@ export class StepTraceSession {
      *
      * The end path and a fresh settled observation are the trace's
      * postcondition — the state the step passed in. The delta between the
-     * baseline and the passing observation becomes the end anchors. When the
-     * step moved to another pathname the whole new screen is the delta, and its
-     * first stable anchors back the path check, which matches a created
-     * record's page up to the id the app minted for it. A postcondition that
-     * cannot be captured stages nothing: a trace without its check would
-     * replay on mechanics alone.
+     * baseline and the passing observation becomes the anchors: what appeared
+     * and what vanished. When the step moved to another pathname the whole new
+     * screen is the delta, and its first stable anchors back the path check,
+     * which matches a created record's page up to the id the app minted for
+     * it. A postcondition that cannot be captured stages nothing, and neither
+     * does a step that changed nothing a replay could check, no node and no
+     * route: a trace without its check would replay on mechanics alone.
      */
     async stage(recorder, verdictSummary) {
         if (!this.host.traceEligible || this.startNodes === undefined || recorder.recordedCount === 0)
-            return;
+            return false;
         const observation = await probeScreen(this.host, 'held-still');
         if (!this.host.traceEligible || observation?.kind !== 'semantic')
-            return;
+            return false;
         const { nodes: endNodes, path: endPath } = observation;
-        const endAnchors = describeAnchors(this.startNodes, endNodes, this.options);
+        // The start capture may predate a secret this step resolved; read with
+        // the ledger as it is now, an unchanged node is no delta.
+        const startNodes = redactNodesAgain(this.startNodes, this.redaction);
+        const routeMoved = this.startPath !== undefined && endPath !== undefined && !sameRoute(this.startPath, endPath);
+        const delta = describeDelta(startNodes, endNodes, routeMoved);
+        if (delta.appeared.length === 0 && delta.gone.length === 0 && !routeMoved)
+            return false;
         const trace = recorder.finalize({
             executor: this.options.executor,
-            recordedFor: {
-                testId: this.cache.identity.testId,
-                targetId: this.cache.identity.targetId,
-                instructionDigest: instructionDigest(this.options.instruction),
-            },
+            recordedFor: this.claim.step,
             summary: verdictSummary ?? 'step passed',
             ...(this.startPath === undefined ? {} : { startPath: this.startPath }),
             ...(endPath === undefined ? {} : { endPath }),
-            endAnchors,
+            endAnchors: delta.appeared,
+            goneAnchors: delta.gone,
             // How long the app took to show its end state after the last action,
             // plus room for a slower day: the budget a replay waits for the anchors
             // to return. Measured from the last action, not the step's start: the
@@ -435,12 +500,12 @@ export class StepTraceSession {
             endWaitMs: Date.now() - (recorder.lastActionAtMs ?? this.startedMs) + END_WAIT_MARGIN_MS,
         });
         if (trace === undefined)
-            return;
+            return false;
         // A trace with no start anchor — no recorded path (a surface without a URL)
         // and no opening navigate — could never replay: `wrong-context` forever.
         // Writing it would be pure store traffic, so it is not written at all.
         if (trace.startPath === undefined && !opensWithNavigate(trace))
-            return;
+            return false;
         // Stored with a slot where each `unique()` value appeared, so the next
         // run's values — a fresh timestamped name — replay the same flow. A
         // recording that cannot be templated safely is not written at all; when
@@ -448,12 +513,13 @@ export class StepTraceSession {
         if (templatesCollide(this.options.params, this.options.templates)) {
             if (this.info !== undefined)
                 this.info = { ...this.info, notRecorded: 'param-collision' };
-            return;
+            return false;
         }
         const templated = templateTrace(trace, this.options.templates);
         if (templated === undefined)
-            return;
+            return false;
         this.cache.staged.push({ kind: 'write', keyHash: this.keyHash, trace: templated, stepIndex: this.options.stepIndex });
+        return true;
     }
     /**
      * Awaited so the step does not close — and a later read cannot be served
@@ -476,18 +542,41 @@ export class StepTraceSession {
         };
     }
 }
+/** The controls a trace's input actions set a value or a state on: their changed anchors echo the input. */
+function inputTargets(trace) {
+    return trace.actions.flatMap((action) => ('target' in action && action.target !== undefined ? [action.target] : []));
+}
+/**
+ * The first semantic screen of the replay's last stretch on the route it
+ * ended on (`endPath`), or undefined when its last screen before the end
+ * was on another route, so the last action moved it. A screen or an end
+ * without a location counts as on the route: there is nothing to compare.
+ */
+function baselineScreen(screens, endPath) {
+    let baseline;
+    for (const screen of screens) {
+        if (endPath !== undefined && screen.path !== undefined && !sameRoute(screen.path, endPath))
+            baseline = undefined;
+        else if (screen.kind === 'semantic')
+            baseline ??= screen;
+    }
+    return baseline;
+}
 /**
  * One cache capture, settled as far as `mode` asks, or undefined when the
  * surface cannot be observed right now, which is the executor's business,
  * not the cache's. Runtime hard stops (timeout, cancellation) are the step's
- * truth even when they land during cache bookkeeping, and propagate.
+ * truth even when they land during cache bookkeeping, and propagate. So does
+ * a policy denial on the step's opening look (`opening`): the executor's
+ * first look reads the same screen under the same policy, and would spend
+ * another operation budget to be denied again.
  */
-async function probeScreen(host, mode) {
+async function probeScreen(host, mode, opening = false) {
     try {
         return await host.observe(mode);
     }
     catch (cause) {
-        if (isRuntimeHardStop(cause))
+        if (isRuntimeHardStop(cause) || (opening && isAgentError(cause) && cause.code === 'POLICY_DENIED'))
             throw cause;
         return undefined;
     }

package/dist/agent/tool-loop.js

@@ -11,10 +11,11 @@
  * - model-call accounting and a step transcript for `--debug`.
  */
 import { asSdkLanguageModel, loadAiSdk } from './ai-sdk.js';
+import { MODEL_REQUEST_HEADERS } from '../internal/client-identity.js';
 import { ConfigurationError, withHint } from '../internal/errors.js';
 import { failureHint, isAbort, TRANSPORT_RETRIES } from './model/sdk.js';
 import { isContextOverflow } from './model/overflow.js';
-import { isForcedToolCallSkipped, isForcedToolChoiceDowngraded, isForcedToolChoiceRejected } from './model/tool-choice.js';
+import { isForcedToolCallMismatched, 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';
@@ -192,6 +193,13 @@ class LoopRun {
                     prompt = shrunk;
                     continue;
                 }
+                const corrected = this.correctForcedTurn(cause, tracker);
+                if (corrected === 'out-of-turns')
+                    break;
+                if (corrected !== undefined) {
+                    prompt = corrected;
+                    continue;
+                }
                 const freed = this.freeToolChoiceRetry(cause, tracker);
                 if (freed !== undefined) {
                     prompt = freed;
@@ -241,6 +249,7 @@ class LoopRun {
             toolChoice: this.toolChoice,
             ...(providerOptions === undefined ? {} : { providerOptions: providerOptions }),
             maxRetries: TRANSPORT_RETRIES,
+            headers: MODEL_REQUEST_HEADERS,
             stopWhen: [
                 () => this.conclusion.concluded() || this.hardStop !== undefined,
                 // Counted across every generate call of the step, so a retry after an
@@ -273,6 +282,49 @@ class LoopRun {
             { role: 'user', content: TEXT_REPLY_NOTICE },
         ];
     }
+    /**
+     * A turn forced to call `complete_step` that called other tools instead:
+     * the SDK throws `ToolChoiceViolationError` before running any of them. It
+     * is handled like a call to a tool the turn does not offer: the turn counts,
+     * each call goes back to the model as an error result, and the model is
+     * asked again on the same turn budget. Out of turns, the step ends as
+     * `STEP_NO_CONCLUSION`, like any step that never concluded.
+     */
+    correctForcedTurn(cause, tracker) {
+        if (this.lastRequest === undefined || this.context.signal.aborted || this.hardStop !== undefined)
+            return undefined;
+        if (!isForcedToolCallMismatched(cause))
+            return undefined;
+        const reply = thrownReply(cause.content);
+        const results = reply.calls.map((call) => ({
+            type: 'tool-result',
+            toolCallId: call.toolCallId,
+            toolName: call.toolName,
+            output: {
+                type: 'error-text',
+                value: `${call.toolName} did not run: only complete_step is available now. Call complete_step with your verdict.`,
+            },
+        }));
+        this.recordThrownTurn(tracker, reply.calls.map((call) => `${call.toolName}(${truncate(safeJson(call.input), MAX_TURN_CALL_CHARS)})`), [
+            skippedReplyText(cause.content),
+            ...results.map((result) => `[${result.toolName}] error: ${result.output.value}`),
+        ].filter((line) => line !== '').join('\n'));
+        if (this.turnsUsed >= this.maxTurns)
+            return 'out-of-turns';
+        this.note(`turn ${String(this.turnsUsed)} called other tools in place of complete_step: asking again`);
+        this.turnOffset = this.turnsUsed;
+        return [...this.lastRequest, reply.message, { role: 'tool', content: results }];
+    }
+    /**
+     * Counts a turn the provider answered, and billed, before the SDK threw on
+     * it. The SDK reports no usage for such a turn.
+     */
+    recordThrownTurn(tracker, calls, outcome) {
+        tracker.onStepEnd({ usage: UNREPORTED_USAGE, providerMetadata: undefined, reasoningText: undefined });
+        this.turnsUsed += 1;
+        this.turns.push({ index: this.turnsUsed, calls, outcome, notes: [] });
+        this.attachTranscript();
+    }
     /**
      * 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
@@ -288,10 +340,7 @@ class LoopRun {
         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.recordThrownTurn(tracker, [], skippedReplyText(cause.content));
             this.note(`turn ${String(this.turnsUsed)} answered without the forced tool call: retrying with auto`);
         }
         else if (isForcedToolChoiceRejected(cause)) {
@@ -617,6 +666,46 @@ function skippedReplyText(content) {
         .trim();
     return text === '' ? '' : `assistant: ${truncate(text, MAX_TURN_TEXT_CHARS)}`;
 }
+/**
+ * A reply the SDK threw on, as the assistant message the SDK's own history
+ * would carry: its text, reasoning, and tool calls, each with the provider's
+ * metadata (reasoning signatures and Gemini's thought signatures ride there),
+ * and the tool calls apart, to answer each with a result.
+ */
+function thrownReply(content) {
+    const parts = [];
+    const calls = [];
+    for (const part of content) {
+        const metadata = part.providerMetadata === undefined ? {} : { providerOptions: part.providerMetadata };
+        if (part.type === 'text' && typeof part.text === 'string' && part.text !== '') {
+            parts.push({ type: 'text', text: part.text, ...metadata });
+        }
+        else if (part.type === 'reasoning' && typeof part.text === 'string') {
+            parts.push({ type: 'reasoning', text: part.text, ...metadata });
+        }
+        else if (part.type === 'tool-call' && typeof part.toolCallId === 'string' && typeof part.toolName === 'string') {
+            const call = {
+                type: 'tool-call',
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                input: typeof part.input === 'string' ? parseToolInput(part.input) : part.input,
+                ...metadata,
+            };
+            parts.push(call);
+            calls.push(call);
+        }
+    }
+    return { message: { role: 'assistant', content: parts }, calls };
+}
+/** A raw tool call's input for the history: the parsed JSON, or the text itself when it does not parse. */
+function parseToolInput(input) {
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        return input;
+    }
+}
 function describeOutput(output) {
     if (isScreenOutput(output))
         return `${output.text}\n[screenshot, ${String(output.pixels.data.byteLength)} bytes]`;