@dereekb/openrouter 14.8.0 → 14.9.0

package/openrouter.decision.esm.js

@@ -0,0 +1,1185 @@
+import { mergeObjects, filterUndefinedValues, mapObjectMap } from '@dereekb/util';
+
+/**
+ * The namespace every System One model slug lives under.
+ */ var OPENROUTER_SYSTEM_ONE_MODEL_NAMESPACE = 'typesafe';
+/**
+ * Jev 1.13, the System One model this package pins by default.
+ *
+ * A VERSIONED slug rather than one of the moving aliases (`jev-latest`, `jev-preview`), for the same
+ * reason {@link OpenRouterPromptVersionNumber} exists: a decision's answer is only reproducible against
+ * the exact model that produced it, and an alias silently moves out from under a stored prompt. Point a
+ * prompt at an alias deliberately, never by default.
+ */ var OPENROUTER_JEV_1_13_MODEL_ID = 'typesafe/jev-1.13';
+/**
+ * The newest STABLE Jev. A moving alias — see {@link OPENROUTER_JEV_1_13_MODEL_ID}.
+ */ var OPENROUTER_JEV_LATEST_MODEL_ID = 'typesafe/jev-latest';
+/**
+ * The newest Jev, stable or not. A moving alias — see {@link OPENROUTER_JEV_1_13_MODEL_ID}.
+ */ var OPENROUTER_JEV_PREVIEW_MODEL_ID = 'typesafe/jev-preview';
+/**
+ * The System One model a decision uses when its config names none.
+ */ var DEFAULT_OPENROUTER_SYSTEM_ONE_MODEL_ID = OPENROUTER_JEV_1_13_MODEL_ID;
+/**
+ * Matches the bare System One slugs OpenRouter maps into the `typesafe/` namespace.
+ */ var OPENROUTER_BARE_SYSTEM_ONE_MODEL_REGEX = /^jev(-|$)/;
+/**
+ * Whether a model slug names a System One model.
+ *
+ * This is the ONLY discriminator available, and it is the reason this function exists rather than a
+ * lookup: System One models are NOT listed by `GET /models`, so nothing can be learned about one from
+ * the catalog. A caller that guessed wrong does not get an error it can read — a Jev slug sent to
+ * `/responses` fails at the provider, and a chat slug sent to `/systemone` is refused by the route.
+ *
+ * Both forms are recognised: the namespaced slug (`typesafe/jev-1.13`) and the bare one (`jev-1.13`,
+ * `jev-latest`), which the SDK documents itself as mapping onto the `typesafe/` namespace.
+ *
+ * @param model - The model slug to test.
+ * @returns True when the slug names a System One model.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function isOpenRouterSystemOneModelId(model) {
+    var slug = model === null || model === void 0 ? void 0 : model.trim().toLowerCase();
+    return slug == null || slug === '' ? false : slug.startsWith("".concat(OPENROUTER_SYSTEM_ONE_MODEL_NAMESPACE, "/")) || OPENROUTER_BARE_SYSTEM_ONE_MODEL_REGEX.test(slug);
+}
+
+function _array_like_to_array$2(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$2(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$2(arr);
+}
+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$2(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread$2() {
+    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 _to_consumable_array$2(arr) {
+    return _array_without_holes$2(arr) || _iterable_to_array$2(arr) || _unsupported_iterable_to_array$2(arr) || _non_iterable_spread$2();
+}
+function _unsupported_iterable_to_array$2(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$2(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$2(o, minLen);
+}
+/**
+ * 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$2({
+        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.
+ * @param options - Which arm the config is for.
+ * @returns The validation result.
+ */ function validateOpenRouterModelConfig(config, options) {
+    var errors = [];
+    var warnings = [];
+    var decision = (options === null || options === void 0 ? void 0 : options.decision) === true;
+    if (config == null) {
+        errors.push('No model config was provided.');
+    } else {
+        var _config_models, _ref;
+        var _config_models1, _config_text, _config_plugins, _fileParser_pdf, _config_tools, _config_tools1, _config_provider, _config_provider_only, _config_provider1;
+        if (!config.model && !((_config_models1 = config.models) === null || _config_models1 === void 0 ? void 0 : _config_models1.length)) {
+            errors.push('No `model` (or `models` fallback chain) was specified.');
+        }
+        // OpenRouter has TWO inference surfaces and the model slug is the only thing that says which one a
+        // request belongs to — System One models are absent from `GET /models`, so nothing can be learned
+        // about one from the catalog. Checked here because this runs at publish time: a Jev slug typed into
+        // a stored prompt version is refused when it is written, rather than failing in a sweep days later
+        // with an error that names neither the prompt nor the reason.
+        var declaredModels = [
+            config.model
+        ].concat(_to_consumable_array$2((_config_models = config.models) !== null && _config_models !== void 0 ? _config_models : [])).filter(Boolean);
+        var systemOneModels = declaredModels.filter(function(x) {
+            return isOpenRouterSystemOneModelId(x);
+        });
+        if (decision) {
+            var _config_models2;
+            declaredModels.filter(function(x) {
+                return !isOpenRouterSystemOneModelId(x);
+            }).forEach(function(model) {
+                errors.push("`".concat(model, "` is not a System One model, and only a System One model answers a decision. Name a `typesafe/…` model (see DEFAULT_OPENROUTER_SYSTEM_ONE_MODEL_ID)."));
+            });
+            if ((_config_models2 = config.models) === null || _config_models2 === void 0 ? void 0 : _config_models2.length) {
+                warnings.push('`models` has no meaning on a decision: the decisions route takes a single `model` and no fallback chain, so every entry here is dropped.');
+            }
+        } else {
+            systemOneModels.forEach(function(model) {
+                errors.push("`".concat(model, "` is a System One model, which answers only `POST /systemone` and cannot serve a completion. Ask it through `openRouterDecision` rather than `callModelForOpenRouterRequest`, or name a chat model here."));
+            });
+        }
+        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 _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 _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 _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$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;
+}
+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$1(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);
+}
+/**
+ * Confidence at or above which {@link asOpenRouterDecisionConfidenceBand} reads `high`.
+ *
+ * A documented STARTING POINT, not a tuned threshold. Note also that a Noul probability and a Choice
+ * confidence answer different questions and are not comparable, so a threshold calibrated for one may
+ * not be carried over to the other.
+ */ var OPENROUTER_DECISION_CONFIDENCE_HIGH = 0.75;
+/**
+ * Confidence at or above which {@link asOpenRouterDecisionConfidenceBand} reads `medium`.
+ *
+ * See the note on {@link OPENROUTER_DECISION_CONFIDENCE_HIGH}.
+ */ var OPENROUTER_DECISION_CONFIDENCE_MEDIUM = 0.5;
+/**
+ * Most options a single Choice may declare.
+ *
+ * A hard transport limit, not a guideline. Past it, narrow in two stages — ask a first Choice that picks
+ * the branch, then a second over that branch's members — rather than truncating the set, because an
+ * option that was truncated away is one the model can never pick and nothing reports that it was missing.
+ */ var OPENROUTER_DECISION_CHOICE_OPTIONS_MAX = 255;
+/**
+ * Fewest levels a Score may declare.
+ */ var OPENROUTER_DECISION_SCORE_LEVELS_MIN = 2;
+/**
+ * Most levels a Score may declare.
+ *
+ * The trap this guards: a 0..8 band is NINE levels and legal, while a 0..10 scale is eleven and is
+ * rejected at the wire. Past the ceiling, MERGE the levels that cannot be told apart — never truncate
+ * the top, which silently removes the extreme the threshold usually cares about.
+ */ var OPENROUTER_DECISION_SCORE_LEVELS_MAX = 10;
+/**
+ * Whether a declaration entry says nothing at all.
+ *
+ * A blank string, an empty array, and a keyless object all ask nothing, and all three reach the wire as
+ * a question the model cannot answer.
+ *
+ * @param entry - The entry to test.
+ * @returns True when the entry carries no guidance.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function isBlankOpenRouterDecisionEntry(entry) {
+    var result;
+    if (entry == null) {
+        result = true;
+    } else if (typeof entry === 'string') {
+        result = entry.trim() === '';
+    } else if (Array.isArray(entry)) {
+        result = entry.length === 0;
+    } else {
+        result = Object.keys(entry).length === 0;
+    }
+    return result;
+}
+/**
+ * The option names a Choice declared — what the model was SHOWN.
+ *
+ * @param question - The choice question.
+ * @returns The declared option names, in declaration order.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterDecisionChoiceOptionNames(question) {
+    return Object.keys(question.options);
+}
+/**
+ * Reads a confidence as a band.
+ *
+ * An ABSENT confidence reads `low` rather than throwing: the model is not required to report one, and a
+ * caller that branches on the band should treat "did not say" the same as "not sure". A non-finite one
+ * (`NaN`, `Infinity`) reads `low` for the same reason — a garbled number is not a report of certainty,
+ * and without the guard `NaN` fails every comparison below and falls through to `medium`.
+ *
+ * @param confidence - The reported confidence, if any.
+ * @returns The band.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function asOpenRouterDecisionConfidenceBand(confidence) {
+    var result;
+    if (confidence == null || !Number.isFinite(confidence) || confidence < OPENROUTER_DECISION_CONFIDENCE_MEDIUM) {
+        result = 'low';
+    } else if (confidence >= OPENROUTER_DECISION_CONFIDENCE_HIGH) {
+        result = 'high';
+    } else {
+        result = 'medium';
+    }
+    return result;
+}
+/**
+ * Reads a Choice's distribution as a ranking, most probable first.
+ *
+ * The distribution is a FREE full ranking — the model reports every option, not just the winner — so a
+ * caller wanting a shortlist should read this rather than paying for a second question.
+ *
+ * Returns an empty array when the answer carried no distribution, which is a real reply rather than an
+ * error. The sort is stable, so tied options keep declaration order.
+ *
+ * @param answer - The choice answer.
+ * @returns The ranking rows.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterDecisionChoiceRanking(answer) {
+    var probabilities = answer.probabilities;
+    return probabilities == null ? [] : Object.keys(probabilities).map(function(option) {
+        return {
+            option: option,
+            probability: probabilities[option]
+        };
+    }).sort(function(a, b) {
+        return b.probability - a.probability;
+    });
+}
+/**
+ * Reads a Choice's distribution back as the caller's OWN rows, most probable first.
+ *
+ * The seam exists because a Choice's options are usually derived from rows the caller already holds, and
+ * walking the distribution back to them by hand at every call site is where the option-name convention
+ * quietly drifts.
+ *
+ * @param config - The answers, the question to read, and how to resolve an option to a row.
+ * @returns The resolved rows, most probable first. Options that resolve to nothing are dropped.
+ */ function mapOpenRouterDecisionChoiceRows(config) {
+    var answers = config.answers, question = config.question, rowOf = config.rowOf;
+    var answer = answers[question];
+    return answer.type === 'choice' ? openRouterDecisionChoiceRanking(answer).map(function(param) {
+        var option = param.option, probability = param.probability;
+        return {
+            row: rowOf(option),
+            probability: probability
+        };
+    }).filter(function(x) {
+        return x.row != null;
+    }) : [];
+}
+/**
+ * Matches a backticked dot-and-index path, the convention for naming a part of the state from inside
+ * `instructions`.
+ */ var OPENROUTER_DECISION_STATE_PATH_REGEX = /`([A-Za-z_$][\w$]*((\.[A-Za-z_$][\w$]*)|(\[\d+\]))*)`/g;
+/**
+ * Reads back the state paths a declaration entry names.
+ *
+ * The convention is to name a part of the state as a dot-and-index path IN BACKTICKS — `` `phrase` ``,
+ * `` `ticket.sender.email` ``, `` `messages[0].text` `` — so a question points at something the state
+ * actually carries rather than describing it again in prose.
+ *
+ * Documented and inspectable, deliberately NOT enforced: backticks also legitimately quote an option key
+ * or a literal, so a spec may pin that a declaration points at keys its state has, while the transport
+ * never refuses one that does not.
+ *
+ * @param entry - The entry to read. Objects and arrays are walked.
+ * @returns The paths, deduplicated, in the order they first appear.
+ */ function openRouterDecisionStatePaths(entry) {
+    var found = new Set();
+    function read(value) {
+        if (typeof value === 'string') {
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = value.matchAll(OPENROUTER_DECISION_STATE_PATH_REGEX)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var match = _step.value;
+                    found.add(match[1]);
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        } else if (Array.isArray(value)) {
+            value.forEach(read);
+        } else if (value != null && (typeof value === "undefined" ? "undefined" : _type_of$1(value)) === 'object') {
+            Object.values(value).forEach(read);
+        }
+    }
+    read(entry);
+    return Array.from(found);
+}
+/**
+ * Declares a Choice question.
+ *
+ * Supply the FULL option set, plus an explicit `other` / `none of the above` when the set may not cover
+ * the input — the distribution is normalised over what was supplied, so a Choice always names a winner
+ * whether or not one fits.
+ *
+ * @param instructions - The complete question, as the model will read it.
+ * @param options - The options, keyed by the name the answer will quote.
+ * @returns The declared question.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterChoiceQuestion(instructions, options) {
+    return {
+        type: 'choice',
+        instructions: instructions,
+        options: options
+    };
+}
+/**
+ * Declares a Score question.
+ *
+ * Use as many levels as can be described DISTINCTLY, lowest to highest — three is fine, and a rare
+ * extreme deserves its own level. One dimension per question.
+ *
+ * @param instructions - The complete question, as the model will read it.
+ * @param levels - The levels, lowest first. At least two.
+ * @returns The declared question.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterScoreQuestion(instructions, levels) {
+    return {
+        type: 'score',
+        instructions: instructions,
+        levels: _to_consumable_array$1(levels)
+    };
+}
+/**
+ * Declares a Noul question.
+ *
+ * @param instructions - The complete question, as the model will read it.
+ * @param means - Optional explicit definitions of the true and false sides.
+ * @returns The declared question.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterNoulQuestion(instructions, means) {
+    return _object_spread$1({
+        type: 'noul',
+        instructions: instructions
+    }, means == null ? undefined : {
+        means: means
+    });
+}
+/**
+ * Describes what is wrong with one declared question, or undefined when nothing is.
+ *
+ * @param question - The question to check.
+ * @returns The problem, or undefined.
+ */ function openRouterDecisionQuestionDeclarationDetail(question) {
+    var result;
+    if (isBlankOpenRouterDecisionEntry(question.instructions)) {
+        result = 'a question with no instructions asks nothing';
+    } else {
+        switch(question.type){
+            case 'choice':
+                {
+                    var options = openRouterDecisionChoiceOptionNames(question).length;
+                    if (options === 0) {
+                        result = 'a Choice declaring no options asks nothing';
+                    } else if (options > OPENROUTER_DECISION_CHOICE_OPTIONS_MAX) {
+                        result = "a Choice may declare at most ".concat(OPENROUTER_DECISION_CHOICE_OPTIONS_MAX, " options and this one declares ").concat(options, "; narrow in two stages rather than truncating");
+                    }
+                    break;
+                }
+            case 'score':
+                {
+                    var levels = question.levels.length;
+                    if (levels < OPENROUTER_DECISION_SCORE_LEVELS_MIN) {
+                        result = "a Score needs at least ".concat(OPENROUTER_DECISION_SCORE_LEVELS_MIN, " ordered levels and this one declares ").concat(levels);
+                    } else if (levels > OPENROUTER_DECISION_SCORE_LEVELS_MAX) {
+                        result = "a Score may declare at most ".concat(OPENROUTER_DECISION_SCORE_LEVELS_MAX, " levels and this one declares ").concat(levels, "; merge the levels that cannot be described distinctly rather than truncating the top");
+                    }
+                    break;
+                }
+        }
+    }
+    return result;
+}
+/**
+ * Validates a declared question map.
+ *
+ * Every problem here fails AT THE DECLARATION, naming the question, rather than as a 4xx about a request
+ * body — which is the difference between a publish that is refused and a run that dies in a sweep at 2am.
+ *
+ * Returns the package's standard validation result so a caller can report question problems and config
+ * problems through one surface.
+ *
+ * @param questions - The declared questions.
+ * @returns The validation result.
+ */ function validateOpenRouterDecisionQuestions(questions) {
+    var errors = [];
+    var warnings = [];
+    var ids = questions == null ? [] : Object.keys(questions);
+    if (ids.length === 0) {
+        errors.push('No questions were declared. A decision asks the model to pick a position inside an answer space, so there is nothing to ask without one.');
+    }
+    ids.forEach(function(id) {
+        var detail = openRouterDecisionQuestionDeclarationDetail(questions[id]);
+        if (detail != null) {
+            errors.push("Question `".concat(id, "` cannot be asked: ").concat(detail, "."));
+        }
+    });
+    return {
+        valid: errors.length === 0,
+        errors: errors,
+        warnings: warnings
+    };
+}
+
+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 _assert_this_initialized(self) {
+    if (self === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+    return self;
+}
+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(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 _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(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 _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;
+}
+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(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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);
+}
+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);
+}
+/**
+ * How far a distribution's probabilities may sum from 1 before the reply is read as malformed.
+ *
+ * Wide enough to absorb the float rounding a JSON round-trip introduces, narrow enough that a
+ * distribution missing an option does not pass.
+ */ var OPENROUTER_DECISION_DISTRIBUTION_SUM_TOLERANCE = 0.05;
+/**
+ * Raised when a decision cannot be asked as declared.
+ *
+ * Every declaration problem fails HERE — before a request is built, naming the question — rather than as
+ * a 4xx about a request body. The distinction matters because the fixes are different: a malformed
+ * declaration is a code or authoring bug, while a 4xx is an operational one.
+ */ var OpenRouterDecisionDeclarationError = /*#__PURE__*/ function(Error1) {
+    _inherits(OpenRouterDecisionDeclarationError, Error1);
+    function OpenRouterDecisionDeclarationError(errors) {
+        _class_call_check(this, OpenRouterDecisionDeclarationError);
+        var _this;
+        _this = _call_super(this, OpenRouterDecisionDeclarationError, [
+            "This decision cannot be asked as declared: ".concat(errors.join(' '))
+        ]), _define_property(_this, "errors", void 0);
+        _this.name = 'OpenRouterDecisionDeclarationError';
+        _this.errors = errors;
+        return _this;
+    }
+    return OpenRouterDecisionDeclarationError;
+}(_wrap_native_super(Error));
+/**
+ * Builds a decision request from an optional resolved prompt plus the caller's state and questions.
+ *
+ * Stored questions and caller questions are merged BY ID with the caller winning, the same composition
+ * a prompt's static seed messages and dynamic `input` already use. What differs is the reason: there is
+ * no prompt cache on this route, so the merge is about where a question is authored — a fixed taxonomy
+ * belongs in a version an operator can edit, a per-call candidate set can only come from code.
+ *
+ * @param params - The prompt, state, questions, overrides, session id, and trace.
+ * @returns The built request.
+ * @throws {OpenRouterDecisionDeclarationError} When the merged question map cannot be asked.
+ */ function openRouterDecisionRequest(params) {
+    var _ref;
+    var prompt = params.prompt, state = params.state, questions = params.questions, overrides = params.overrides, sessionId = params.sessionId, trace = params.trace;
+    var config = mergeOpenRouterModelConfig([
+        prompt === null || prompt === void 0 ? void 0 : prompt.config,
+        overrides
+    ]);
+    var merged = _object_spread({}, (_ref = prompt === null || prompt === void 0 ? void 0 : prompt.questions) !== null && _ref !== void 0 ? _ref : undefined, questions !== null && questions !== void 0 ? questions : undefined);
+    var validation = validateOpenRouterDecisionQuestions(merged);
+    if (!validation.valid) {
+        throw new OpenRouterDecisionDeclarationError(validation.errors);
+    }
+    return {
+        config: config,
+        state: state,
+        questions: merged,
+        sessionId: sessionId,
+        trace: trace
+    };
+}
+/**
+ * Splits a model config into the parameters a decisions request accepts and the ones it does not.
+ *
+ * The decisions route takes only `model`, `provider` and `user`. Everything else on
+ * {@link OpenRouterModelConfig} describes a completion — an output format, a reasoning budget, a tool
+ * set, a temperature — and none of it has a meaning here: a decision has no free-form output to shape
+ * and no tools to call. Those keys are reported in `dropped` rather than quietly discarded, because a
+ * `temperature` a caller believes is in effect is exactly the kind of thing that is only noticed when
+ * an answer is already wrong.
+ *
+ * `models` (the fallback chain) is dropped for a sharper reason: the decisions route takes a single
+ * `model`, so a chain authored here does not degrade to its first entry — it simply does not exist.
+ *
+ * @param config - The merged model config.
+ * @returns The split config.
+ */ function splitOpenRouterDecisionModelConfig(config) {
+    // Named in a destructure rather than a list of strings, exactly as `splitOpenRouterModelConfig` does,
+    // so TypeScript checks the names against the config interface and a rename cannot leave a stale entry.
+    var _ref = config !== null && config !== void 0 ? config : {}, model = _ref.model, provider = _ref.provider, user = _ref.user, requestTimeoutMs = _ref.requestTimeoutMs, rest = _object_without_properties(_ref, [
+        "model",
+        "provider",
+        "user",
+        "requestTimeoutMs"
+    ]);
+    var dropped = Object.keys(filterUndefinedValues(rest));
+    return {
+        requestConfig: filterUndefinedValues({
+            model: model,
+            provider: provider,
+            user: user
+        }),
+        requestTimeoutMs: requestTimeoutMs,
+        dropped: dropped
+    };
+}
+/**
+ * Validates a decision request before it is sent.
+ *
+ * The mirror of `validateOpenRouterModelConfig` for this arm, and the reason both exist: the model slug
+ * is the ONLY thing that says which of OpenRouter's two inference surfaces a request belongs to, so it
+ * is checked on both, and neither arm can be entered with a model the other one owns.
+ *
+ * @param request - The request to check.
+ * @returns The validation result.
+ */ function validateOpenRouterDecisionRequest(request) {
+    var errors = [];
+    var warnings = [];
+    if (request == null) {
+        errors.push('No decision request was provided.');
+    } else {
+        var _splitOpenRouterDecisionModelConfig = splitOpenRouterDecisionModelConfig(request.config), requestConfig = _splitOpenRouterDecisionModelConfig.requestConfig, dropped = _splitOpenRouterDecisionModelConfig.dropped;
+        var model = requestConfig.model;
+        if (!model) {
+            errors.push('No `model` was specified.');
+        } else if (!isOpenRouterSystemOneModelId(model)) {
+            errors.push("`".concat(model, "` is not a System One model, and only a System One model answers a decision. Name a `typesafe/…` model (see DEFAULT_OPENROUTER_SYSTEM_ONE_MODEL_ID), or call `callModelForOpenRouterRequest` instead."));
+        }
+        var questionValidation = validateOpenRouterDecisionQuestions(request.questions);
+        questionValidation.errors.forEach(function(x) {
+            return errors.push(x);
+        });
+        questionValidation.warnings.forEach(function(x) {
+            return warnings.push(x);
+        });
+        if (dropped.length > 0) {
+            var names = dropped.map(function(x) {
+                return '`' + x + '`';
+            }).join(', ');
+            warnings.push("The decisions route accepts only `model`, `provider` and `user`; ".concat(names, " ").concat(dropped.length === 1 ? 'was' : 'were', " dropped from the request."));
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors: errors,
+        warnings: warnings
+    };
+}
+/**
+ * Converts one declared question to its wire shape.
+ *
+ * A pure rename. Three details carry meaning and are not incidental:
+ *
+ * - an option with no description becomes an explicit `null`, which is how the wire spells "undescribed
+ *   option" — omitting the key would instead remove the option from the answer space;
+ * - a Noul with no `means` omits `criteria` ENTIRELY rather than sending an empty object;
+ * - a structured entry is passed through by IDENTITY, never copied or re-serialized, because the wire
+ *   carries declaration guidance verbatim and a normalising round-trip is exactly the kind of silent
+ *   edit this mapping must not make.
+ *
+ * @param question - The declared question.
+ * @returns The wire question.
+ */ function openRouterDecisionWireQuestion(question) {
+    var result;
+    switch(question.type){
+        case 'choice':
+            result = {
+                type: 'choice',
+                instructions: question.instructions,
+                criteria: openRouterDecisionChoiceOptionNames(question).reduce(function(all, option) {
+                    var _question_options_option;
+                    all[option] = (_question_options_option = question.options[option]) !== null && _question_options_option !== void 0 ? _question_options_option : null;
+                    return all;
+                }, {})
+            };
+            break;
+        case 'score':
+            result = {
+                type: 'score',
+                instructions: question.instructions,
+                criteria: _to_consumable_array(question.levels)
+            };
+            break;
+        case 'noul':
+            result = _object_spread({
+                type: 'noul',
+                instructions: question.instructions
+            }, question.means == null ? undefined : {
+                criteria: {
+                    true: question.means.true,
+                    false: question.means.false
+                }
+            });
+            break;
+    }
+    return result;
+}
+/**
+ * Converts a built request into the `/systemone` request body.
+ *
+ * @param request - The built request.
+ * @returns The request body, in the SDK's request surface.
+ */ function openRouterDecisionRequestBody(request) {
+    var _requestConfig_model, _request_sessionId;
+    var requestConfig = splitOpenRouterDecisionModelConfig(request.config).requestConfig;
+    return filterUndefinedValues(_object_spread_props(_object_spread({}, requestConfig), {
+        model: (_requestConfig_model = requestConfig.model) !== null && _requestConfig_model !== void 0 ? _requestConfig_model : '',
+        state: request.state,
+        questions: mapObjectMap(request.questions, function(question) {
+            return openRouterDecisionWireQuestion(question);
+        }),
+        sessionId: (_request_sessionId = request.sessionId) !== null && _request_sessionId !== void 0 ? _request_sessionId : undefined,
+        trace: request.trace == null ? undefined : {
+            additionalProperties: _object_spread({}, request.trace)
+        }
+    }));
+}
+/**
+ * Raised when a reply did not answer the questions that were declared.
+ *
+ * This is always a defect in the RESPONSE and never a judgement the model made. "None of these fits" is
+ * not a fault — it is said through a Noul the caller declared for it, and arrives as an ANSWER. A caller
+ * that catches this is handling a malformed reply, not a negative one.
+ */ var OpenRouterDecisionAnswerFaultError = /*#__PURE__*/ function(Error1) {
+    _inherits(OpenRouterDecisionAnswerFaultError, Error1);
+    function OpenRouterDecisionAnswerFaultError(faults) {
+        _class_call_check(this, OpenRouterDecisionAnswerFaultError);
+        var _this;
+        var described = faults.map(function(x) {
+            return x.question + ' (' + x.kind + '): ' + x.detail;
+        }).join('; ');
+        _this = _call_super(this, OpenRouterDecisionAnswerFaultError, [
+            "The decision reply did not answer its declared questions: ".concat(described)
+        ]), _define_property(_this, "faults", void 0);
+        _this.name = 'OpenRouterDecisionAnswerFaultError';
+        _this.faults = faults;
+        return _this;
+    }
+    return OpenRouterDecisionAnswerFaultError;
+}(_wrap_native_super(Error));
+/**
+ * Collects everything wrong with one answer against the question that asked it.
+ *
+ * @param question - The declared question.
+ * @param id - The question's id, for reporting.
+ * @param answer - The answer as returned, if any.
+ * @returns The faults found. Empty when the answer is well formed.
+ */ function openRouterDecisionAnswerFaults(question, id, answer) {
+    var faults = [];
+    if (answer == null) {
+        faults.push({
+            kind: 'answer-missing',
+            question: id,
+            detail: 'no answer was returned'
+        });
+    } else if (answer.type !== question.type) {
+        faults.push({
+            kind: 'answer-mistyped',
+            question: id,
+            detail: "a ".concat(question.type, " question was answered with a ").concat(answer.type)
+        });
+    } else if (answer.type === 'choice' && question.type === 'choice') {
+        var declared = new Set(openRouterDecisionChoiceOptionNames(question));
+        if (!declared.has(answer.choice)) {
+            faults.push({
+                kind: 'choice-off-option',
+                question: id,
+                detail: "`".concat(answer.choice, "` was not one of the declared options")
+            });
+        }
+        var probabilities = answer.probabilities;
+        if (probabilities != null) {
+            var options = Object.keys(probabilities);
+            var undeclared = options.filter(function(x) {
+                return !declared.has(x);
+            });
+            if (undeclared.length > 0) {
+                var names = undeclared.map(function(x) {
+                    return '`' + x + '`';
+                }).join(', ');
+                faults.push({
+                    kind: 'choice-off-option',
+                    question: id,
+                    detail: "the distribution covers undeclared options ".concat(names)
+                });
+            }
+            var sum = options.reduce(function(total, option) {
+                return total + probabilities[option];
+            }, 0);
+            if (Math.abs(sum - 1) > OPENROUTER_DECISION_DISTRIBUTION_SUM_TOLERANCE) {
+                faults.push({
+                    kind: 'value-out-of-range',
+                    question: id,
+                    detail: "the distribution sums to ".concat(sum, " rather than 1")
+                });
+            }
+        }
+    } else if (answer.type === 'score' && question.type === 'score') {
+        var max = question.levels.length - 1;
+        if (!(answer.score >= 0 && answer.score <= max)) {
+            faults.push({
+                kind: 'value-out-of-range',
+                question: id,
+                detail: "the score ".concat(answer.score, " is outside the declared 0..").concat(max)
+            });
+        }
+    } else if (answer.type === 'noul' && !(answer.noul >= 0 && answer.noul <= 1)) {
+        faults.push({
+            kind: 'value-out-of-range',
+            question: id,
+            detail: "the noul ".concat(answer.noul, " is outside 0..1")
+        });
+    }
+    return faults;
+}
+/**
+ * Membership-checks a reply against the questions that were declared.
+ *
+ * This is the transport's GUARANTEE, and the reason no consumer re-checks: past this point a `choice` is
+ * one of the declared options, a `score` is inside the declared range, and a `noul` is a probability. It
+ * is what a decision has instead of the parse-and-salvage a completion needs — the answer space was
+ * declared, so an answer either sits inside it or the reply is broken.
+ *
+ * Every fault is collected rather than the first, because a reply that lost one answer has usually lost
+ * more than one and reporting them one round-trip at a time is no way to debug a declaration.
+ *
+ * An ABSENT distribution or confidence is checked for nothing: only `choice` / `score` / `noul` are
+ * guaranteed on the wire, so their absence is a real reply.
+ *
+ * @param config - The declared questions and the raw answers.
+ * @returns The answers, or the faults.
+ */ function readOpenRouterDecisionAnswers(config) {
+    var questions = config.questions, raw = config.raw;
+    var faults = Object.keys(questions).flatMap(function(id) {
+        return openRouterDecisionAnswerFaults(questions[id], id, raw[id]);
+    });
+    return faults.length > 0 ? {
+        faults: faults
+    } : {
+        answers: raw
+    };
+}
+/**
+ * Flattens a decisions reply's usage into the package's usage shape.
+ *
+ * Reported through the SAME {@link OpenRouterRunUsage} a completion reports, so the cost ledger needs no
+ * second counting site and a run's spend is readable without knowing which arm served it.
+ *
+ * Two things about this route's numbers, both measured rather than assumed:
+ *
+ * - `outputTokens` is REPORTED and non-zero, but it is not billed. `cost` is input alone at the model's
+ *   input rate — verified live at 350 input tokens and $0.042/Mtok giving exactly $0.0000147, with 34
+ *   output tokens on the same reply. So a cost-per-token derived from `totalTokens` here is wrong.
+ * - `cost` is FINAL when it arrives. A completion's is settled server-side afterwards and refined by the
+ *   broadcast webhook; a decision's is synchronous, which is why a decision run needs no reconciliation.
+ *
+ * A measurement the reply did not report is OMITTED rather than carried as `undefined`, because a spread
+ * `cost: undefined` reads downstream as "cost zero" rather than "cost unknown".
+ *
+ * @param usage - The usage as returned.
+ * @returns The flattened usage.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterRunUsageFromDecisionsUsage(usage) {
+    var result;
+    if (usage != null) {
+        var inputTokens = usage.inputTokens, outputTokens = usage.outputTokens, cost = usage.cost;
+        var totalTokens = inputTokens == null && outputTokens == null ? undefined : (inputTokens !== null && inputTokens !== void 0 ? inputTokens : 0) + (outputTokens !== null && outputTokens !== void 0 ? outputTokens : 0);
+        result = filterUndefinedValues({
+            inputTokens: inputTokens,
+            outputTokens: outputTokens,
+            totalTokens: totalTokens,
+            cost: cost
+        }, true);
+    }
+    return result;
+}
+
+export { openRouterNoulQuestion as A, openRouterProviderPinnedTo as B, openRouterRunUsageFromDecisionsUsage as C, DEFAULT_OPENROUTER_PDF_PARSER_ENGINE as D, openRouterScoreQuestion as E, readOpenRouterDecisionAnswers as F, splitOpenRouterDecisionModelConfig as G, validateOpenRouterDecisionQuestions as H, validateOpenRouterDecisionRequest as I, validateOpenRouterModelConfig as J, OPENROUTER_DECISION_CHOICE_OPTIONS_MAX as O, DEFAULT_OPENROUTER_SYSTEM_ONE_MODEL_ID as a, OPENROUTER_DECISION_CONFIDENCE_HIGH as b, OPENROUTER_DECISION_CONFIDENCE_MEDIUM as c, OPENROUTER_DECISION_DISTRIBUTION_SUM_TOLERANCE as d, OPENROUTER_DECISION_SCORE_LEVELS_MAX as e, OPENROUTER_DECISION_SCORE_LEVELS_MIN as f, OPENROUTER_JEV_1_13_MODEL_ID as g, OPENROUTER_JEV_LATEST_MODEL_ID as h, OPENROUTER_JEV_PREVIEW_MODEL_ID as i, OPENROUTER_SYSTEM_ONE_MODEL_NAMESPACE as j, OpenRouterDecisionAnswerFaultError as k, OpenRouterDecisionDeclarationError as l, asOpenRouterDecisionConfidenceBand as m, isBlankOpenRouterDecisionEntry as n, isOpenRouterSystemOneModelId as o, mapOpenRouterDecisionChoiceRows as p, mergeOpenRouterModelConfig as q, openRouterChoiceQuestion as r, openRouterDecisionChoiceOptionNames as s, openRouterDecisionChoiceRanking as t, openRouterDecisionRequest as u, openRouterDecisionRequestBody as v, openRouterDecisionStatePaths as w, openRouterDecisionWireQuestion as x, openRouterFileParserPlugin as y, openRouterFileSearchTool as z };