@agentionai/agents 1.11.0 → 1.13.0

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,
+                });
             }
         }
     }

package/dist/agents/openrouter/OpenRouterAgent.js

@@ -294,6 +294,7 @@ class OpenRouterAgent extends BaseAgent_1.BaseAgent {
     beginRun(input) {
         this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
         this.resetTokenUsage();
+        this.resetPartialTurn();
         this.lastGeneration = undefined;
         this.currentToolCallCount = 0;
         if (VizConfig_1.vizConfig.isEnabled()) {
@@ -323,12 +324,12 @@ class OpenRouterAgent extends BaseAgent_1.BaseAgent {
         if ((0, cancellation_1.isAbortError)(error, options?.signal)) {
             const abortError = this.abortError(error, options?.signal);
             this.closeViz("AbortError", abortError.message, false);
-            return abortError;
+            return this.withPartialTurn(abortError);
         }
         const mapped = this.mapProviderError(error);
         this.emit(AgentEvent_1.AgentEvent.ERROR, mapped);
         this.closeViz(mapped.name, mapped.message, mapped instanceof AgentError_1.ApiError && mapped.statusCode === 429);
-        return mapped;
+        return this.withPartialTurn(mapped);
     }
     /**
      * Turn an `@openrouter/sdk` error into an {@link AgentError}.
@@ -515,108 +516,140 @@ class OpenRouterAgent extends BaseAgent_1.BaseAgent {
         let finishReason = null;
         let streamUsage;
         let streamError;
-        for await (const chunk of stream) {
-            // Once the first token is out the 200 and its headers are committed, so a
-            // provider failure after that point arrives as an SSE payload instead of
-            // an HTTP status. Recorded and thrown after the loop, so the tokens
-            // already spent still get reported.
-            if (chunk?.error)
-                streamError = chunk.error;
-            // Usage rides on whichever chunk OpenRouter chooses — often the last
-            // content chunk rather than a trailing choice-less one. It is a running
-            // total for the turn, not a delta, so keeping the most recent covers both
-            // layouts without double-counting.
-            if (chunk?.usage)
-                streamUsage = chunk.usage;
-            if (chunk?.id || chunk?.model)
-                this.recordGeneration(chunk);
-            const choice = chunk?.choices?.[0];
-            if (!choice)
-                continue;
-            finishReason = choice.finishReason ?? 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 minutes of generation, 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) {
+                // Once the first token is out the 200 and its headers are committed, so a
+                // provider failure after that point arrives as an SSE payload instead of
+                // an HTTP status. Recorded and thrown after the loop, so the tokens
+                // already spent still get reported.
+                if (chunk?.error)
+                    streamError = chunk.error;
+                // Usage rides on whichever chunk OpenRouter chooses — often the last
+                // content chunk rather than a trailing choice-less one. It is a running
+                // total for the turn, not a delta, so keeping the most recent covers both
+                // layouts without double-counting.
+                if (chunk?.usage)
+                    streamUsage = chunk.usage;
+                if (chunk?.id || chunk?.model)
+                    this.recordGeneration(chunk);
+                const choice = chunk?.choices?.[0];
+                if (!choice)
+                    continue;
+                finishReason = choice.finishReason ?? 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 };
+                }
+                if (delta.reasoning) {
+                    this.markFirstToken();
+                    // Accumulated as well as yielded: the assistant turn has to carry its
+                    // reasoning back on the next request.
+                    reasoningContent += delta.reasoning;
+                    this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, delta.reasoning);
+                    yield { type: "reasoning", content: delta.reasoning };
+                }
+                if (delta.reasoningDetails?.length) {
+                    reasoningDetails = reasoningDetails.concat(delta.reasoningDetails);
+                }
+                if (delta.toolCalls) {
+                    for (const tc of delta.toolCalls) {
+                        const index = tc.index ?? 0;
+                        if (!toolCallAcc.has(index)) {
+                            toolCallAcc.set(index, { id: "", name: "", arguments: "" });
+                        }
+                        const acc = toolCallAcc.get(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 (delta.reasoning) {
-                this.markFirstToken();
-                // Accumulated as well as yielded: the assistant turn has to carry its
-                // reasoning back on the next request.
-                reasoningContent += delta.reasoning;
-                this.emit(AgentEvent_1.AgentEvent.REASONING_CHUNK, delta.reasoning);
-                yield { type: "reasoning", content: delta.reasoning };
+            // Before any throw below, so a turn that failed part way still reports what
+            // it spent.
+            if (streamUsage)
+                this.accumulateUsage(this.parseUsageObject(streamUsage));
+            // The SDK's stream iterator stops yielding on abort rather than throwing, 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 (streamError) {
+                throw new AgentError_1.ApiError(`OpenRouter stream error: ${unwrapOpenRouterMessage(streamError, streamError.message ?? "no message")}`, streamError.code, streamError);
             }
-            if (delta.reasoningDetails?.length) {
-                reasoningDetails = reasoningDetails.concat(delta.reasoningDetails);
+            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);
+                throw error;
             }
-            if (delta.toolCalls) {
-                for (const tc of delta.toolCalls) {
-                    const index = tc.index ?? 0;
-                    if (!toolCallAcc.has(index)) {
-                        toolCallAcc.set(index, { id: "", name: "", arguments: "" });
-                    }
-                    const acc = toolCallAcc.get(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;
+            const assistantMessage = {
+                role: "assistant",
+                content: textContent || null,
+                reasoning: reasoningContent || null,
+                reasoningDetails,
+            };
+            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;
+                this.addToHistory(transformers_1.openRouterTransformer.fromProviderMessage({
+                    ...assistantMessage,
+                    toolCalls,
+                }));
+                committed = true;
+                const toolResults = await this.handleToolCalls(toolCalls, options);
+                for (const result of toolResults) {
+                    this.addToHistory(transformers_1.openRouterTransformer.toolResultEntry(result.toolCallId, result.content));
                 }
+                yield* this.streamTurn(options);
+            }
+            else {
+                this.addToHistory(transformers_1.openRouterTransformer.fromProviderMessage(assistantMessage));
+                committed = true;
+                this.emit(AgentEvent_1.AgentEvent.DONE, { content: textContent }, this.lastTokenUsage);
+                this.completeViz(textContent);
             }
         }
-        // Before any throw below, so a turn that failed part way still reports what
-        // it spent.
-        if (streamUsage)
-            this.accumulateUsage(this.parseUsageObject(streamUsage));
-        // The SDK's stream iterator stops yielding on abort rather than throwing, 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 (streamError) {
-            throw new AgentError_1.ApiError(`OpenRouter stream error: ${unwrapOpenRouterMessage(streamError, streamError.message ?? "no message")}`, streamError.code, streamError);
-        }
-        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);
+        catch (error) {
+            failure = error;
             throw error;
         }
-        const assistantMessage = {
-            role: "assistant",
-            content: textContent || null,
-            reasoning: reasoningContent || null,
-            reasoningDetails,
-        };
-        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;
-            this.addToHistory(transformers_1.openRouterTransformer.fromProviderMessage({
-                ...assistantMessage,
-                toolCalls,
-            }));
-            const toolResults = await this.handleToolCalls(toolCalls, options);
-            for (const result of toolResults) {
-                this.addToHistory(transformers_1.openRouterTransformer.toolResultEntry(result.toolCallId, result.content));
+        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,
+                    meta: reasoningDetails.length ? { reasoningDetails } : undefined,
+                });
             }
-            yield* this.streamTurn(options);
-        }
-        else {
-            this.addToHistory(transformers_1.openRouterTransformer.fromProviderMessage(assistantMessage));
-            this.emit(AgentEvent_1.AgentEvent.DONE, { content: textContent }, this.lastTokenUsage);
-            this.completeViz(textContent);
         }
     }
     async handleToolCalls(toolCalls, options) {

package/dist/agents/reasoning-text.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Display-only normalization for streamed reasoning text.
+ *
+ * Reasoning models routed through OpenRouter (and other OpenAI-compatible
+ * backends) sometimes stream `reasoning`/`reasoning_content` whose formatting
+ * is far noisier than the model's final answer — GLM-series models in
+ * particular emit heavily bulleted chain-of-thought with a blank line between
+ * almost every point, and some provider routes break tokens one phrase per
+ * line instead of wrapping normally. That formatting comes from the model
+ * itself (verified against live OpenRouter streams — the SDK and this
+ * library's accumulation just concatenate deltas verbatim), so it can't be
+ * fixed at the source.
+ *
+ * This is display-only: never apply it to the string that gets stored in
+ * history or replayed to the provider on the next turn (DeepSeek/GLM require
+ * that text back byte-for-byte, see {@link OpenAICompatibleAgent.streamTurn}).
+ * Apply it only where you render or log a `reasoning` chunk for a human.
+ */
+export interface CollapseReasoningWhitespaceOptions {
+    /** Collapse runs of 3+ newlines down to a single blank line. Default `true`. */
+    collapseBlankLines?: boolean;
+    /**
+     * Merge consecutive non-blank lines into one, joined by a space — for
+     * providers that stream reasoning broken one word or phrase per line. A
+     * line starting a markdown block (list item, heading, blockquote) is never
+     * merged into the line before it, so intentional structure survives.
+     * Off by default since it can also merge genuinely short paragraphs;
+     * enable it for the specific model/provider you've seen this on.
+     */
+    collapseLineWraps?: boolean;
+}
+/**
+ * Collapses excess linebreaks in reasoning text for display, leaving the
+ * original string untouched for anything that needs it verbatim.
+ *
+ * @example
+ * ```typescript
+ * agent.on(AgentEvent.REASONING_CHUNK, (delta) => {
+ *   process.stdout.write(collapseReasoningWhitespace(delta));
+ * });
+ * ```
+ */
+export declare function collapseReasoningWhitespace(text: string, options?: CollapseReasoningWhitespaceOptions): string;
+//# sourceMappingURL=reasoning-text.d.ts.map