@agentionai/agents 1.11.0 → 1.12.0

package/dist/agents/openai/OpenAiAgent.js

@@ -190,6 +190,7 @@ class OpenAiAgent 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;
         const inputPreview = typeof input === "string" ? input : JSON.stringify(input);
         // Start visualization reporting
@@ -461,6 +462,7 @@ class OpenAiAgent 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()) {
@@ -488,7 +490,7 @@ class OpenAiAgent 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 AgentError_1.AgentError) {
                 this.emit(AgentEvent_1.AgentEvent.ERROR, error);
@@ -496,7 +498,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                     VizReporter_1.vizReporter.agentError(this.vizEventId, error.constructor.name, error.message, false);
                     this.vizEventId = undefined;
                 }
-                throw error;
+                throw this.withPartialTurn(error);
             }
             if (error && typeof error === "object" && "error" in error) {
                 const openAIError = error;
@@ -506,7 +508,7 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
                     VizReporter_1.vizReporter.agentError(this.vizEventId, "ApiError", apiError.message, openAIError.error.code === "rate_limit_exceeded");
                     this.vizEventId = undefined;
                 }
-                throw apiError;
+                throw this.withPartialTurn(apiError);
             }
             const executionError = new AgentError_1.ExecutionError(`OpenAI error: ${error instanceof Error ? error.message : "Unknown error"}`);
             this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
@@ -514,7 +516,7 @@ class OpenAiAgent 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();
@@ -536,68 +538,123 @@ class OpenAiAgent extends BaseAgent_1.BaseAgent {
             ...this.buildReasoningParams("auto"),
         }, { signal: options?.signal });
         let completedEvent = null;
