@dereekb/openrouter 14.7.0 → 14.9.0

package/index.esm.js

@@ -1,4 +1,4 @@
-import { filterUndefinedValues, mergeObjects, arrayToMap } from '@dereekb/util';
+import { filterUndefinedValues, 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';
@@ -7,6 +7,8 @@ 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 { systemOneCreate } from '@openrouter/sdk/funcs/systemOneCreate';
+export { systemOneCreate } from '@openrouter/sdk/funcs/systemOneCreate';
 import { generationsGetGeneration } from '@openrouter/sdk/funcs/generationsGetGeneration';
 export { generationsGetGeneration } from '@openrouter/sdk/funcs/generationsGetGeneration';
 import { generationsListGenerationContent } from '@openrouter/sdk/funcs/generationsListGenerationContent';
@@ -20,6 +22,8 @@ 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';
+import { o as isOpenRouterSystemOneModelId, F as readOpenRouterDecisionAnswers, k as OpenRouterDecisionAnswerFaultError, C as openRouterRunUsageFromDecisionsUsage, I as validateOpenRouterDecisionRequest, l as OpenRouterDecisionDeclarationError, G as splitOpenRouterDecisionModelConfig, v as openRouterDecisionRequestBody, q as mergeOpenRouterModelConfig } from './openrouter.decision.esm.js';
+export { D as DEFAULT_OPENROUTER_PDF_PARSER_ENGINE, a as DEFAULT_OPENROUTER_SYSTEM_ONE_MODEL_ID, O as OPENROUTER_DECISION_CHOICE_OPTIONS_MAX, b as OPENROUTER_DECISION_CONFIDENCE_HIGH, c as OPENROUTER_DECISION_CONFIDENCE_MEDIUM, d as OPENROUTER_DECISION_DISTRIBUTION_SUM_TOLERANCE, e as OPENROUTER_DECISION_SCORE_LEVELS_MAX, f as OPENROUTER_DECISION_SCORE_LEVELS_MIN, g as OPENROUTER_JEV_1_13_MODEL_ID, h as OPENROUTER_JEV_LATEST_MODEL_ID, i as OPENROUTER_JEV_PREVIEW_MODEL_ID, j as OPENROUTER_SYSTEM_ONE_MODEL_NAMESPACE, m as asOpenRouterDecisionConfidenceBand, n as isBlankOpenRouterDecisionEntry, p as mapOpenRouterDecisionChoiceRows, r as openRouterChoiceQuestion, s as openRouterDecisionChoiceOptionNames, t as openRouterDecisionChoiceRanking, u as openRouterDecisionRequest, w as openRouterDecisionStatePaths, x as openRouterDecisionWireQuestion, y as openRouterFileParserPlugin, z as openRouterFileSearchTool, A as openRouterNoulQuestion, B as openRouterProviderPinnedTo, E as openRouterScoreQuestion, H as validateOpenRouterDecisionQuestions, J as validateOpenRouterModelConfig } from './openrouter.decision.esm.js';
 
 function _array_like_to_array$1(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
@@ -29,7 +33,11 @@ function _array_like_to_array$1(arr, len) {
 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) {
+function _assert_this_initialized(self) {
+    if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return self;
+}
+function asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
         var value = info.value;
@@ -40,21 +48,44 @@ function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
     if (info.done) resolve(value);
     else Promise.resolve(value).then(_next, _throw);
 }
-function _async_to_generator$2(fn) {
+function _async_to_generator$3(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);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "next", value);
             }
             function _throw(err) {
-                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
             }
             _next(undefined);
         });
     };
 }
