@agentionai/agents 1.13.0 → 1.15.0

package/dist/history/transformers.js

@@ -10,17 +10,33 @@ const types_1 = require("./types");
 // =============================================================================
 // Anthropic Transformer
 // =============================================================================
+/**
+ * Whether a thinking block is one Anthropic itself produced, and so can be sent
+ * back to it.
+ *
+ * Anthropic signs every thinking block it emits (or returns it redacted), and
+ * rejects one whose signature does not verify — an empty string included. Other
+ * providers' reasoning reaches this transformer whenever a `History` is shared
+ * between agents, which the docs recommend: OpenAI's carries a summary and an
+ * encrypted payload but no signature, so it has to be dropped rather than
+ * replayed under an empty one.
+ */
+function isAnthropicThinkingBlock(block) {
+    return block.redactedData !== undefined || block.signature !== undefined;
+}
 exports.anthropicTransformer = {
     /**
      * Convert normalized entries to Anthropic MessageParam format
      */
     toProvider(entries) {
-        return entries
+        return (entries
             .filter((entry) => entry.role !== "system") // Anthropic handles system separately
             .map((entry) => {
             const role = entry.role === "assistant" ? "assistant" : "user";
             // Convert content blocks to Anthropic's ContentBlockParam
-            const content = entry.content.map((block) => {
+            const content = entry.content
+                .filter((block) => !(0, types_1.isThinkingContent)(block) || isAnthropicThinkingBlock(block))
+                .map((block) => {
                 if ((0, types_1.isTextContent)(block)) {
                     return { type: "text", text: block.text };
                 }
@@ -72,7 +88,12 @@ exports.anthropicTransformer = {
                 throw new Error(`Unknown content type: ${block.type}`);
             });
             return { role, content };
-        });
+        })
+            // Dropping a foreign thinking block can empty a turn that held nothing
+            // else (a reasoning-only assistant entry). Anthropic rejects a message
+            // with no content, and there is nothing left to say, so drop the message
+            // too. Tool pairs are unaffected: a thinking-only entry has no tool_use.
+            .filter((message) => message.content.length > 0));
     },
     /**
      * Convert Anthropic response content to normalized HistoryEntry
@@ -139,12 +160,48 @@ function toOpenAiId(originalId) {
     idMappingToOpenAi.set(originalId, newId);
     return newId;
 }
+function isOpenAiReasoningItem(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        value.type === "reasoning");
+}
+/**
+ * The reasoning items stored on an assistant entry, in the order they were
+ * received.
+ *
+ * They ride on `ThinkingContent.reasoningDetails` — the same passthrough slot
+ * OpenRouter's `reasoning_details` uses — because they have to survive the round
+ * trip untouched and there is nothing to model.
+ */
+function openAiReasoningItems(entry) {
+    return entry.content
+        .filter(types_1.isThinkingContent)
+        .filter((block) => (0, types_1.reasoningDetailsFormatOf)(block) === "openai.responses")
+        .flatMap((block) => block.reasoningDetails ?? [])
+        .filter(isOpenAiReasoningItem);
+}
+/** Human-readable text of a reasoning item's summary, for display in history. */
+function reasoningSummaryText(items) {
+    return items
+        .flatMap((item) => item.summary ?? [])
+        .map((part) => part?.text ?? "")
+        .filter(Boolean)
+        .join("\n\n");
+}
 exports.openAiTransformer = {
     /**
-     * Convert normalized entries to OpenAI ResponseInputItem format
+     * Convert normalized entries to OpenAI ResponseInputItem format.
+     *
+     * `replayReasoning` defaults to on and mirrors
+     * `AgentConfig.includeEncryptedReasoning`: requesting the blobs and sending
+     * them back are one feature, so switching it off has to stop *both*.
+     * Otherwise a history that already holds blobs keeps replaying them — which
+     * is exactly the situation the flag is turned off to escape, since reasoning
+     * is tied to the model that produced it and switching models is rejected.
      */
-    toProvider(entries) {
+    toProvider(entries, options) {
         const items = [];
+        const replayReasoning = options?.replayReasoning ?? true;
         for (const entry of entries) {
             if (entry.role === "system") {
                 items.push({
@@ -157,6 +214,18 @@ exports.openAiTransformer = {
                 });
                 continue;
             }
+            // Reasoning first, before anything else this turn produced — the order
+            // the model emitted it in. The Responses API turns out not to enforce
+            // this on the `store: false` + explicit-`input` flow these agents use
+            // (probed live 2026-09-10; see `OpenAiAgent.replayableReasoning` for what
+            // was accepted), so this is fidelity to what the model produced rather
+            // than a constraint. Emitting it out of order is not known to fail, but
+            // there is no reason to.
+            if (replayReasoning) {
+                for (const item of openAiReasoningItems(entry)) {
+                    items.push(item);
+                }
+            }
             // Separate content blocks by type for OpenAI format
             const textBlocks = entry.content.filter(types_1.isTextContent);
             const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
@@ -238,8 +307,21 @@ exports.openAiTransformer = {
     /**
      * Convert OpenAI response to normalized HistoryEntry
      */
-    fromProviderMessage(role, outputText, functionCalls) {
+    fromProviderMessage(role, outputText, functionCalls, 
+    /**
+     * `reasoning` items from `response.output`, stored verbatim so the next
+     * request can replay them. Pass only items that carry `encrypted_content`:
+     * with `store: false` the provider has kept nothing of its own, so a
+     * replayed item without it cannot be resolved and the request is rejected.
+     */
+    reasoningItems) {
         const content = [];
+        const reasoning = (reasoningItems ?? []).filter(isOpenAiReasoningItem);
+        if (reasoning.length > 0) {
+            // Summary text is for humans reading the history; the payload that
+            // matters is the untouched items on `reasoningDetails`.
+            content.push((0, types_1.thinking)(reasoningSummaryText(reasoning), undefined, undefined, reasoning, "openai.responses"));
+        }
         if (outputText) {
             content.push((0, types_1.text)(outputText));
         }
@@ -553,7 +635,10 @@ exports.ollamaTransformer = {
             const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
             const toolResultBlocks = entry.content.filter(types_1.isToolResultContent);
             if (entry.role === "system") {
-                messages.push({ role: "system", content: textBlocks.map((c) => c.text).join("\n") });
+                messages.push({
+                    role: "system",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
                 continue;
             }
             if (entry.role === "assistant") {
@@ -579,7 +664,10 @@ exports.ollamaTransformer = {
                 }
             }
             else if (textBlocks.length > 0) {
-                messages.push({ role: "user", content: textBlocks.map((c) => c.text).join("\n") });
+                messages.push({
+                    role: "user",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
             }
         }
         return messages;
@@ -650,7 +738,10 @@ exports.chatCompletionsTransformer = {
             const imageBase64Blocks = entry.content.filter(types_1.isImageBase64Content);
             const hasImages = imageUrlBlocks.length > 0 || imageBase64Blocks.length > 0;
             if (entry.role === "system") {
-                messages.push({ role: "system", content: textBlocks.map((c) => c.text).join("\n") });
+                messages.push({
+                    role: "system",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
                 continue;
             }
             if (entry.role === "assistant") {
@@ -720,7 +811,10 @@ exports.chatCompletionsTransformer = {
                 messages.push({ role: "user", content: parts });
             }
             else if (textBlocks.length > 0) {
-                messages.push({ role: "user", content: textBlocks.map((c) => c.text).join("\n") });
+                messages.push({
+                    role: "user",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
             }
         }
         return messages;
@@ -807,7 +901,11 @@ function markLatestCacheBreakpoint(messages) {
         const message = messages[i];
         if (typeof message.content === "string" && message.content.length > 0) {
             message.content = [
-                { type: "text", text: message.content, cacheControl: { type: "ephemeral" } },
+                {
+                    type: "text",
+                    text: message.content,
+                    cacheControl: { type: "ephemeral" },
+                },
             ];
             return;
         }
@@ -861,7 +959,15 @@ exports.openRouterTransformer = {
                 // and Anthropic and OpenAI models reject a tool-using turn whose
                 // signature did not come back. Only set the key when there is one, so
                 // requests for non-reasoning models stay byte-identical.
-                const reasoningDetails = thinkingBlocks.flatMap((block) => block.reasoningDetails ?? []);
+                // Only OpenRouter's own blocks. A history shared with an OpenAI agent
+                // also carries Responses-API `reasoning` items in this slot, and they
+                // are not OpenRouter's to interpret — it returned 200 rather than an
+                // error when one was sent (probed live 2026-09-10, upstream
+                // `anthropic/claude-sonnet-4.5`), but forwarding another provider's
+                // opaque payload can only confuse the model or the upstream route.
+                const reasoningDetails = thinkingBlocks
+                    .filter((block) => (0, types_1.reasoningDetailsFormatOf)(block) === "openrouter")
+                    .flatMap((block) => block.reasoningDetails ?? []);
                 if (reasoningDetails.length > 0) {
                     msg.reasoningDetails = reasoningDetails;
                 }
@@ -934,7 +1040,7 @@ exports.openRouterTransformer = {
         const reasoningText = typeof message.reasoning === "string" ? message.reasoning : "";
         const reasoningDetails = message.reasoningDetails ?? [];
         if (reasoningText || reasoningDetails.length > 0) {
-            content.push((0, types_1.thinking)(reasoningText, undefined, undefined, reasoningDetails));
+            content.push((0, types_1.thinking)(reasoningText, undefined, undefined, reasoningDetails, "openrouter"));
         }
         if (typeof message.content === "string" && message.content) {
             content.push((0, types_1.text)(message.content));

package/dist/history/types.d.ts

@@ -62,9 +62,32 @@ export type ThinkingContent = {
      *
      * Nothing here reads the contents; they only have to survive the round trip,
      * so they stay untyped rather than modelling every provider's block shapes.
+     *
+     * The shapes are *not* interchangeable — see
+     * {@link ThinkingContent.reasoningDetailsFormat}.
      */
     reasoningDetails?: unknown[];
+    /**
+     * Which provider's format {@link ThinkingContent.reasoningDetails} is in.
+     *
+     * Two producers share that slot and their shapes are mutually invalid:
+     * OpenRouter's entries are tagged `reasoning.text` / `reasoning.summary` /
+     * `reasoning.encrypted`, while the OpenAI Responses API's are whole
+     * `reasoning` items. A history shared between agents therefore has to say
+     * which is which, or each transformer forwards the other's blocks and the
+     * provider rejects the request.
+     *
+     * Absent on blocks written before this field existed, which are OpenRouter's
+     * by definition — it was the only producer then. Read it through
+     * {@link reasoningDetailsFormatOf} rather than directly, so that default
+     * stays in one place.
+     */
+    reasoningDetailsFormat?: ReasoningDetailsFormat;
 };
+/**
+ * Provider formats that {@link ThinkingContent.reasoningDetails} can hold.
+ */
+export type ReasoningDetailsFormat = "openrouter" | "openai.responses";
 /**
  * Supported image MIME types across all providers
  */
@@ -207,7 +230,14 @@ export declare function toolUse(id: string, name: string, input: Record<string,
 /**
  * Create a thinking content block. Pass `redactedData` for redacted thinking.
  */
-export declare function thinking(thinkingText: string, signature?: string, redactedData?: string, reasoningDetails?: unknown[]): ThinkingContent;
+export declare function thinking(thinkingText: string, signature?: string, redactedData?: string, reasoningDetails?: unknown[], reasoningDetailsFormat?: ReasoningDetailsFormat): ThinkingContent;
+/**
+ * The format of a block's {@link ThinkingContent.reasoningDetails}.
+ *
+ * Untagged blocks are OpenRouter's: it was the only producer before the tag
+ * existed, so that is what an untagged block can only have come from.
+ */
+export declare function reasoningDetailsFormatOf(block: ThinkingContent): ReasoningDetailsFormat;
 /**
  * Create a tool result content block
  */

package/dist/history/types.js

@@ -16,6 +16,7 @@ exports.isImageContent = isImageContent;
 exports.text = text;
 exports.toolUse = toolUse;
 exports.thinking = thinking;
+exports.reasoningDetailsFormatOf = reasoningDetailsFormatOf;
 exports.toolResult = toolResult;
 exports.textMessage = textMessage;
 exports.imageUrl = imageUrl;
@@ -70,20 +71,29 @@ function toolUse(id, name, input, thoughtSignature) {
 /**
  * Create a thinking content block. Pass `redactedData` for redacted thinking.
  */
-function thinking(thinkingText, signature, redactedData, reasoningDetails) {
+function thinking(thinkingText, signature, redactedData, reasoningDetails, reasoningDetailsFormat = "openrouter") {
     // As in `toolUse()`, only set the passthrough key when there is something in
     // it, so a block stored without details serializes exactly as it did before
-    // the field existed.
+    // the field existed. The format tag rides along with the details for the same
+    // reason: it says nothing on its own.
+    const hasDetails = reasoningDetails !== undefined && reasoningDetails.length > 0;
     return {
         type: "thinking",
         thinking: thinkingText,
         signature,
         redactedData,
-        ...(reasoningDetails && reasoningDetails.length > 0
-            ? { reasoningDetails }
-            : {}),
+        ...(hasDetails ? { reasoningDetails, reasoningDetailsFormat } : {}),
     };
 }
+/**
+ * The format of a block's {@link ThinkingContent.reasoningDetails}.
+ *
+ * Untagged blocks are OpenRouter's: it was the only producer before the tag
+ * existed, so that is what an untagged block can only have come from.
+ */
+function reasoningDetailsFormatOf(block) {
+    return block.reasoningDetailsFormat ?? "openrouter";
+}
 /**
  * Create a tool result content block
  */

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./agents/anthropic/ClaudeAgent";
 export { OpenAiAgent } from "./agents/openai/OpenAiAgent";
 export { CODEX_BASE_URL, CODEX_CLIENT_ID, CODEX_ORIGINATOR, CODEX_TOKEN_URL, codexAuthFilePath, createCodexTokenProvider, loadCodexCredentials, refreshCodexCredentials, } from "./agents/openai/codex-auth";
 export type { CodexModelCard, CodexCredentials, CodexTokenProvider, CodexTokenProviderOptions, } from "./agents/openai/codex-auth";
+export { parseCodexUsageLimits, observeHeadersFetch, type CodexUsageLimits, type CodexRateLimitWindow, type CodexCredits, } from "./agents/openai/codex-usage";
 export { CodexAgent } from "./agents/openai/CodexAgent";
 export type { CodexAgentConfig, CodexModel, CodexReasoningEffort, } from "./agents/openai/CodexAgent";
 export { MistralAgent } from "./agents/mistral/MistralAgent";

package/dist/index.js

@@ -22,7 +22,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.openRouterTransformer = exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OpenRouterAgent = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = exports.OllamaAgent = exports.GEMINI_RETIRED_MODELS = exports.GeminiAgent = exports.MistralAgent = exports.CodexAgent = exports.refreshCodexCredentials = exports.loadCodexCredentials = exports.createCodexTokenProvider = exports.codexAuthFilePath = exports.CODEX_TOKEN_URL = exports.CODEX_ORIGINATOR = exports.CODEX_CLIENT_ID = exports.CODEX_BASE_URL = exports.OpenAiAgent = void 0;
+exports.openRouterTransformer = exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OpenRouterAgent = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = exports.OllamaAgent = exports.GEMINI_RETIRED_MODELS = exports.GeminiAgent = exports.MistralAgent = exports.CodexAgent = exports.observeHeadersFetch = exports.parseCodexUsageLimits = exports.refreshCodexCredentials = exports.loadCodexCredentials = exports.createCodexTokenProvider = exports.codexAuthFilePath = exports.CODEX_TOKEN_URL = exports.CODEX_ORIGINATOR = exports.CODEX_CLIENT_ID = exports.CODEX_BASE_URL = exports.OpenAiAgent = void 0;
 // Agents
 __exportStar(require("./agents/BaseAgent"), exports);
 __exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
@@ -37,6 +37,9 @@ Object.defineProperty(exports, "codexAuthFilePath", { enumerable: true, get: fun
 Object.defineProperty(exports, "createCodexTokenProvider", { enumerable: true, get: function () { return codex_auth_1.createCodexTokenProvider; } });
 Object.defineProperty(exports, "loadCodexCredentials", { enumerable: true, get: function () { return codex_auth_1.loadCodexCredentials; } });
 Object.defineProperty(exports, "refreshCodexCredentials", { enumerable: true, get: function () { return codex_auth_1.refreshCodexCredentials; } });
+var codex_usage_1 = require("./agents/openai/codex-usage");
+Object.defineProperty(exports, "parseCodexUsageLimits", { enumerable: true, get: function () { return codex_usage_1.parseCodexUsageLimits; } });
+Object.defineProperty(exports, "observeHeadersFetch", { enumerable: true, get: function () { return codex_usage_1.observeHeadersFetch; } });
 var CodexAgent_1 = require("./agents/openai/CodexAgent");
 Object.defineProperty(exports, "CodexAgent", { enumerable: true, get: function () { return CodexAgent_1.CodexAgent; } });
 var MistralAgent_1 = require("./agents/mistral/MistralAgent");

package/dist/openai.d.ts

@@ -1,7 +1,9 @@
 export * from "./core";
 export { OpenAiAgent, describeOpenAIError, wrapErrorBodyFetch, } from "./agents/openai/OpenAiAgent";
+export type { OpenAIInputTokensDetails } from "./agents/openai/OpenAiAgent";
 export { CodexAgent } from "./agents/openai/CodexAgent";
 export type { CodexAgentConfig, CodexModel, CodexReasoningEffort, } from "./agents/openai/CodexAgent";
 export { openAiTransformer } from "./history/transformers";
 export { CODEX_BASE_URL, CODEX_CLIENT_ID, CODEX_ORIGINATOR, CODEX_TOKEN_URL, codexAuthFilePath, createCodexTokenProvider, decodeJwtClaims, jwtExpiry, loadCodexCredentials, refreshCodexCredentials, type CodexCredentials, type CodexTokenProvider, type CodexTokenProviderOptions, type CodexModelCard, } from "./agents/openai/codex-auth";
+export { parseCodexUsageLimits, observeHeadersFetch, type CodexUsageLimits, type CodexRateLimitWindow, type CodexCredits, } from "./agents/openai/codex-usage";
 //# sourceMappingURL=openai.d.ts.map

package/dist/openai.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.refreshCodexCredentials = exports.loadCodexCredentials = exports.jwtExpiry = exports.decodeJwtClaims = exports.createCodexTokenProvider = exports.codexAuthFilePath = exports.CODEX_TOKEN_URL = exports.CODEX_ORIGINATOR = exports.CODEX_CLIENT_ID = exports.CODEX_BASE_URL = exports.openAiTransformer = exports.CodexAgent = exports.wrapErrorBodyFetch = exports.describeOpenAIError = exports.OpenAiAgent = void 0;
+exports.observeHeadersFetch = exports.parseCodexUsageLimits = exports.refreshCodexCredentials = exports.loadCodexCredentials = exports.jwtExpiry = exports.decodeJwtClaims = exports.createCodexTokenProvider = exports.codexAuthFilePath = exports.CODEX_TOKEN_URL = exports.CODEX_ORIGINATOR = exports.CODEX_CLIENT_ID = exports.CODEX_BASE_URL = exports.openAiTransformer = exports.CodexAgent = exports.wrapErrorBodyFetch = exports.describeOpenAIError = exports.OpenAiAgent = void 0;
 // OpenAI Agent Entry Point
 __exportStar(require("./core"), exports);
 var OpenAiAgent_1 = require("./agents/openai/OpenAiAgent");
@@ -36,4 +36,7 @@ Object.defineProperty(exports, "decodeJwtClaims", { enumerable: true, get: funct
 Object.defineProperty(exports, "jwtExpiry", { enumerable: true, get: function () { return codex_auth_1.jwtExpiry; } });
 Object.defineProperty(exports, "loadCodexCredentials", { enumerable: true, get: function () { return codex_auth_1.loadCodexCredentials; } });
 Object.defineProperty(exports, "refreshCodexCredentials", { enumerable: true, get: function () { return codex_auth_1.refreshCodexCredentials; } });
+var codex_usage_1 = require("./agents/openai/codex-usage");
+Object.defineProperty(exports, "parseCodexUsageLimits", { enumerable: true, get: function () { return codex_usage_1.parseCodexUsageLimits; } });
+Object.defineProperty(exports, "observeHeadersFetch", { enumerable: true, get: function () { return codex_usage_1.observeHeadersFetch; } });
 //# sourceMappingURL=openai.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -132,7 +132,7 @@
     "jsdoc": "^4.0.4",
     "jsdoc-to-markdown": "^9.1.1",
     "nodemon": "^2.0.22",
-    "openai": "^6.16.0",
+    "openai": "^7.13.0",
     "prettier": "^2.8.7",
     "rimraf": "^4.4.1",
     "ts-jest": "^29.2.6",
@@ -153,7 +153,7 @@
     "@openrouter/sdk": "^1.2.106",
     "apache-arrow": "^18.0.0",
     "ollama": "^0.5.18",
-    "openai": "^6.16.0",
+    "openai": "^7.13.0",
     "voyageai": "^0.0.3"
   },
   "peerDependenciesMeta": {