@dereekb/openrouter 13.38.0 → 13.40.0

package/index.cjs.js

@@ -1,1867 +0,0 @@
-'use strict';
-
-var util = require('@dereekb/util');
-var callModel = require('@openrouter/sdk/funcs/call-model');
-var responsesSend = require('@openrouter/sdk/funcs/responsesSend');
-var conversationState = require('@openrouter/sdk/lib/conversation-state');
-var embeddingsGenerate = require('@openrouter/sdk/funcs/embeddingsGenerate');
-var generationsGetGeneration = require('@openrouter/sdk/funcs/generationsGetGeneration');
-var generationsListGenerationContent = require('@openrouter/sdk/funcs/generationsListGenerationContent');
-var modelResult = require('@openrouter/sdk/lib/model-result');
-var tool = require('@openrouter/sdk/lib/tool');
-var toolExecutor = require('@openrouter/sdk/lib/tool-executor');
-var stopConditions = require('@openrouter/sdk/lib/stop-conditions');
-var toolTypes = require('@openrouter/sdk/lib/tool-types');
-
-function _array_like_to_array$1(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes$1(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array$1(arr);
-}
-function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator$2(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _define_property$2(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _iterable_to_array$1(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread$1() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _object_spread$2(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property$2(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys$1(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props$1(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys$1(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-function _object_without_properties$1(source, excluded) {
-    if (source == null) return {};
-    var target = {}, sourceKeys, key, i;
-    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
-        sourceKeys = Reflect.ownKeys(Object(source));
-        for(i = 0; i < sourceKeys.length; i++){
-            key = sourceKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-        return target;
-    }
-    target = _object_without_properties_loose$1(source, excluded);
-    if (Object.getOwnPropertySymbols) {
-        sourceKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceKeys.length; i++){
-            key = sourceKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-    }
-    return target;
-}
-function _object_without_properties_loose$1(source, excluded) {
-    if (source == null) return {};
-    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
-function _to_consumable_array$1(arr) {
-    return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
-}
-function _type_of(obj) {
-    "@swc/helpers - typeof";
-    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
-}
-function _unsupported_iterable_to_array$1(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
-}
-function _ts_generator$2(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
-    return d(g, "next", {
-        value: verb(0)
-    }), d(g, "throw", {
-        value: verb(1)
-    }), d(g, "return", {
-        value: verb(2)
-    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
-        value: function() {
-            return this;
-        }
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-}
-/**
- * Splits a model config into request parameters and execution controls.
- *
- * Forwarding one of ours is not harmless: OpenRouter validates the request body, so leaving `maxSteps` on
- * it risks a 400 on the whole call. Which keys are ours is expressed by naming them in a rest-destructure
- * rather than in a list of strings, so TypeScript checks the names against
- * {@link OpenRouterModelConfig} and a rename cannot leave a stale entry behind.
- *
- * @param config - The merged model config.
- * @returns The split config.
- */ function splitOpenRouterModelConfig(config) {
-    var _ref = config !== null && config !== void 0 ? config : {}, maxSteps = _ref.maxSteps, requestTimeoutMs = _ref.requestTimeoutMs, rest = _object_without_properties$1(_ref, [
-        "maxSteps",
-        "requestTimeoutMs"
-    ]);
-    return {
-        requestConfig: util.filterUndefinedValues(rest),
-        maxSteps: maxSteps,
-        requestTimeoutMs: requestTimeoutMs
-    };
-}
-/**
- * The hosted (server-executed) tool entries a config carries, e.g. `file_search`, `web_search`, `mcp`.
- *
- * These are NOT client tools and must never be handed to `callModel`: it destructures `tools` off the
- * request and runs every entry through `convertToolsToAPIFormat`, which reads `tool.function.name` — so
- * a hosted entry is dropped outright when no client tools are present and throws a
- * `Cannot read properties of undefined` from inside the SDK when they are. They are dispatched instead
- * by {@link sendOpenRouterResponsesRequest} or merged in after conversion by
- * {@link openRouterModelResultForRequest}.
- *
- * @param config - The merged model config.
- * @returns The hosted tool entries, or an empty array.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterHostedTools(config) {
-    var tools = config === null || config === void 0 ? void 0 : config.tools;
-    return Array.isArray(tools) ? tools : [];
-}
-/**
- * Converts a built request into the `/responses` request body.
- *
- * This is the whole wire body minus the SDK-only keys (`tools`/`state`/`stopWhen` on the `callModel`
- * path), so both dispatch paths assemble the request the same way and cannot drift.
- *
- * @param request - The built request.
- * @returns The request body, in the SDK's camelCase request surface.
- */ function openRouterResponsesRequestBody(request) {
-    var requestConfig = splitOpenRouterModelConfig(request.config).requestConfig;
-    return util.filterUndefinedValues(_object_spread_props$1(_object_spread$2({}, requestConfig), {
-        input: request.input,
-        instructions: request.instructions || undefined,
-        trace: request.trace == null ? undefined : {
-            additionalProperties: _object_spread$2({}, request.trace)
-        }
-    }));
-}
-/**
- * Converts a built request into the `callModel` input.
- *
- * Any hosted tools on the config are STRIPPED here rather than passed through: `callModel` owns the
- * `tools` key and converts every entry as a client function tool. Hosted entries are re-attached after
- * that conversion by {@link openRouterModelResultForRequest}.
- *
- * @param params - The request, tools, and state accessor.
- * @returns The `callModel` input.
- */ function openRouterCallModelInput(params) {
-    var request = params.request, tools = params.tools, state = params.state;
-    var maxSteps = splitOpenRouterModelConfig(request.config).maxSteps;
-    // dropped by name rather than by mutation, so TypeScript sees which keys leave the body: the hosted
-    // tools `callModel` cannot carry, and a config-set `stream` the non-streaming path must not inherit.
-    var _openRouterResponsesRequestBody = openRouterResponsesRequestBody(request); _openRouterResponsesRequestBody.tools; _openRouterResponsesRequestBody.stream; var body = _object_without_properties$1(_openRouterResponsesRequestBody, [
-        "tools",
-        "stream"
-    ]);
-    var input = util.filterUndefinedValues(_object_spread_props$1(_object_spread$2({}, body), {
-        tools: tools !== null && tools !== void 0 ? tools : undefined,
-        state: state !== null && state !== void 0 ? state : undefined,
-        stopWhen: maxSteps == null ? undefined : stopConditions.stepCountIs(maxSteps)
-    }));
-    return input;
-}
-/**
- * Header `callModel` stamps on every request it dispatches, so OpenRouter can tell an agent-loop request
- * apart from a plain one. Replicated on the merged hosted-tool path, which is a `callModel` request in
- * everything but the entry point.
- */ var OPENROUTER_CALL_MODEL_HEADER = 'x-openrouter-callmodel';
-/**
- * Builds the request options for a call, folding in the config's `requestTimeoutMs`.
- *
- * @param options - Caller-supplied options.
- * @param requestTimeoutMs - The per-request timeout from the config, when it set one.
- * @returns The merged options.
- */ function openRouterRequestOptions(options, requestTimeoutMs) {
-    return _object_spread$2({}, options, requestTimeoutMs == null ? undefined : {
-        timeoutMs: requestTimeoutMs
-    });
-}
-/**
- * Copies request options and stamps the `x-openrouter-callmodel` header onto them.
- *
- * Both header sources are read for the same reason `callModel` reads both: the SDK resolves
- * `options.headers ?? options.fetchOptions.headers`, so setting `headers` alone would SHADOW a caller
- * who passed theirs through the (deprecated) `fetchOptions` instead of losing nothing.
- *
- * @param options - The request options.
- * @returns Options carrying the caller's headers plus the callModel marker.
- */ function openRouterCallModelRequestOptions(options) {
-    var _ref, _options_headers;
-    var _options_fetchOptions;
-    // eslint-disable-next-line @typescript-eslint/no-deprecated
-    var headers = new Headers((_ref = (_options_headers = options.headers) !== null && _options_headers !== void 0 ? _options_headers : (_options_fetchOptions = options.fetchOptions) === null || _options_fetchOptions === void 0 ? void 0 : _options_fetchOptions.headers) !== null && _ref !== void 0 ? _ref : undefined);
-    headers.set(OPENROUTER_CALL_MODEL_HEADER, 'true');
-    return _object_spread_props$1(_object_spread$2({}, options), {
-        headers: headers
-    });
-}
-/**
- * Sends a built request straight to `/responses`, bypassing `callModel` entirely.
- *
- * This is the path hosted (server-executed) tools take. `callModel` cannot carry them — it converts
- * every `tools` entry as a client function tool — and there is nothing for its loop to do on a run whose
- * tools are executed upstream anyway. Going direct also keeps the response VERBATIM: the request is
- * non-streaming, so the returned `OpenResponsesResult` is the body OpenRouter sent rather than one
- * reassembled from stream events, which is what preserves hosted-tool output items such as a
- * `file_search_call` and the chunks `include: ['file_search_call.results']` asked for.
- *
- * @param params - The client, request, and options.
- * @returns The response.
- * @throws {Error} When the request fails, or when a streaming response comes back for a non-streaming request.
- */ function sendOpenRouterResponsesRequest(params) {
-    return _async_to_generator$2(function() {
-        var client, request, options, requestTimeoutMs, responsesRequest, result;
-        return _ts_generator$2(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    client = params.client, request = params.request, options = params.options;
-                    requestTimeoutMs = splitOpenRouterModelConfig(request.config).requestTimeoutMs;
-                    responsesRequest = _object_spread_props$1(_object_spread$2({}, openRouterResponsesRequestBody(request)), {
-                        stream: false
-                    });
-                    return [
-                        4,
-                        responsesSend.responsesSend(client, {
-                            responsesRequest: responsesRequest
-                        }, openRouterRequestOptions(options, requestTimeoutMs))
-                    ];
-                case 1:
-                    result = _state.sent();
-                    if (!result.ok) {
-                        throw result.error;
-                    }
-                    // `stream: false` narrows the SDK's response union by contract only, so the narrowing is asserted
-                    // rather than assumed: an event stream read as a result yields a value whose every field is undefined,
-                    // which a caller would store as a successful call that produced nothing.
-                    if (typeof result.value[Symbol.asyncIterator] === 'function') {
-                        throw new TypeError('OpenRouter returned a streaming response for a non-streaming `/responses` request.');
-                    }
-                    return [
-                        2,
-                        result.value
-                    ];
-            }
-        });
-    })();
-}
-/**
- * Starts a call for a built request and returns the SDK's `ModelResult` without consuming it.
- *
- * Use this when the caller needs the streaming / tool-event surface. Most callers want
- * {@link callModelForOpenRouterRequest}, which consumes the result into a normalized value.
- *
- * Hosted tools and client tools are NOT mutually exclusive here. When a config carries hosted tools this
- * assembles the `ModelResult` itself — client tools converted to API format exactly as `callModel` would,
- * with the hosted entries appended after that conversion — so a run can search a vector store AND drive
- * the client-side tool loop. `callModel` cannot express that: it owns the `tools` key and there is no
- * seam between its conversion and dispatch. Everything else about the run is unchanged, including the
- * `x-openrouter-callmodel` header and the `stopWhen` step ceiling.
- *
- * @param params - The client, request, tools, state, and options.
- * @returns The in-flight model result.
- */ function openRouterModelResultForRequest(params) {
-    var client = params.client, request = params.request, tools = params.tools, state = params.state, options = params.options;
-    var _splitOpenRouterModelConfig = splitOpenRouterModelConfig(request.config), maxSteps = _splitOpenRouterModelConfig.maxSteps, requestTimeoutMs = _splitOpenRouterModelConfig.requestTimeoutMs;
-    var requestOptions = openRouterRequestOptions(options, requestTimeoutMs);
-    var hostedTools = openRouterHostedTools(request.config);
-    var result;
-    if (hostedTools.length === 0) {
-        result = callModel.callModel(client, openRouterCallModelInput(params), requestOptions);
-    } else {
-        // `stream` is dropped by name, exactly as the `callModel` path drops it, so neither path can inherit
-        // a config-set value.
-        var _openRouterResponsesRequestBody = openRouterResponsesRequestBody(request); _openRouterResponsesRequestBody.stream; var body = _object_without_properties$1(_openRouterResponsesRequestBody, [
-            "stream"
-        ]);
-        var apiRequest = _object_spread_props$1(_object_spread$2({}, body), {
-            tools: _to_consumable_array$1(tools == null ? [] : toolExecutor.convertToolsToAPIFormat(tools)).concat(_to_consumable_array$1(hostedTools))
-        });
-        result = new modelResult.ModelResult(_object_spread$2({
-            client: client,
-            request: apiRequest,
-            options: openRouterCallModelRequestOptions(requestOptions)
-        }, tools == null ? undefined : {
-            tools: tools
-        }, state == null ? undefined : {
-            state: state
-        }, maxSteps == null ? undefined : {
-            stopWhen: stopConditions.stepCountIs(maxSteps)
-        }));
-    }
-    return result;
-}
-/**
- * Runs a built request to completion and normalizes the response.
- *
- * Routes to the direct `/responses` path for a hosted-tool run that needs no client-side tool loop, and
- * to `ModelResult` otherwise. The caller does not choose: which transport a request needs is a property
- * of the request, and making it a parameter would only create a way to get it wrong.
- *
- * @param params - The client, request, tools, state, and options.
- * @returns The normalized call result.
- */ function callModelForOpenRouterRequest(params) {
-    return _async_to_generator$2(function() {
-        var _ref, _params_tools, needsClientToolLoop, sendDirect, response, _tmp;
-        return _ts_generator$2(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    // Client tools and a `StateAccessor` both live on `ModelResult`, so a run using either needs the loop
-                    // that executes tools and round-trips conversation state — even when its hosted tools would otherwise
-                    // qualify it for the direct path.
-                    needsClientToolLoop = ((_ref = (_params_tools = params.tools) === null || _params_tools === void 0 ? void 0 : _params_tools.length) !== null && _ref !== void 0 ? _ref : 0) > 0 || params.state != null;
-                    sendDirect = openRouterHostedTools(params.request.config).length > 0 && !needsClientToolLoop;
-                    if (!sendDirect) return [
-                        3,
-                        2
-                    ];
-                    return [
-                        4,
-                        sendOpenRouterResponsesRequest(params)
-                    ];
-                case 1:
-                    _tmp = _state.sent();
-                    return [
-                        3,
-                        4
-                    ];
-                case 2:
-                    return [
-                        4,
-                        openRouterModelResultForRequest(params).getResponse()
-                    ];
-                case 3:
-                    _tmp = _state.sent();
-                    _state.label = 4;
-                case 4:
-                    response = _tmp;
-                    return [
-                        2,
-                        openRouterCallResultFromResponse(response)
-                    ];
-            }
-        });
-    })();
-}
-/**
- * Normalizes an OpenRouter response into an {@link OpenRouterCallResult}.
- *
- * @param response - The response to normalize.
- * @returns The normalized result.
- */ function openRouterCallResultFromResponse(response) {
-    var outputText = openRouterOutputTextFromResponse(response);
-    var usage = response.usage;
-    return {
-        outputText: outputText,
-        outputJson: parseOpenRouterJsonOutput(outputText),
-        generationIds: response.id ? [
-            response.id
-        ] : [],
-        usage: usage == null ? undefined : openRouterRunUsageFromResponseUsage(usage),
-        model: response.model,
-        error: response.error == null ? undefined : openRouterRunErrorFromResponseError(response.error),
-        response: response
-    };
-}
-/**
- * Reads the assistant text out of a response.
- *
- * The convenience `output_text` field is NOT populated by OpenRouter's `/responses` API — verified live,
- * on both a streaming and a non-streaming request: the body carries `output` items (`reasoning`, then
- * `message`) and no `output_text` at all. Reading that field alone therefore returns undefined for every
- * real call, so a run task would store an empty `o` on a call that answered perfectly well and was
- * charged for.
- *
- * Text is concatenated across ALL message items rather than just the first, since nothing guarantees a
- * response is limited to one.
- *
- * @param response - The response.
- * @returns The output text, or undefined when the response carried none.
- */ function openRouterOutputTextFromResponse(response) {
-    var result = response.outputText;
-    if (!result) {
-        var _response_output;
-        var text = ((_response_output = response.output) !== null && _response_output !== void 0 ? _response_output : []).filter(function(item) {
-            return item.type === 'message';
-        }).flatMap(function(item) {
-            var _item_content;
-            return (_item_content = item.content) !== null && _item_content !== void 0 ? _item_content : [];
-        }).filter(function(part) {
-            return part.type === 'output_text';
-        }).map(function(part) {
-            var _part_text;
-            return (_part_text = part.text) !== null && _part_text !== void 0 ? _part_text : '';
-        }).join('');
-        result = text || undefined;
-    }
-    return result;
-}
-/**
- * Flattens the SDK's nested usage object.
- *
- * A measurement the response did not report is OMITTED rather than carried as `undefined` or `null`.
- *
- * @param usage - The SDK usage object.
- * @returns The flattened usage.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterRunUsageFromResponseUsage(usage) {
-    var inputTokens = usage.inputTokens, outputTokens = usage.outputTokens, totalTokens = usage.totalTokens, cost = usage.cost, isByok = usage.isByok, inputTokensDetails = usage.inputTokensDetails, outputTokensDetails = usage.outputTokensDetails;
-    return util.filterUndefinedValues({
-        inputTokens: inputTokens,
-        outputTokens: outputTokens,
-        totalTokens: totalTokens,
-        reasoningTokens: outputTokensDetails === null || outputTokensDetails === void 0 ? void 0 : outputTokensDetails.reasoningTokens,
-        cachedTokens: inputTokensDetails === null || inputTokensDetails === void 0 ? void 0 : inputTokensDetails.cachedTokens,
-        cost: cost,
-        isByok: isByok
-    }, true);
-}
-/**
- * Flattens the error an OpenRouter response reports in its body.
- *
- * Named rather than inlined at the one call site for the same reason
- * {@link openRouterRunUsageFromResponseUsage} is: a library that exports `OpenRouterRunError` as a type
- * should let a caller holding a raw `OpenResponsesResult` produce one without transcribing its shape.
- *
- * `code` goes through `String()` because OpenRouter reports a NUMERIC code here (the HTTP status), while
- * `OpenRouterRunError.code` is a string — the same field an SDK-thrown error fills with `ECONNRESET`.
- *
- * @param error - The error reported on the response.
- * @returns The flattened error.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterRunErrorFromResponseError(error) {
-    var code = error.code, message = error.message;
-    return {
-        code: code == null ? undefined : String(code),
-        message: message
-    };
-}
-/**
- * Parses model output as a JSON object.
- *
- * Returns undefined rather than throwing on anything that is not a JSON object: a model asked for
- * text can and will return prose, and that is not an error.
- *
- * @param outputText - The output text.
- * @returns The parsed object, or undefined when the output is not a JSON object.
- */ function parseOpenRouterJsonOutput(outputText) {
-    var result;
-    if (outputText) {
-        try {
-            var parsed = JSON.parse(outputText);
-            if (parsed != null && (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && !Array.isArray(parsed)) {
-                result = parsed;
-            }
-        } catch (unused) {
-        // not JSON — leave undefined
-        }
-    }
-    return result;
-}
-
-function _define_property$1(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread$1(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property$1(target, key, source[key]);
-        });
-    }
-    return target;
-}
-/**
- * Builds a hosted `file_search` tool entry with the field names the SDK actually forwards.
- *
- * @param vectorStoreIds - The `vs_…` ids to search.
- * @param maxNumResults - Optional cap on returned chunks.
- * @returns The hosted tool entry.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterFileSearchTool(vectorStoreIds, maxNumResults) {
-    return _object_spread$1({
-        type: 'file_search',
-        vectorStoreIds: vectorStoreIds
-    }, maxNumResults == null ? undefined : {
-        maxNumResults: maxNumResults
-    });
-}
-/**
- * The default PDF parser engine this package pins.
- *
- * Pinned because the alternative is silent: with no engine named, OpenRouter downgrades any model it
- * believes lacks native file support to `mistral-ocr`, inheriting its 8-image cap and per-page billing with
- * no error — which on a multi-page document quietly truncates content.
- *
- * `native` rather than the equally-free `pdf-text` because it fails LOUDLY. It requires a model with
- * native file input and 400s on one without, where `pdf-text` would hand a scanned PDF to the model as
- * empty text and let it answer ungrounded. A caller on a text-only model wants
- * `openRouterFileParserPlugin('pdf-text')` — see {@link OpenRouterPdfParserEngine}.
- */ var DEFAULT_OPENROUTER_PDF_PARSER_ENGINE = 'native';
-/**
- * The `file-parser` plugin entry with the PDF engine pinned.
- *
- * @param engine - Engine to pin. Defaults to {@link DEFAULT_OPENROUTER_PDF_PARSER_ENGINE}.
- * @returns The plugin config entry.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterFileParserPlugin() {
-    var engine = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : DEFAULT_OPENROUTER_PDF_PARSER_ENGINE;
-    return {
-        id: 'file-parser',
-        pdf: {
-            engine: engine
-        }
-    };
-}
-/**
- * A provider config that pins routing to a single provider with fallbacks off and parameter support
- * required — the configuration that makes a BYOK request actually reach the intended upstream with
- * every parameter intact.
- *
- * @param provider - The provider slug to pin to (e.g. `openai`).
- * @returns The provider routing config.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterProviderPinnedTo(provider) {
-    return {
-        only: [
-            provider
-        ],
-        allowFallbacks: false,
-        requireParameters: true
-    };
-}
-/**
- * Merges model configs left-to-right, so the last input wins.
- *
- * Merging is SHALLOW by key: an override that supplies `provider` replaces the whole provider object
- * rather than merging into it. That is the behaviour a caller wants — a half-overridden `provider`
- * (say, `only` from the override and `allowFallbacks` from the version) is a configuration nobody
- * wrote down and nobody can reason about.
- *
- * `undefined` values do not overwrite; an explicit `null` does (it is how a caller clears a value
- * the version set).
- *
- * @param configs - Configs to merge, lowest priority first.
- * @returns The merged config.
- */ function mergeOpenRouterModelConfig(configs) {
-    return util.mergeObjects(configs);
-}
-/**
- * Validates a merged model config, catching the misconfigurations that fail silently at runtime
- * rather than loudly.
- *
- * @param config - The merged config to check.
- * @returns The validation result.
- */ function validateOpenRouterModelConfig(config) {
-    var errors = [];
-    var warnings = [];
-    if (config == null) {
-        errors.push('No model config was provided.');
-    } else {
-        var _ref;
-        var _config_models, _config_text, _config_plugins, _fileParser_pdf, _config_tools, _config_tools1, _config_provider, _config_provider_only, _config_provider1;
-        if (!config.model && !((_config_models = config.models) === null || _config_models === void 0 ? void 0 : _config_models.length)) {
-            errors.push('No `model` (or `models` fallback chain) was specified.');
-        }
-        var format = (_config_text = config.text) === null || _config_text === void 0 ? void 0 : _config_text.format;
-        if ((format === null || format === void 0 ? void 0 : format.type) === 'json_schema') {
-            if (!format.name) {
-                errors.push('A `json_schema` text format requires a `name`.');
-            }
-            if (!format.schema) {
-                errors.push('A `json_schema` text format requires a `schema`.');
-            }
-        }
-        var fileParser = (_config_plugins = config.plugins) === null || _config_plugins === void 0 ? void 0 : _config_plugins.find(function(x) {
-            return x.id === 'file-parser';
-        });
-        if (fileParser != null && !((_fileParser_pdf = fileParser.pdf) === null || _fileParser_pdf === void 0 ? void 0 : _fileParser_pdf.engine)) {
-            warnings.push('The `file-parser` plugin has no pinned `pdf.engine`; OpenRouter will silently fall back to `mistral-ocr` (8-image cap, per-page billing) on any model it believes lacks native file support.');
-        }
-        var hasHostedTools = ((_ref = (_config_tools = config.tools) === null || _config_tools === void 0 ? void 0 : _config_tools.length) !== null && _ref !== void 0 ? _ref : 0) > 0;
-        var fileSearchWithoutStores = (_config_tools1 = config.tools) === null || _config_tools1 === void 0 ? void 0 : _config_tools1.some(function(x) {
-            return x.type === 'file_search' && !Array.isArray(x['vectorStoreIds']);
-        });
-        if (fileSearchWithoutStores) {
-            // The SDK drops an unrecognized field (a `vector_store_ids` authored in wire case, say) during
-            // outbound serialization, leaving a tool that searches nothing and a model that answers ungrounded
-            // with no error at all. That is exactly the failure worth refusing to publish.
-            errors.push('A `file_search` hosted tool requires a `vectorStoreIds` array. Note the CAMELCASE — the SDK drops the wire-cased `vector_store_ids`, leaving a tool that searches nothing.');
-        }
-        if (hasHostedTools && ((_config_provider = config.provider) === null || _config_provider === void 0 ? void 0 : _config_provider.requireParameters) !== true) {
-            warnings.push('Hosted tools were requested without `provider.requireParameters: true`; a provider that does not support them receives only the parameters it supports and ignores the rest, returning an ungrounded answer with no error.');
-        }
-        if (((_config_provider1 = config.provider) === null || _config_provider1 === void 0 ? void 0 : (_config_provider_only = _config_provider1.only) === null || _config_provider_only === void 0 ? void 0 : _config_provider_only.length) && config.provider.allowFallbacks !== false) {
-            warnings.push('`provider.only` was set without `provider.allowFallbacks: false`, so routing can still leave the pinned provider.');
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors: errors,
-        warnings: warnings
-    };
-}
-
-function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator$1(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _ts_generator$1(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
-    return d(g, "next", {
-        value: verb(0)
-    }), d(g, "throw", {
-        value: verb(1)
-    }), d(g, "return", {
-        value: verb(2)
-    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
-        value: function() {
-            return this;
-        }
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-}
-/**
- * Generates embeddings.
- *
- * Base64-encoded embeddings are decoded to numbers before being returned, so a caller never has to
- * branch on the encoding the model happened to use.
- *
- * @param params - The client, model, input, and routing options.
- * @returns The embeddings.
- */ function openRouterEmbeddings(params) {
-    return _async_to_generator$1(function() {
-        var _response_usage, _response_usage1, client, model, input, dimensions, inputType, provider, options, requestBody, result, response, embeddings;
-        return _ts_generator$1(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    client = params.client, model = params.model, input = params.input, dimensions = params.dimensions, inputType = params.inputType, provider = params.provider, options = params.options;
-                    requestBody = {
-                        model: model,
-                        input: input,
-                        dimensions: dimensions !== null && dimensions !== void 0 ? dimensions : undefined,
-                        inputType: inputType !== null && inputType !== void 0 ? inputType : undefined,
-                        provider: provider !== null && provider !== void 0 ? provider : undefined
-                    };
-                    return [
-                        4,
-                        embeddingsGenerate.embeddingsGenerate(client, {
-                            requestBody: requestBody
-                        }, options !== null && options !== void 0 ? options : undefined)
-                    ];
-                case 1:
-                    result = _state.sent();
-                    if (!result.ok) {
-                        throw result.error;
-                    }
-                    response = result.value;
-                    if (typeof response === 'string') {
-                        throw new TypeError('OpenRouter returned a non-JSON embeddings response.');
-                    }
-                    embeddings = response.data.map(function(entry, index) {
-                        var _entry_index;
-                        return {
-                            index: (_entry_index = entry.index) !== null && _entry_index !== void 0 ? _entry_index : index,
-                            embedding: openRouterEmbeddingVector(entry.embedding)
-                        };
-                    });
-                    return [
-                        2,
-                        {
-                            model: response.model,
-                            embeddings: embeddings,
-                            promptTokens: (_response_usage = response.usage) === null || _response_usage === void 0 ? void 0 : _response_usage.promptTokens,
-                            totalTokens: (_response_usage1 = response.usage) === null || _response_usage1 === void 0 ? void 0 : _response_usage1.totalTokens
-                        }
-                    ];
-            }
-        });
-    })();
-}
-/**
- * Decodes a base64 string to bytes.
- *
- * `atob` is a WHATWG global, present on Node ≥16 and in every browser, so no Node-only `Buffer` is assumed.
- * Anything outside the base64 alphabet — padding, embedded newlines from a wrapped response — is stripped
- * first, which is what makes the input tolerant rather than strict.
- *
- * @param base64 - The base64 string. Padding is optional.
- * @returns The decoded bytes.
- */ function openRouterDecodeBase64(base64) {
-    // `charCodeAt`, not `codePointAt`: `atob` returns a latin1 string, so every character is a single UTF-16
-    // code unit below 256. The two agree here, and only `charCodeAt` is typed to return a plain `number`.
-    // eslint-disable-next-line unicorn/prefer-code-point
-    return Uint8Array.from(atob(base64.replaceAll(/[^A-Za-z0-9+/]/g, '')), function(c) {
-        return c.charCodeAt(0);
-    });
-}
-/**
- * Normalizes an embedding to a number array, decoding the base64 (little-endian float32) form.
- *
- * @param embedding - The embedding as returned.
- * @returns The vector.
- */ function openRouterEmbeddingVector(embedding) {
-    var result;
-    if (typeof embedding === 'string') {
-        var bytes = openRouterDecodeBase64(embedding);
-        var view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        var length = Math.floor(bytes.byteLength / 4);
-        result = [];
-        for(var i = 0; i < length; i += 1){
-            result.push(view.getFloat32(i * 4, true));
-        }
-    } else {
-        result = embedding;
-    }
-    return result;
-}
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
-    try {
-        var info = gen[key](arg);
-        var value = info.value;
-    } catch (error) {
-        reject(error);
-        return;
-    }
-    if (info.done) {
-        resolve(value);
-    } else {
-        Promise.resolve(value).then(_next, _throw);
-    }
-}
-function _async_to_generator(fn) {
-    return function() {
-        var self = this, args = arguments;
-        return new Promise(function(resolve, reject) {
-            var gen = fn.apply(self, args);
-            function _next(value) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
-            }
-            function _throw(err) {
-                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
-            }
-            _next(undefined);
-        });
-    };
-}
-function _ts_generator(thisArg, body) {
-    var f, y, t, _ = {
-        label: 0,
-        sent: function() {
-            if (t[0] & 1) throw t[1];
-            return t[1];
-        },
-        trys: [],
-        ops: []
-    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
-    return d(g, "next", {
-        value: verb(0)
-    }), d(g, "throw", {
-        value: verb(1)
-    }), d(g, "return", {
-        value: verb(2)
-    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
-        value: function() {
-            return this;
-        }
-    }), g;
-    function verb(n) {
-        return function(v) {
-            return step([
-                n,
-                v
-            ]);
-        };
-    }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while(g && (g = 0, op[0] && (_ = 0)), _)try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [
-                op[0] & 2,
-                t.value
-            ];
-            switch(op[0]){
-                case 0:
-                case 1:
-                    t = op;
-                    break;
-                case 4:
-                    _.label++;
-                    return {
-                        value: op[1],
-                        done: false
-                    };
-                case 5:
-                    _.label++;
-                    y = op[1];
-                    op = [
-                        0
-                    ];
-                    continue;
-                case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
-                        _ = 0;
-                        continue;
-                    }
-                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
-                        _.label = op[1];
-                        break;
-                    }
-                    if (op[0] === 6 && _.label < t[1]) {
-                        _.label = t[1];
-                        t = op;
-                        break;
-                    }
-                    if (t && _.label < t[2]) {
-                        _.label = t[2];
-                        _.ops.push(op);
-                        break;
-                    }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) {
-            op = [
-                6,
-                e
-            ];
-            y = 0;
-        } finally{
-            f = t = 0;
-        }
-        if (op[0] & 5) throw op[1];
-        return {
-            value: op[0] ? op[1] : void 0,
-            done: true
-        };
-    }
-}
-/**
- * Loads a generation's metadata — finish reason, cancellation, BYOK, latency, and the full token/cost
- * breakdown, which is finalised server-side and so can be more complete than the usage the response
- * carried.
- *
- * This is an AUDIT surface, never the system of record. What it returns is tied to account logging
- * settings (nothing is retained under ZDR / logging-disabled), its retention is undocumented, and it is
- * keyed per generation rather than per conversation — which is why a run task stores its own output and
- * keeps `gi (generationIds)` only for lookups like this one.
- *
- * @param params - The client and generation id.
- * @returns The generation metadata.
- * @throws {Error} When the lookup fails, including the 404 a generation that was never retained produces.
- */ function openRouterGeneration(params) {
-    return _async_to_generator(function() {
-        var client, id, options, result;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    client = params.client, id = params.id, options = params.options;
-                    return [
-                        4,
-                        generationsGetGeneration.generationsGetGeneration(client, {
-                            id: id
-                        }, options !== null && options !== void 0 ? options : undefined)
-                    ];
-                case 1:
-                    result = _state.sent();
-                    if (!result.ok) {
-                        throw result.error;
-                    }
-                    return [
-                        2,
-                        result.value.data
-                    ];
-            }
-        });
-    })();
-}
-/**
- * Loads a generation's stored content — prompt, completion, reasoning, and output.
- *
- * Subject to every caveat on {@link openRouterGeneration}: this reloads what OpenRouter happened to
- * retain, not what the run produced.
- *
- * @param params - The client and generation id.
- * @returns The stored content.
- * @throws {Error} When the lookup fails.
- */ function openRouterGenerationContent(params) {
-    return _async_to_generator(function() {
-        var client, id, options, result;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    client = params.client, id = params.id, options = params.options;
-                    return [
-                        4,
-                        generationsListGenerationContent.generationsListGenerationContent(client, {
-                            id: id
-                        }, options !== null && options !== void 0 ? options : undefined)
-                    ];
-                case 1:
-                    result = _state.sent();
-                    if (!result.ok) {
-                        throw result.error;
-                    }
-                    return [
-                        2,
-                        result.value.data
-                    ];
-            }
-        });
-    })();
-}
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _object_spread(target) {
-    for(var i = 1; i < arguments.length; i++){
-        var source = arguments[i] != null ? arguments[i] : {};
-        var ownKeys = Object.keys(source);
-        if (typeof Object.getOwnPropertySymbols === "function") {
-            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
-                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
-            }));
-        }
-        ownKeys.forEach(function(key) {
-            _define_property(target, key, source[key]);
-        });
-    }
-    return target;
-}
-function ownKeys(object, enumerableOnly) {
-    var keys = Object.keys(object);
-    if (Object.getOwnPropertySymbols) {
-        var symbols = Object.getOwnPropertySymbols(object);
-        keys.push.apply(keys, symbols);
-    }
-    return keys;
-}
-function _object_spread_props(target, source) {
-    source = source != null ? source : {};
-    if (Object.getOwnPropertyDescriptors) {
-        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-        ownKeys(Object(source)).forEach(function(key) {
-            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-        });
-    }
-    return target;
-}
-function _object_without_properties(source, excluded) {
-    if (source == null) return {};
-    var target = {}, sourceKeys, key, i;
-    if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
-        sourceKeys = Reflect.ownKeys(Object(source));
-        for(i = 0; i < sourceKeys.length; i++){
-            key = sourceKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-        return target;
-    }
-    target = _object_without_properties_loose(source, excluded);
-    if (Object.getOwnPropertySymbols) {
-        sourceKeys = Object.getOwnPropertySymbols(source);
-        for(i = 0; i < sourceKeys.length; i++){
-            key = sourceKeys[i];
-            if (excluded.indexOf(key) >= 0) continue;
-            if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-            target[key] = source[key];
-        }
-    }
-    return target;
-}
-function _object_without_properties_loose(source, excluded) {
-    if (source == null) return {};
-    var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
-    for(i = 0; i < sourceKeys.length; i++){
-        key = sourceKeys[i];
-        if (excluded.indexOf(key) >= 0) continue;
-        if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
-        target[key] = source[key];
-    }
-    return target;
-}
-/**
- * Normalizes input to a message array.
- *
- * @param input - The input to normalize.
- * @returns The messages, empty when no input was given.
- */ function openRouterInputMessages(input) {
-    var result;
-    if (input == null) {
-        result = [];
-    } else if (typeof input === 'string') {
-        result = [
-            {
-                role: 'user',
-                content: [
-                    {
-                        type: 'input_text',
-                        text: input
-                    }
-                ]
-            }
-        ];
-    } else {
-        result = input;
-    }
-    return result;
-}
-/**
- * Builds a text content part.
- *
- * @param text - The text.
- * @returns The content part.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterInputTextPart(text) {
-    return {
-        type: 'input_text',
-        text: text
-    };
-}
-/**
- * Builds an image content part.
- *
- * @param imageUrl - The image url (a signed url, a data url, or any publicly reachable url).
- * @param detail - Detail level. Defaults to `auto`.
- * @returns The content part.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterInputImagePart(imageUrl) {
-    var detail = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 'auto';
-    return {
-        type: 'input_image',
-        imageUrl: imageUrl,
-        detail: detail
-    };
-}
-/**
- * Builds a file content part from a url.
- *
- * @param fileUrl - The url the parser will dereference. Must be reachable from the public internet.
- * @param filename - Filename to present; its extension is what tells OpenRouter how to treat the file.
- * @returns The content part.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterInputFileUrlPart(fileUrl, filename) {
-    return {
-        type: 'input_file',
-        fileUrl: fileUrl,
-        filename: filename
-    };
-}
-/**
- * Builds a file content part from base64 data.
- *
- * @param base64 - Base64 content, with or without a `data:` prefix.
- * @param filename - Filename to present.
- * @param contentType - Mime type used to build the `data:` prefix when the input lacks one. Defaults to `application/pdf`.
- * @returns The content part.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterInputFileDataPart(base64, filename) {
-    var contentType = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 'application/pdf';
-    var fileData = base64.startsWith('data:') ? base64 : "data:".concat(contentType, ";base64,").concat(base64);
-    return {
-        type: 'input_file',
-        fileData: fileData,
-        filename: filename
-    };
-}
-/**
- * Expands attached file references into file content parts.
- *
- * @param files - The attached file references.
- * @returns One content part per file.
- */ function openRouterInputFilePartsForAttachedFiles(files) {
-    return (files !== null && files !== void 0 ? files : []).map(function(param) {
-        var file = param.file, fileUrl = param.fileUrl, fileData = param.fileData;
-        return fileData == null ? openRouterInputFileUrlPart(fileUrl, file.filename) : openRouterInputFileDataPart(fileData, file.filename);
-    });
-}
-/**
- * Rewrites the `input_file` parts of an already-assembled conversation with the attachment resolved for
- * THIS attempt, matching on filename.
- *
- * A conversation persisted mid-run carries whatever the attempt that persisted it was carrying —
- * a url that has since expired, or (with inline attachments stripped on save) nothing at all. Replaying
- * it unchanged is the failure mode most likely to reach production unnoticed, because it only shows up
- * on a retry or a deferred resume. Resolving fresh per attempt is only half the fix; the other half is
- * making sure the stored history is re-pointed at the fresh attachment too.
- *
- * The field the attachment does NOT carry is REMOVED rather than left alone: a stored `fileUrl` sitting
- * next to a fresh `fileData` would send OpenRouter both, and it is not defined which one wins. Removed
- * rather than nulled, because this output goes on the wire — the SDK validates `input_file` against a
- * schema where an explicit `null` is not a legal absent value.
- *
- * A part whose filename matches nothing in `files` is left alone: it came from somewhere other than
- * this task's file list, and guessing at it would be worse than leaving it.
- *
- * @param messages - The assembled conversation.
- * @param files - The files attached for this attempt.
- * @returns The conversation with fresh attachments, or the input unchanged when there is nothing to rewrite.
- */ function openRouterMessagesWithFreshFileAttachments(messages, files) {
-    var attachmentsByFilename = util.arrayToMap(files !== null && files !== void 0 ? files : [], function(attached) {
-        return attached.file.filename;
-    });
-    var result = messages !== null && messages !== void 0 ? messages : [];
-    if (attachmentsByFilename.size > 0 && result.length > 0) {
-        result = result.map(function(message) {
-            var updated = message;
-            if (Array.isArray(message.content)) {
-                var content = message.content.map(function(part) {
-                    var updatedPart = part;
-                    if (part.type === 'input_file' && part.filename != null) {
-                        var fresh = attachmentsByFilename.get(part.filename);
-                        if (fresh != null) {
-                            part.fileUrl; part.fileData; var rest = _object_without_properties(part, [
-                                "fileUrl",
-                                "fileData"
-                            ]);
-                            updatedPart = _object_spread({}, rest, fresh.fileData == null ? {
-                                fileUrl: fresh.fileUrl
-                            } : {
-                                fileData: fresh.fileData
-                            });
-                        }
-                    }
-                    return updatedPart;
-                });
-                updated = _object_spread_props(_object_spread({}, message), {
-                    content: content
-                });
-            }
-            return updated;
-        });
-    }
-    return result;
-}
-/**
- * Strips the attachment payload off every `input_file` part, keeping `filename` as the rejoin key.
- *
- * Applied on the way INTO Firestore. An attachment is resolved per attempt and is meaningless the
- * moment that attempt ends — a signed url has expired, and inline base64 is the whole file, on a
- * document with a 1 MiB ceiling and a `msg` field that already grows without bound. Nothing is lost:
- * {@link openRouterMessagesWithFreshFileAttachments} re-points the stored parts on the way back out.
- *
- * @param messages - The conversation about to be persisted.
- * @returns The conversation with attachment payloads removed.
- */ function openRouterMessagesWithoutFileAttachmentData(messages) {
-    return (messages !== null && messages !== void 0 ? messages : []).map(function(message) {
-        var updated = message;
-        if (Array.isArray(message.content)) {
-            var content = message.content.map(function(part) {
-                return part.type === 'input_file' ? _object_spread_props(_object_spread({}, part), {
-                    fileUrl: null,
-                    fileData: null
-                }) : part;
-            });
-            updated = _object_spread_props(_object_spread({}, message), {
-                content: content
-            });
-        }
-        return updated;
-    });
-}
-/**
- * Renders one cached annotation as message text.
- *
- * @param annotation - The cached annotation.
- * @returns The text carrying the parse.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterFileAnnotationText(annotation) {
-    var _annotation_content, _annotation_filename;
-    var content = typeof annotation.content === 'string' ? annotation.content : JSON.stringify((_annotation_content = annotation.content) !== null && _annotation_content !== void 0 ? _annotation_content : null);
-    return '<file name="'.concat((_annotation_filename = annotation.filename) !== null && _annotation_filename !== void 0 ? _annotation_filename : annotation.hash, '" hash="').concat(annotation.hash, '">\n').concat(content, "\n</file>");
-}
-/**
- * Builds the assistant message that carries cached `file-parser` output back, so an already-parsed file
- * is not parsed again.
- *
- * It carries the parse TWICE, deliberately, and for an empirical reason rather than a defensive one:
- *
- *  - `annotations` is OpenRouter's own documented echo format, so the shape is kept and the mechanism
- *    starts working the day the Responses API models it. Today it does not: the SDK validates the request
- *    body against a closed union whose message variants have no `annotations` field, so the property is
- *    STRIPPED during outbound serialization. Verified against the wire, not assumed.
- *  - The parse is therefore ALSO rendered into `content`, as ordinary text, which does survive. Paired
- *    with the request builder dropping the file part for an already-parsed file, that is what makes the
- *    cache real today.
- *
- * @param annotations - The cached annotations.
- * @returns The message, or undefined when there is nothing cached to resubmit.
- */ function openRouterFileAnnotationMessage(annotations) {
-    var result;
-    if (annotations != null && annotations.length > 0) {
-        result = {
-            role: 'assistant',
-            content: annotations.map(openRouterFileAnnotationText).join('\n'),
-            annotations: annotations.map(function(annotation) {
-                return {
-                    type: 'file',
-                    file: {
-                        hash: annotation.hash,
-                        name: annotation.filename,
-                        content: annotation.content
-                    }
-                };
-            })
-        };
-    }
-    return result;
-}
-/**
- * Drops the files whose parse is already cached.
- *
- * Not re-sending the document is what actually prevents a re-parse. The annotation echo alone cannot:
- * the SDK strips it, and even where it survives it is a hint the provider is free to ignore, so a run
- * that relied on it would pay for the parse again with no error to show for it.
- *
- * A file is matched to its cached parse by filename, which is the only handle both sides share — the
- * annotation's `hash` is assigned by OpenRouter and the reference's `storagePath` is ours.
- *
- * @param files - The files attached for this attempt.
- * @param annotations - The cached annotations.
- * @returns The files that still need sending.
- *
- * @__NO_SIDE_EFFECTS__
- */ function openRouterUnparsedAttachedFiles(files, annotations) {
-    var cachedFilenames = new Set((annotations !== null && annotations !== void 0 ? annotations : []).map(function(annotation) {
-        return annotation.filename;
-    }).filter(function(filename) {
-        return filename != null;
-    }));
-    return (files !== null && files !== void 0 ? files : []).filter(function(param) {
-        var file = param.file;
-        return !cachedFilenames.has(file.filename);
-    });
-}
-
-function _array_like_to_array(arr, len) {
-    if (len == null || len > arr.length) len = arr.length;
-    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
-    return arr2;
-}
-function _array_without_holes(arr) {
-    if (Array.isArray(arr)) return _array_like_to_array(arr);
-}
-function _iterable_to_array(iter) {
-    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
-}
-function _non_iterable_spread() {
-    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
-}
-function _to_consumable_array(arr) {
-    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
-}
-function _unsupported_iterable_to_array(o, minLen) {
-    if (!o) return;
-    if (typeof o === "string") return _array_like_to_array(o, minLen);
-    var n = Object.prototype.toString.call(o).slice(8, -1);
-    if (n === "Object" && o.constructor) n = o.constructor.name;
-    if (n === "Map" || n === "Set") return Array.from(n);
-    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
-}
-/**
- * Builds a request from a resolved prompt version plus a caller's dynamic input.
- *
- * Content is emitted STATIC FIRST — seed messages, then annotation echoes, then continued history,
- * then the caller's input, with attached files appended to the final user message. That ordering is
- * not cosmetic: a prompt cache only hits on a shared prefix, so putting the per-call content last is
- * what keeps the static prefix cacheable across runs of the same prompt.
- *
- * @param params - The prompt, input, overrides, files, history, and trace.
- * @returns The built request.
- */ function openRouterPromptRequest(params) {
-    var _messages;
-    var _prompt_messages;
-    var prompt = params.prompt, input = params.input, overrides = params.overrides, files = params.files, fileAnnotations = params.fileAnnotations, history = params.history, trace = params.trace;
-    var config = mergeOpenRouterModelConfig([
-        prompt.config,
-        overrides
-    ]);
-    var seedMessages = ((_prompt_messages = prompt.messages) !== null && _prompt_messages !== void 0 ? _prompt_messages : []).map(function(param) {
-        var role = param.role, content = param.content;
-        return {
-            role: role,
-            content: content
-        };
-    });
-    var annotationMessage = openRouterFileAnnotationMessage(fileAnnotations);
-    var inputMessages = openRouterInputMessages(input);
-    // A file whose parse is already cached is NOT re-attached. Sending it again is what causes the
-    // re-parse; the annotation echo alone cannot prevent one.
-    var fileParts = openRouterInputFilePartsForAttachedFiles(openRouterUnparsedAttachedFiles(files, fileAnnotations));
-    var messages = _to_consumable_array(seedMessages);
-    if (annotationMessage != null) {
-        messages.push(annotationMessage);
-    }
-    if (history != null && history.length > 0) {
-        var _messages1;
-        (_messages1 = messages).push.apply(_messages1, _to_consumable_array(history));
-    }
-    (_messages = messages).push.apply(_messages, _to_consumable_array(inputMessages));
-    if (fileParts.length > 0) {
-        // Files ride on the last user message so they sit alongside the text that refers to them. When
-        // the caller passed no input at all (a file-only run) a user message is created to carry them.
-        var lastUserIndex = messages.findLastIndex(function(x) {
-            return x.role === 'user';
-        });
-        if (lastUserIndex >= 0) {
-            var target = messages[lastUserIndex];
-            var content = typeof target.content === 'string' ? [
-                {
-                    type: 'input_text',
-                    text: target.content
-                }
-            ] : target.content;
-            messages[lastUserIndex] = {
-                role: target.role,
-                content: _to_consumable_array(content).concat(_to_consumable_array(fileParts))
-            };
-        } else {
-            messages.push({
-                role: 'user',
-                content: fileParts
-            });
-        }
-    }
-    return {
-        config: config,
-        instructions: prompt.instructions,
-        input: messages,
-        trace: trace
-    };
-}
-
-/**
- * Extracts the deferred (manual) tool calls from a conversation state.
- *
- * Only manual tools can be pending on resume: a tool with an `execute` function was run in-process
- * before the state was ever saved.
- *
- * @param state - The conversation state.
- * @param tools - The tool set the run was configured with, used to tell manual tools from executable ones.
- * @returns The pending deferred tool calls.
- */ function openRouterPendingDeferredToolCalls(state, tools) {
-    var _ref;
-    var manualToolNames = new Set((tools !== null && tools !== void 0 ? tools : []).filter(function(x) {
-        return toolTypes.isManualTool(x);
-    }).map(function(x) {
-        return x.function.name;
-    }));
-    return ((_ref = state === null || state === void 0 ? void 0 : state.pendingToolCalls) !== null && _ref !== void 0 ? _ref : []).filter(function(call) {
-        return manualToolNames.size === 0 || manualToolNames.has(call.name);
-    }).map(function(call) {
-        return openRouterPendingDeferredToolCallFromParsedCall(call);
-    });
-}
-/**
- * Converts an SDK parsed tool call into a pending deferred tool call.
- *
- * @param call - The parsed tool call.
- * @param taskId - Optional task id to associate. Defaults to the call id.
- * @returns The pending deferred tool call.
- */ function openRouterPendingDeferredToolCallFromParsedCall(call, taskId) {
-    return {
-        callId: call.id,
-        name: call.name,
-        taskId: taskId !== null && taskId !== void 0 ? taskId : call.id,
-        arguments: call.arguments
-    };
-}
-/**
- * Turns resolutions into the `unsentToolResults` entries the SDK replays on the next call.
- *
- * A resolution whose `taskId` matches no pending call is DROPPED rather than throwing. Deferred
- * resolutions arrive from outside this process and may be replayed — an unmatched one means the task
- * was already settled, which must be a no-op, not a failure.
- *
- * @param pending - The currently pending deferred tool calls.
- * @param resolutions - The resolutions received.
- * @returns The unsent tool results, in the order the resolutions were given.
- */ function openRouterResolvedDeferredToolResults(pending, resolutions) {
-    var byTaskId = util.arrayToMap(pending !== null && pending !== void 0 ? pending : [], function(call) {
-        return call.taskId;
-    });
-    var results = [];
-    (resolutions !== null && resolutions !== void 0 ? resolutions : []).forEach(function(resolution) {
-        var call = byTaskId.get(resolution.taskId);
-        if (call != null) {
-            results.push({
-                callId: call.callId,
-                name: call.name,
-                output: resolution.output,
-                error: resolution.error
-            });
-        }
-    });
-    return results;
-}
-/**
- * Whether a conversation state is paused waiting on a deferred tool result.
- *
- * @param state - The conversation state.
- * @returns True when the state has pending tool calls it cannot resolve itself.
- */ function isOpenRouterStateAwaitingDeferredTools(state) {
-    var _ref;
-    var _state_pendingToolCalls;
-    return ((_ref = state === null || state === void 0 ? void 0 : (_state_pendingToolCalls = state.pendingToolCalls) === null || _state_pendingToolCalls === void 0 ? void 0 : _state_pendingToolCalls.length) !== null && _ref !== void 0 ? _ref : 0) > 0;
-}
-/**
- * Converts recorded tool results into the `function_call_output` items that get appended to the
- * conversation before the run is resumed.
- *
- * This is how a deferred pause is un-paused, and it is done HERE rather than through the SDK on
- * purpose. `@openrouter/sdk@1.2.x` only knows how to resume a pause by re-running the tool locally
- * (`approveToolCalls` calls the tool's `execute`, and a manual tool has none) or by rejecting it — so
- * a result produced by another process has no route back in through the SDK's own API. Appending the
- * outputs to the persisted conversation and re-sending it does have one, and it is the same wire
- * format the SDK would have produced itself.
- *
- * @param results - The recorded results, in the persisted `callId` / `name` / `output` / `error` shape.
- * @returns The `function_call_output` items to append to the conversation.
- */ function openRouterFunctionCallOutputItems(results) {
-    return conversationState.unsentResultsToAPIFormat((results !== null && results !== void 0 ? results : []).map(function(result) {
-        var _result_error;
-        return {
-            callId: result.callId,
-            name: result.name,
-            output: result.output,
-            error: (_result_error = result.error) !== null && _result_error !== void 0 ? _result_error : undefined
-        };
-    }));
-}
-
-Object.defineProperty(exports, "callModel", {
-    enumerable: true,
-    get: function () { return callModel.callModel; }
-});
-Object.defineProperty(exports, "responsesSend", {
-    enumerable: true,
-    get: function () { return responsesSend.responsesSend; }
-});
-Object.defineProperty(exports, "unsentResultsToAPIFormat", {
-    enumerable: true,
-    get: function () { return conversationState.unsentResultsToAPIFormat; }
-});
-Object.defineProperty(exports, "embeddingsGenerate", {
-    enumerable: true,
-    get: function () { return embeddingsGenerate.embeddingsGenerate; }
-});
-Object.defineProperty(exports, "generationsGetGeneration", {
-    enumerable: true,
-    get: function () { return generationsGetGeneration.generationsGetGeneration; }
-});
-Object.defineProperty(exports, "generationsListGenerationContent", {
-    enumerable: true,
-    get: function () { return generationsListGenerationContent.generationsListGenerationContent; }
-});
-Object.defineProperty(exports, "ModelResult", {
-    enumerable: true,
-    get: function () { return modelResult.ModelResult; }
-});
-Object.defineProperty(exports, "tool", {
-    enumerable: true,
-    get: function () { return tool.tool; }
-});
-Object.defineProperty(exports, "convertToolsToAPIFormat", {
-    enumerable: true,
-    get: function () { return toolExecutor.convertToolsToAPIFormat; }
-});
-Object.defineProperty(exports, "finishReasonIs", {
-    enumerable: true,
-    get: function () { return stopConditions.finishReasonIs; }
-});
-Object.defineProperty(exports, "hasToolCall", {
-    enumerable: true,
-    get: function () { return stopConditions.hasToolCall; }
-});
-Object.defineProperty(exports, "maxCost", {
-    enumerable: true,
-    get: function () { return stopConditions.maxCost; }
-});
-Object.defineProperty(exports, "maxTokensUsed", {
-    enumerable: true,
-    get: function () { return stopConditions.maxTokensUsed; }
-});
-Object.defineProperty(exports, "stepCountIs", {
-    enumerable: true,
-    get: function () { return stopConditions.stepCountIs; }
-});
-Object.defineProperty(exports, "ToolType", {
-    enumerable: true,
-    get: function () { return toolTypes.ToolType; }
-});
-Object.defineProperty(exports, "isManualTool", {
-    enumerable: true,
-    get: function () { return toolTypes.isManualTool; }
-});
-exports.DEFAULT_OPENROUTER_PDF_PARSER_ENGINE = DEFAULT_OPENROUTER_PDF_PARSER_ENGINE;
-exports.OPENROUTER_CALL_MODEL_HEADER = OPENROUTER_CALL_MODEL_HEADER;
-exports.callModelForOpenRouterRequest = callModelForOpenRouterRequest;
-exports.isOpenRouterStateAwaitingDeferredTools = isOpenRouterStateAwaitingDeferredTools;
-exports.mergeOpenRouterModelConfig = mergeOpenRouterModelConfig;
-exports.openRouterCallModelInput = openRouterCallModelInput;
-exports.openRouterCallResultFromResponse = openRouterCallResultFromResponse;
-exports.openRouterDecodeBase64 = openRouterDecodeBase64;
-exports.openRouterEmbeddingVector = openRouterEmbeddingVector;
-exports.openRouterEmbeddings = openRouterEmbeddings;
-exports.openRouterFileAnnotationMessage = openRouterFileAnnotationMessage;
-exports.openRouterFileAnnotationText = openRouterFileAnnotationText;
-exports.openRouterFileParserPlugin = openRouterFileParserPlugin;
-exports.openRouterFileSearchTool = openRouterFileSearchTool;
-exports.openRouterFunctionCallOutputItems = openRouterFunctionCallOutputItems;
-exports.openRouterGeneration = openRouterGeneration;
-exports.openRouterGenerationContent = openRouterGenerationContent;
-exports.openRouterHostedTools = openRouterHostedTools;
-exports.openRouterInputFileDataPart = openRouterInputFileDataPart;
-exports.openRouterInputFilePartsForAttachedFiles = openRouterInputFilePartsForAttachedFiles;
-exports.openRouterInputFileUrlPart = openRouterInputFileUrlPart;
-exports.openRouterInputImagePart = openRouterInputImagePart;
-exports.openRouterInputMessages = openRouterInputMessages;
-exports.openRouterInputTextPart = openRouterInputTextPart;
-exports.openRouterMessagesWithFreshFileAttachments = openRouterMessagesWithFreshFileAttachments;
-exports.openRouterMessagesWithoutFileAttachmentData = openRouterMessagesWithoutFileAttachmentData;
-exports.openRouterModelResultForRequest = openRouterModelResultForRequest;
-exports.openRouterOutputTextFromResponse = openRouterOutputTextFromResponse;
-exports.openRouterPendingDeferredToolCallFromParsedCall = openRouterPendingDeferredToolCallFromParsedCall;
-exports.openRouterPendingDeferredToolCalls = openRouterPendingDeferredToolCalls;
-exports.openRouterPromptRequest = openRouterPromptRequest;
-exports.openRouterProviderPinnedTo = openRouterProviderPinnedTo;
-exports.openRouterResolvedDeferredToolResults = openRouterResolvedDeferredToolResults;
-exports.openRouterResponsesRequestBody = openRouterResponsesRequestBody;
-exports.openRouterRunErrorFromResponseError = openRouterRunErrorFromResponseError;
-exports.openRouterRunUsageFromResponseUsage = openRouterRunUsageFromResponseUsage;
-exports.openRouterUnparsedAttachedFiles = openRouterUnparsedAttachedFiles;
-exports.parseOpenRouterJsonOutput = parseOpenRouterJsonOutput;
-exports.sendOpenRouterResponsesRequest = sendOpenRouterResponsesRequest;
-exports.splitOpenRouterModelConfig = splitOpenRouterModelConfig;
-exports.validateOpenRouterModelConfig = validateOpenRouterModelConfig;