@agentionai/agents 1.10.3 → 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}.
@@ -392,9 +393,24 @@ class OpenRouterAgent extends BaseAgent_1.BaseAgent {
     }
     /** The `ChatRequest` body, identical for the streaming and buffered paths. */
     buildRequest(stream) {
-        const messages = transformers_1.openRouterTransformer.toProvider(this.history.getEntries());
+        const cachePrompt = this.config.promptCaching === true;
+        const messages = transformers_1.openRouterTransformer.toProvider(this.history.getEntries(), {
+            cacheSystemPrompt: cachePrompt,
+        });
         const allTools = this.getAllToolDefinitions();
-        const tools = allTools.length > 0 ? allTools : undefined;
+        // The breakpoint goes on the *last* tool: Anthropic (and OpenRouter's
+        // translation of this marker for other providers, see
+        // OpenRouterSpecificConfig.promptCaching) caches everything up through a
+        // marked block, so one marker at the end of the array covers the whole
+        // tool list in one cached segment. Marking every tool would just spend
+        // more cache-write budget for the same coverage.
+        const cacheableTools = cachePrompt && allTools.length > 0
+            ? [
+                ...allTools.slice(0, -1),
+                { ...allTools[allTools.length - 1], cacheControl: { type: "ephemeral" } },
+            ]
+            : allTools;
+        const tools = cacheableTools.length > 0 ? cacheableTools : undefined;
         return {
             model: this.config.model,
             messages,
@@ -500,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) {
@@ -656,6 +704,7 @@ class OpenRouterAgent extends BaseAgent_1.BaseAgent {
             output_tokens: usage?.completionTokens ?? 0,
             total_tokens: usage?.totalTokens ?? 0,
             reasoning_tokens: usage?.completionTokensDetails?.reasoningTokens ?? undefined,
+            cost_usd: typeof usage?.cost === "number" ? usage.cost : undefined,
         };
     }
     completeViz(textContent) {

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/history/transformers.d.ts

@@ -163,24 +163,20 @@ export declare const chatCompletionsTransformer: {
      */
     toolResultEntry(tool_call_id: string, output: string): HistoryEntry;
 };
-/**
- * Convert normalized entries to/from the message format `@openrouter/sdk`
- * accepts.
- *
- * The wire format is OpenAI Chat Completions, but the SDK's TypeScript surface
- * is camelCase (`toolCalls`, `toolCallId`, `reasoningDetails`) and it
- * zod-serializes to snake_case on the way out — so this cannot reuse
- * {@link chatCompletionsTransformer}, whose output is already snake_case.
- *
- * Beyond the casing it also carries `reasoning_details` through the round trip,
- * which the OpenAI-compatible path has no equivalent for.
- */
 export declare const openRouterTransformer: {
     /**
      * Convert normalized entries to OpenRouter message format.
      * Tool results become role:"tool" messages; tool calls ride on the assistant message.
+     *
+     * `cacheSystemPrompt` marks the system message *and* the latest eligible
+     * message with a cache breakpoint each — see
+     * {@link markLatestCacheBreakpoint} for why it's both ends, not just the
+     * front, and {@link OpenRouterSpecificConfig.promptCaching} for why this is
+     * opt-in rather than automatic.
      */
-    toProvider(entries: HistoryEntry[]): OpenRouterMessage[];
+    toProvider(entries: HistoryEntry[], options?: {
+        cacheSystemPrompt?: boolean;
+    }): OpenRouterMessage[];
     /**
      * Convert an OpenRouter assistant message to a normalized HistoryEntry.
      */
@@ -201,6 +197,7 @@ type OpenRouterToolCallParam = {
 type OpenRouterContentPart = {
     type: "text";
     text: string;
+    cacheControl?: OpenRouterCacheControl;
 } | {
     type: "image_url";
     imageUrl: {
@@ -208,15 +205,23 @@ type OpenRouterContentPart = {
         detail?: "auto" | "low" | "high";
     };
 };
+/**
+ * A cache breakpoint on one content block. `cacheControl` (camelCase, per
+ * this file's header) rather than the wire's `cache_control` — the SDK
+ * zod-serializes the rename on the way out.
+ */
+export type OpenRouterCacheControl = {
+    type: "ephemeral";
+};
 export type OpenRouterMessage = {
     role: "system";
-    content: string;
+    content: string | OpenRouterContentPart[];
 } | {
     role: "user";
     content: string | OpenRouterContentPart[];
 } | {
     role: "assistant";
-    content: string | null;
+    content: string | null | OpenRouterContentPart[];
     toolCalls?: OpenRouterToolCallParam[];
     /** Plain reasoning text replayed from a previous turn. */
     reasoning?: string;
@@ -228,7 +233,7 @@ export type OpenRouterMessage = {
 } | {
     role: "tool";
     toolCallId: string;
-    content: string;
+    content: string | OpenRouterContentPart[];
 };
 type OpenRouterResponseMessage = {
     role: string;

package/dist/history/transformers.js

@@ -782,12 +782,49 @@ exports.chatCompletionsTransformer = {
  * Beyond the casing it also carries `reasoning_details` through the round trip,
  * which the OpenAI-compatible path has no equivalent for.
  */
+/**
+ * Marks the *last* message carrying plain string content with an Anthropic
+ * cache breakpoint, mutating it in place.
+ *
+ * The system-prompt breakpoint alone only caches the fixed part of a request
+ * — an agentic loop's growing tool-call history is not fixed, and without a
+ * second breakpoint it is resent as fresh, full-price input on every turn.
+ * Marking the tail instead: turn N's breakpoint lands on its newest message,
+ * so turn N+1's *identical, longer prefix up to that point* is a cache hit,
+ * and only the new content past it needs to be freshly priced (and gets its
+ * own breakpoint in turn). Anthropic allows up to 4 breakpoints total; this
+ * is the second, after the one on the system message — see
+ * {@link OpenRouterSpecificConfig.promptCaching}.
+ *
+ * Skips a message whose content isn't a non-empty string — `null` (an
+ * assistant turn that's purely a tool call, nothing to attach a text block
+ * to) or an already-structured array (images). Landing one message later
+ * than ideal in that case is a smaller loss than the alternative of writing
+ * this for every content shape up front.
+ */
+function markLatestCacheBreakpoint(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (typeof message.content === "string" && message.content.length > 0) {
+            message.content = [
+                { type: "text", text: message.content, cacheControl: { type: "ephemeral" } },
+            ];
+            return;
+        }
+    }
+}
 exports.openRouterTransformer = {
     /**
      * Convert normalized entries to OpenRouter message format.
      * Tool results become role:"tool" messages; tool calls ride on the assistant message.
+     *
+     * `cacheSystemPrompt` marks the system message *and* the latest eligible
+     * message with a cache breakpoint each — see
+     * {@link markLatestCacheBreakpoint} for why it's both ends, not just the
+     * front, and {@link OpenRouterSpecificConfig.promptCaching} for why this is
+     * opt-in rather than automatic.
      */
-    toProvider(entries) {
+    toProvider(entries, options) {
         const messages = [];
         for (const entry of entries) {
             const textBlocks = entry.content.filter(types_1.isTextContent);
@@ -798,9 +835,12 @@ exports.openRouterTransformer = {
             const imageBase64Blocks = entry.content.filter(types_1.isImageBase64Content);
             const hasImages = imageUrlBlocks.length > 0 || imageBase64Blocks.length > 0;
             if (entry.role === "system") {
+                const text = textBlocks.map((c) => c.text).join("\n");
                 messages.push({
                     role: "system",
-                    content: textBlocks.map((c) => c.text).join("\n"),
+                    content: options?.cacheSystemPrompt
+                        ? [{ type: "text", text, cacheControl: { type: "ephemeral" } }]
+                        : text,
                 });
                 continue;
             }
@@ -879,6 +919,8 @@ exports.openRouterTransformer = {
                 });
             }
         }
+        if (options?.cacheSystemPrompt)
+            markLatestCacheBreakpoint(messages);
         return messages;
     },
     /**

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.10.3",
+  "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",