@dereekb/openrouter 14.6.0 → 14.8.0

package/index.esm.js

@@ -1,4 +1,4 @@
-import { filterUndefinedValues, mergeObjects, arrayToMap } from '@dereekb/util';
+import { filterUndefinedValues, mergeObjects, mapObjectMap, 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';
@@ -21,15 +23,62 @@ export { finishReasonIs, hasToolCall, maxCost, maxTokensUsed, stepCountIs } from
 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) {
+/**
+ * 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$4(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 _array_without_holes$4(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$4(arr);
 }
-function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+function _assert_this_initialized$1(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,22 +89,45 @@ 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 _define_property$2(obj, key, value) {
+function _call_super$1(_this, derived, args) {
+    derived = _get_prototype_of$1(derived);
+    return _possible_constructor_return$1(_this, _is_native_reflect_construct$1() ? Reflect.construct(derived, args || [], _get_prototype_of$1(_this).constructor) : derived.apply(_this, args));
+}
+function _class_call_check$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function _construct$1(Parent, args, Class) {
+    if (_is_native_reflect_construct$1()) _construct$1 = Reflect.construct;
+    else {
+        _construct$1 = 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$1(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct$1.apply(null, arguments);
+}
+function _define_property$4(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -66,15 +138,45 @@ function _define_property$2(obj, key, value) {
     } else obj[key] = value;
     return obj;
 }
-function _iterable_to_array$1(iter) {
+function _get_prototype_of$1(o) {
+    _get_prototype_of$1 = Object.setPrototypeOf ? Object.getPrototypeOf : function getPrototypeOf(o) {
+        return o.__proto__ || Object.getPrototypeOf(o);
+    };
+    return _get_prototype_of$1(o);
+}
+function _inherits$1(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$1(subClass, superClass);
+}
+function _is_native_function$1(fn) {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+}
+function _is_native_reflect_construct$1() {
+    try {
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct$1 = function() {
+        return !!result;
+    })();
+}
+function _iterable_to_array$4(iter) {
     if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
         return Array.from(iter);
     }
 }
-function _non_iterable_spread$1() {
+function _non_iterable_spread$4() {
     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) {
+function _object_spread$4(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -84,12 +186,12 @@ function _object_spread$2(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$2(target, key, source[key]);
+            _define_property$4(target, key, source[key]);
         });
     }
     return target;
 }
-function ownKeys$1(object, enumerableOnly) {
+function ownKeys$2(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
@@ -97,17 +199,17 @@ function ownKeys$1(object, enumerableOnly) {
     }
     return keys;
 }
-function _object_spread_props$1(target, source) {
+function _object_spread_props$2(target, source) {
     source = source != null ? source : {};
     if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     else {
-        ownKeys$1(Object(source)).forEach(function(key) {
+        ownKeys$2(Object(source)).forEach(function(key) {
             Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
         });
     }
     return target;
 }
-function _object_without_properties$1(source, excluded) {
+function _object_without_properties$2(source, excluded) {
     if (source == null) return {};
     var target = {}, sourceKeys, key, i;
     if (typeof Reflect !== "undefined" && Reflect.ownKeys) {
@@ -120,7 +222,7 @@ function _object_without_properties$1(source, excluded) {
         }
         return target;
     }
-    target = _object_without_properties_loose$1(source, excluded);
+    target = _object_without_properties_loose$2(source, excluded);
     if (Object.getOwnPropertySymbols) {
         sourceKeys = Object.getOwnPropertySymbols(source);
         for(i = 0; i < sourceKeys.length; i++){
@@ -132,7 +234,7 @@ function _object_without_properties$1(source, excluded) {
     }
     return target;
 }
-function _object_without_properties_loose$1(source, excluded) {
+function _object_without_properties_loose$2(source, excluded) {
     if (source == null) return {};
     var target = {}, sourceKeys = Object.getOwnPropertyNames(source), key, i;
     for(i = 0; i < sourceKeys.length; i++){
@@ -143,10 +245,21 @@ function _object_without_properties_loose$1(source, excluded) {
     }
     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 _possible_constructor_return$1(self, call) {
+    if (call && (_type_of$2(call) === "object" || typeof call === "function")) return call;
+    return _assert_this_initialized$1(self);
 }
-function _ts_generator$2(thisArg, body) {
+function _set_prototype_of$1(o, p) {
+    _set_prototype_of$1 = Object.setPrototypeOf || function setPrototypeOf(o, p) {
+        o.__proto__ = p;
+        return o;
+    };
+    return _set_prototype_of$1(o, p);
+}
+function _to_consumable_array$4(arr) {
+    return _array_without_holes$4(arr) || _iterable_to_array$4(arr) || _unsupported_iterable_to_array$4(arr) || _non_iterable_spread$4();
+}
+function _ts_generator$3(thisArg, body) {
     var f, y, t, _ = {
         label: 0,
         sent: function() {
@@ -245,17 +358,41 @@ function _ts_generator$2(thisArg, body) {
         };
     }
 }
-function _type_of(obj) {
+function _type_of$2(obj) {
     "@swc/helpers - typeof";
     return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
 }
-function _unsupported_iterable_to_array$1(o, minLen) {
+function _unsupported_iterable_to_array$4(o, minLen) {
     if (!o) return;
-    if (typeof o === "string") return _array_like_to_array$1(o, minLen);
+    if (typeof o === "string") return _array_like_to_array$4(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);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$4(o, minLen);
+}
+function _wrap_native_super$1(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super$1 = function(Class) {
+        if (Class === null || !_is_native_function$1(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$1(Class, arguments, _get_prototype_of$1(this).constructor);
+        }
+        Wrapper.prototype = Object.create(Class.prototype, {
+            constructor: {
+                value: Wrapper,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        return _set_prototype_of$1(Wrapper, Class);
+    };
+    return _wrap_native_super$1(Class);
 }
 /**
  * Splits a model config into request parameters and execution controls.
@@ -268,7 +405,7 @@ function _unsupported_iterable_to_array$1(o, minLen) {
  * @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, [
+    var _ref = config !== null && config !== void 0 ? config : {}, maxSteps = _ref.maxSteps, requestTimeoutMs = _ref.requestTimeoutMs, rest = _object_without_properties$2(_ref, [
         "maxSteps",
         "requestTimeoutMs"
     ]);
@@ -296,21 +433,69 @@ 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$1(OpenRouterSystemOneModelOnCompletionArmError, Error1);
+    function OpenRouterSystemOneModelOnCompletionArmError(model) {
+        _class_call_check$1(this, OpenRouterSystemOneModelOnCompletionArmError);
+        var _this;
+        _this = _call_super$1(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$4(_this, "model", void 0);
+        _this.name = 'OpenRouterSystemOneModelOnCompletionArmError';
+        _this.model = model;
+        return _this;
+    }
+    return OpenRouterSystemOneModelOnCompletionArmError;
+}(_wrap_native_super$1(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$4((_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), {
+    return filterUndefinedValues(_object_spread_props$2(_object_spread$4({}, requestConfig), {
         input: request.input,
         instructions: request.instructions || undefined,
         trace: request.trace == null ? undefined : {
-            additionalProperties: _object_spread$2({}, request.trace)
+            additionalProperties: _object_spread$4({}, request.trace)
         }
     }));
 }
@@ -328,11 +513,11 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     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, [
+    var _openRouterResponsesRequestBody = openRouterResponsesRequestBody(request); _openRouterResponsesRequestBody.tools; _openRouterResponsesRequestBody.stream; var body = _object_without_properties$2(_openRouterResponsesRequestBody, [
         "tools",
         "stream"
     ]);
-    var input = filterUndefinedValues(_object_spread_props$1(_object_spread$2({}, body), {
+    var input = filterUndefinedValues(_object_spread_props$2(_object_spread$4({}, body), {
         tools: tools !== null && tools !== void 0 ? tools : undefined,
         state: state !== null && state !== void 0 ? state : undefined,
         stopWhen: maxSteps == null ? undefined : stepCountIs(maxSteps)
@@ -351,7 +536,7 @@ function _unsupported_iterable_to_array$1(o, minLen) {
  * @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 : {
+    return _object_spread$4({}, options, requestTimeoutMs == null ? undefined : {
         timeoutMs: requestTimeoutMs
     });
 }
@@ -370,7 +555,7 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     // 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), {
+    return _object_spread_props$2(_object_spread$4({}, options), {
         headers: headers
     });
 }
@@ -388,14 +573,14 @@ 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;
                     requestTimeoutMs = splitOpenRouterModelConfig(request.config).requestTimeoutMs;
-                    responsesRequest = _object_spread_props$1(_object_spread$2({}, openRouterResponsesRequestBody(request)), {
+                    responsesRequest = _object_spread_props$2(_object_spread$4({}, openRouterResponsesRequestBody(request)), {
                         stream: false
                     });
                     return [
@@ -449,13 +634,13 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     } 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, [
+        var _openRouterResponsesRequestBody = openRouterResponsesRequestBody(request); _openRouterResponsesRequestBody.stream; var body = _object_without_properties$2(_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))
+        var apiRequest = _object_spread_props$2(_object_spread$4({}, body), {
+            tools: _to_consumable_array$4(tools == null ? [] : convertToolsToAPIFormat(tools)).concat(_to_consumable_array$4(hostedTools))
         });
-        result = new ModelResult(_object_spread$2({
+        result = new ModelResult(_object_spread$4({
             client: client,
             request: apiRequest,
             options: openRouterCallModelRequestOptions(requestOptions)
@@ -479,9 +664,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
@@ -629,7 +814,7 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     if (outputText) {
         try {
             var parsed = JSON.parse(outputText);
-            if (parsed != null && (typeof parsed === "undefined" ? "undefined" : _type_of(parsed)) === 'object' && !Array.isArray(parsed)) {
+            if (parsed != null && (typeof parsed === "undefined" ? "undefined" : _type_of$2(parsed)) === 'object' && !Array.isArray(parsed)) {
                 result = parsed;
             }
         } catch (unused) {
@@ -639,7 +824,15 @@ function _unsupported_iterable_to_array$1(o, minLen) {
     return result;
 }
 
-function _define_property$1(obj, key, value) {
+function _array_like_to_array$3(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$3(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array$3(arr);
+}
+function _define_property$3(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -650,7 +843,15 @@ function _define_property$1(obj, key, value) {
     } else obj[key] = value;
     return obj;
 }
-function _object_spread$1(target) {
+function _iterable_to_array$3(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) {
+        return Array.from(iter);
+    }
+}
+function _non_iterable_spread$3() {
+    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$3(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -660,11 +861,22 @@ function _object_spread$1(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$1(target, key, source[key]);
+            _define_property$3(target, key, source[key]);
         });
     }
     return target;
 }
+function _to_consumable_array$3(arr) {
+    return _array_without_holes$3(arr) || _iterable_to_array$3(arr) || _unsupported_iterable_to_array$3(arr) || _non_iterable_spread$3();
+}
+function _unsupported_iterable_to_array$3(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array$3(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$3(o, minLen);
+}
 /**
  * Builds a hosted `file_search` tool entry with the field names the SDK actually forwards.
  *
@@ -674,7 +886,7 @@ function _object_spread$1(target) {
  *
  * @__NO_SIDE_EFFECTS__
  */ function openRouterFileSearchTool(vectorStoreIds, maxNumResults) {
-    return _object_spread$1({
+    return _object_spread$3({
         type: 'file_search',
         vectorStoreIds: vectorStoreIds
     }, maxNumResults == null ? undefined : {
@@ -748,18 +960,46 @@ function _object_spread$1(target) {
  * 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) {
+ */ 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 _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)) {
+        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$3((_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) {
@@ -799,6 +1039,1116 @@ function _object_spread$1(target) {
     };
 }
 
+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 _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+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);
+}
+/**
+ * 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".
+ *
+ * @param confidence - The reported confidence, if any.
+ * @returns The band.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function asOpenRouterDecisionConfidenceBand(confidence) {
+    var result;
+    if (confidence == null || 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$2(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$2({
+        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$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 _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$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 _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$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 _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);
+    }
+}
+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 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 _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) {
+    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
+        };
+    }
+}
+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 _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$1(_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$1({}, (_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$1(_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$1(question.levels)
+            };
+            break;
+        case 'noul':
+            result = _object_spread$1({
+                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$1(_object_spread$1({}, 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$1({}, 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$1(_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;
+}
+/**
+ * Asks a decision and returns its answers.
+ *
+ * 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 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
+                        }
+                    ];
+            }
+        });
+    })();
+}
+
 function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
     try {
         var info = gen[key](arg);
@@ -1755,4 +3105,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 { DEFAULT_OPENROUTER_PDF_PARSER_ENGINE, DEFAULT_OPENROUTER_SYSTEM_ONE_MODEL_ID, OPENROUTER_CALL_MODEL_HEADER, OPENROUTER_DECISION_CHOICE_OPTIONS_MAX, OPENROUTER_DECISION_CONFIDENCE_HIGH, OPENROUTER_DECISION_CONFIDENCE_MEDIUM, OPENROUTER_DECISION_DISTRIBUTION_SUM_TOLERANCE, OPENROUTER_DECISION_SCORE_LEVELS_MAX, OPENROUTER_DECISION_SCORE_LEVELS_MIN, OPENROUTER_JEV_1_13_MODEL_ID, OPENROUTER_JEV_LATEST_MODEL_ID, OPENROUTER_JEV_PREVIEW_MODEL_ID, OPENROUTER_SYSTEM_ONE_MODEL_NAMESPACE, OpenRouterDecisionAnswerFaultError, OpenRouterDecisionDeclarationError, OpenRouterSystemOneModelOnCompletionArmError, asOpenRouterDecisionConfidenceBand, callModelForOpenRouterRequest, isBlankOpenRouterDecisionEntry, isOpenRouterStateAwaitingDeferredTools, isOpenRouterSystemOneModelId, mapOpenRouterDecisionChoiceRows, mergeOpenRouterModelConfig, openRouterCallModelInput, openRouterCallResultFromResponse, openRouterChoiceQuestion, openRouterDecision, openRouterDecisionChoiceOptionNames, openRouterDecisionChoiceRanking, openRouterDecisionRequest, openRouterDecisionRequestBody, openRouterDecisionStatePaths, openRouterDecisionWireQuestion, openRouterDecodeBase64, openRouterEmbeddingVector, openRouterEmbeddings, openRouterFileAnnotationMessage, openRouterFileAnnotationText, openRouterFileParserPlugin, openRouterFileSearchTool, openRouterFunctionCallOutputItems, openRouterGeneration, openRouterGenerationContent, openRouterHostedTools, openRouterInputFileDataPart, openRouterInputFilePartsForAttachedFiles, openRouterInputFileUrlPart, openRouterInputImagePart, openRouterInputMessages, openRouterInputTextPart, openRouterMessagesWithFreshFileAttachments, openRouterMessagesWithoutFileAttachmentData, openRouterModelResultForRequest, openRouterNoulQuestion, openRouterOutputTextFromResponse, openRouterPendingDeferredToolCallFromParsedCall, openRouterPendingDeferredToolCalls, openRouterPromptRequest, openRouterProviderPinnedTo, openRouterResolvedDeferredToolResults, openRouterResponsesRequestBody, openRouterRunErrorFromResponseError, openRouterRunUsageFromDecisionsUsage, openRouterRunUsageFromResponseUsage, openRouterScoreQuestion, openRouterUnparsedAttachedFiles, parseOpenRouterJsonOutput, readOpenRouterDecisionAnswers, sendOpenRouterResponsesRequest, splitOpenRouterDecisionModelConfig, splitOpenRouterModelConfig, validateOpenRouterDecisionQuestions, validateOpenRouterDecisionRequest, validateOpenRouterModelConfig };