@dereekb/openrouter 13.37.0

package/index.esm.js

@@ -0,0 +1,1771 @@
+import { filterUndefinedValues, mergeObjects, arrayToMap } from '@dereekb/util';
+import { callModel } from '@openrouter/sdk/funcs/call-model';
+export { callModel } from '@openrouter/sdk/funcs/call-model';
+import { responsesSend } from '@openrouter/sdk/funcs/responsesSend';
+export { responsesSend } from '@openrouter/sdk/funcs/responsesSend';
+import { unsentResultsToAPIFormat } from '@openrouter/sdk/lib/conversation-state';
+export { unsentResultsToAPIFormat } from '@openrouter/sdk/lib/conversation-state';
+import { embeddingsGenerate } from '@openrouter/sdk/funcs/embeddingsGenerate';
+export { embeddingsGenerate } from '@openrouter/sdk/funcs/embeddingsGenerate';
+import { generationsGetGeneration } from '@openrouter/sdk/funcs/generationsGetGeneration';
+export { generationsGetGeneration } from '@openrouter/sdk/funcs/generationsGetGeneration';
+import { generationsListGenerationContent } from '@openrouter/sdk/funcs/generationsListGenerationContent';
+export { generationsListGenerationContent } from '@openrouter/sdk/funcs/generationsListGenerationContent';
+import { ModelResult } from '@openrouter/sdk/lib/model-result';
+export { ModelResult } from '@openrouter/sdk/lib/model-result';
+export { tool } from '@openrouter/sdk/lib/tool';
+import { convertToolsToAPIFormat } from '@openrouter/sdk/lib/tool-executor';
+export { convertToolsToAPIFormat } from '@openrouter/sdk/lib/tool-executor';
+import { stepCountIs } from '@openrouter/sdk/lib/stop-conditions';
+export { finishReasonIs, hasToolCall, maxCost, maxTokensUsed, stepCountIs } from '@openrouter/sdk/lib/stop-conditions';
+import { isManualTool } from '@openrouter/sdk/lib/tool-types';
+export { ToolType, isManualTool } from '@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: 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 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 = 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 : 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(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(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 ? [] : convertToolsToAPIFormat(tools)).concat(_to_consumable_array$1(hostedTools))
+        });
+        result = new 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: 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 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 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(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(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(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 = 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 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 = 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 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
+        };
+    }));
+}
+
+export { DEFAULT_OPENROUTER_PDF_PARSER_ENGINE, OPENROUTER_CALL_MODEL_HEADER, callModelForOpenRouterRequest, isOpenRouterStateAwaitingDeferredTools, mergeOpenRouterModelConfig, openRouterCallModelInput, openRouterCallResultFromResponse, openRouterDecodeBase64, openRouterEmbeddingVector, openRouterEmbeddings, openRouterFileAnnotationMessage, openRouterFileAnnotationText, openRouterFileParserPlugin, openRouterFileSearchTool, openRouterFunctionCallOutputItems, openRouterGeneration, openRouterGenerationContent, openRouterHostedTools, openRouterInputFileDataPart, openRouterInputFilePartsForAttachedFiles, openRouterInputFileUrlPart, openRouterInputImagePart, openRouterInputMessages, openRouterInputTextPart, openRouterMessagesWithFreshFileAttachments, openRouterMessagesWithoutFileAttachmentData, openRouterModelResultForRequest, openRouterOutputTextFromResponse, openRouterPendingDeferredToolCallFromParsedCall, openRouterPendingDeferredToolCalls, openRouterPromptRequest, openRouterProviderPinnedTo, openRouterResolvedDeferredToolResults, openRouterResponsesRequestBody, openRouterRunErrorFromResponseError, openRouterRunUsageFromResponseUsage, openRouterUnparsedAttachedFiles, parseOpenRouterJsonOutput, sendOpenRouterResponsesRequest, splitOpenRouterModelConfig, validateOpenRouterModelConfig };