@agentionai/agents 1.7.0-beta.0 → 1.8.0

package/dist/agents/openrouter/types.d.ts

@@ -0,0 +1,164 @@
+/**
+ * OpenRouter request-shaping types.
+ *
+ * Declared structurally rather than imported from `@openrouter/sdk` so that
+ * consumers who have not installed the optional peer dependency still typecheck
+ * — the same approach `lib/mcp/types.ts` takes for the MCP SDK. Assignability
+ * against the SDK's own types is asserted in `types.spec.ts`, which fails the
+ * build if OpenRouter's shapes drift away from these.
+ *
+ * Field names are camelCase because that is what the SDK accepts; it
+ * zod-serializes them to the snake_case the HTTP API expects.
+ */
+/**
+ * Provider sorting strategy applied when no explicit `order` is given.
+ *
+ * - `"price"` — cheapest endpoint first
+ * - `"throughput"` — highest tokens/second first
+ * - `"latency"` — lowest time-to-first-token first
+ * - `"exacto"` — OpenRouter's accuracy-verified endpoints first
+ *
+ * Setting any of these disables load balancing.
+ */
+export type OpenRouterProviderSort = "price" | "throughput" | "latency" | "exacto";
+/**
+ * Maximum price to pay for a request, in USD per million tokens (per image or
+ * per request for the corresponding fields). Values are strings, as the API
+ * takes them.
+ */
+export type OpenRouterMaxPrice = {
+    /** USD per million prompt tokens */
+    prompt?: string;
+    /** USD per million completion tokens */
+    completion?: string;
+    /** USD per image */
+    image?: string;
+    /** USD per request */
+    request?: string;
+    /** USD per audio unit */
+    audio?: string;
+};
+/**
+ * Where OpenRouter is allowed to route a request.
+ *
+ * Directly relevant to throttling: `order`/`only`/`ignore` decide which
+ * upstream providers are in play, and `allowFallbacks` (default `true`) is what
+ * lets OpenRouter move past one that is rate limited or down.
+ *
+ * @see https://openrouter.ai/docs/guides/features/provider-routing
+ */
+export type OpenRouterProviderPreferences = {
+    /**
+     * Ordered list of provider slugs. The router uses the first one in this list
+     * that serves the requested model, falling back to the next when it is
+     * unavailable.
+     */
+    order?: string[] | null;
+    /** Provider slugs to allow, merged with your account-wide allow list. */
+    only?: string[] | null;
+    /** Provider slugs to skip, merged with your account-wide ignore list. */
+    ignore?: string[] | null;
+    /**
+     * Whether backup providers may serve the request.
+     *
+     * `true` (default) moves to the next best provider when the primary is
+     * unavailable — including when it rate limits you. `false` returns the
+     * upstream error instead, which is what you want when `order` names the only
+     * provider you will accept.
+     */
+    allowFallbacks?: boolean | null;
+    /** Sorting strategy used when `order` is not set. Disables load balancing. */
+    sort?: OpenRouterProviderSort | null;
+    /** Cap on what the request may cost. */
+    maxPrice?: OpenRouterMaxPrice;
+    /**
+     * Route only to providers that support every parameter sent. Off by default,
+     * in which case providers silently drop parameters they do not understand.
+     */
+    requireParameters?: boolean | null;
+    /**
+     * `"deny"` restricts routing to providers that do not store prompts.
+     * `"allow"` (default) permits providers that may retain and train on them.
+     */
+    dataCollection?: "allow" | "deny" | null;
+    /** Restrict routing to Zero Data Retention endpoints. */
+    zdr?: boolean | null;
+    /** Quantization levels to accept (e.g. `"fp8"`, `"bf16"`). */
+    quantizations?: OpenRouterQuantization[] | null;
+    /** Deprioritize endpoints slower than this p50 latency, in seconds. */
+    preferredMaxLatency?: number | null;
+    /** Deprioritize endpoints below this p50 throughput, in tokens/second. */
+    preferredMinThroughput?: number | null;
+};
+/**
+ * How hard a reasoning model should think. `"none"` disables reasoning where
+ * the model allows it; which values a given model accepts is model-dependent
+ * and OpenRouter normalizes the rest per upstream provider.
+ */
+/**
+ * Quantization levels accepted when filtering providers, e.g. `"fp8"`, `"bf16"`.
+ *
+ * Kept as an explicit string-literal union (rather than `string`) so a caller's
+ * config is assignable to `@openrouter/sdk`'s branded `Quantization` enum —
+ * see `types.spec.ts`. OpenRouter may add values over time; unknown ones are
+ * rejected by the SDK at runtime.
+ */
+export type OpenRouterQuantization = "int4" | "int8" | "fp4" | "mxfp4" | "nvfp4" | "fp6" | "fp8" | "mxfp8" | "fp16" | "bf16" | "fp32" | "unknown";
+export type OpenRouterReasoningEffort = "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+/** Reasoning configuration sent with the request. */
+export type OpenRouterReasoningConfig = {
+    effort?: OpenRouterReasoningEffort | null;
+    /** Verbosity of the reasoning summary, on models that produce one. */
+    summary?: string | null;
+};
+/**
+ * Retry policy handed to the SDK per chat request.
+ *
+ * Mirrors the SDK's own `RetryConfig`. See
+ * {@link OpenRouterSpecificConfig.retry} for why the agent does not simply take
+ * the SDK's defaults.
+ */
+export type OpenRouterRetryConfig = {
+    strategy: "none";
+} | {
+    strategy: "backoff";
+    backoff?: {
+        /** Base delay in ms; the nth retry waits `initialInterval * n ** exponent`. */
+        initialInterval: number;
+        /** Ceiling on a single wait, in ms — also caps a long `Retry-After`. */
+        maxInterval: number;
+        exponent: number;
+        /** Total ms the retry loop may run before giving up. */
+        maxElapsedTime: number;
+    };
+    /** Also retry timeouts and connection failures. */
+    retryConnectionErrors?: boolean;
+};
+/**
+ * The cost and routing facts OpenRouter reports for a completed turn, which no
+ * other provider in this library exposes.
+ *
+ * Populated after each `execute()` / `executeStream()` on
+ * {@link OpenRouterAgent.lastGeneration}, summed across the turn's API calls
+ * where the field is additive.
+ */
+export type OpenRouterGenerationInfo = {
+    /** Generation id of the last API call, for lookups against `/generation`. */
+    id?: string;
+    /**
+     * Model that actually answered. Differs from the configured model when a
+     * fallback in `models` was used, or when routing through `openrouter/auto`.
+     */
+    model?: string;
+    /**
+     * Cost in USD credits, summed over every API call in the turn (a tool loop
+     * bills once per hop). Undefined when OpenRouter does not report a cost —
+     * BYOK requests being the usual case.
+     */
+    cost?: number;
+    /** Whether the request was served through a Bring Your Own Key configuration. */
+    isByok?: boolean;
+    /** Number of provider attempts OpenRouter made before one succeeded. */
+    attempts?: number;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/agents/openrouter/types.js

@@ -0,0 +1,15 @@
+"use strict";
+/**
+ * OpenRouter request-shaping types.
+ *
+ * Declared structurally rather than imported from `@openrouter/sdk` so that
+ * consumers who have not installed the optional peer dependency still typecheck
+ * — the same approach `lib/mcp/types.ts` takes for the MCP SDK. Assignability
+ * against the SDK's own types is asserted in `types.spec.ts`, which fails the
+ * build if OpenRouter's shapes drift away from these.
+ *
+ * Field names are camelCase because that is what the SDK accepts; it
+ * zod-serializes them to the snake_case the HTTP API expects.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/history/transformers.d.ts

@@ -154,6 +154,86 @@ 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.
+     */
+    toProvider(entries: HistoryEntry[]): OpenRouterMessage[];
+    /**
+     * Convert an OpenRouter assistant message to a normalized HistoryEntry.
+     */
+    fromProviderMessage(message: OpenRouterResponseMessage): HistoryEntry;
+    /**
+     * Create a normalized tool result entry for an OpenRouter tool call
+     */
+    toolResultEntry(tool_call_id: string, output: string): HistoryEntry;
+};
+type OpenRouterToolCallParam = {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+};
+type OpenRouterContentPart = {
+    type: "text";
+    text: string;
+} | {
+    type: "image_url";
+    imageUrl: {
+        url: string;
+        detail?: "auto" | "low" | "high";
+    };
+};
+export type OpenRouterMessage = {
+    role: "system";
+    content: string;
+} | {
+    role: "user";
+    content: string | OpenRouterContentPart[];
+} | {
+    role: "assistant";
+    content: string | null;
+    toolCalls?: OpenRouterToolCallParam[];
+    /** Plain reasoning text replayed from a previous turn. */
+    reasoning?: string;
+    /**
+     * Opaque reasoning blocks replayed verbatim. Omitted entirely when the
+     * turn carried none.
+     */
+    reasoningDetails?: unknown[];
+} | {
+    role: "tool";
+    toolCallId: string;
+    content: string;
+};
+type OpenRouterResponseMessage = {
+    role: string;
+    content?: string | null;
+    toolCalls?: Array<{
+        id: string;
+        function?: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    reasoning?: string | null;
+    reasoningDetails?: unknown[];
+};
 type ChatCompletionToolCallParam = {
     id: string;
     type: "function";

package/dist/history/transformers.js

@@ -5,7 +5,7 @@
  * Transform between normalized HistoryEntry format and provider-specific formats.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = void 0;
+exports.openRouterTransformer = exports.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = void 0;
 const types_1 = require("./types");
 // =============================================================================
 // Anthropic Transformer
@@ -759,4 +759,159 @@ exports.chatCompletionsTransformer = {
         };
     },
 };
