@agentionai/agents 1.7.0-beta.0 → 1.8.0

package/dist/agents/openrouter/OpenRouterAgent.js

@@ -0,0 +1,754 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenRouterAgent = void 0;
+exports.defaultHeadersHook = defaultHeadersHook;
+exports.parseRetryAfter = parseRetryAfter;
+exports.parseResetAt = parseResetAt;
+const BaseAgent_1 = require("../BaseAgent");
+const AgentEvent_1 = require("../AgentEvent");
+const cancellation_1 = require("../cancellation");
+const AgentError_1 = require("../errors/AgentError");
+const transformers_1 = require("../../history/transformers");
+const VizReporter_1 = require("../../viz/VizReporter");
+const VizConfig_1 = require("../../viz/VizConfig");
+/**
+ * Retry policy the agent applies when the config does not name one.
+ *
+ * `@openrouter/sdk` already knows how to honour `Retry-After` and
+ * `retry-after-ms` (`lib/retries.js`), but `chat.send()` defaults to
+ * `retryCodes: ["5XX"]`, so a 429 never reaches that code — and its default
+ * `maxElapsedTime` is 3_600_000, an hour-long retry loop. Both are replaced
+ * here; see {@link OpenRouterSpecificConfig.retry}.
+ */
+const DEFAULT_RETRY = {
+    strategy: "backoff",
+    backoff: {
+        initialInterval: 500,
+        maxInterval: 30000,
+        exponent: 1.5,
+        // Two minutes: long enough to sit out a couple of `Retry-After` waits on a
+        // per-minute limit, short enough that a daily quota (whose reset is hours
+        // away) fails fast instead of blocking the run. Use `models` fallbacks for
+        // that case, not a longer wait.
+        maxElapsedTime: 120000,
+    },
+    retryConnectionErrors: true,
+};
+/** Status codes retried by default. `429` is the one the SDK omits. */
+const DEFAULT_RETRY_CODES = ["408", "409", "429", "5XX"];
+/**
+ * Build a `beforeRequest` hook that adds custom headers to every request.
+ *
+ * `@openrouter/sdk` has no `defaultHeaders` option like the Anthropic and
+ * OpenAI clients, so headers are injected at the HTTP layer instead. They
+ * overwrite headers the SDK already set, so that `defaultHeaders` means the
+ * same thing on every provider — see `CommonAgentConfig.defaultHeaders`.
+ *
+ * `httpReferer` / `appTitle` are a separate OpenRouter attribution path
+ * (`HTTP-Referer` / `X-Title`). They are not a substitute for tracing or
+ * gateway headers.
+ */
+function defaultHeadersHook(headers) {
+    return (request) => {
+        for (const [name, value] of Object.entries(headers)) {
+            request.headers.set(name, value);
+        }
+    };
+}
+/**
+ * Agent backed by [OpenRouter](https://openrouter.ai) via the official
+ * `@openrouter/sdk`, giving one API key access to models from every provider it
+ * fronts.
+ *
+ * Beyond what an OpenAI-compatible endpoint offers, this agent exposes
+ * OpenRouter's routing controls — `models` fallbacks, `provider` preferences —
+ * reports the credit cost of each run on {@link lastGeneration}, and round-trips
+ * `reasoning_details` so multi-turn tool calls work on reasoning models whose
+ * thinking blocks are signed.
+ *
+ * @requires @openrouter/sdk - Install as a peer dependency:
+ * ```bash
+ * npm install @openrouter/sdk
+ * ```
+ * The SDK is ESM-only, so it is loaded through a dynamic import. On CommonJS
+ * that needs Node 20.19+ or 22.12+, where `require()` of an ES module works.
+ *
+ * @example
+ * ```typescript
+ * const agent = new OpenRouterAgent({
+ *   id: "router",
+ *   name: "Router",
+ *   description: "Answers questions",
+ *   apiKey: process.env.OPENROUTER_API_KEY!,
+ *   model: "anthropic/claude-opus-4-20250514",
+ *   models: ["openai/gpt-5.6"],          // used if the primary is rate limited
+ *   provider: { sort: "throughput" },
+ * });
+ *
+ * const answer = await agent.execute("Explain recursion");
+ * console.log(agent.lastGeneration?.cost, "credits");
+ * ```
+ */
+class OpenRouterAgent extends BaseAgent_1.BaseAgent {
+    constructor(config, history) {
+        super({ ...config, vendor: "openrouter" }, history);
+        this.currentToolCallCount = 0;
+        // Flat config wins over the nested form, matching the other agents.
+        const nested = config.vendorConfig?.openrouter ?? {};
+        this.config = {
+            ...config,
+            vendor: "openrouter",
+            model: config.model || "openrouter/auto",
+            models: config.models ?? nested.models,
+            provider: config.provider ?? nested.provider,
+            retry: config.retry ?? nested.retry,
+            retryCodes: config.retryCodes ?? nested.retryCodes,
+            reasoning: config.reasoning ?? nested.reasoning,
+            plugins: config.plugins ?? nested.plugins,
+            sessionId: config.sessionId ?? nested.sessionId,
+            user: config.user ?? nested.user,
+            serviceTier: config.serviceTier ?? nested.serviceTier,
+            httpReferer: config.httpReferer ?? nested.httpReferer,
+            appTitle: config.appTitle ?? nested.appTitle,
+            disableParallelToolUse: config.disableParallelToolUse ?? nested.disableParallelToolUse,
+        };
+        this.model = this.config.model;
+        this.addSystemMessage(this.getSystemMessage());
+    }
+    /**
+     * Load `@openrouter/sdk` and construct the client, once per agent.
+     *
+     * The specifier goes through a variable so TypeScript does not resolve it at
+     * build time, which keeps the dependency genuinely optional — the same
+     * approach `MCPClient` uses. The promise is memoized including its rejection,
+     * so a missing package reports the install hint on every call rather than
+     * retrying the import.
+     */
+    getClient() {
+        if (!this.clientPromise) {
+            this.clientPromise = this.createClient();
+        }
+        return this.clientPromise;
+    }
+    async createClient() {
+        const pkg = "@openrouter/sdk";
+        let OpenRouter;
+        let HTTPClient;
+        try {
+            ({ OpenRouter, HTTPClient } = (await Promise.resolve(`${pkg}`).then(s => __importStar(require(s)))));
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`OpenRouterAgent requires the '@openrouter/sdk' package. Install it with: npm install @openrouter/sdk` +
+                `\nUnderlying error: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        let httpClient;
+        if (this.config.defaultHeaders) {
+            httpClient = new HTTPClient();
+            httpClient.addHook("beforeRequest", defaultHeadersHook(this.config.defaultHeaders));
+        }
+        return new OpenRouter({
+            apiKey: this.config.apiKey,
+            ...(this.config.baseURL ? { serverURL: this.config.baseURL } : {}),
+            ...(this.config.httpReferer ? { httpReferer: this.config.httpReferer } : {}),
+            ...(this.config.appTitle ? { appTitle: this.config.appTitle } : {}),
+            ...(this.config.timeout ? { timeoutMs: this.config.timeout } : {}),
+            ...(this.config.debug ? { debugLogger: console } : {}),
+            ...(httpClient ? { httpClient } : {}),
+        });
+    }
+    getToolDefinitions() {
+        return Array.from(this.tools.values()).map((tool) => {
+            const prompt = tool.getPrompt();
+            return {
+                type: "function",
+                function: {
+                    name: prompt.name,
+                    description: prompt.description,
+                    parameters: prompt.input_schema,
+                },
+            };
+        });
+    }
+    async process(_input) {
+        return "";
+    }
+    /**
+     * List the models OpenRouter offers, following pagination to the end.
+     *
+     * Fills `contextLength`, `maxOutputTokens` and `capabilities` from
+     * OpenRouter's own metadata: `supported_parameters` says whether a model takes
+     * `tools` and `reasoning`, and `architecture.input_modalities` whether it
+     * accepts images. Per-token pricing is on `raw.pricing`.
+     */
+    async listModels() {
+        try {
+            const client = await this.getClient();
+            const result = await client.models.list();
+            const models = [];
+            for await (const page of result) {
+                // `models.list()` yields GetModelsResponse: `{ result: { data, links, totalCount } }`.
+                const entries = page?.result?.data ?? [];
+                for (const card of entries) {
+                    const params = card.supportedParameters ?? [];
+                    const modalities = card.architecture?.inputModalities ?? [];
+                    models.push({
+                        id: card.id,
+                        displayName: card.name,
+                        created: card.created ? new Date(card.created * 1000) : undefined,
+                        contextLength: card.contextLength ?? card.topProvider?.contextLength ?? undefined,
+                        maxOutputTokens: card.topProvider?.maxCompletionTokens ?? undefined,
+                        capabilities: {
+                            chat: true,
+                            tools: params.includes("tools"),
+                            vision: modalities.includes("image"),
+                            thinking: params.includes("reasoning") || params.includes("include_reasoning"),
+                        },
+                        raw: card,
+                    });
+                }
+            }
+            return models;
+        }
+        catch (error) {
+            throw new AgentError_1.ExecutionError(`Failed to list OpenRouter models: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async execute(input, options) {
+        this.beginRun(input);
+        try {
+            const response = await this.callProvider(options);
+            this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, response);
+            return await this.handleResponse(response, options);
+        }
+        catch (error) {
+            throw this.failRun(error, options);
+        }
+        finally {
+            this.history.endExecution();
+        }
+    }
+    /**
+     * Stream a response as an async generator of {@link StreamChunk} objects.
+     *
+     * Tool calls are executed transparently — the generator keeps streaming after
+     * each tool-call round trip.
+     */
+    async *executeStream(input, options) {
+        this.beginRun(input);
+        try {
+            yield* this.streamTurn(options);
+        }
+        catch (error) {
+            throw this.failRun(error, options);
+        }
+        finally {
+            this.history.endExecution();
+        }
+    }
+    /** Shared setup for `execute()` and `executeStream()`. */
+    beginRun(input) {
+        this.emit(AgentEvent_1.AgentEvent.BEFORE_EXECUTE, input);
+        this.resetTokenUsage();
+        this.lastGeneration = undefined;
+        this.currentToolCallCount = 0;
+        if (VizConfig_1.vizConfig.isEnabled()) {
+            this.vizEventId = VizReporter_1.vizReporter.agentStart(this.id, this.name, this.config.model, this.vendor, typeof input === "string" ? input : JSON.stringify(input));
+        }
+        if (this.history.transient) {
+            this.history.clear();
+            this.addSystemMessage(this.getSystemMessage());
+        }
+        if (typeof input === "string") {
+            this.addTextToHistory("user", input);
+        }
+        else {
+            this.addMessageToHistory("user", input);
+        }
+        this.history.setSessionAnchor();
+        this.history.beginExecution();
+    }
+    /**
+     * Map whatever a run threw onto this library's error types, emit it, and close
+     * any open visualization event. Returns the error for the caller to throw.
+     */
+    failRun(error, options) {
+        // The abort branch comes first and keys off the signal rather than the
+        // error's name, so a cancellation still surfaces as an AbortError even when
+        // an inner catch already wrapped it.
+        if ((0, cancellation_1.isAbortError)(error, options?.signal)) {
+            const abortError = this.abortError(error, options?.signal);
+            this.closeViz("AbortError", abortError.message, false);
+            return 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;
+    }
+    /**
+     * Turn an `@openrouter/sdk` error into an {@link AgentError}.
+     *
+     * The SDK throws one class per status code, all extending `OpenRouterError`
+     * with `statusCode`, `headers` and `body`. Rather than importing those classes
+     * — which would make the optional peer dependency mandatory — this reads the
+     * shape structurally.
+     */
+    mapProviderError(error) {
+        if (error instanceof AgentError_1.AgentError)
+            return error;
+        const err = error;
+        if (typeof err?.statusCode === "number") {
+            const message = unwrapOpenRouterMessage(parseOpenRouterErrorBody(err.body), err.message ?? "Unknown error");
+            if (err.statusCode === 429) {
+                return this.rateLimitError(err, message);
+            }
+            return new AgentError_1.ApiError(`OpenRouter API error: ${message}`, err.statusCode, error);
+        }
+        return new AgentError_1.ExecutionError(`OpenRouter error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    /**
+     * Build a {@link RateLimitError} from a 429, lifting OpenRouter's rate-limit
+     * headers onto it. They are only present on OpenRouter's own platform limits —
+     * a 429 passed through from an upstream provider carries neither, which is why
+     * every field is optional.
+     */
+    rateLimitError(err, message) {
+        const headers = err.headers;
+        const num = (name) => {
+            const raw = headers?.get(name);
+            if (!raw)
+                return undefined;
+            const parsed = Number(raw);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        };
+        // `Retry-After` is defined by RFC 9110 as either delay-seconds or an
+        // HTTP-date. OpenRouter sends the numeric form, but the date form is
+        // legal and costs one branch to accept.
+        const retryAfterRaw = headers?.get("retry-after");
+        const retryAfterMs = parseRetryAfter(retryAfterRaw);
+        return new AgentError_1.RateLimitError(`OpenRouter rate limit: ${message}`, retryAfterMs, num("x-ratelimit-limit"), num("x-ratelimit-remaining"), parseResetAt(num("x-ratelimit-reset")), err);
+    }
+    closeViz(name, message, throttled) {
+        if (!this.vizEventId)
+            return;
+        VizReporter_1.vizReporter.agentError(this.vizEventId, name, message, throttled);
+        this.vizEventId = undefined;
+    }
+    /**
+     * Wrap a `ChatRequest` in the envelope `@openrouter/sdk` `chat.send()` expects.
+     * Passing the body bare fails Speakeasy validation (`Input validation failed`).
+     */
+    sendRequest(stream) {
+        return {
+            chatRequest: this.buildRequest(stream),
+            ...(this.config.httpReferer ? { httpReferer: this.config.httpReferer } : {}),
+            ...(this.config.appTitle ? { appTitle: this.config.appTitle } : {}),
+        };
+    }
+    /** The `ChatRequest` body, identical for the streaming and buffered paths. */
+    buildRequest(stream) {
+        const messages = transformers_1.openRouterTransformer.toProvider(this.history.getEntries());
+        const tools = this.tools.size > 0 ? this.getToolDefinitions() : undefined;
+        return {
+            model: this.config.model,
+            messages,
+            stream,
+            // Ask for usage in the stream. Without this OpenRouter often omits the
+            // `usage` chunk, leaving `lastTokenUsage` / `lastGeneration.cost` empty
+            // on `executeStream()` — same option the OpenAI-compatible agent sends.
+            ...(stream ? { stream_options: { include_usage: true } } : {}),
+            ...(tools ? { tools } : {}),
+            ...(this.config.models?.length ? { models: this.config.models } : {}),
+            ...(this.config.provider ? { provider: this.config.provider } : {}),
+            ...(this.config.reasoning ? { reasoning: this.config.reasoning } : {}),
+            ...(this.config.plugins?.length ? { plugins: this.config.plugins } : {}),
+            ...(this.config.sessionId ? { sessionId: this.config.sessionId } : {}),
+            ...(this.config.user ? { user: this.config.user } : {}),
+            ...(this.config.serviceTier ? { serviceTier: this.config.serviceTier } : {}),
+            ...(this.config.disableParallelToolUse !== undefined
+                ? { parallelToolCalls: !this.config.disableParallelToolUse }
+                : {}),
+            maxTokens: this.config.maxTokens,
+            temperature: this.config.temperature,
+            topP: this.config.topP,
+            topK: this.config.topK,
+            stop: this.config.stopSequences,
+            seed: this.config.seed,
+            presencePenalty: this.config.presencePenalty,
+            frequencyPenalty: this.config.frequencyPenalty,
+        };
+    }
+    /**
+     * Per-request options: the cancellation signal plus the retry policy.
+     *
+     * `retryCodes` has to be passed on every call — the SDK reads it only from the
+     * call options, never from the client's, so setting it once at construction
+     * would silently do nothing.
+     */
+    requestOptions(options) {
+        return {
+            ...(options?.signal ? { signal: options.signal } : {}),
+            retries: this.config.retry ?? DEFAULT_RETRY,
+            retryCodes: this.config.retryCodes ?? DEFAULT_RETRY_CODES,
+            // Ask OpenRouter to include `openrouter_metadata` (attempt count, etc.)
+            // in the response. It only does so when the header is present, and default
+            // is off — without it `openrouterMetadata` never appears.
+            headers: { "X-OpenRouter-Metadata": "1" },
+        };
+    }
+    async callProvider(options) {
+        const client = await this.getClient();
+        this.startTurnTimer();
+        return client.chat.send(this.sendRequest(false), this.requestOptions(options));
+    }
+    async handleResponse(response, options) {
+        const usage = this.accumulateUsage(this.parseUsage(response));
+        this.recordGeneration(response);
+        const choice = response?.choices?.[0];
+        // OpenRouter can report a provider failure inside a 200 body rather than as
+        // an HTTP error, with whatever text was generated before it failed. Without
+        // this the run would look like a successful short answer.
+        if (!choice) {
+            throw new AgentError_1.ExecutionError(`OpenRouter returned no choices: ${response?.error?.message ?? "empty response"}`);
+        }
+        if (choice.finishReason === "error") {
+            throw new AgentError_1.ApiError(`OpenRouter provider error mid-generation: ${response?.error?.message ?? "no message"}`, response?.error?.code, response);
+        }
+        const message = choice.message ?? {};
+        if (choice.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;
+        }
+        const toolCalls = message.toolCalls ?? [];
+        if (toolCalls.length === 0) {
+            const textContent = message.content || "";
+            this.addToHistory(transformers_1.openRouterTransformer.fromProviderMessage(message));
+            this.emit(AgentEvent_1.AgentEvent.DONE, message, usage);
+            this.completeViz(textContent);
+            return textContent;
+        }
+        // Stop before the assistant turn is written: bailing out here avoids both
+        // running the tools' side effects and leaving a tool call in history with no
+        // tool message to answer it.
+        (0, cancellation_1.throwIfAborted)(options?.signal, `Execution of agent ${this.getName()}`);
+        this.emit(AgentEvent_1.AgentEvent.TOOL_USE, toolCalls);
+        this.currentToolCallCount += toolCalls.length;
+        this.addToHistory(transformers_1.openRouterTransformer.fromProviderMessage(message));
+        const toolResults = await this.handleToolCalls(toolCalls, options);
+        for (const result of toolResults) {
+            this.addToHistory(transformers_1.openRouterTransformer.toolResultEntry(result.toolCallId, result.content));
+        }
+        const newResponse = await this.callProvider(options);
+        this.emit(AgentEvent_1.AgentEvent.AFTER_EXECUTE, newResponse);
+        return this.handleResponse(newResponse, options);
+    }
+    async *streamTurn(options) {
+        const client = await this.getClient();
+        this.startTurnTimer();
+        const stream = await client.chat.send(this.sendRequest(true), this.requestOptions(options));
+        let textContent = "";
+        let reasoningContent = "";
+        let reasoningDetails = [];
+        const toolCallAcc = new Map();
+        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 };
+            }
+            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;
+                }
+            }
+        }
+        // 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);
+            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));
+            }
+            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) {
+        return Promise.all(toolCalls.map(async (toolCall) => {
+            const toolName = toolCall.function?.name ?? "";
+            const tool = this.tools.get(toolName);
+            const toolCallId = toolCall.id;
+            if (!toolCall.function || !tool) {
+                const errorMessage = `Tool '${toolName}' not found`;
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.function?.arguments));
+                return { toolCallId, content: errorMessage };
+            }
+            try {
+                const args = JSON.parse(toolCall.function.arguments || "{}");
+                const result = await tool.execute(this.getId(), this.getName(), args, toolCallId, this.config.model, this.vendor, { signal: options?.signal });
+                return { toolCallId, content: JSON.stringify(result) };
+            }
+            catch (error) {
+                const errorMessage = `Error executing tool '${toolName}': ${error instanceof Error ? error.message : "Unknown error"}`;
+                if (this.debug) {
+                    console.error(errorMessage);
+                }
+                this.emit(AgentEvent_1.AgentEvent.TOOL_ERROR, new AgentError_1.ToolExecutionError(errorMessage, toolName, toolCall.function.arguments));
+                return { toolCallId, content: errorMessage };
+            }
+        }));
+    }
+    /**
+     * Fold one API call's cost and routing facts into {@link lastGeneration}.
+     * Cost is summed — a tool loop bills once per hop — while the id and model
+     * describe the most recent call.
+     */
+    recordGeneration(response) {
+        const cost = response?.usage?.cost;
+        const previous = this.lastGeneration;
+        this.lastGeneration = {
+            id: response?.id ?? previous?.id,
+            model: response?.model ?? previous?.model,
+            cost: typeof cost === "number"
+                ? (previous?.cost ?? 0) + cost
+                : previous?.cost,
+            isByok: response?.usage?.isByok ?? previous?.isByok,
+            attempts: response?.openrouterMetadata?.attempt ?? previous?.attempts,
+        };
+    }
+    parseUsage(response) {
+        return this.parseUsageObject(response?.usage);
+    }
+    parseUsageObject(usage) {
+        return {
+            input_tokens: usage?.promptTokens ?? 0,
+            output_tokens: usage?.completionTokens ?? 0,
+            total_tokens: usage?.totalTokens ?? 0,
+            reasoning_tokens: usage?.completionTokensDetails?.reasoningTokens ?? undefined,
+        };
+    }
+    completeViz(textContent) {
+        if (!this.vizEventId)
+            return;
+        VizReporter_1.vizReporter.agentComplete(this.vizEventId, {
+            input: this.lastTokenUsage?.input_tokens || 0,
+            output: this.lastTokenUsage?.output_tokens || 0,
+            total: this.lastTokenUsage?.total_tokens || 0,
+        }, "end_turn", this.currentToolCallCount > 0, this.currentToolCallCount, textContent);
+        this.vizEventId = undefined;
+    }
+}
+exports.OpenRouterAgent = OpenRouterAgent;
+/**
+ * Milliseconds to wait from a `Retry-After` header.
+ *
+ * RFC 9110 allows two forms — delay-seconds (`120`) and an HTTP-date
+ * (`Wed, 21 Oct 2026 07:28:00 GMT`). OpenRouter sends the first; the second is
+ * accepted because it is legal and cheap to support. A date already in the past
+ * yields `0` rather than a negative wait.
+ *
+ * @returns The delay in milliseconds, or `undefined` when the header is absent
+ *          or unparseable.
+ */
+function parseRetryAfter(raw) {
+    if (!raw)
+        return undefined;
+    const seconds = Number(raw);
+    if (Number.isFinite(seconds)) {
+        return Math.max(0, seconds * 1000);
+    }
+    const date = Date.parse(raw);
+    if (Number.isFinite(date)) {
+        return Math.max(0, date - Date.now());
+    }
+    return undefined;
+}
+/**
+ * The instant an `X-RateLimit-Reset` header points at.
+ *
+ * OpenRouter documents that the header exists but not what is in it, and the
+ * three encodings in common use across APIs are indistinguishable by type — so
+ * they are told apart by magnitude, taking "the answer is somewhere near now" as
+ * the tiebreaker:
+ *
+ * - below `10^9` — a duration in seconds from now (a literal epoch would be
+ *   before 2001, which no live API means)
+ * - below `10^11` — Unix **seconds** (`10^11` seconds is the year 5138, so
+ *   anything under it is a plausible timestamp and anything over it is not)
+ * - otherwise — Unix **milliseconds**
+ *
+ * Returns `undefined` for a missing or non-finite value, so callers see "not
+ * reported" rather than a date in 1970. Prefer
+ * {@link RateLimitError.retryAfterMs} when both are present: it is unambiguous.
+ */
+function parseResetAt(value) {
+    if (value === undefined || !Number.isFinite(value) || value < 0) {
+        return undefined;
+    }
+    if (value < 1e9)
+        return new Date(Date.now() + value * 1000);
+    if (value < 1e11)
+        return new Date(value * 1000);
+    return new Date(value);
+}
+/**
+ * Parse an OpenRouter HTTP error body (`OpenRouterError.body`) down to its
+ * `error` field. Returns `undefined` for a missing or non-JSON body rather
+ * than throwing, since a malformed body is itself just something to fall back
+ * from, not a reason to lose the original error.
+ */
+function parseOpenRouterErrorBody(body) {
+    if (!body)
+        return undefined;
+    try {
+        return JSON.parse(body)?.error;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Best-effort extraction of the most specific message an OpenRouter error
+ * payload carries, unwrapping `metadata.raw` when present. `raw` holds the
+ * upstream provider's exact error text (e.g. OpenAI's own `{error: {message}}`
+ * shape) — falls back to the payload's own `message`, then to `fallback`, so an
+ * unfamiliar or non-JSON `raw` still yields something rather than throwing.
+ */
+function unwrapOpenRouterMessage(payload, fallback) {
+    const topMessage = payload?.message ?? fallback;
+    const raw = payload?.metadata?.raw;
+    if (typeof raw !== "string" || !raw)
+        return topMessage;
+    try {
+        const parsedRaw = JSON.parse(raw);
+        const upstreamMessage = parsedRaw?.error?.message ?? parsedRaw?.message;
+        if (typeof upstreamMessage === "string" && upstreamMessage)
+            return upstreamMessage;
+    }
+    catch {
+        // Not JSON — some upstreams return plain text. Use it directly if short
+        // enough to be a message rather than a stack trace or HTML error page.
+        if (raw.length < 500)
+            return raw;
+    }
+    return topMessage;
+}
+//# sourceMappingURL=OpenRouterAgent.js.map