@dereekb/openrouter 14.7.0 → 14.9.0

package/firebase-server/index.esm.js

@@ -1,6 +1,6 @@
 import { firestoreModelId, firestoreModelKeyParentKey, getDocumentSnapshotDataTuples } from '@dereekb/firebase';
-import { runAsyncTasksForValues, mergeObjects, KeyValueTypleValueFilter, concatArraysUnique, MS_IN_MINUTE, arrayToMap, expiringCachedGetter, filterMaybeArrayValues, filterUniqueValues, mergeArrays, addMilliseconds, filterUndefinedValues, randomNumberFactory, performTasksInParallel } from '@dereekb/util';
-import { validateOpenRouterModelConfig, openRouterPromptRequest, callModelForOpenRouterRequest, openRouterMessagesWithoutFileAttachmentData, openRouterMessagesWithFreshFileAttachments, openRouterInputMessages, openRouterFunctionCallOutputItems } from '@dereekb/openrouter';
+import { runAsyncTasksForValues, mergeObjects, KeyValueTypleValueFilter, concatArraysUnique, MS_IN_MINUTE, arrayToMap, expiringCachedGetter, filterMaybeArrayValues, addMilliseconds, filterUniqueValues, mergeArrays, filterUndefinedValues, randomNumberFactory, performTasksInParallel } from '@dereekb/util';
+import { validateOpenRouterModelConfig, validateOpenRouterDecisionQuestions, openRouterPromptRequest, callModelForOpenRouterRequest, openRouterDecisionRequest, openRouterDecision, openRouterMessagesWithoutFileAttachmentData, openRouterMessagesWithFreshFileAttachments, openRouterInputMessages, openRouterFunctionCallOutputItems } from '@dereekb/openrouter';
 import { updateOpenRouterPromptParamsType, readOpenRouterPromptParamsType, createOpenRouterPromptVersionParamsType, updateOpenRouterPromptVersionParamsType, OpenRouterPromptState, openRouterPromptVersionId, openRouterResolvedPromptForVersion, OpenRouterRunTaskState, openRouterRunTasksRunnableQuery, openRouterRunTasksReclaimableQuery, OPENROUTER_RUN_TASK_MAX_AGE, openRouterRunTasksExpiredQuery, isOpenRouterRunTaskStateTerminal } from '@dereekb/openrouter/firebase';
 
 function _array_like_to_array$2(arr, len) {
@@ -299,9 +299,9 @@ function _unsupported_iterable_to_array$2(o, minLen) {
     var firebaseServerActionTransformFunctionFactory = context.firebaseServerActionTransformFunctionFactory, openRouterPromptCollection = context.openRouterPromptCollection, openRouterPromptVersionCollectionFactory = context.openRouterPromptVersionCollectionFactory, openRouterPromptService = context.openRouterPromptService;
     return firebaseServerActionTransformFunctionFactory(updateOpenRouterPromptParamsType, function(params) {
         return _async_to_generator$8(function() {
-            var name, description, tags, state, activeVersion;
+            var name, description, tags, state, activeVersion, storeLocked;
             return _ts_generator$8(this, function(_state) {
-                name = params.name, description = params.description, tags = params.tags, state = params.state, activeVersion = params.activeVersion;
+                name = params.name, description = params.description, tags = params.tags, state = params.state, activeVersion = params.activeVersion, storeLocked = params.storeLocked;
                 return [
                     2,
                     function(document) {
@@ -353,6 +353,7 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                                                         t: tags,
                                                                         s: state !== null && state !== void 0 ? state : undefined,
                                                                         av: activeVersion,
+                                                                        sl: storeLocked,
                                                                         uat: new Date()
                                                                     })
                                                                 ];
@@ -423,7 +424,9 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                             2
                                         ]), prompt = _ref[0], resolution = _ref[1];
                                         resolved = resolution.resolved, source = resolution.source;
-                                        validation = validateOpenRouterModelConfig(resolved.config);
+                                        validation = validateOpenRouterModelConfig(resolved.config, {
+                                            decision: resolved.questions != null
+                                        });
                                         result = {
                                             prompt: prompt !== null && prompt !== void 0 ? prompt : null,
                                             resolved: resolved,
@@ -457,22 +460,31 @@ function _unsupported_iterable_to_array$2(o, minLen) {
     var firebaseServerActionTransformFunctionFactory = context.firebaseServerActionTransformFunctionFactory, openRouterPromptCollection = context.openRouterPromptCollection, openRouterPromptVersionCollectionFactory = context.openRouterPromptVersionCollectionFactory, openRouterPromptService = context.openRouterPromptService;
     return firebaseServerActionTransformFunctionFactory(createOpenRouterPromptVersionParamsType, function(params) {
         return _async_to_generator$8(function() {
-            var instructions, messages, config, notes, activate;
+            var instructions, messages, config, questions, notes, activate;
             return _ts_generator$8(this, function(_state) {
-                instructions = params.instructions, messages = params.messages, config = params.config, notes = params.notes, activate = params.activate;
+                instructions = params.instructions, messages = params.messages, config = params.config, questions = params.questions, notes = params.notes, activate = params.activate;
                 return [
                     2,
                     function(document) {
                         return _async_to_generator$8(function() {
-                            var modelConfig, validation, result;
+                            var modelConfig, modelQuestions, validation, questionValidation, result;
                             return _ts_generator$8(this, function(_state) {
                                 switch(_state.label){
                                     case 0:
                                         modelConfig = config !== null && config !== void 0 ? config : undefined;
-                                        validation = validateOpenRouterModelConfig(modelConfig !== null && modelConfig !== void 0 ? modelConfig : {});
+                                        modelQuestions = questions !== null && questions !== void 0 ? questions : undefined;
+                                        validation = validateOpenRouterModelConfig(modelConfig !== null && modelConfig !== void 0 ? modelConfig : {}, {
+                                            decision: modelQuestions != null
+                                        });
                                         if (!validation.valid) {
                                             throw new Error('Cannot create a version of OpenRouterPrompt "'.concat(document.id, '": ').concat(validation.errors.join(' ')));
                                         }
+                                        if (modelQuestions != null) {
+                                            questionValidation = validateOpenRouterDecisionQuestions(modelQuestions);
+                                            if (!questionValidation.valid) {
+                                                throw new Error('Cannot create a version of OpenRouterPrompt "'.concat(document.id, '": ').concat(questionValidation.errors.join(' ')));
+                                            }
+                                        }
                                         return [
                                             4,
                                             openRouterPromptCollection.firestoreContext.runTransaction(function(transaction) {
@@ -532,6 +544,7 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                                                         };
                                                                     }),
                                                                     c: modelConfig,
+                                                                    q: modelQuestions,
                                                                     nt: notes
                                                                 };
                                                                 if (!(previousVersionDocument != null && previousVersionExists)) return [
@@ -611,23 +624,24 @@ function _unsupported_iterable_to_array$2(o, minLen) {
     var firebaseServerActionTransformFunctionFactory = context.firebaseServerActionTransformFunctionFactory, openRouterPromptCollection = context.openRouterPromptCollection, openRouterPromptVersionCollectionGroup = context.openRouterPromptVersionCollectionGroup, openRouterPromptService = context.openRouterPromptService;
     return firebaseServerActionTransformFunctionFactory(updateOpenRouterPromptVersionParamsType, function(params) {
         return _async_to_generator$8(function() {
-            var instructions, messages, config, notes;
+            var instructions, messages, config, questions, notes;
             return _ts_generator$8(this, function(_state) {
-                instructions = params.instructions, messages = params.messages, config = params.config, notes = params.notes;
+                instructions = params.instructions, messages = params.messages, config = params.config, questions = params.questions, notes = params.notes;
                 return [
                     2,
                     function(document) {
                         return _async_to_generator$8(function() {
-                            var inputConfig, validation;
+                            var inputConfig, inputQuestions, validation;
                             return _ts_generator$8(this, function(_state) {
                                 switch(_state.label){
                                     case 0:
                                         inputConfig = config;
+                                        inputQuestions = questions;
                                         return [
                                             4,
                                             openRouterPromptCollection.firestoreContext.runTransaction(function(transaction) {
                                                 return _async_to_generator$8(function() {
-                                                    var _ref, inTransaction, version, result;
+                                                    var _ref, inTransaction, version, nextQuestions, result, questionValidation;
                                                     return _ts_generator$8(this, function(_state) {
                                                         switch(_state.label){
                                                             case 0:
@@ -648,10 +662,22 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                                                 // touches only the instructions must not be judged against an empty config and refused for
                                                                 // naming no model. An explicitly null config is judged as the empty config it would leave behind,
                                                                 // which is exactly the refusal that should happen.
-                                                                result = validateOpenRouterModelConfig((_ref = config === undefined ? version.c : inputConfig) !== null && _ref !== void 0 ? _ref : {});
+                                                                // The same "judge what it will SAY" rule applied to the questions: an omitted `questions` leaves
+                                                                // the version's own, so an edit touching only the instructions is still judged as the decision
+                                                                // it remains rather than as a completion that names a System One model.
+                                                                nextQuestions = questions === undefined ? version.q : inputQuestions;
+                                                                result = validateOpenRouterModelConfig((_ref = config === undefined ? version.c : inputConfig) !== null && _ref !== void 0 ? _ref : {}, {
+                                                                    decision: nextQuestions != null
+                                                                });
                                                                 if (!result.valid) {
                                                                     throw new Error('Cannot update OpenRouterPromptVersion "'.concat(document.key, '": ').concat(result.errors.join(' ')));
                                                                 }
+                                                                if (nextQuestions != null) {
+                                                                    questionValidation = validateOpenRouterDecisionQuestions(nextQuestions);
+                                                                    if (!questionValidation.valid) {
+                                                                        throw new Error('Cannot update OpenRouterPromptVersion "'.concat(document.key, '": ').concat(questionValidation.errors.join(' ')));
+                                                                    }
+                                                                }
                                                                 // Undefined fields are stripped before the write, so an omitted field is left as it was. `null`
                                                                 // is passed through for the fields that can meaningfully carry nothing.
                                                                 return [
@@ -666,6 +692,7 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                                                             };
                                                                         }),
                                                                         c: inputConfig,
+                                                                        q: inputQuestions,
                                                                         nt: notes
                                                                     })
                                                                 ];
@@ -753,7 +780,7 @@ function _unsupported_iterable_to_array$2(o, minLen) {
          * @returns What the write did.
          */ function seedTarget(target) {
                 return _async_to_generator$8(function() {
-                    var _ref, definition, promptDocument, prompt, promptKey, version, latestVersion, archived, outcome, versionCollection, versionAccessor, targetVersionId, targetVersionExists, _definition_messages, previousVersionId, previousVersionExists, _tmp, versionData, writeBatch, versionWriteAccessor, promptWriteDocument;
+                    var _ref, definition, promptDocument, prompt, promptKey, version, latestVersion, archived, storeLocked, outcome, versionCollection, versionAccessor, targetVersionId, targetVersionExists, _definition_messages, previousVersionId, previousVersionExists, _tmp, versionData, writeBatch, versionWriteAccessor, promptWriteDocument;
                     return _ts_generator$8(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -764,6 +791,11 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                 // reseed silently undoing it is the same class of bug as reverting an operator's rename. Decided
                                 // from the prompt alone, so an archived definition costs no further read.
                                 archived = (prompt === null || prompt === void 0 ? void 0 : prompt.s) === OpenRouterPromptState.ARCHIVED;
+                                // A STORE-LOCKED prompt is the same rule pointed at a different writer: its content is maintained
+                                // at runtime, so code publishing over it would silently discard an operator's work. Reported as a
+                                // warning rather than skipped in silence, because a definition whose version has moved ahead and
+                                // never lands otherwise looks exactly like a seed that ran and did nothing.
+                                storeLocked = (prompt === null || prompt === void 0 ? void 0 : prompt.sl) === true;
                                 if (!archived) return [
                                     3,
                                     1
@@ -771,9 +803,20 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                 outcome = 'skipped';
                                 return [
                                     3,
-                                    15
+                                    16
                                 ];
                             case 1:
+                                if (!storeLocked) return [
+                                    3,
+                                    2
+                                ];
+                                warnings.push("".concat(promptKey, ": the prompt is store-locked, so the definition declaring version ").concat(version, " was not published. Unset `storeLocked` to let code seed it again."));
+                                outcome = 'skipped';
+                                return [
+                                    3,
+                                    16
+                                ];
+                            case 2:
                                 versionCollection = openRouterPromptVersionCollectionFactory(promptDocument);
                                 versionAccessor = versionCollection.documentAccessor();
                                 targetVersionId = openRouterPromptVersionId(version);
@@ -781,11 +824,11 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                     4,
                                     versionAccessor.loadDocumentForId(targetVersionId).accessor.exists()
                                 ];
-                            case 2:
+                            case 3:
                                 targetVersionExists = _state.sent();
                                 if (!(version > latestVersion && !targetVersionExists)) return [
                                     3,
-                                    14
+                                    15
                                 ];
                                 // The outgoing head's address comes from the prompt's own `lv`, and `version > latestVersion`
                                 // above is what guarantees it is not the document about to be written. Existence-checked
@@ -794,22 +837,22 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                 previousVersionId = latestVersion > 0 ? openRouterPromptVersionId(latestVersion) : undefined;
                                 if (!(previousVersionId == null)) return [
                                     3,
-                                    3
+                                    4
                                 ];
                                 _tmp = false;
                                 return [
                                     3,
-                                    5
+                                    6
                                 ];
-                            case 3:
+                            case 4:
                                 return [
                                     4,
                                     versionAccessor.loadDocumentForId(previousVersionId).accessor.exists()
                                 ];
-                            case 4:
-                                _tmp = _state.sent();
-                                _state.label = 5;
                             case 5:
+                                _tmp = _state.sent();
+                                _state.label = 6;
+                            case 6:
                                 previousVersionExists = _tmp;
                                 versionData = {
                                     cat: new Date(),
@@ -823,6 +866,7 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                         };
                                     }),
                                     c: definition.config,
+                                    q: definition.questions,
                                     nt: "Seeded from the code definition declaring version ".concat(version, ".")
                                 };
                                 // One batch for this definition and nothing else. Atomic, so a prompt never ends up pointing
@@ -833,7 +877,7 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                 promptWriteDocument = openRouterPromptCollection.documentAccessorForWriteBatch(writeBatch).loadDocumentForId(promptKey);
                                 if (!(previousVersionId != null && previousVersionExists)) return [
                                     3,
-                                    7
+                                    8
                                 ];
                                 return [
                                     4,
@@ -841,20 +885,23 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                         lk: true
                                     })
                                 ];
-                            case 6:
-                                _state.sent();
-                                _state.label = 7;
                             case 7:
+                                _state.sent();
+                                _state.label = 8;
+                            case 8:
                                 return [
                                     4,
                                     versionWriteAccessor.loadDocumentForId(targetVersionId).accessor.set(versionData)
                                 ];
-                            case 8:
+                            case 9:
                                 _state.sent();
                                 if (!(prompt == null)) return [
                                     3,
-                                    10
+                                    11
                                 ];
+                                // `storeLocked` is written ONLY here, on create. A definition cannot lock a prompt it did
+                                // not create: doing so would let code seize one an operator is already maintaining, which
+                                // is the exact thing the flag exists to prevent in the other direction.
                                 return [
                                     4,
                                     promptWriteDocument.accessor.set({
@@ -863,16 +910,17 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                         d: definition.description,
                                         s: OpenRouterPromptState.ACTIVE,
                                         lv: version,
-                                        av: version
+                                        av: version,
+                                        sl: definition.storeLocked
                                     })
                                 ];
-                            case 9:
+                            case 10:
                                 _state.sent();
                                 return [
                                     3,
-                                    12
+                                    13
                                 ];
-                            case 10:
+                            case 11:
                                 // `n`/`d`/`t` are deliberately untouched: they are operator-editable through
                                 // updateOpenRouterPrompt, and a scheduled reseed reverting a rename is a silent regression.
                                 return [
@@ -884,15 +932,15 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                         uat: new Date()
                                     })
                                 ];
-                            case 11:
-                                _state.sent();
-                                _state.label = 12;
                             case 12:
+                                _state.sent();
+                                _state.label = 13;
+                            case 13:
                                 return [
                                     4,
                                     writeBatch.commit()
                                 ];
-                            case 13:
+                            case 14:
                                 _state.sent();
                                 // Only the prompts that actually changed, and only once the commit landed. Missing this
                                 // leaves a scheduled reseed invisible for the whole OPENROUTER_PROMPT_CACHE_DURATION window.
@@ -900,15 +948,15 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                                 outcome = prompt == null ? 'created' : 'published';
                                 return [
                                     3,
-                                    15
+                                    16
                                 ];
-                            case 14:
+                            case 15:
                                 // The only way to land on `upToDate` is a prompt whose `lv` already covers the declared
                                 // number AND whose document at that number is present — anything else is drift the seed
                                 // refuses to paper over by overwriting a number someone else wrote.
                                 outcome = version > latestVersion || !targetVersionExists ? 'skipped' : 'upToDate';
-                                _state.label = 15;
-                            case 15:
+                                _state.label = 16;
+                            case 16:
                                 return [
                                     2,
                                     outcome
@@ -938,13 +986,26 @@ function _unsupported_iterable_to_array$2(o, minLen) {
                             if (!Number.isInteger(version) || version < 1) {
                                 throw new Error('Cannot seed OpenRouterPrompt "'.concat(promptKey, '": the definition declares version ').concat(version, ", which is not an integer >= 1."));
                             }
-                            var validation = validateOpenRouterModelConfig(config);
+                            var decision = definition.questions != null;
+                            var validation = validateOpenRouterModelConfig(config, {
+                                decision: decision
+                            });
                             if (!validation.valid) {
                                 throw new Error('Cannot seed OpenRouterPrompt "'.concat(promptKey, '": ').concat(validation.errors.join(' ')));
                             }
                             validation.warnings.forEach(function(warning) {
                                 return warnings.push("".concat(promptKey, ": ").concat(warning));
                             });
+                            if (decision) {
+                                // A malformed question map is refused HERE rather than at the wire. The limits it enforces are
+                                // quiet ones — an eleven-level Score looks entirely reasonable and is rejected by the route — so
+                                // a seed that published one would produce a prompt that resolves, validates, and then fails
+                                // every time it is asked.
+                                var questionValidation = validateOpenRouterDecisionQuestions(definition.questions);
+                                if (!questionValidation.valid) {
+                                    throw new Error('Cannot seed OpenRouterPrompt "'.concat(promptKey, '": ').concat(questionValidation.errors.join(' ')));
+                                }
+                            }
                         });
                         // Every prompt document up front, in one pass, before a single write: the addresses are the keys the
                         // definitions declare, so they all resolve together, and reading them here is what lets the write
@@ -1443,6 +1504,55 @@ function _ts_generator$6(thisArg, body) {
         });
     })();
 }
+/**
+ * Asks a decision prompt INLINE and returns its answers, with no run task document.
+ *
+ * The default way to ask a decision. A System One call typically answers in around a hundred
+ * milliseconds, has no tools to loop and nothing to defer, so the queue's lease, sweep interval and
+ * retry ladder buy nothing on the happy path — paying for a document to run a call that finishes before
+ * the write does is pure overhead.
+ *
+ * Reach for `enqueueRunTask({ state, questions, immediate: true })` instead when a FAILURE needs to
+ * survive this process: that keeps the same run-it-now latency and leaves a retryable failure queued for
+ * the sweep, at the cost of one document per run.
+ *
+ * @param params - The client, prompt service, prompt, state, and questions.
+ * @returns The decision result.
+ */ function decideForPrompt(params) {
+    return _async_to_generator$6(function() {
+        var client, promptService, promptKey, version, state, questions, configOverrides, sessionId, trace, prompt, request;
+        return _ts_generator$6(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    client = params.client, promptService = params.promptService, promptKey = params.promptKey, version = params.version, state = params.state, questions = params.questions, configOverrides = params.configOverrides, sessionId = params.sessionId, trace = params.trace;
+                    return [
+                        4,
+                        promptService.resolvePrompt({
+                            promptKey: promptKey,
+                            version: version
+                        })
+                    ];
+                case 1:
+                    prompt = _state.sent();
+                    request = openRouterDecisionRequest({
+                        prompt: prompt,
+                        state: state,
+                        questions: questions,
+                        overrides: configOverrides,
+                        sessionId: sessionId,
+                        trace: trace
+                    });
+                    return [
+                        2,
+                        openRouterDecision({
+                            client: client,
+                            request: request
+                        })
+                    ];
+            }
+        });
+    })();
+}
 
 function asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, key, arg) {
     try {
@@ -2165,11 +2275,17 @@ function _wrap_native_super(Class) {
                             8
                         ];
                     case 5:
-                        if (!(definition != null && (storedActiveVersion == null || definition.version > storedActiveVersion))) return [
+                        if (!(definition != null && (storedActiveVersion == null || definition.version > storedActiveVersion && (prompt === null || prompt === void 0 ? void 0 : prompt.sl) !== true))) return [
                             3,
                             6
                         ];
                         // Unpinned, and code is either standing in for the store or ahead of it.
+                        //
+                        // A STORE-LOCKED prompt (`sl`) cannot be overtaken: past this point the store is the source of
+                        // truth, and a definition whose version has moved ahead is ignored rather than served. It can
+                        // still STAND IN when the store holds nothing at all, which is what keeps a fresh environment —
+                        // an emulator, a test, a project that has never been seeded — able to serve the prompt with no
+                        // manual step first. The lock defends against being overwritten, not against being served.
                         resolved = definition;
                         source = 'definition';
                         return [
@@ -2203,7 +2319,11 @@ function _wrap_native_super(Class) {
                             }
                         }
                         if (rejectInvalidConfig) {
-                            validation = validateOpenRouterModelConfig(resolved.config);
+                            // Which arm the version belongs to is read off the version itself: a version carrying questions is
+                            // a decision and needs a System One model, one without is a completion and must not have one.
+                            validation = validateOpenRouterModelConfig(resolved.config, {
+                                decision: resolved.questions != null
+                            });
                             if (!validation.valid) {
                                 throw new OpenRouterPromptResolutionError(promptKey, "has an invalid config: ".concat(validation.errors.join(' ')), resolved.version);
                             }
@@ -2460,6 +2580,33 @@ function _ts_generator$3(thisArg, body) {
         };
     }
 }
+/**
+ * Whether a run task is a DECISION run.
+ *
+ * Reads the state field, which is the discriminator — see `OpenRouterRunTask.st`.
+ *
+ * @param task - The run task.
+ * @returns True when the task asks a decision rather than a completion.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function isOpenRouterDecisionRunTask(task) {
+    return (task === null || task === void 0 ? void 0 : task.st) != null;
+}
+/**
+ * Reads the answers off a completed decision run.
+ *
+ * The type parameter is the caller's own question map, which is what lets a consumer read
+ * `answers.urgency.noul` rather than walking an untyped record. It is an ASSERTION, not a check: the
+ * answers were membership-checked against the declared questions when they were written, so the only
+ * way this lies is a caller naming a different question map than the run used.
+ *
+ * @param task - The run task.
+ * @returns The answers, or undefined when the run is not a completed decision.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterRunTaskDecisionAnswers(task) {
+    return task === null || task === void 0 ? void 0 : task.an;
+}
 /**
  * Classifies a run task into an outcome.
  *
@@ -3229,6 +3376,13 @@ function _unsupported_iterable_to_array(o, minLen) {
  * Comfortably longer than any single inference plus its retries, so a healthy run is never stolen from
  * itself, and short enough that a crashed sweep's work resumes on the next tick or two.
  */ var DEFAULT_OPENROUTER_LEASE_DURATION = MS_IN_MINUTE * 10;
+/**
+ * Distinguishes one immediate run's lease from another's, and from a sweep's.
+ */ var randomImmediateRunId = /* @__PURE__ */ randomNumberFactory({
+    min: 0,
+    max: 1000000000,
+    round: 'floor'
+});
 /**
  * Default number of attempts before a task is marked FAILED.
  *
@@ -3278,11 +3432,11 @@ function _unsupported_iterable_to_array(o, minLen) {
     }
     function enqueueRunTask(params) {
         return _async_to_generator$1(function() {
-            var key, promptKey, version, input, files, configOverrides, continueFrom, restart, document, existing, created, task, resolved, history, _tmp;
+            var key, promptKey, version, input, files, configOverrides, continueFrom, restart, state, questions, immediate, document, existing, created, task, resolved, history, _tmp, execution;
             return _ts_generator$1(this, function(_state) {
                 switch(_state.label){
                     case 0:
-                        key = params.key, promptKey = params.promptKey, version = params.version, input = params.input, files = params.files, configOverrides = params.configOverrides, continueFrom = params.continueFrom, restart = params.restart;
+                        key = params.key, promptKey = params.promptKey, version = params.version, input = params.input, files = params.files, configOverrides = params.configOverrides, continueFrom = params.continueFrom, restart = params.restart, state = params.state, questions = params.questions, immediate = params.immediate;
                         document = runTaskDocument(key);
                         return [
                             4,
@@ -3339,6 +3493,8 @@ function _unsupported_iterable_to_array(o, minLen) {
                             in: openRouterInputMessages(input),
                             fp: files,
                             co: configOverrides,
+                            st: state,
+                            q: questions,
                             msg: history
                         };
                         created = true;
@@ -3350,19 +3506,81 @@ function _unsupported_iterable_to_array(o, minLen) {
                         _state.sent();
                         _state.label = 8;
                     case 8:
+                        if (!immediate) return [
+                            3,
+                            10
+                        ];
+                        return [
+                            4,
+                            runEnqueuedRunTaskNow(document)
+                        ];
+                    case 9:
+                        execution = _state.sent();
+                        _state.label = 10;
+                    case 10:
                         return [
                             2,
                             {
                                 key: key,
                                 document: document,
                                 created: created,
-                                task: task
+                                task: task,
+                                execution: execution
                             }
                         ];
                 }
             });
         })();
     }
+    /**
+     * Runs a just-enqueued task in this process, through the same claim-and-execute the sweep uses.
+     *
+     * Leased first, and not as a formality: an overlapping sweep tick can reach a QUEUED document between
+     * the write above and this line, and the lease is what stops the two from running the same call twice
+     * and billing for both. A task the claim does not win is left alone — its other owner will finish it —
+     * and no execution is reported.
+     *
+     * Nothing thrown here escapes as an enqueue failure. `executeRunTask` already records a failed attempt
+     * on the document and classifies whether it may be retried, so the state is on the document and the
+     * caller's queue write succeeded either way. Throwing instead would make `immediate: true` a strictly
+     * more fragile enqueue than `immediate: false`, which is the opposite of the point.
+     *
+     * @param document - The enqueued run task.
+     * @returns What the attempt did, or undefined when the task was not claimable.
+     */ function runEnqueuedRunTaskNow(document) {
+        return _async_to_generator$1(function() {
+            var now, leaseCutoff, claimed, result;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        now = new Date();
+                        leaseCutoff = addMilliseconds(now, -defaultLeaseDuration);
+                        return [
+                            4,
+                            claimRunTask(document, "openRouterRunTaskImmediate_".concat(now.getTime(), "_").concat(randomImmediateRunId()), now, leaseCutoff)
+                        ];
+                    case 1:
+                        claimed = _state.sent();
+                        if (!(claimed != null)) return [
+                            3,
+                            3
+                        ];
+                        return [
+                            4,
+                            executeRunTask(claimed)
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        _state.label = 3;
+                    case 3:
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        })();
+    }
     function historyForRunTask(key) {
         return _async_to_generator$1(function() {
             var prior, result, _prior_in, messages;
@@ -3648,6 +3866,156 @@ function _unsupported_iterable_to_array(o, minLen) {
         })();
     }
     function executeRunTaskData(document, task) {
+        return _async_to_generator$1(function() {
+            var executionResult;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        if (!(task.st == null)) return [
+                            3,
+                            2
+                        ];
+                        return [
+                            4,
+                            executeCompletionRunTaskData(document, task)
+                        ];
+                    case 1:
+                        executionResult = _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            executeDecisionRunTaskData(document, task, task.st)
+                        ];
+                    case 3:
+                        executionResult = _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        return [
+                            2,
+                            executionResult
+                        ];
+                }
+            });
+        })();
+    }
+    /**
+     * Runs a DECISION task: resolve the version, merge its questions with the run's own, ask, and record.
+     *
+     * @param document - The run task document.
+     * @param task - The task data.
+     * @param state - The content to judge.
+     * @returns What the attempt did.
+     */ function executeDecisionRunTaskData(document, task, state) {
+        return _async_to_generator$1(function() {
+            var key, executionResult, resolved, request, decision, e, failure;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        key = document.id;
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            5,
+                            ,
+                            7
+                        ]);
+                        return [
+                            4,
+                            promptService.resolvePrompt({
+                                promptKey: task.pk,
+                                version: task.pv
+                            })
+                        ];
+                    case 2:
+                        resolved = _state.sent();
+                        request = openRouterDecisionRequest({
+                            prompt: resolved,
+                            state: state,
+                            questions: task.q,
+                            overrides: task.co,
+                            sessionId: key,
+                            trace: {
+                                runTaskKey: key
+                            }
+                        });
+                        return [
+                            4,
+                            openRouterDecision({
+                                client: client,
+                                request: request
+                            })
+                        ];
+                    case 3:
+                        decision = _state.sent();
+                        return [
+                            4,
+                            document.update({
+                                s: OpenRouterRunTaskState.COMPLETE,
+                                fat: new Date(),
+                                an: decision.answers,
+                                gi: concatArraysUnique(task.gi, decision.generationIds),
+                                u: decision.usage,
+                                e: null,
+                                lat: null,
+                                lo: null
+                            })
+                        ];
+                    case 4:
+                        _state.sent();
+                        executionResult = {
+                            key: key,
+                            state: OpenRouterRunTaskState.COMPLETE,
+                            decision: decision
+                        };
+                        return [
+                            3,
+                            7
+                        ];
+                    case 5:
+                        e = _state.sent();
+                        return [
+                            4,
+                            recordFailure({
+                                document: document,
+                                task: task,
+                                error: {
+                                    code: openRouterErrorCode(e),
+                                    message: openRouterErrorMessage(e)
+                                },
+                                cause: e,
+                                at: new Date()
+                            })
+                        ];
+                    case 6:
+                        failure = _state.sent();
+                        executionResult = _object_spread_props(_object_spread({}, failure), {
+                            error: e
+                        });
+                        return [
+                            3,
+                            7
+                        ];
+                    case 7:
+                        return [
+                            2,
+                            executionResult
+                        ];
+                }
+            });
+        })();
+    }
+    /**
+     * Runs a COMPLETION task.
+     *
+     * @param document - The run task document.
+     * @param task - The task data.
+     * @returns What the attempt did.
+     */ function executeCompletionRunTaskData(document, task) {
         return _async_to_generator$1(function() {
             var key, executionResult, resolved, attachedFiles, hasTools, request, result, afterCall, _tmp, pausedForTools, finishedAt, e, failure;
             return _ts_generator$1(this, function(_state) {
@@ -4558,4 +4926,4 @@ var randomSweepId = randomNumberFactory({
     })();
 }
 
-export { AbstractAppOpenRouterModule, DEFAULT_OPENROUTER_EXPIRATION_SWEEP_MAX_RUN_TIME, DEFAULT_OPENROUTER_EXPIRATION_SWEEP_PAGE_SIZE, DEFAULT_OPENROUTER_INLINE_FILE_CONTENT_TYPE, DEFAULT_OPENROUTER_LEASE_DURATION, DEFAULT_OPENROUTER_MAX_ATTEMPTS, DEFAULT_OPENROUTER_MAX_INLINE_FILE_SIZE_BYTES, DEFAULT_OPENROUTER_SIGNED_URL_TTL, DEFAULT_OPENROUTER_SWEEP_MAX_PARALLEL_TASKS, DEFAULT_OPENROUTER_SWEEP_MAX_RUN_TIME, DEFAULT_OPENROUTER_SWEEP_PAGE_SIZE, OPENROUTER_BROADCAST_RUN_TASK_KEY_ATTRIBUTES, OPENROUTER_MAX_EXPIRED_RUN_TASK_DELETE_PAGE_SIZE, OPENROUTER_PERMANENT_ERROR_STATUSES, OPENROUTER_PROMPT_CACHE_DURATION, OPENROUTER_PROMPT_SERVICE_TOKEN, OPENROUTER_RUN_TASK_SERVICE_TOKEN, OPENROUTER_SEED_PROMPTS_MAX_PARALLEL_UPDATES, OpenRouterPromptResolutionError, OpenRouterPromptServerActions, OpenRouterPromptService, OpenRouterRunTaskService, appOpenRouterModuleMetadata, callModelForPrompt, conversationStateForOpenRouterRunTask, conversationStatusForOpenRouterRunTaskState, createOpenRouterPromptFactory, createOpenRouterPromptVersionFactory, firestoreOpenRouterStateAccessor, handleOpenRouterRunTaskResultFactory, hasUnresolvedOpenRouterPendingToolCalls, isOpenRouterRunTaskClaimable, isRetryableOpenRouterError, mergeOpenRouterRunUsage, openRouterConversationValueForFirestore, openRouterDeferredToolResolutionsForRunTask, openRouterErrorCode, openRouterErrorMessage, openRouterFileAttachmentModeForConfig, openRouterFileAttachmentResolver, openRouterPromptServerActions, openRouterPromptService, openRouterRunTaskExpirationSweep, openRouterRunTaskKeyFromBroadcastAttributes, openRouterRunTaskOutcome, openRouterRunTaskService, openRouterRunTaskStateForConversationStatus, openRouterRunTaskSweep, openRouterRunTaskUpdateForConversationState, readOpenRouterPromptFactory, reconcileOpenRouterRunTaskFromBroadcast, seedOpenRouterPromptsFactory, updateOpenRouterPromptFactory, updateOpenRouterPromptVersionFactory };
+export { AbstractAppOpenRouterModule, DEFAULT_OPENROUTER_EXPIRATION_SWEEP_MAX_RUN_TIME, DEFAULT_OPENROUTER_EXPIRATION_SWEEP_PAGE_SIZE, DEFAULT_OPENROUTER_INLINE_FILE_CONTENT_TYPE, DEFAULT_OPENROUTER_LEASE_DURATION, DEFAULT_OPENROUTER_MAX_ATTEMPTS, DEFAULT_OPENROUTER_MAX_INLINE_FILE_SIZE_BYTES, DEFAULT_OPENROUTER_SIGNED_URL_TTL, DEFAULT_OPENROUTER_SWEEP_MAX_PARALLEL_TASKS, DEFAULT_OPENROUTER_SWEEP_MAX_RUN_TIME, DEFAULT_OPENROUTER_SWEEP_PAGE_SIZE, OPENROUTER_BROADCAST_RUN_TASK_KEY_ATTRIBUTES, OPENROUTER_MAX_EXPIRED_RUN_TASK_DELETE_PAGE_SIZE, OPENROUTER_PERMANENT_ERROR_STATUSES, OPENROUTER_PROMPT_CACHE_DURATION, OPENROUTER_PROMPT_SERVICE_TOKEN, OPENROUTER_RUN_TASK_SERVICE_TOKEN, OPENROUTER_SEED_PROMPTS_MAX_PARALLEL_UPDATES, OpenRouterPromptResolutionError, OpenRouterPromptServerActions, OpenRouterPromptService, OpenRouterRunTaskService, appOpenRouterModuleMetadata, callModelForPrompt, conversationStateForOpenRouterRunTask, conversationStatusForOpenRouterRunTaskState, createOpenRouterPromptFactory, createOpenRouterPromptVersionFactory, decideForPrompt, firestoreOpenRouterStateAccessor, handleOpenRouterRunTaskResultFactory, hasUnresolvedOpenRouterPendingToolCalls, isOpenRouterDecisionRunTask, isOpenRouterRunTaskClaimable, isRetryableOpenRouterError, mergeOpenRouterRunUsage, openRouterConversationValueForFirestore, openRouterDeferredToolResolutionsForRunTask, openRouterErrorCode, openRouterErrorMessage, openRouterFileAttachmentModeForConfig, openRouterFileAttachmentResolver, openRouterPromptServerActions, openRouterPromptService, openRouterRunTaskDecisionAnswers, openRouterRunTaskExpirationSweep, openRouterRunTaskKeyFromBroadcastAttributes, openRouterRunTaskOutcome, openRouterRunTaskService, openRouterRunTaskStateForConversationStatus, openRouterRunTaskSweep, openRouterRunTaskUpdateForConversationState, readOpenRouterPromptFactory, reconcileOpenRouterRunTaskFromBroadcast, seedOpenRouterPromptsFactory, updateOpenRouterPromptFactory, updateOpenRouterPromptVersionFactory };