+// =============================================================================
+// OpenRouter Transformer
+// =============================================================================
+/**
+ * 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.
+ */
+exports.openRouterTransformer = {
+    /**
+     * Convert normalized entries to OpenRouter message format.
+     * Tool results become role:"tool" messages; tool calls ride on the assistant message.
+     */
+    toProvider(entries) {
+        const messages = [];
+        for (const entry of entries) {
+            const textBlocks = entry.content.filter(types_1.isTextContent);
+            const toolUseBlocks = entry.content.filter(types_1.isToolUseContent);
+            const toolResultBlocks = entry.content.filter(types_1.isToolResultContent);
+            const thinkingBlocks = entry.content.filter(types_1.isThinkingContent);
+            const imageUrlBlocks = entry.content.filter(types_1.isImageUrlContent);
+            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"),
+                });
+                continue;
+            }
+            if (entry.role === "assistant") {
+                const msg = {
+                    role: "assistant",
+                    content: textBlocks.map((c) => c.text).join("\n") || null,
+                };
+                const reasoning = thinkingBlocks
+                    .map((block) => block.thinking)
+                    .filter((thought) => thought.length > 0)
+                    .join("\n");
+                if (reasoning) {
+                    msg.reasoning = reasoning;
+                }
+                // The signed/encrypted blocks matter more than the text: OpenRouter
+                // rebuilds the upstream provider's native thinking blocks from these,
+                // 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 ?? []);
+                if (reasoningDetails.length > 0) {
+                    msg.reasoningDetails = reasoningDetails;
+                }
+                if (toolUseBlocks.length > 0) {
+                    msg.toolCalls = toolUseBlocks.map((block) => ({
+                        id: block.id,
+                        type: "function",
+                        function: {
+                            name: block.name,
+                            arguments: JSON.stringify(block.input),
+                        },
+                    }));
+                }
+                messages.push(msg);
+                continue;
+            }
+            // User role — text, images, or tool results
+            if (toolResultBlocks.length > 0) {
+                for (const result of toolResultBlocks) {
+                    messages.push({
+                        role: "tool",
+                        toolCallId: result.tool_use_id,
+                        content: result.content,
+                    });
+                }
+            }
+            else if (hasImages) {
+                const parts = [];
+                for (const block of entry.content) {
+                    if ((0, types_1.isTextContent)(block)) {
+                        parts.push({ type: "text", text: block.text });
+                    }
+                    else if ((0, types_1.isImageUrlContent)(block)) {
+                        parts.push({
+                            type: "image_url",
+                            imageUrl: {
+                                url: block.url,
+                                ...(block.detail ? { detail: block.detail } : {}),
+                            },
+                        });
+                    }
+                    else if ((0, types_1.isImageBase64Content)(block)) {
+                        parts.push({
+                            type: "image_url",
+                            imageUrl: { url: `data:${block.mimeType};base64,${block.data}` },
+                        });
+                    }
+                }
+                messages.push({ role: "user", content: parts });
+            }
+            else if (textBlocks.length > 0) {
+                messages.push({
+                    role: "user",
+                    content: textBlocks.map((c) => c.text).join("\n"),
+                });
+            }
+        }
+        return messages;
+    },
+    /**
+     * Convert an OpenRouter assistant message to a normalized HistoryEntry.
+     */
+    fromProviderMessage(message) {
+        const content = [];
+        // Reasoning first, matching the order the model produced it in. Both the
+        // plain text and the opaque details are kept: the text is what a caller
+        // reads, the details are what the next request has to echo back.
+        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));
+        }
+        if (typeof message.content === "string" && message.content) {
+            content.push((0, types_1.text)(message.content));
+        }
+        if (message.toolCalls) {
+            message.toolCalls.forEach((call) => {
+                if (!call.function)
+                    return;
+                const args = JSON.parse(call.function.arguments || "{}");
+                content.push((0, types_1.toolUse)(call.id, call.function.name, args));
+            });
+        }
+        return {
+            role: "assistant",
+            content,
+            meta: { provider: "openrouter" },
+        };
+    },
+    /**
+     * Create a normalized tool result entry for an OpenRouter tool call
+     */
+    toolResultEntry(tool_call_id, output) {
+        return {
+            role: "user",
+            content: [(0, types_1.toolResult)(tool_call_id, output)],
+            meta: { provider: "openrouter", tool_call_id },
+        };
+    },
+};
 //# sourceMappingURL=transformers.js.map