-        for await (const event of stream) {
-            if (event.type === "response.output_text.delta") {
-                this.markFirstToken();
-                this.emit(AgentEvent_1.AgentEvent.CHUNK, event.delta);
-                yield { type: "text", content: event.delta };
+        // The Responses API builds the committed turn out of `response.completed`,
+        // which only arrives on success, so the deltas are mirrored here as well:
+        // without them a stream that dies mid-flight leaves nothing behind at all,
+        // and a reasoning summary can be minutes of generation.
+        let textDelta = "";
+        let reasoningDelta = "";
+        const partialCalls = new Map();
+        // Set once this frame's assistant message reaches history.
+        let committed = false;
+        let failure;
+        try {
+            for await (const event of stream) {
+                if (event.type === "response.output_text.delta") {
+                    this.markFirstToken();
+                    // Accumulated as well as yielded purely so the `finally` below can hand
+                    // it back if the stream dies: the committed turn is rebuilt from
+                    // `response.completed`, which never arrives on a failure.
+                    textDelta += event.delta;
+                    this.emit(AgentEvent_1.AgentEvent.CHUNK, event.delta);
+                    yield { type: "text", content: event.delta };
+                }
+                if (event.type === "response.reasoning_summary_text.delta") {
+                    this.markFirstToken();
+                    reasoningDelta += event.delta;
+                    this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, event.delta);
+                    yield { type: "reasoning", content: event.delta };
+                }
+                if (event.type === "response.output_item.added") {
+                    const item = event.item;
+                    if (item.type === "function_call") {
+                        partialCalls.set(event.output_index, {
+                            id: item.call_id || item.id || "",
+                            name: item.name ?? "",
+                            arguments: "",
+                        });
+                    }
+                }
+                if (event.type === "response.function_call_arguments.delta") {
+                    const acc = partialCalls.get(event.output_index);
+                    if (acc)
+                        acc.arguments += event.delta;
+                }
+                if (event.type === "response.completed") {
+                    completedEvent = event;
+                    if (event.response.usage) {
+                        this.accumulateUsage(this.parseUsage(event.response.usage));
+                    }
+                }
+                if (event.type === "response.incomplete") {
+                    throw new AgentError_1.MaxTokensExceededError("Response incomplete: max tokens reached", this.config.maxTokens);
+                }
             }
-            if (event.type === "response.reasoning_summary_text.delta") {
-                this.markFirstToken();
-                this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, event.delta);
-                yield { type: "reasoning", content: event.delta };
+            // The SDK's stream iterator swallows the abort and simply stops yielding.
+            // Without this the turn would fail as a malformed stream instead of a
+            // cancellation — checked here so the tokens already spent are reported.
+            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+            if (!completedEvent) {
+                throw new AgentError_1.ExecutionError("OpenAI stream ended without a completed event");
             }
-            if (event.type === "response.completed") {
-                completedEvent = event;
-                if (event.response.usage) {
-                    this.accumulateUsage(this.parseUsage(event.response.usage));
+            const response = completedEvent.response;
+            const toolCalls = response.output.filter((o) => o.type === "function_call");
+            if (toolCalls.length > 0) {
+                // As in handleResponse(): bail out before the assistant turn is written,
+                // so a cancelled run leaves no unanswered function call in history.
+                (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+                this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+                this.currentToolCallCount += toolCalls.length;
+                const functionCalls = toolCalls.map((tc) => ({
+                    id: tc.id || tc.call_id,
+                    call_id: tc.call_id,
+                    name: tc.name,
+                    arguments: tc.arguments,
+                }));
+                const assistantEntry = transformers_1.openAiTransformer.fromProviderMessage("assistant", response.output_text || "", functionCalls);
+                this.addToHistory(assistantEntry);
+                committed = true;
+                const toolResults = await this.handleToolUse(toolCalls, options);
+                for (const result of toolResults) {
+                    this.addToHistory(transformers_1.openAiTransformer.toolResultEntry(result.call_id, result.output, false));
                 }
+                yield* this.streamTurn(options);
             }
-            if (event.type === "response.incomplete") {
-                throw new AgentError_1.MaxTokensExceededError("Response incomplete: max tokens reached", this.config.maxTokens);
+            else {
+                const textContent = response.output_text || "";
+                const entry = transformers_1.openAiTransformer.fromProviderMessage("assistant", textContent);
+                this.addToHistory(entry);
+                committed = true;
+                this.emit(AgentEvent_1.AgentEvent.DONE, response, 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;
+                }
             }
         }
-        // The SDK's stream iterator swallows the abort and simply stops yielding.
-        // Without this the turn would fail as a malformed stream instead of a
-        // cancellation — checked here so the tokens already spent are reported.
-        (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-        if (!completedEvent) {
-            throw new AgentError_1.ExecutionError("OpenAI stream ended without a completed event");
-        }
-        const response = completedEvent.response;
-        const toolCalls = response.output.filter((o) => o.type === "function_call");
-        if (toolCalls.length > 0) {
-            // As in handleResponse(): bail out before the assistant turn is written,
-            // so a cancelled run leaves no unanswered function call in history.
-            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
-            this.currentToolCallCount += toolCalls.length;
-            const functionCalls = toolCalls.map((tc) => ({
-                id: tc.id || tc.call_id,
-                call_id: tc.call_id,
-                name: tc.name,
-                arguments: tc.arguments,
-            }));
-            const assistantEntry = transformers_1.openAiTransformer.fromProviderMessage("assistant", response.output_text || "", functionCalls);
-            this.addToHistory(assistantEntry);
-            const toolResults = await this.handleToolUse(toolCalls, options);
-            for (const result of toolResults) {
-                this.addToHistory(transformers_1.openAiTransformer.toolResultEntry(result.call_id, result.output, false));
-            }
-            yield* this.streamTurn(options);
+        catch (error) {
+            failure = error;
+            throw error;
         }
-        else {
-            const textContent = response.output_text || "";
-            const entry = transformers_1.openAiTransformer.fromProviderMessage("assistant", textContent);
-            this.addToHistory(entry);
-            this.emit(AgentEvent_1.AgentEvent.DONE, response, 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) {
+                this.capturePartialTurn({
+                    text: textDelta,
+                    reasoning: reasoningDelta,
+                    toolCalls: Array.from(partialCalls.entries())
+                        .sort(([a], [b]) => a - b)
+                        .map(([, tc]) => ({
+                        id: tc.id,
+                        name: tc.name,
+                        arguments: tc.arguments,
+                    })),
+                    reason: this.partialTurnReason(failure, options?.signal),
+                    error: failure,
+                });
             }
         }
     }

package/dist/agents/openai-compatible/OpenAICompatibleAgent.js

@@ -89,6 +89,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
     async execute(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()) {
@@ -312,6 +313,7 @@ class OpenAICompatibleAgent 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()) {
@@ -339,7 +341,7 @@ class OpenAICompatibleAgent 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 openai_1.default.APIError) {
                 const apiError = new AgentError_1.ApiError(`${this.getVendorName()} API error: ${error.message}`, error.status, error);
@@ -348,7 +350,7 @@ class OpenAICompatibleAgent 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);
             }
             if (error instanceof AgentError_1.AgentError) {
                 this.emit(AgentEvent_1.AgentEvent.ERROR, error);
@@ -356,7 +358,7 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
                     VizReporter_1.vizReporter.agentError(this.vizEventId, error.constructor.name, error.message, false);
                     this.vizEventId = undefined;
                 }
-                throw error;
+                throw this.withPartialTurn(error);
             }
             const executionError = new AgentError_1.ExecutionError(`${this.getVendorName()} error: ${error instanceof Error ? error.message : "Unknown error"}`);
             this.emit(AgentEvent_1.AgentEvent.ERROR, executionError);
@@ -364,7 +366,7 @@ class OpenAICompatibleAgent 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();
@@ -393,116 +395,147 @@ class OpenAICompatibleAgent extends BaseAgent_1.BaseAgent {
         const toolCallAcc = new Map();
         let finishReason = null;
         let streamUsage;
-        for await (const chunk of stream) {
-            // Usage can ride on any chunk: OpenAI sends it on a final choice-less
-            // chunk, OpenRouter attaches it to the last content chunk (the one
-            // carrying finish_reason). Keep the most recent and fold it in once the
-            // stream ends — it is a running total for the turn, not a delta, so
-            // taking the last one covers both layouts without double-counting.
-            if (chunk.usage)
-                streamUsage = chunk.usage;
-            if (chunk.id)
-                this.lastChunkId = chunk.id;
-            if (chunk.choices.length === 0)
-                continue;
-            const choice = chunk.choices[0];
-            finishReason = choice.finish_reason ?? finishReason;
-            const delta = choice.delta;
-            if (delta.content) {
-                this.markFirstToken();
-                textContent += delta.content;
-                this.emit(AgentEvent_1.AgentEvent.CHUNK, delta.content);
-                yield { type: "text", content: delta.content };
+        // Set once this frame's assistant message reaches history. Until then the
+        // turn exists only in the accumulators above, and the `finally` salvages
+        // them — a reasoning trail can be twenty minutes of local compute, and the
+        // stream throwing (or the consumer walking away) would otherwise drop it.
+        let committed = false;
+        let failure;
+        try {
+            for await (const chunk of stream) {
+                // Usage can ride on any chunk: OpenAI sends it on a final choice-less
+                // chunk, OpenRouter attaches it to the last content chunk (the one
+                // carrying finish_reason). Keep the most recent and fold it in once the
+                // stream ends — it is a running total for the turn, not a delta, so
+                // taking the last one covers both layouts without double-counting.
+                if (chunk.usage)
+                    streamUsage = chunk.usage;
+                if (chunk.id)
+                    this.lastChunkId = chunk.id;
+                if (chunk.choices.length === 0)
+                    continue;
+                const choice = chunk.choices[0];
+                finishReason = choice.finish_reason ?? finishReason;
+                const delta = choice.delta;
+                if (delta.content) {
+                    this.markFirstToken();
+                    textContent += delta.content;
+                    this.emit(AgentEvent_1.AgentEvent.CHUNK, delta.content);
+                    yield { type: "text", content: delta.content };
+                }
+                // Reasoning tokens (not in OpenAI SDK types — cast required). Servers
+                // disagree on the field name: OpenRouter sends `delta.reasoning`, while
+                // DeepSeek/llama.cpp send `delta.reasoning_content`. Prefer `reasoning`;
+                // never concatenate — that would duplicate the text if both were sent.
+                const deltaExtras = delta;
+                const reasoningDelta = (deltaExtras.reasoning ?? deltaExtras.reasoning_content);
+                if (reasoningDelta) {
+                    this.markFirstToken();
+                    // Accumulated as well as yielded: DeepSeek's thinking mode requires the
+                    // assistant turn's reasoning to be replayed on the next request, so it
+                    // has to reach history rather than only the caller.
+                    reasoningContent += reasoningDelta;
+                    this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, reasoningDelta);
+                    yield { type: "reasoning", content: reasoningDelta };
+                }
+                if (delta.tool_calls) {
+                    for (const tc of delta.tool_calls) {
+                        if (!toolCallAcc.has(tc.index)) {
+                            toolCallAcc.set(tc.index, { id: "", name: "", arguments: "" });
+                        }
+                        const acc = toolCallAcc.get(tc.index);
+                        if (tc.id)
+                            acc.id = tc.id;
+                        if (tc.function?.name)
+                            acc.name += tc.function.name;
+                        if (tc.function?.arguments)
+                            acc.arguments += tc.function.arguments;
+                    }
+                }
             }
-            // Reasoning tokens (not in OpenAI SDK types — cast required). Servers
-            // disagree on the field name: OpenRouter sends `delta.reasoning`, while
-            // DeepSeek/llama.cpp send `delta.reasoning_content`. Prefer `reasoning`;
-            // never concatenate — that would duplicate the text if both were sent.
-            const deltaExtras = delta;
-            const reasoningDelta = (deltaExtras.reasoning ?? deltaExtras.reasoning_content);
-            if (reasoningDelta) {
-                this.markFirstToken();
-                // Accumulated as well as yielded: DeepSeek's thinking mode requires the
-                // assistant turn's reasoning to be replayed on the next request, so it
-                // has to reach history rather than only the caller.
-                reasoningContent += reasoningDelta;
-                this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, reasoningDelta);
-                yield { type: "reasoning", content: reasoningDelta };
+            // Before any early return below, so a turn that hits the token limit or
+            // continues into a tool call still reports what it spent.
+            if (streamUsage)
+                this.accumulateStreamUsage(streamUsage);
+            // 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.
+            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+            if (finishReason === "length") {
+                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;
+                }
+                throw error;
             }
-            if (delta.tool_calls) {
-                for (const tc of delta.tool_calls) {
-                    if (!toolCallAcc.has(tc.index)) {
-                        toolCallAcc.set(tc.index, { id: "", name: "", arguments: "" });
-                    }
-                    const acc = toolCallAcc.get(tc.index);
-                    if (tc.id)
-                        acc.id = tc.id;
-                    if (tc.function?.name)
-                        acc.name += tc.function.name;
-                    if (tc.function?.arguments)
-                        acc.arguments += tc.function.arguments;
+            if (finishReason === "tool_calls" && toolCallAcc.size > 0) {
+                // As in handleResponse(): bail out before the assistant turn is written,
+                // so a cancelled run leaves no unanswered tool call in history.
+                (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+                const toolCalls = Array.from(toolCallAcc.entries())
+                    .sort(([a], [b]) => a - b)
+                    .map(([, tc]) => ({
+                    id: tc.id,
+                    type: "function",
+                    function: { name: tc.name, arguments: tc.arguments },
+                }));
+                this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+                this.currentToolCallCount += toolCalls.length;
+                const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage({
+                    role: "assistant",
+                    content: textContent || null,
+                    tool_calls: toolCalls,
+                    reasoning_content: reasoningContent || null,
+                });
+                this.addToHistory(assistantEntry);
+                committed = true;
+                const toolResults = await this.handleToolCalls(toolCalls, options);
+                for (const result of toolResults) {
+                    this.addToHistory(transformers_1.chatCompletionsTransformer.toolResultEntry(result.toolCallId, result.content));
                 }
+                yield* this.streamTurn(options);
             }
-        }
-        // Before any early return below, so a turn that hits the token limit or
-        // continues into a tool call still reports what it spent.
-        if (streamUsage)
-            this.accumulateStreamUsage(streamUsage);
-        // 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.
-        (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-        if (finishReason === "length") {
-            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 {
+                const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage({
+                    role: "assistant",
+                    content: textContent || null,
+                    reasoning_content: reasoningContent || null,
+                });
+                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;
+                }
             }
-            throw error;
         }
-        if (finishReason === "tool_calls" && toolCallAcc.size > 0) {
-            // As in handleResponse(): bail out before the assistant turn is written,
-            // so a cancelled run leaves no unanswered tool call in history.
-            (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
-            const toolCalls = Array.from(toolCallAcc.entries())
-                .sort(([a], [b]) => a - b)
-                .map(([, tc]) => ({
-                id: tc.id,
-                type: "function",
-                function: { name: tc.name, arguments: tc.arguments },
-            }));
-            this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
-            this.currentToolCallCount += toolCalls.length;
-            const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage({
-                role: "assistant",
-                content: textContent || null,
-                tool_calls: toolCalls,
-                reasoning_content: reasoningContent || null,
-            });
-            this.addToHistory(assistantEntry);
-            const toolResults = await this.handleToolCalls(toolCalls, options);
-            for (const result of toolResults) {
-                this.addToHistory(transformers_1.chatCompletionsTransformer.toolResultEntry(result.toolCallId, result.content));
-            }
-            yield* this.streamTurn(options);
+        catch (error) {
+            failure = error;
+            throw error;
         }
-        else {
-            const assistantEntry = transformers_1.chatCompletionsTransformer.fromProviderMessage({
-                role: "assistant",
-                content: textContent || null,
-                reasoning_content: reasoningContent || null,
-            });
-            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) {
+                this.capturePartialTurn({
+                    text: textContent,
+                    reasoning: reasoningContent,
+                    toolCalls: Array.from(toolCallAcc.entries())
+                        .sort(([a], [b]) => a - b)
+                        .map(([, tc]) => ({
+                        id: tc.id,
+                        name: tc.name,
+                        arguments: tc.arguments,
+                    })),
+                    reason: this.partialTurnReason(failure, options?.signal),
+                    error: failure,
+                });
             }
         }
     }