+function _call_super(_this, derived, args) {
+    derived = _get_prototype_of(derived);
+    return _possible_constructor_return(_this, _is_native_reflect_construct() ? Reflect.construct(derived, args || [], _get_prototype_of(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
 function _define_property$2(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -66,6 +97,36 @@ function _define_property$2(obj, key, value) {
     } else obj[key] = value;
     return obj;
 }
+function _get_prototype_of(o) {
+    _get_prototype_of = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of(o);
+}
+function _inherits(subClass, superClass) {
+    if (typeof superClass !== "function" && superClass !== null) {
+        throw new TypeError("Super expression must either be null or a function");
+    }
+    subClass.prototype = Object.create(superClass && superClass.prototype, {
+        constructor: {
+            value: subClass,
+            writable: true,
+            configurable: true
+        }
+    });
+    if (superClass) _set_prototype_of(subClass, superClass);
+}
+function _is_native_function(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _is_native_reflect_construct() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
 function _iterable_to_array$1(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
         return Array.from(iter);
@@ -143,10 +204,21 @@ function _object_without_properties_loose$1(source, excluded) {
     }
     return target;
 }
+function _possible_constructor_return(self, call) {
+    if (call && (_type_of(call) === "object" || typeof call === "function")) return call;
+    return _assert_this_initialized(self);
+}
+function _set_prototype_of(o, p) {
+    _set_prototype_of = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of(o, p);
+}
 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 _ts_generator$2(thisArg, body) {
+function _ts_generator$3(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -257,6 +329,30 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     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 _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function(Class) {
+        if (Class === null || !_is_native_function(Class)) return Class;
+        if (typeof Class !== "function") throw new TypeError("Super expression must either be null or a function");
+        if (typeof _cache !== "undefined") {
+            if (_cache.has(Class)) return _cache.get(Class);
+            _cache.set(Class, Wrapper);
+        }
+        function Wrapper() {
+            return _construct(Class, arguments, _get_prototype_of(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of(Wrapper, Class);
+    };
+    return _wrap_native_super(Class);
+}
 /**
  * Splits a model config into request parameters and execution controls.
  *
@@ -296,15 +392,63 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     var tools = config === null || config === void 0 ? void 0 : config.tools;
     return Array.isArray(tools) ? tools : [];
 }
+/**
+ * Raised when a request naming a System One model is sent down the completion arm.
+ *
+ * Its own error type rather than a generic one because the fix is specific and mechanical — the call
+ * goes to `openRouterDecision` — and an error a reader can act on without opening the source is worth
+ * a named class.
+ */ var OpenRouterSystemOneModelOnCompletionArmError = /*#__PURE__*/ function(Error1) {
+    _inherits(OpenRouterSystemOneModelOnCompletionArmError, Error1);
+    function OpenRouterSystemOneModelOnCompletionArmError(model) {
+        _class_call_check(this, OpenRouterSystemOneModelOnCompletionArmError);
+        var _this;
+        _this = _call_super(this, OpenRouterSystemOneModelOnCompletionArmError, [
+            "`".concat(model, "` is a System One model. It answers only `POST /systemone` and cannot serve a completion — build an `OpenRouterDecisionRequest` and call `openRouterDecision` instead of `callModelForOpenRouterRequest`.")
+        ]), _define_property$2(_this, "model", void 0);
+        _this.name = 'OpenRouterSystemOneModelOnCompletionArmError';
+        _this.model = model;
+        return _this;
+    }
+    return OpenRouterSystemOneModelOnCompletionArmError;
+}(_wrap_native_super(Error));
+/**
+ * Refuses a config whose model cannot serve a completion.
+ *
+ * Asserted rather than assumed, for the same reason {@link sendOpenRouterResponsesRequest} asserts its
+ * response is not an event stream: the alternative failure is unreadable. A Jev slug on `/responses`
+ * comes back as a provider-level error naming neither the model class nor the route that would have
+ * served it, from inside a sweep, on a request whose config was accepted when it was written.
+ *
+ * @param config - The merged model config.
+ * @throws {OpenRouterSystemOneModelOnCompletionArmError} When the config names a System One model.
+ */ function assertOpenRouterCompletionModel(config) {
+    var _ref;
+    var model = [
+        config === null || config === void 0 ? void 0 : config.model
+    ].concat(_to_consumable_array$1((_ref = config === null || config === void 0 ? void 0 : config.models) !== null && _ref !== void 0 ? _ref : [])).filter(Boolean).find(function(x) {
+        return isOpenRouterSystemOneModelId(x);
+    });
+    if (model != null) {
+        throw new OpenRouterSystemOneModelOnCompletionArmError(model);
+    }
+}
 /**
  * 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.
  *
+ * It is also where a System One model is refused, because it is the ONE point every dispatch path
+ * converges on — `openRouterCallModelInput`, `sendOpenRouterResponsesRequest` and
+ * `openRouterModelResultForRequest` all build their body here — so no route to the completion arm can
+ * be added later that quietly skips the check.
+ *
  * @param request - The built request.
  * @returns The request body, in the SDK's camelCase request surface.
+ * @throws {OpenRouterSystemOneModelOnCompletionArmError} When the config names a System One model.
  */ function openRouterResponsesRequestBody(request) {
+    assertOpenRouterCompletionModel(request.config);
     var requestConfig = splitOpenRouterModelConfig(request.config).requestConfig;
     return filterUndefinedValues(_object_spread_props$1(_object_spread$2({}, requestConfig), {
         input: request.input,
@@ -388,9 +532,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
  * @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() {
+    return _async_to_generator$3(function() {
         var client, request, options, requestTimeoutMs, responsesRequest, result;
-        return _ts_generator$2(this, function(_state) {
+        return _ts_generator$3(this, function(_state) {
             switch(_state.label){
                 case 0:
                     client = params.client, request = params.request, options = params.options;
@@ -479,9 +623,9 @@ function _unsupported_iterable_to_array$1(o, minLen) {
  * @param params - The client, request, tools, state, and options.
  * @returns The normalized call result.
  */ function callModelForOpenRouterRequest(params) {
-    return _async_to_generator$2(function() {
+    return _async_to_generator$3(function() {
         var _ref, _params_tools, needsClientToolLoop, sendDirect, response, _tmp;
-        return _ts_generator$2(this, function(_state) {
+        return _ts_generator$3(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
@@ -639,6 +783,32 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     return result;
 }
 
+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$1(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -665,138 +835,167 @@ function _object_spread$1(target) {
     }
     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
+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;
         }
-    };
-}
-/**
- * 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
-    };
+    }), 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
+        };
+    }
 }
 /**
- * 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.
+ * Asks a decision and returns its answers.
  *
- * `undefined` values do not overwrite; an explicit `null` does (it is how a caller clears a value
- * the version set).
+ * The request is validated first, so a model that cannot serve a decision is refused HERE rather than by
+ * the route — the mirror of the refusal `callModelForOpenRouterRequest` makes for a System One model on
+ * the completion arm. Which surface a request belongs to is a property of the request, not a choice the
+ * caller makes at the call site.
  *
- * @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`.');
+ * @param params - The client, request, and options.
+ * @returns The normalized decision result.
+ * @throws {OpenRouterDecisionDeclarationError} When the request cannot be asked as declared.
+ * @throws {OpenRouterDecisionAnswerFaultError} When the reply did not answer the declared questions.
+ */ function openRouterDecision(params) {
+    return _async_to_generator$2(function() {
+        var _response_answers, client, request, options, validation, requestTimeoutMs, decisionsRequest, result, response, read;
+        return _ts_generator$2(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    client = params.client, request = params.request, options = params.options;
+                    validation = validateOpenRouterDecisionRequest(request);
+                    if (!validation.valid) {
+                        throw new OpenRouterDecisionDeclarationError(validation.errors);
+                    }
+                    requestTimeoutMs = splitOpenRouterDecisionModelConfig(request.config).requestTimeoutMs;
+                    decisionsRequest = openRouterDecisionRequestBody(request);
+                    return [
+                        4,
+                        systemOneCreate(client, {
+                            decisionsRequest: decisionsRequest
+                        }, _object_spread$1({}, options, requestTimeoutMs == null ? undefined : {
+                            timeoutMs: requestTimeoutMs
+                        }))
+                    ];
+                case 1:
+                    result = _state.sent();
+                    if (!result.ok) {
+                        throw result.error;
+                    }
+                    response = result.value;
+                    read = readOpenRouterDecisionAnswers({
+                        questions: request.questions,
+                        raw: (_response_answers = response.answers) !== null && _response_answers !== void 0 ? _response_answers : {}
+                    });
+                    if (read.faults != null) {
+                        throw new OpenRouterDecisionAnswerFaultError(read.faults);
+                    }
+                    return [
+                        2,
+                        {
+                            answers: read.answers,
+                            model: response.model,
+                            provider: response.provider,
+                            generationIds: response.id ? [
+                                response.id
+                            ] : [],
+                            usage: openRouterRunUsageFromDecisionsUsage(response.usage),
+                            response: response
+                        }
+                    ];
             }
-        }
-        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) {
@@ -1755,4 +1954,4 @@ function _unsupported_iterable_to_array(o, minLen) {
     }));
 }
 
-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 };
+export { OPENROUTER_CALL_MODEL_HEADER, OpenRouterDecisionAnswerFaultError, OpenRouterDecisionDeclarationError, OpenRouterSystemOneModelOnCompletionArmError, callModelForOpenRouterRequest, isOpenRouterStateAwaitingDeferredTools, isOpenRouterSystemOneModelId, mergeOpenRouterModelConfig, openRouterCallModelInput, openRouterCallResultFromResponse, openRouterDecision, openRouterDecisionRequestBody, openRouterDecodeBase64, openRouterEmbeddingVector, openRouterEmbeddings, openRouterFileAnnotationMessage, openRouterFileAnnotationText, openRouterFunctionCallOutputItems, openRouterGeneration, openRouterGenerationContent, openRouterHostedTools, openRouterInputFileDataPart, openRouterInputFilePartsForAttachedFiles, openRouterInputFileUrlPart, openRouterInputImagePart, openRouterInputMessages, openRouterInputTextPart, openRouterMessagesWithFreshFileAttachments, openRouterMessagesWithoutFileAttachmentData, openRouterModelResultForRequest, openRouterOutputTextFromResponse, openRouterPendingDeferredToolCallFromParsedCall, openRouterPendingDeferredToolCalls, openRouterPromptRequest, openRouterResolvedDeferredToolResults, openRouterResponsesRequestBody, openRouterRunErrorFromResponseError, openRouterRunUsageFromDecisionsUsage, openRouterRunUsageFromResponseUsage, openRouterUnparsedAttachedFiles, parseOpenRouterJsonOutput, readOpenRouterDecisionAnswers, sendOpenRouterResponsesRequest, splitOpenRouterDecisionModelConfig, splitOpenRouterModelConfig, validateOpenRouterDecisionRequest };