package/dist/history/types.d.ts

@@ -51,6 +51,19 @@ export type ThinkingContent = {
     thinking: string;
     signature?: string;
     redactedData?: string;
+    /**
+     * Provider-opaque reasoning blocks that have to be echoed back verbatim.
+     *
+     * OpenRouter returns `reasoning_details` beside the plain `reasoning` text and
+     * requires them back on the next request — the `reasoning.encrypted` variant
+     * carries the upstream provider's signed thinking (Anthropic's `signature`,
+     * OpenAI's encrypted reasoning), which cannot be reconstructed from the text.
+     * Dropping them makes a multi-turn tool call fail on those models.
+     *
+     * 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.
+     */
+    reasoningDetails?: unknown[];
 };
 /**
  * Supported image MIME types across all providers
@@ -124,10 +137,17 @@ export type LlamaCppMeta = {
     provider: "llamacpp";
     tool_call_id?: string;
 };
+/**
+ * OpenRouter-specific metadata
+ */
+export type OpenRouterMeta = {
+    provider: "openrouter";
+    tool_call_id?: string;
+};
 /**
  * Union of all provider metadata types
  */
-export type ProviderMeta = AnthropicMeta | OpenAiMeta | MistralMeta | GeminiMeta | OllamaMeta | LlamaCppMeta;
+export type ProviderMeta = AnthropicMeta | OpenAiMeta | MistralMeta | GeminiMeta | OllamaMeta | LlamaCppMeta | OpenRouterMeta;
 /**
  * Valid roles for history entries
  */
