@agentionai/agents 1.11.0 → 1.12.0

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

package/dist/agents/reasoning-text.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collapseReasoningWhitespace = collapseReasoningWhitespace;
+const MARKDOWN_BLOCK_START = /^\s*(?:[-*+]\s|\d+[.)]\s|#{1,6}\s|>)/;
+/**
+ * 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));
+ * });
+ * ```
+ */
+function collapseReasoningWhitespace(text, options = {}) {
+    const { collapseBlankLines = true, collapseLineWraps = false } = options;
+    let result = text;
+    if (collapseBlankLines) {
+        result = result.replace(/\n{3,}/g, "\n\n");
+    }
+    if (collapseLineWraps) {
+        const lines = result.split("\n");
+        const merged = [];
+        for (const line of lines) {
+            const prev = merged[merged.length - 1];
+            const canMergeIntoPrev = prev !== undefined &&
+                prev.trim().length > 0 &&
+                line.trim().length > 0 &&
+                !MARKDOWN_BLOCK_START.test(line) &&
+                !MARKDOWN_BLOCK_START.test(prev);
+            if (canMergeIntoPrev) {
+                merged[merged.length - 1] = `${prev.replace(/\s+$/, "")} ${line.replace(/^\s+/, "")}`;
+            }
+            else {
+                merged.push(line);
+            }
+        }
+        result = merged.join("\n");
+    }
+    return result;
+}
+//# sourceMappingURL=reasoning-text.js.map

package/dist/core.d.ts

@@ -4,6 +4,7 @@ export * from "./agents/AgentConfig";
 export * from "./agents/AgentEvent";
 export * from "./agents/errors/AgentError";
 export * from "./agents/cancellation";
+export * from "./agents/reasoning-text";
 export * from "./history/History";
 export * from "./history/types";
 export * from "./graph/AgentGraph";

package/dist/core.js

@@ -23,6 +23,7 @@ __exportStar(require("./agents/AgentConfig"), exports);
 __exportStar(require("./agents/AgentEvent"), exports);
 __exportStar(require("./agents/errors/AgentError"), exports);
 __exportStar(require("./agents/cancellation"), exports);
+__exportStar(require("./agents/reasoning-text"), exports);
 // History
 __exportStar(require("./history/History"), exports);
 __exportStar(require("./history/types"), exports);

package/dist/index.d.ts

@@ -19,6 +19,7 @@ export * from "./agents/AgentConfig";
 export * from "./agents/AgentEvent";
 export * from "./agents/errors/AgentError";
 export * from "./agents/cancellation";
+export * from "./agents/reasoning-text";
 export * from "./history/History";
 export * from "./history/types";
 export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, ollamaTransformer, chatCompletionsTransformer, openRouterTransformer, } from "./history/transformers";

package/dist/index.js

@@ -46,6 +46,7 @@ __exportStar(require("./agents/AgentConfig"), exports);
 __exportStar(require("./agents/AgentEvent"), exports);
 __exportStar(require("./agents/errors/AgentError"), exports);
 __exportStar(require("./agents/cancellation"), exports);
+__exportStar(require("./agents/reasoning-text"), exports);
 // History
 __exportStar(require("./history/History"), exports);
 __exportStar(require("./history/types"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "1.11.0",
+  "version": "1.12.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -118,7 +118,7 @@
     "@lancedb/lancedb": "^0.23.0",
     "@mistralai/mistralai": "^1.13.0",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@openrouter/sdk": "^1.2.37",
+    "@openrouter/sdk": "^1.2.106",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
     "apache-arrow": "^18.1.0",
@@ -150,7 +150,7 @@
     "@lancedb/lancedb": "^0.23.0",
     "@mistralai/mistralai": "^1.13.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
-    "@openrouter/sdk": "^1.2.29",
+    "@openrouter/sdk": "^1.2.106",
     "apache-arrow": "^18.0.0",
     "ollama": "^0.5.18",
     "openai": "^6.16.0",