@agentionai/agents 1.11.0 → 1.12.0

package/dist/agents/AgentEvent.d.ts

@@ -12,6 +12,11 @@ export declare class AgentEvent {
     static TOOL_ERROR: string;
     static CHUNK: string;
     static REASONING_CHUNK: string;
+    /**
+     * A streamed turn was cut short before its assistant message could be written
+     * to history. The listener receives the `PartialTurn` that was salvaged.
+     */
+    static PARTIAL_TURN: string;
     private defaultPrevented;
     constructor(target: BaseAgent<any>);
     preventDefault(): void;

package/dist/agents/AgentEvent.js

@@ -25,4 +25,9 @@ AgentEvent.MAX_TOKENS_EXCEEDED = "max_tokens_exceeded";
 AgentEvent.TOOL_ERROR = "tool_error";
 AgentEvent.CHUNK = "chunk";
 AgentEvent.REASONING_CHUNK = "reasoning_chunk";
+/**
+ * A streamed turn was cut short before its assistant message could be written
+ * to history. The listener receives the `PartialTurn` that was salvaged.
+ */
+AgentEvent.PARTIAL_TURN = "partial_turn";
 //# sourceMappingURL=AgentEvent.js.map

package/dist/agents/BaseAgent.d.ts

@@ -2,7 +2,7 @@ import EventEmitter from "events";
 import { Tool } from "../tools/Tool";
 import { History, HistoryEntry, MessageRole, MessageContent, ImageMimeType } from "../history/History";
 import { AgentVendor, CommonAgentConfig, VendorSpecificConfig } from "./AgentConfig";
-import { AbortError } from "./errors/AgentError";
+import { AbortError, AgentError } from "./errors/AgentError";
 import { ExecuteOptions } from "./cancellation";
 export type { HistoryEntry, MessageRole, MessageContent, ImageMimeType };
 export type { AgentVendor };
@@ -146,6 +146,76 @@ export type ModelInfo<TRaw = unknown> = {
     /** The provider's unmodified entry for this model. */
     raw: TRaw;
 };
+/**
+ * Why a streamed turn stopped before its assistant message could be written to
+ * history. See {@link PartialTurn}.
+ */
+export type PartialTurnReason = 
+/** The stream or the code around it threw. */
+"error"
+/** The caller's `AbortSignal` fired. */
+ | "aborted"
+/** The provider stopped on its token limit. */
+ | "max_tokens"
+/** The consumer stopped iterating the generator (a `break`, or a `return`). */
+ | "abandoned";
+/** One tool call as it stood when a streamed turn was cut short. */
+export type PartialToolCall = {
+    /** Provider-assigned call id. Empty if the stream ended before it arrived. */
+    id: string;
+    /** Tool name, which streams in before the arguments do. */
+    name: string;
+    /**
+     * Raw JSON argument text as received. Very likely truncated mid-token, so
+     * this is for inspection and recovery, not for `JSON.parse`.
+     */
+    arguments: string;
+};
+/**
+ * What a streamed turn had generated when it was cut short — the text,
+ * the reasoning trail, and any tool calls that had started to arrive.
+ *
+ * Streaming agents accumulate a turn locally and only write it to history once
+ * the stream ends cleanly, so a connection drop, a provider-side error or a
+ * token-limit stop would otherwise discard everything generated up to that
+ * point. That is cheap for a short answer and expensive for a local reasoning
+ * model, where the trail can represent twenty minutes of compute.
+ *
+ * The partial turn is therefore always captured, on {@link BaseAgent.lastPartialTurn}
+ * and on the thrown {@link AgentError.partial}, but never written to history:
+ * a half-finished turn is frequently not replayable (Anthropic thinking blocks
+ * need the `signature` that arrives last, truncated tool-call JSON does not
+ * parse), so what to do with it is the caller's decision.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   for await (const chunk of agent.executeStream("...")) process.stdout.write(chunk.content);
+ * } catch (err) {
+ *   const salvaged = agent.lastPartialTurn;
+ *   if (salvaged) fs.writeFileSync("trail.md", salvaged.reasoning);
+ * }
+ * ```
+ */
+export type PartialTurn = {
+    /** Assistant text generated so far. Empty if none arrived. */
+    text: string;
+    /** Reasoning/thinking text generated so far. Empty if none arrived. */
+    reasoning: string;
+    /** Tool calls that had begun streaming, in index order. */
+    toolCalls: PartialToolCall[];
+    /** Why the turn stopped. */
+    reason: PartialTurnReason;
+    /** The error that ended it, where one did. */
+    error?: unknown;
+    /**
+     * Provider-specific extras worth keeping — currently Anthropic's thinking
+     * block `signature`, which is what decides whether the trail can be replayed.
+     */
+    meta?: Record<string, unknown>;
+    /** When the turn was cut short. */
+    at: Date;
+};
 /**
  * The base agent is what the other agents are inheriting from
  * Handles the BaseConfig
@@ -168,6 +238,12 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
      * Reset at the start of each execution.
      */
     lastTokenUsage?: TokenUsage;
+    /**
+     * What the most recent streamed turn had generated when it was cut short,
+     * or `undefined` if the last execution completed and its turn reached
+     * history. Reset at the start of every execution. See {@link PartialTurn}.
+     */
+    lastPartialTurn?: PartialTurn;
     /** Start of the API call currently in flight, set by `startTurnTimer()`. */
     private turnStartedAt?;
     /** First-token timestamp of the call in flight, set by `markFirstToken()`. */
@@ -265,6 +341,36 @@ export declare abstract class BaseAgent<TInput = unknown, TOutput = unknown> ext
      * chunk.
      */
     protected markFirstToken(): void;
+    /**
+     * Clear any captured partial turn. Called at the start of every `execute()` /
+     * `executeStream()`, so a set `lastPartialTurn` always refers to the current
+     * execution and never to an earlier one.
+     */
+    protected resetPartialTurn(): void;
+    /**
+     * Record what a streamed turn had generated when it was cut short, and
+     * announce it on {@link AgentEvent.PARTIAL_TURN}.
+     *
+     * Called from the `finally` of every streaming turn that did not commit its
+     * assistant message to history. A turn with nothing in it is ignored, so
+     * `lastPartialTurn` being set always means there is unsaved work.
+     *
+     * @returns the recorded partial turn, or `undefined` if there was nothing to
+     *          record.
+     */
+    protected capturePartialTurn(partial: Omit<PartialTurn, "at">): PartialTurn | undefined;
+    /**
+     * Classify why a streamed turn stopped, from the error that ended it.
+     *
+     * @param error the error propagating out of the turn, or `undefined` when the
+     *              consumer simply stopped iterating.
+     */
+    protected partialTurnReason(error: unknown, signal?: AbortSignal): PartialTurnReason;
+    /**
+     * Attach the captured partial turn to an error on its way out, so a caller
+     * holding only the error can still recover the trail.
+     */
+    protected withPartialTurn<E extends AgentError>(error: E): E;
     /**
      * Fold one API call's usage into `lastTokenUsage`, filling in any timings
      * the provider did not report from the local turn timer.

package/dist/agents/BaseAgent.js

@@ -8,6 +8,7 @@ const events_1 = __importDefault(require("events"));
 const Tool_1 = require("../tools/Tool");
 const History_1 = require("../history/History");
 const AgentError_1 = require("./errors/AgentError");
+const cancellation_1 = require("./cancellation");
 const AgentEvent_1 = require("./AgentEvent");
 /**
  * The base agent is what the other agents are inheriting from
@@ -181,6 +182,61 @@ class BaseAgent extends events_1.default {
             this.turnFirstTokenAt = Date.now();
         }
     }
+    /**
+     * Clear any captured partial turn. Called at the start of every `execute()` /
+     * `executeStream()`, so a set `lastPartialTurn` always refers to the current
+     * execution and never to an earlier one.
+     */
+    resetPartialTurn() {
+        this.lastPartialTurn = undefined;
+    }
+    /**
+     * Record what a streamed turn had generated when it was cut short, and
+     * announce it on {@link AgentEvent.PARTIAL_TURN}.
+     *
+     * Called from the `finally` of every streaming turn that did not commit its
+     * assistant message to history. A turn with nothing in it is ignored, so
+     * `lastPartialTurn` being set always means there is unsaved work.
+     *
+     * @returns the recorded partial turn, or `undefined` if there was nothing to
+     *          record.
+     */
+    capturePartialTurn(partial) {
+        if (!partial.text &&
+            !partial.reasoning &&
+            partial.toolCalls.length === 0) {
+            return undefined;
+        }
+        const captured = { ...partial, at: new Date() };
+        this.lastPartialTurn = captured;
+        this.emit(AgentEvent_1.AgentEvent.PARTIAL_TURN, captured);
+        return captured;
+    }
+    /**
+     * Classify why a streamed turn stopped, from the error that ended it.
+     *
+     * @param error the error propagating out of the turn, or `undefined` when the
+     *              consumer simply stopped iterating.
+     */
+    partialTurnReason(error, signal) {
+        if (error === undefined)
+            return "abandoned";
+        if (signal?.aborted || (0, cancellation_1.isAbortError)(error, signal))
+            return "aborted";
+        if (error instanceof AgentError_1.MaxTokensExceededError)
+            return "max_tokens";
+        return "error";
+    }
+    /**
+     * Attach the captured partial turn to an error on its way out, so a caller
+     * holding only the error can still recover the trail.
+     */
+    withPartialTurn(error) {
+        if (this.lastPartialTurn && error.partial === undefined) {
+            error.partial = this.lastPartialTurn;
+        }
+        return error;
+    }
     /**
      * Fold one API call's usage into `lastTokenUsage`, filling in any timings
      * the provider did not report from the local turn timer.

package/dist/agents/anthropic/ClaudeAgent.js

@@ -148,6 +148,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         // Reset token usage for this execution
         this.resetTokenUsage();
+        this.resetPartialTurn();
         this.currentToolCallCount = 0;
         // Normalise input to a display string for viz reporting
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
@@ -375,6 +376,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
     async *executeStream(input, options) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         this.resetTokenUsage();
+        this.resetPartialTurn();
         this.currentToolCallCount = 0;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -402,7 +404,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                     VizReporter_1.vizReporter.agentError(this.vizEventId, "AbortError", abortError.message, false);
                     this.vizEventId = undefined;
                 }
-                throw abortError;
+                throw this.withPartialTurn(abortError);
             }
             if (error instanceof sdk_1.APIError) {
                 const apiError = new AgentError_1.ApiError(`Anthropic API error: ${error.message}`, error.status, error);
@@ -411,13 +413,13 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                     VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, error.status === 429);
                     this.vizEventId = undefined;
                 }
-                throw apiError;
+                throw this.withPartialTurn(apiError);
             }
             // Errors raised inside streamTurn() (e.g. MaxTokensExceededError) are
             // already emitted and viz-reported at the throw site — preserve their
             // type rather than re-wrapping them in a generic ExecutionError.
             if (error instanceof AgentError_1.AgentError) {
-                throw error;
+                throw this.withPartialTurn(error);
             }
             const executionError = new AgentError_1.ExecutionError(`Anthropic error: ${error instanceof Error ? error.message : "Unknown error"}`);
             this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
@@ -425,7 +427,7 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
                 VizReporter_1.vizReporter.agentError(this.vizEventId, "ExecutionError", executionError.message, false);
                 this.vizEventId = undefined;
             }
-            throw executionError;
+            throw this.withPartialTurn(executionError);
         }
         finally {
             this.history.endExecution();
@@ -442,131 +444,169 @@ class ClaudeAgent extends BaseAgent_1.BaseAgent {
         let stopReason = null;
         let inputTokens = 0;
         let outputTokens = 0;
-        for await (const event of stream) {
-            if (event.type === "message_start") {
-                const e = event;
-                inputTokens = e.message.usage.input_tokens;
-                outputTokens = e.message.usage.output_tokens;
-            }
-            if (event.type === "message_delta") {
-                const e = event;
-                stopReason = e.delta.stop_reason ?? stopReason;
-                outputTokens += e.usage?.output_tokens ?? 0;
-            }
-            if (event.type === "content_block_start") {
-                const e = event;
-                const block = e.content_block;
-                if (block.type === "tool_use") {
-                    blocks.set(e.index, { kind: "tool_use", id: block.id, name: block.name, inputJson: "" });
+        // Set once this frame's assistant message reaches history. Until then the
+        // turn exists only in `blocks`, and the `finally` salvages it — extended
+        // thinking can run for minutes, and the stream throwing (or the consumer
+        // walking away) would otherwise drop the whole trail.
+        let committed = false;
+        let failure;
+        try {
+            for await (const event of stream) {
+                if (event.type === "message_start") {
+                    const e = event;
+                    inputTokens = e.message.usage.input_tokens;
+                    outputTokens = e.message.usage.output_tokens;
                 }
-                else if (block.type === "text") {
-                    blocks.set(e.index, { kind: "text", text: "" });
+                if (event.type === "message_delta") {
+                    const e = event;
+                    stopReason = e.delta.stop_reason ?? stopReason;
+                    outputTokens += e.usage?.output_tokens ?? 0;
                 }
-                else if (block.type === "thinking") {
-                    blocks.set(e.index, { kind: "thinking", thinking: "", signature: "" });
+                if (event.type === "content_block_start") {
+                    const e = event;
+                    const block = e.content_block;
+                    if (block.type === "tool_use") {
+                        blocks.set(e.index, { kind: "tool_use", id: block.id, name: block.name, inputJson: "" });
+                    }
+                    else if (block.type === "text") {
+                        blocks.set(e.index, { kind: "text", text: "" });
+                    }
+                    else if (block.type === "thinking") {
+                        blocks.set(e.index, { kind: "thinking", thinking: "", signature: "" });
+                    }
+                    else if (block.type === "redacted_thinking") {
+                        blocks.set(e.index, { kind: "redacted_thinking", data: block.data });
+                    }
                 }
-                else if (block.type === "redacted_thinking") {
-                    blocks.set(e.index, { kind: "redacted_thinking", data: block.data });
+                if (event.type === "content_block_delta") {
+                    // First generated content of the turn — thinking counts, since it is
+                    // generation time either way.
+                    this.markFirstToken();
+                    const e = event;
+                    const delta = e.delta;
+                    const acc = blocks.get(e.index);
+                    if (delta.type === "text_delta") {
+                        textContent += delta.text;
+                        if (acc?.kind === "text")
+                            acc.text += delta.text;
+                        this.emit(AgentEvent_1.AgentEvent.CHUNK, delta.text);
+                        yield { type: "text", content: delta.text };
+                    }
+                    else if (delta.type === "thinking_delta") {
+                        if (acc?.kind === "thinking")
+                            acc.thinking += delta.thinking;
+                        this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, delta.thinking);
+                        yield { type: "reasoning", content: delta.thinking };
+                    }
+                    else if (delta.type === "signature_delta") {
+                        if (acc?.kind === "thinking")
+                            acc.signature += delta.signature;
+                    }
+                    else if (delta.type === "input_json_delta") {
+                        if (acc?.kind === "tool_use")
+                            acc.inputJson += delta.partial_json;
+                    }
                 }
             }
-            if (event.type === "content_block_delta") {
-                // First generated content of the turn — thinking counts, since it is
-                // generation time either way.
-                this.markFirstToken();
-                const e = event;
-                const delta = e.delta;
-                const acc = blocks.get(e.index);
-                if (delta.type === "text_delta") {
-                    textContent += delta.text;
-                    if (acc?.kind === "text")
-                        acc.text += delta.text;
-                    this.emit(AgentEvent_1.AgentEvent.CHUNK, delta.text);
-                    yield { type: "text", content: delta.text };
-                }
-                else if (delta.type === "thinking_delta") {
-                    if (acc?.kind === "thinking")
-                        acc.thinking += delta.thinking;
-                    this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, delta.thinking);
-                    yield { type: "reasoning", content: delta.thinking };
-                }
-                else if (delta.type === "signature_delta") {
-                    if (acc?.kind === "thinking")
-                        acc.signature += delta.signature;
+            this.accumulateUsage({
+                input_tokens: inputTokens,
+                output_tokens: outputTokens,
+                total_tokens: inputTokens + outputTokens,
+            });
+            // The SDK's stream iterator swallows the abort and simply stops yielding,
+            // so without this an interrupted stream would look like a short but
+            // complete turn — writing partial text to history and emitting DONE.
+            // Checked after accumulateUsage() so the tokens already spent are reported.
+            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+            if (stopReason === "max_tokens") {
+                const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens);
+                this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
+                this.emit(AgentEvent_1.AgentEvent.ERROR, error);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
+                    this.vizEventId = undefined;
                 }
-                else if (delta.type === "input_json_delta") {
-                    if (acc?.kind === "tool_use")
-                        acc.inputJson += delta.partial_json;
+                throw error;
+            }
+            // Rebuild the assistant turn in stream order (thinking → text → tool_use).
+            const orderedBlocks = Array.from(blocks.entries())
+                .sort(([a], [b]) => a - b)
+                .map(([, b]) => {
+                switch (b.kind) {
+                    case "thinking":
+                        return { type: "thinking", thinking: b.thinking, signature: b.signature };
+                    case "redacted_thinking":
+                        return { type: "redacted_thinking", data: b.data };
+                    case "tool_use":
+                        return {
+                            type: "tool_use",
+                            id: b.id,
+                            name: b.name,
+                            input: JSON.parse(b.inputJson || "{}"),
+                        };
+                    case "text":
+                        return { type: "text", text: b.text, citations: [] };
                 }
+            });
+            // Fallback: preserve streamed text even if no text block start was observed.
+            if (textContent && !orderedBlocks.some((b) => b.type === "text")) {
+                orderedBlocks.push({ type: "text", text: textContent, citations: [] });
             }
-        }
-        this.accumulateUsage({
-            input_tokens: inputTokens,
-            output_tokens: outputTokens,
-            total_tokens: inputTokens + outputTokens,
-        });
-        // The SDK's stream iterator swallows the abort and simply stops yielding,
-        // so without this an interrupted stream would look like a short but
-        // complete turn — writing partial text to history and emitting DONE.
-        // Checked after accumulateUsage() so the tokens already spent are reported.
-        (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-        if (stopReason === "max_tokens") {
-            const error = new AgentError_1.MaxTokensExceededError("Response exceeded maximum token limit", this.config.maxTokens);
-            this.emit(AgentEvent_1.AgentEvent.MAX_TOKENS_EXCEEDED, error);
-            this.emit(AgentEvent_1.AgentEvent.ERROR, error);
-            if (this.vizEventId) {
-                VizReporter_1.vizReporter.agentError(this.vizEventId, "MaxTokensExceededError", error.message, false);
-                this.vizEventId = undefined;
+            const toolUseBlocks = orderedBlocks.filter((b) => b.type === "tool_use");
+            if (stopReason === "tool_use" && toolUseBlocks.length > 0) {
+                // As in handleResponse(): bail out before the assistant turn is written,
+                // so a cancelled run leaves no unanswered tool_use in history.
+                (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_USE, orderedBlocks);
+                this.currentToolCallCount += toolUseBlocks.length;
+                const assistantEntry = transformers_1.anthropicTransformer.fromProviderContent("assistant", orderedBlocks);
+                this.addToHistory(assistantEntry);
+                committed = true;
+                const toolResults = await this.handleToolUse(orderedBlocks, options);
+                this.addMessageToHistory("user", toolResults);
+                yield* this.streamTurn(options);
             }
-            throw error;
-        }
-        // Rebuild the assistant turn in stream order (thinking → text → tool_use).
-        const orderedBlocks = Array.from(blocks.entries())
-            .sort(([a], [b]) => a - b)
-            .map(([, b]) => {
-            switch (b.kind) {
-                case "thinking":
-                    return { type: "thinking", thinking: b.thinking, signature: b.signature };
-                case "redacted_thinking":
-                    return { type: "redacted_thinking", data: b.data };
-                case "tool_use":
-                    return {
-                        type: "tool_use",
-                        id: b.id,
-                        name: b.name,
-                        input: JSON.parse(b.inputJson || "{}"),
-                    };
-                case "text":
-                    return { type: "text", text: b.text, citations: [] };
+            else {
+                const assistantEntry = transformers_1.anthropicTransformer.fromProviderContent("assistant", orderedBlocks);
+                this.addToHistory(assistantEntry);
+                committed = true;
+                this.emit(AgentEvent_1.AgentEvent.DONE, { content: textContent }, this.lastTokenUsage);
+                if (this.vizEventId) {
+                    VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+                        input: this.lastTokenUsage?.input_tokens || 0,
+                        output: this.lastTokenUsage?.output_tokens || 0,
+                        total: this.lastTokenUsage?.total_tokens || 0,
+                    }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+                    this.vizEventId = undefined;
+                }
             }
-        });
-        // Fallback: preserve streamed text even if no text block start was observed.
-        if (textContent && !orderedBlocks.some((b) => b.type === "text")) {
-            orderedBlocks.push({ type: "text", text: textContent, citations: [] });
         }
-        const toolUseBlocks = orderedBlocks.filter((b) => b.type === "tool_use");
-        if (stopReason === "tool_use" && toolUseBlocks.length > 0) {
-            // As in handleResponse(): bail out before the assistant turn is written,
-            // so a cancelled run leaves no unanswered tool_use in history.
-            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, orderedBlocks);
-            this.currentToolCallCount += toolUseBlocks.length;
-            const assistantEntry = transformers_1.anthropicTransformer.fromProviderContent("assistant", orderedBlocks);
-            this.addToHistory(assistantEntry);
-            const toolResults = await this.handleToolUse(orderedBlocks, options);
-            this.addMessageToHistory("user", toolResults);
-            yield* this.streamTurn(options);
+        catch (error) {
+            failure = error;
+            throw error;
         }
-        else {
-            const assistantEntry = transformers_1.anthropicTransformer.fromProviderContent("assistant", orderedBlocks);
-            this.addToHistory(assistantEntry);
-            this.emit(AgentEvent_1.AgentEvent.DONE, { content: textContent }, this.lastTokenUsage);
-            if (this.vizEventId) {
-                VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
-                    input: this.lastTokenUsage?.input_tokens || 0,
-                    output: this.lastTokenUsage?.output_tokens || 0,
-                    total: this.lastTokenUsage?.total_tokens || 0,
-                }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
-                this.vizEventId = undefined;
+        finally {
+            if (!committed) {
+                // `signature` is what decides whether the trail can ever be replayed to
+                // Anthropic: it arrives in a `signature_delta` after the thinking text,
+                // so an interrupted block usually has none. Reported rather than
+                // guessed at, since a signatureless thinking block is rejected on
+                // replay while the text itself is still worth keeping.
+                const thinking = Array.from(blocks.values()).filter((b) => b.kind === "thinking");
+                this.capturePartialTurn({
+                    text: textContent,
+                    reasoning: thinking.map((b) => b.thinking).join(""),
+                    toolCalls: Array.from(blocks.entries())
+                        .sort(([a], [b]) => a - b)
+                        .flatMap(([, b]) => b.kind === "tool_use"
+                        ? [{ id: b.id, name: b.name, arguments: b.inputJson }]
+                        : []),
+                    reason: this.partialTurnReason(failure, options?.signal),
+                    error: failure,
+                    meta: thinking.length
+                        ? { signatures: thinking.map((b) => b.signature) }
+                        : undefined,
+                });
             }
         }
     }

package/dist/agents/errors/AgentError.d.ts

@@ -1,7 +1,19 @@
+import type { PartialTurn } from "../BaseAgent";
 /**
  * Base error class for all agent-related errors
  */
 export declare class AgentError extends Error {
+    /**
+     * What a streamed turn had generated when this error cut it short, where the
+     * error came out of `executeStream()`. Streaming agents only write an
+     * assistant turn to history once the stream ends cleanly, so without this the
+     * text and the reasoning trail generated up to the failure would be lost —
+     * cheap for a short answer, expensive for a local reasoning model.
+     *
+     * Also available as `agent.lastPartialTurn`. See {@link PartialTurn} for why
+     * it is handed back rather than written to history.
+     */
+    partial?: PartialTurn;
     /**
      * @param message Error message
      * @param options Additional error options