@@ -187,7 +207,7 @@ 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): ThinkingContent;
+export declare function thinking(thinkingText: string, signature?: string, redactedData?: string, reasoningDetails?: unknown[]): ThinkingContent;
 /**
  * Create a tool result content block
  */

package/dist/history/types.js

@@ -70,8 +70,19 @@ function toolUse(id, name, input, thoughtSignature) {
 /**
  * Create a thinking content block. Pass `redactedData` for redacted thinking.
  */
-function thinking(thinkingText, signature, redactedData) {
-    return { type: "thinking", thinking: thinkingText, signature, redactedData };
+function thinking(thinkingText, signature, redactedData, reasoningDetails) {
+    // 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.
+    return {
+        type: "thinking",
+        thinking: thinkingText,
+        signature,
+        redactedData,
+        ...(reasoningDetails && reasoningDetails.length > 0
+            ? { reasoningDetails }
+            : {}),
+    };
 }
 /**
  * Create a tool result content block

package/dist/index.d.ts

@@ -11,6 +11,9 @@ export { LlamaCppAgent } from "./agents/llamacpp/LlamaCppAgent";
 export type { LlamaCppModelCard, LlamaCppModelMeta, } from "./agents/llamacpp/LlamaCppAgent";
 export { OpenAICompatibleAgent } from "./agents/openai-compatible/OpenAICompatibleAgent";
 export type { OpenAICompatibleConfig, StreamChunk } from "./agents/openai-compatible/OpenAICompatibleAgent";
+export { OpenRouterAgent } from "./agents/openrouter/OpenRouterAgent";
+export type { OpenRouterConfig, OpenRouterModelCard, } from "./agents/openrouter/OpenRouterAgent";
+export type { OpenRouterProviderPreferences, OpenRouterProviderSort, OpenRouterMaxPrice, OpenRouterReasoningConfig, OpenRouterReasoningEffort, OpenRouterRetryConfig, OpenRouterGenerationInfo, } from "./agents/openrouter/types";
 export * from "./agents/model-types";
 export * from "./agents/AgentConfig";
 export * from "./agents/AgentEvent";
@@ -18,7 +21,7 @@ export * from "./agents/errors/AgentError";
 export * from "./agents/cancellation";
 export * from "./history/History";
 export * from "./history/types";
-export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, ollamaTransformer, chatCompletionsTransformer, } from "./history/transformers";
+export { anthropicTransformer, openAiTransformer, mistralTransformer, geminiTransformer, ollamaTransformer, chatCompletionsTransformer, openRouterTransformer, } from "./history/transformers";
 export * from "./graph/AgentGraph";
 export * from "./tools/Tool";
 export * from "./tools/BuiltInTool";

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.chatCompletionsTransformer = exports.ollamaTransformer = exports.geminiTransformer = exports.mistralTransformer = exports.openAiTransformer = exports.anthropicTransformer = exports.OpenAICompatibleAgent = exports.LlamaCppAgent = exports.OllamaAgent = exports.GEMINI_RETIRED_MODELS = exports.GeminiAgent = exports.MistralAgent = 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.OpenAiAgent = void 0;
 // Agents
 __exportStar(require("./agents/BaseAgent"), exports);
 __exportStar(require("./agents/anthropic/ClaudeAgent"), exports);
@@ -39,6 +39,8 @@ var LlamaCppAgent_1 = require("./agents/llamacpp/LlamaCppAgent");
 Object.defineProperty(exports, "LlamaCppAgent", { enumerable: true, get: function () { return LlamaCppAgent_1.LlamaCppAgent; } });
 var OpenAICompatibleAgent_1 = require("./agents/openai-compatible/OpenAICompatibleAgent");
 Object.defineProperty(exports, "OpenAICompatibleAgent", { enumerable: true, get: function () { return OpenAICompatibleAgent_1.OpenAICompatibleAgent; } });
+var OpenRouterAgent_1 = require("./agents/openrouter/OpenRouterAgent");
+Object.defineProperty(exports, "OpenRouterAgent", { enumerable: true, get: function () { return OpenRouterAgent_1.OpenRouterAgent; } });
 __exportStar(require("./agents/model-types"), exports);
 __exportStar(require("./agents/AgentConfig"), exports);
 __exportStar(require("./agents/AgentEvent"), exports);
@@ -54,6 +56,7 @@ Object.defineProperty(exports, "mistralTransformer", { enumerable: true, get: fu
 Object.defineProperty(exports, "geminiTransformer", { enumerable: true, get: function () { return transformers_1.geminiTransformer; } });
 Object.defineProperty(exports, "ollamaTransformer", { enumerable: true, get: function () { return transformers_1.ollamaTransformer; } });
 Object.defineProperty(exports, "chatCompletionsTransformer", { enumerable: true, get: function () { return transformers_1.chatCompletionsTransformer; } });
+Object.defineProperty(exports, "openRouterTransformer", { enumerable: true, get: function () { return transformers_1.openRouterTransformer; } });
 // Graph
 __exportStar(require("./graph/AgentGraph"), exports);
 // Tools

package/dist/openrouter.d.ts

@@ -0,0 +1,6 @@
+export * from "./core";
+export { OpenRouterAgent } from "./agents/openrouter/OpenRouterAgent";
+export type { OpenRouterConfig, OpenRouterModelCard, StreamChunk, } from "./agents/openrouter/OpenRouterAgent";
+export type { OpenRouterProviderPreferences, OpenRouterProviderSort, OpenRouterMaxPrice, OpenRouterReasoningConfig, OpenRouterReasoningEffort, OpenRouterRetryConfig, OpenRouterGenerationInfo, } from "./agents/openrouter/types";
+export { openRouterTransformer } from "./history/transformers";
+//# sourceMappingURL=openrouter.d.ts.map

package/dist/openrouter.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.OpenRouterAgent = void 0;
+// OpenRouter Agent Entry Point
+__exportStar(require("./core"), exports);
+var OpenRouterAgent_1 = require("./agents/openrouter/OpenRouterAgent");
+Object.defineProperty(exports, "OpenRouterAgent", { enumerable: true, get: function () { return OpenRouterAgent_1.OpenRouterAgent; } });
+var transformers_1 = require("./history/transformers");
+Object.defineProperty(exports, "openRouterTransformer", { enumerable: true, get: function () { return transformers_1.openRouterTransformer; } });
+//# sourceMappingURL=openrouter.js.map

package/dist/viz/types.d.ts

@@ -2,7 +2,7 @@
  * Visualization event types and interfaces for agent monitoring.
  * These types define the contract between agention-lib and @agention/viz.
  */
-export type VizVendor = "anthropic" | "openai" | "mistral" | "gemini" | "ollama" | "llamacpp";
+export type VizVendor = "anthropic" | "openai" | "mistral" | "gemini" | "ollama" | "llamacpp" | "openrouter";
 export type VizEventType = "session.start" | "session.end" | "pipeline.start" | "pipeline.end" | "executor.start" | "executor.end" | "agent.start" | "agent.complete" | "agent.error" | "tool.start" | "tool.complete" | "tool.error" | "message.user" | "message.assistant";
 export type VizExecutorType = "sequential" | "parallel" | "map" | "voting" | "router";
 export type VizStopReason = "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | "error";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentionai/agents",
   "author": "Laurent Zuijdwijk",
-  "version": "1.7.0-beta.0",
+  "version": "1.8.0",
   "description": "Agent Library",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,6 +38,10 @@
       "types": "./dist/llamacpp.d.ts",
       "default": "./dist/llamacpp.js"
     },
+    "./openrouter": {
+      "types": "./dist/openrouter.d.ts",
+      "default": "./dist/openrouter.js"
+    },
     "./embeddings": {
       "types": "./dist/embeddings/index.d.ts",
       "default": "./dist/embeddings/index.js"
@@ -114,6 +118,7 @@
     "@lancedb/lancedb": "^0.23.0",
     "@mistralai/mistralai": "^1.13.0",
     "@modelcontextprotocol/sdk": "^1.30.0",
+    "@openrouter/sdk": "^1.2.37",
     "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
     "apache-arrow": "^18.1.0",
@@ -145,6 +150,7 @@
     "@lancedb/lancedb": "^0.23.0",
     "@mistralai/mistralai": "^1.13.0",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@openrouter/sdk": "^1.2.29",
     "apache-arrow": "^18.0.0",
     "ollama": "^0.5.18",
     "openai": "^6.16.0",
@@ -180,6 +186,9 @@
     },
     "ollama": {
       "optional": true
+    },
+    "@openrouter/sdk": {
+      "optional": true
     }
   },
   "dependencies": {