@dereekb/openrouter 13.37.0

package/firebase-server/index.cjs.js

@@ -0,0 +1,4520 @@
+'use strict';
+
+var firebase$1 = require('@dereekb/firebase');
+var util = require('@dereekb/util');
+var openrouter = require('@dereekb/openrouter');
+var firebase = require('@dereekb/openrouter/firebase');
+
+function asyncGeneratorStep$8(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$8(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$8(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property$3(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$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$3(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function _ts_generator$8(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
+        };
+    }
+}
+/**
+ * Server actions for managing prompts.
+ *
+ * The writes exist instead of an Angular UI: they reach the model API, and the existing callModel MCP
+ * surface makes them callable without building a screen for it. Reads are absent because the prompt and
+ * version model services already make both fetchable by key through model-get, and listing is the
+ * model API's standard query operation over {@link openRouterPromptsWithStateQuery}.
+ */ var OpenRouterPromptServerActions = function OpenRouterPromptServerActions() {
+    _class_call_check$3(this, OpenRouterPromptServerActions);
+};
+/**
+ * Creates the {@link OpenRouterPromptServerActions}.
+ *
+ * @param context - The actions context.
+ * @returns The server actions.
+ */ function openRouterPromptServerActions(context) {
+    return {
+        createOpenRouterPrompt: createOpenRouterPromptFactory(context),
+        updateOpenRouterPrompt: updateOpenRouterPromptFactory(context),
+        createOpenRouterPromptVersion: createOpenRouterPromptVersionFactory(context),
+        updateOpenRouterPromptVersion: updateOpenRouterPromptVersionFactory(context),
+        seedOpenRouterPrompts: seedOpenRouterPromptsFactory(context)
+    };
+}
+/**
+ * Creates a new prompt at its caller-supplied key, refusing a key that already exists.
+ *
+ * Takes its params directly rather than through an arktype-validated action: the only callers are a
+ * seed and a test, both of them server-side.
+ *
+ * @param context - The actions context.
+ * @returns The create action.
+ */ function createOpenRouterPromptFactory(context) {
+    var openRouterPromptCollection = context.openRouterPromptCollection;
+    return function(params) {
+        return _async_to_generator$8(function() {
+            var key, name, description, tags;
+            return _ts_generator$8(this, function(_state) {
+                key = params.key, name = params.name, description = params.description, tags = params.tags;
+                return [
+                    2,
+                    openRouterPromptCollection.firestoreContext.runTransaction(function(transaction) {
+                        return _async_to_generator$8(function() {
+                            var document, exists;
+                            return _ts_generator$8(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        document = openRouterPromptCollection.documentAccessorForTransaction(transaction).loadDocumentForId(key);
+                                        return [
+                                            4,
+                                            document.accessor.exists()
+                                        ];
+                                    case 1:
+                                        exists = _state.sent();
+                                        if (exists) {
+                                            throw new Error('An OpenRouterPrompt with the key "'.concat(key, '" already exists.'));
+                                        }
+                                        return [
+                                            4,
+                                            document.accessor.set({
+                                                cat: new Date(),
+                                                n: name,
+                                                d: description,
+                                                s: firebase.OpenRouterPromptState.DRAFT,
+                                                lv: 0,
+                                                t: tags
+                                            })
+                                        ];
+                                    case 2:
+                                        _state.sent();
+                                        return [
+                                            2,
+                                            openRouterPromptCollection.documentAccessor().loadDocumentForId(key)
+                                        ];
+                                }
+                            });
+                        })();
+                    })
+                ];
+            });
+        })();
+    };
+}
+/**
+ * Updates a prompt's metadata, lifecycle state, or active version, then drops its cached resolution.
+ *
+ * @param context - The actions context.
+ * @returns The update action.
+ */ function updateOpenRouterPromptFactory(context) {
+    var firebaseServerActionTransformFunctionFactory = context.firebaseServerActionTransformFunctionFactory, openRouterPromptCollection = context.openRouterPromptCollection, openRouterPromptVersionCollectionFactory = context.openRouterPromptVersionCollectionFactory, openRouterPromptService = context.openRouterPromptService;
+    return firebaseServerActionTransformFunctionFactory(firebase.updateOpenRouterPromptParamsType, function(params) {
+        return _async_to_generator$8(function() {
+            var name, description, tags, state, activeVersion;
+            return _ts_generator$8(this, function(_state) {
+                name = params.name, description = params.description, tags = params.tags, state = params.state, activeVersion = params.activeVersion;
+                return [
+                    2,
+                    function(document) {
+                        return _async_to_generator$8(function() {
+                            return _ts_generator$8(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        return [
+                                            4,
+                                            openRouterPromptCollection.firestoreContext.runTransaction(function(transaction) {
+                                                return _async_to_generator$8(function() {
+                                                    var inTransaction, prompt, versionDocument, versionExists;
+                                                    return _ts_generator$8(this, function(_state) {
+                                                        switch(_state.label){
+                                                            case 0:
+                                                                inTransaction = openRouterPromptCollection.documentAccessorForTransaction(transaction).loadDocument(document.documentRef);
+                                                                return [
+                                                                    4,
+                                                                    inTransaction.snapshotData()
+                                                                ];
+                                                            case 1:
+                                                                prompt = _state.sent();
+                                                                if (prompt == null) {
+                                                                    throw new Error('The OpenRouterPrompt "'.concat(document.id, '" does not exist.'));
+                                                                }
+                                                                if (!(activeVersion != null)) return [
+                                                                    3,
+                                                                    3
+                                                                ];
+                                                                // Promoting to a version that was never published would leave every unpinned caller failing to
+                                                                // resolve, so the pointer is only allowed to move to a version that exists.
+                                                                versionDocument = openRouterPromptVersionCollectionFactory(inTransaction).documentAccessorForTransaction(transaction).loadDocumentForId(firebase.openRouterPromptVersionId(activeVersion));
+                                                                return [
+                                                                    4,
+                                                                    versionDocument.accessor.exists()
+                                                                ];
+                                                            case 2:
+                                                                versionExists = _state.sent();
+                                                                if (!versionExists) {
+                                                                    throw new Error("Cannot set activeVersion to ".concat(activeVersion, ' on OpenRouterPrompt "').concat(document.id, '": that version does not exist.'));
+                                                                }
+                                                                _state.label = 3;
+                                                            case 3:
+                                                                return [
+                                                                    4,
+                                                                    inTransaction.update({
+                                                                        n: name !== null && name !== void 0 ? name : undefined,
+                                                                        d: description,
+                                                                        t: tags,
+                                                                        s: state !== null && state !== void 0 ? state : undefined,
+                                                                        av: activeVersion,
+                                                                        uat: new Date()
+                                                                    })
+                                                                ];
+                                                            case 4:
+                                                                _state.sent();
+                                                                return [
+                                                                    2
+                                                                ];
+                                                        }
+                                                    });
+                                                })();
+                                            })
+                                        ];
+                                    case 1:
+                                        _state.sent();
+                                        openRouterPromptService.clearCachedPrompt(document.id);
+                                        return [
+                                            2,
+                                            document
+                                        ];
+                                }
+                            });
+                        })();
+                    }
+                ];
+            });
+        })();
+    });
+}
+/**
+ * Creates a new version, allocating its number inside the transaction, locking the version it succeeds,
+ * and optionally promoting it.
+ *
+ * @param context - The actions context.
+ * @returns The create version action.
+ */ function createOpenRouterPromptVersionFactory(context) {
+    var firebaseServerActionTransformFunctionFactory = context.firebaseServerActionTransformFunctionFactory, openRouterPromptCollection = context.openRouterPromptCollection, openRouterPromptVersionCollectionFactory = context.openRouterPromptVersionCollectionFactory, openRouterPromptService = context.openRouterPromptService;
+    return firebaseServerActionTransformFunctionFactory(firebase.createOpenRouterPromptVersionParamsType, function(params) {
+        return _async_to_generator$8(function() {
+            var instructions, messages, config, notes, activate;
+            return _ts_generator$8(this, function(_state) {
+                instructions = params.instructions, messages = params.messages, config = params.config, notes = params.notes, activate = params.activate;
+                return [
+                    2,
+                    function(document) {
+                        return _async_to_generator$8(function() {
+                            var modelConfig, validation, result;
+                            return _ts_generator$8(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        modelConfig = config !== null && config !== void 0 ? config : undefined;
+                                        validation = openrouter.validateOpenRouterModelConfig(modelConfig !== null && modelConfig !== void 0 ? modelConfig : {});
+                                        if (!validation.valid) {
+                                            throw new Error('Cannot create a version of OpenRouterPrompt "'.concat(document.id, '": ').concat(validation.errors.join(' ')));
+                                        }
+                                        return [
+                                            4,
+                                            openRouterPromptCollection.firestoreContext.runTransaction(function(transaction) {
+                                                return _async_to_generator$8(function() {
+                                                    var inTransaction, prompt, version, versionCollection, versionDocument, previousVersionDocument, previousVersionExists, _tmp, versionData;
+                                                    return _ts_generator$8(this, function(_state) {
+                                                        switch(_state.label){
+                                                            case 0:
+                                                                inTransaction = openRouterPromptCollection.documentAccessorForTransaction(transaction).loadDocument(document.documentRef);
+                                                                return [
+                                                                    4,
+                                                                    inTransaction.snapshotData()
+                                                                ];
+                                                            case 1:
+                                                                prompt = _state.sent();
+                                                                if (prompt == null) {
+                                                                    throw new Error('The OpenRouterPrompt "'.concat(document.id, '" does not exist.'));
+                                                                }
+                                                                // Allocated from the prompt document inside the transaction rather than supplied by the caller:
+                                                                // two concurrent creates picking the same number would silently overwrite one another.
+                                                                version = prompt.lv + 1;
+                                                                versionCollection = openRouterPromptVersionCollectionFactory(inTransaction).documentAccessorForTransaction(transaction);
+                                                                versionDocument = versionCollection.loadDocumentForId(firebase.openRouterPromptVersionId(version));
+                                                                // The outgoing version stops being editable the moment it stops being the head — in the same
+                                                                // transaction, so there is no window in which two versions are both unlocked. Read first:
+                                                                // Firestore forbids a read after a write in a transaction, and a `set` on a version that was
+                                                                // deleted out from under us would resurrect it as a document holding nothing but a lock.
+                                                                previousVersionDocument = prompt.lv > 0 ? versionCollection.loadDocumentForId(firebase.openRouterPromptVersionId(prompt.lv)) : undefined;
+                                                                if (!(previousVersionDocument == null)) return [
+                                                                    3,
+                                                                    2
+                                                                ];
+                                                                _tmp = false;
+                                                                return [
+                                                                    3,
+                                                                    4
+                                                                ];
+                                                            case 2:
+                                                                return [
+                                                                    4,
+                                                                    previousVersionDocument.accessor.exists()
+                                                                ];
+                                                            case 3:
+                                                                _tmp = _state.sent();
+                                                                _state.label = 4;
+                                                            case 4:
+                                                                previousVersionExists = _tmp;
+                                                                versionData = {
+                                                                    cat: new Date(),
+                                                                    v: version,
+                                                                    i: instructions,
+                                                                    m: messages === null || messages === void 0 ? void 0 : messages.map(function(param) {
+                                                                        var role = param.role, content = param.content;
+                                                                        return {
+                                                                            r: role,
+                                                                            c: content
+                                                                        };
+                                                                    }),
+                                                                    c: modelConfig,
+                                                                    nt: notes
+                                                                };
+                                                                if (!(previousVersionDocument != null && previousVersionExists)) return [
+                                                                    3,
+                                                                    6
+                                                                ];
+                                                                return [
+                                                                    4,
+                                                                    previousVersionDocument.update({
+                                                                        lk: true
+                                                                    })
+                                                                ];
+                                                            case 5:
+                                                                _state.sent();
+                                                                _state.label = 6;
+                                                            case 6:
+                                                                return [
+                                                                    4,
+                                                                    versionDocument.accessor.set(versionData)
+                                                                ];
+                                                            case 7:
+                                                                _state.sent();
+                                                                return [
+                                                                    4,
+                                                                    inTransaction.update(_object_spread$2({
+                                                                        lv: version,
+                                                                        uat: new Date()
+                                                                    }, activate ? {
+                                                                        av: version,
+                                                                        s: firebase.OpenRouterPromptState.ACTIVE
+                                                                    } : undefined))
+                                                                ];
+                                                            case 8:
+                                                                _state.sent();
+                                                                // The version document's own path, not the prompt's: a create reports what it created.
+                                                                return [
+                                                                    2,
+                                                                    {
+                                                                        modelKeys: [
+                                                                            versionDocument.documentRef.path
+                                                                        ],
+                                                                        version: version,
+                                                                        activated: activate === true,
+                                                                        warnings: validation.warnings
+                                                                    }
+                                                                ];
+                                                        }
+                                                    });
+                                                })();
+                                            })
+                                        ];
+                                    case 1:
+                                        result = _state.sent();
+                                        openRouterPromptService.clearCachedPrompt(document.id);
+                                        return [
+                                            2,
+                                            result
+                                        ];
+                                }
+                            });
+                        })();
+                    }
+                ];
+            });
+        })();
+    });
+}
+/**
+ * Edits the latest version of a prompt in place, refusing one the next version has locked.
+ *
+ * The lock is re-read inside the transaction rather than trusted from the caller's snapshot: a create
+ * racing this edit would otherwise let the write land on a version that had just stopped being the head.
+ *
+ * @param context - The actions context.
+ * @returns The update version action.
+ */ function updateOpenRouterPromptVersionFactory(context) {
+    var firebaseServerActionTransformFunctionFactory = context.firebaseServerActionTransformFunctionFactory, openRouterPromptCollection = context.openRouterPromptCollection, openRouterPromptVersionCollectionGroup = context.openRouterPromptVersionCollectionGroup, openRouterPromptService = context.openRouterPromptService;
+    return firebaseServerActionTransformFunctionFactory(firebase.updateOpenRouterPromptVersionParamsType, function(params) {
+        return _async_to_generator$8(function() {
+            var instructions, messages, config, notes;
+            return _ts_generator$8(this, function(_state) {
+                instructions = params.instructions, messages = params.messages, config = params.config, notes = params.notes;
+                return [
+                    2,
+                    function(document) {
+                        return _async_to_generator$8(function() {
+                            var inputConfig, validation;
+                            return _ts_generator$8(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        inputConfig = config;
+                                        return [
+                                            4,
+                                            openRouterPromptCollection.firestoreContext.runTransaction(function(transaction) {
+                                                return _async_to_generator$8(function() {
+                                                    var _ref, inTransaction, version, result;
+                                                    return _ts_generator$8(this, function(_state) {
+                                                        switch(_state.label){
+                                                            case 0:
+                                                                inTransaction = openRouterPromptVersionCollectionGroup.documentAccessorForTransaction(transaction).loadDocument(document.documentRef);
+                                                                return [
+                                                                    4,
+                                                                    inTransaction.snapshotData()
+                                                                ];
+                                                            case 1:
+                                                                version = _state.sent();
+                                                                if (version == null) {
+                                                                    throw new Error('The OpenRouterPromptVersion "'.concat(document.key, '" does not exist.'));
+                                                                }
+                                                                if (version.lk) {
+                                                                    throw new Error('The OpenRouterPromptVersion "'.concat(document.key, '" is locked, because a newer version exists. Create a new version instead.'));
+                                                                }
+                                                                // Validated against what the version will SAY once written, not against the patch: an edit that
+                                                                // 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 = openrouter.validateOpenRouterModelConfig((_ref = config === undefined ? version.c : inputConfig) !== null && _ref !== void 0 ? _ref : {});
+                                                                if (!result.valid) {
+                                                                    throw new Error('Cannot update OpenRouterPromptVersion "'.concat(document.key, '": ').concat(result.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 [
+                                                                    4,
+                                                                    inTransaction.update({
+                                                                        i: instructions,
+                                                                        m: messages == null ? messages : messages.map(function(param) {
+                                                                            var role = param.role, content = param.content;
+                                                                            return {
+                                                                                r: role,
+                                                                                c: content
+                                                                            };
+                                                                        }),
+                                                                        c: inputConfig,
+                                                                        nt: notes
+                                                                    })
+                                                                ];
+                                                            case 2:
+                                                                _state.sent();
+                                                                return [
+                                                                    2,
+                                                                    result
+                                                                ];
+                                                        }
+                                                    });
+                                                })();
+                                            })
+                                        ];
+                                    case 1:
+                                        validation = _state.sent();
+                                        // Keyed by the parent prompt, which is the id the cache and the resolver both work in.
+                                        openRouterPromptService.clearCachedPrompt(firebase$1.firestoreModelId(firebase$1.firestoreModelKeyParentKey(document)));
+                                        return [
+                                            2,
+                                            {
+                                                warnings: validation.warnings
+                                            }
+                                        ];
+                                }
+                            });
+                        })();
+                    }
+                ];
+            });
+        })();
+    });
+}
+/**
+ * How many definitions {@link seedOpenRouterPromptsFactory} publishes at a time.
+ *
+ * Each definition's writes are their own commit against documents no other definition touches, so the
+ * bound is not a correctness requirement — it keeps a large registry from opening one connection per
+ * prompt against Firestore all at once.
+ */ var OPENROUTER_SEED_PROMPTS_MAX_PARALLEL_UPDATES = 25;
+/**
+ * Publishes each code definition the prompt service carries at ITS OWN declared version number.
+ *
+ * The number is a compile-time constant rather than one allocated from `lv`, which is the whole point:
+ * an auto-allocating writer cannot converge on a number chosen in code, because its write address moves
+ * with its own effect — so a store seeded by {@link createOpenRouterPromptVersionFactory} sits
+ * permanently behind the definition and the resolver stands in for it forever. Pinning makes the write
+ * address a pure function of the definition, so a re-seed is a no-op rather than a step toward
+ * convergence, and a scheduled reseed can keep the store in step with deploys.
+ *
+ * Publishing is gated on `lv` rather than `av`: `lv` is the allocator and is monotone, while `av` is a
+ * pointer an operator can move backwards — gating on it would let a demotion re-trigger a publish on
+ * every scheduled tick, forever.
+ *
+ * Deliberately NOT built on {@link createOpenRouterPromptVersionFactory}: that action is reachable over
+ * callModel/MCP, and its in-transaction allocation is a race-safety contract on a public surface rather
+ * than an implementation detail. A seed needs no allocator at all, because the number it writes is a
+ * compile-time constant — something `CreateOpenRouterPromptVersionParams` cannot assert about an
+ * arbitrary caller.
+ *
+ * No transaction, at any scope. A version document carries a whole prompt's text, so a registry of them
+ * can put megabytes through a single commit, and a commit — transaction or write batch alike — is capped
+ * around 10MB. The run is instead one read pass over every prompt document, then each definition
+ * published independently through its OWN write batch, at most
+ * {@link OPENROUTER_SEED_PROMPTS_MAX_PARALLEL_UPDATES} at a time. The batch is what keeps a publish
+ * atomic — the version, the lock on the head it replaces, and the pointer move land together or not at
+ * all — while holding any one commit to the three documents a single definition touches.
+ *
+ * What that costs is the transaction's read set: the check that nothing else already holds the number
+ * being written is now a read taken shortly before the commit rather than a conflict detected at it.
+ * Losing that window means a seed overwrites a version an operator published under the same number in
+ * the same instant — narrow enough to trade for a run whose size cannot refuse it.
+ *
+ * @param context - The actions context.
+ * @returns The seed action.
+ */ function seedOpenRouterPromptsFactory(context) {
+    var openRouterPromptCollection = context.openRouterPromptCollection, openRouterPromptVersionCollectionFactory = context.openRouterPromptVersionCollectionFactory, openRouterPromptService = context.openRouterPromptService;
+    return function(params) {
+        return _async_to_generator$8(function() {
+            var promptKeys, keyFilter, definitions, warnings, promptDocumentAccessor, promptTuples, targets, outcomes, promptsCreated, versionsPublished, upToDate, skipped;
+            /**
+         * Publishes one definition, starting from the prompt the opening read already produced.
+         *
+         * @param target - The definition and the prompt document it seeds.
+         * @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;
+                    return _ts_generator$8(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                definition = target.definition, promptDocument = target.promptDocument, prompt = target.prompt;
+                                promptKey = definition.promptKey, version = definition.version;
+                                latestVersion = (_ref = prompt === null || prompt === void 0 ? void 0 : prompt.lv) !== null && _ref !== void 0 ? _ref : 0;
+                                // An ARCHIVED prompt is never resurrected: retirement is a deliberate act, and a scheduled
+                                // 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) === firebase.OpenRouterPromptState.ARCHIVED;
+                                if (!archived) return [
+                                    3,
+                                    1
+                                ];
+                                outcome = 'skipped';
+                                return [
+                                    3,
+                                    15
+                                ];
+                            case 1:
+                                versionCollection = openRouterPromptVersionCollectionFactory(promptDocument);
+                                versionAccessor = versionCollection.documentAccessor();
+                                targetVersionId = firebase.openRouterPromptVersionId(version);
+                                return [
+                                    4,
+                                    versionAccessor.loadDocumentForId(targetVersionId).accessor.exists()
+                                ];
+                            case 2:
+                                targetVersionExists = _state.sent();
+                                if (!(version > latestVersion && !targetVersionExists)) return [
+                                    3,
+                                    14
+                                ];
+                                // 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
+                                // because a batched `update` on a missing document fails the whole commit, and a `set` on a
+                                // deleted version would resurrect it holding nothing but a lock.
+                                previousVersionId = latestVersion > 0 ? firebase.openRouterPromptVersionId(latestVersion) : undefined;
+                                if (!(previousVersionId == null)) return [
+                                    3,
+                                    3
+                                ];
+                                _tmp = false;
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 3:
+                                return [
+                                    4,
+                                    versionAccessor.loadDocumentForId(previousVersionId).accessor.exists()
+                                ];
+                            case 4:
+                                _tmp = _state.sent();
+                                _state.label = 5;
+                            case 5:
+                                previousVersionExists = _tmp;
+                                versionData = {
+                                    cat: new Date(),
+                                    v: version,
+                                    i: definition.instructions,
+                                    m: (_definition_messages = definition.messages) === null || _definition_messages === void 0 ? void 0 : _definition_messages.map(function(param) {
+                                        var role = param.role, content = param.content;
+                                        return {
+                                            r: role,
+                                            c: content
+                                        };
+                                    }),
+                                    c: definition.config,
+                                    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
+                                // at a version the run failed to write, and bounded, so the commit carries one prompt's text
+                                // rather than the registry's.
+                                writeBatch = openRouterPromptCollection.firestoreContext.batch();
+                                versionWriteAccessor = versionCollection.documentAccessorForWriteBatch(writeBatch);
+                                promptWriteDocument = openRouterPromptCollection.documentAccessorForWriteBatch(writeBatch).loadDocumentForId(promptKey);
+                                if (!(previousVersionId != null && previousVersionExists)) return [
+                                    3,
+                                    7
+                                ];
+                                return [
+                                    4,
+                                    versionWriteAccessor.loadDocumentForId(previousVersionId).update({
+                                        lk: true
+                                    })
+                                ];
+                            case 6:
+                                _state.sent();
+                                _state.label = 7;
+                            case 7:
+                                return [
+                                    4,
+                                    versionWriteAccessor.loadDocumentForId(targetVersionId).accessor.set(versionData)
+                                ];
+                            case 8:
+                                _state.sent();
+                                if (!(prompt == null)) return [
+                                    3,
+                                    10
+                                ];
+                                return [
+                                    4,
+                                    promptWriteDocument.accessor.set({
+                                        cat: new Date(),
+                                        n: definition.name,
+                                        d: definition.description,
+                                        s: firebase.OpenRouterPromptState.ACTIVE,
+                                        lv: version,
+                                        av: version
+                                    })
+                                ];
+                            case 9:
+                                _state.sent();
+                                return [
+                                    3,
+                                    12
+                                ];
+                            case 10:
+                                // `n`/`d`/`t` are deliberately untouched: they are operator-editable through
+                                // updateOpenRouterPrompt, and a scheduled reseed reverting a rename is a silent regression.
+                                return [
+                                    4,
+                                    promptWriteDocument.update({
+                                        lv: version,
+                                        av: version,
+                                        s: firebase.OpenRouterPromptState.ACTIVE,
+                                        uat: new Date()
+                                    })
+                                ];
+                            case 11:
+                                _state.sent();
+                                _state.label = 12;
+                            case 12:
+                                return [
+                                    4,
+                                    writeBatch.commit()
+                                ];
+                            case 13:
+                                _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.
+                                openRouterPromptService.clearCachedPrompt(promptKey);
+                                outcome = prompt == null ? 'created' : 'published';
+                                return [
+                                    3,
+                                    15
+                                ];
+                            case 14:
+                                // 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:
+                                return [
+                                    2,
+                                    outcome
+                                ];
+                        }
+                    });
+                })();
+            }
+            return _ts_generator$8(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        promptKeys = params.promptKeys;
+                        keyFilter = promptKeys == null ? undefined : new Set(promptKeys);
+                        return [
+                            4,
+                            openRouterPromptService.loadPromptDefinitions()
+                        ];
+                    case 1:
+                        definitions = _state.sent().filter(function(x) {
+                            return keyFilter == null || keyFilter.has(x.promptKey);
+                        });
+                        warnings = [];
+                        // Every definition is validated before anything is written: half-seeding a registry because entry
+                        // three is broken leaves a state no rerun explains.
+                        definitions.forEach(function(definition) {
+                            var promptKey = definition.promptKey, version = definition.version, config = definition.config;
+                            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 = openrouter.validateOpenRouterModelConfig(config);
+                            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));
+                            });
+                        });
+                        // 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
+                        // phase decide each definition without a transaction to re-read them in.
+                        promptDocumentAccessor = openRouterPromptCollection.documentAccessor();
+                        return [
+                            4,
+                            firebase$1.getDocumentSnapshotDataTuples(definitions.map(function(x) {
+                                return promptDocumentAccessor.loadDocumentForId(x.promptKey);
+                            }))
+                        ];
+                    case 2:
+                        promptTuples = _state.sent();
+                        targets = definitions.map(function(definition, i) {
+                            return {
+                                definition: definition,
+                                promptDocument: promptTuples[i][0],
+                                prompt: promptTuples[i][1]
+                            };
+                        });
+                        return [
+                            4,
+                            util.runAsyncTasksForValues(targets, seedTarget, {
+                                maxParallelTasks: OPENROUTER_SEED_PROMPTS_MAX_PARALLEL_UPDATES
+                            })
+                        ];
+                    case 3:
+                        outcomes = _state.sent();
+                        promptsCreated = 0;
+                        versionsPublished = 0;
+                        upToDate = 0;
+                        skipped = 0;
+                        outcomes.forEach(function(outcome) {
+                            switch(outcome){
+                                case 'created':
+                                    promptsCreated += 1;
+                                    versionsPublished += 1;
+                                    break;
+                                case 'published':
+                                    versionsPublished += 1;
+                                    break;
+                                case 'upToDate':
+                                    upToDate += 1;
+                                    break;
+                                case 'skipped':
+                                    skipped += 1;
+                                    break;
+                            }
+                        });
+                        return [
+                            2,
+                            {
+                                considered: definitions.length,
+                                promptsCreated: promptsCreated,
+                                versionsPublished: versionsPublished,
+                                upToDate: upToDate,
+                                skipped: skipped,
+                                warnings: warnings
+                            }
+                        ];
+                }
+            });
+        })();
+    };
+}
+
+function asyncGeneratorStep$7(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$7(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$7(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$7(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
+        };
+    }
+}
+/**
+ * The attribute key OpenRouter surfaces a `trace: { runTaskKey }` property under.
+ *
+ * OpenRouter's docs: "custom metadata from the `trace` field is included as span attributes in the OTLP
+ * JSON payload". The exact prefix is not contractual, so several candidates are checked.
+ */ var OPENROUTER_BROADCAST_RUN_TASK_KEY_ATTRIBUTES = [
+    'runTaskKey',
+    'trace.runTaskKey',
+    'openrouter.trace.runTaskKey',
+    'gen_ai.trace.runTaskKey'
+];
+/**
+ * Reads the run task key out of a span's attribute map.
+ *
+ * @param attributes - The flattened span attributes.
+ * @returns The run task key, when the span carries one.
+ */ function openRouterRunTaskKeyFromBroadcastAttributes(attributes) {
+    var result;
+    if (attributes != null) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = OPENROUTER_BROADCAST_RUN_TASK_KEY_ATTRIBUTES[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                var value = attributes.get(key);
+                if (value != null) {
+                    result = String(value);
+                    break;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Reconciles generation id, usage, and cost onto a run task from a broadcast span.
+ *
+ * This exists for the one thing the runner cannot always know: cost is finalised server-side, so the
+ * value the runner wrote from the response can be provisional.
+ *
+ * TELEMETRY ONLY — it never changes `s`, and a span it cannot match is dropped silently. Broadcast is
+ * enabled account-wide rather than per request, delivery is asynchronous and best-effort, and a dropped
+ * trace must not be able to strand a task. Putting control flow here would make a missing trace look
+ * exactly like a stuck run.
+ *
+ * @param params - The collections, run task key, and generation info.
+ * @returns Whether anything was written.
+ */ function reconcileOpenRouterRunTaskFromBroadcast(params) {
+    return _async_to_generator$7(function() {
+        var collections, key, generation, reconciled, document, task, generationIds, usage;
+        return _ts_generator$7(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    collections = params.collections, key = params.key, generation = params.generation;
+                    reconciled = false;
+                    if (!key) return [
+                        3,
+                        3
+                    ];
+                    document = collections.openRouterRunTaskCollection.documentAccessor().loadDocumentForId(key);
+                    return [
+                        4,
+                        document.snapshotData()
+                    ];
+                case 1:
+                    task = _state.sent();
+                    if (!(task != null)) return [
+                        3,
+                        3
+                    ];
+                    generationIds = generation.generationId == null ? task.gi : util.concatArraysUnique(task.gi, [
+                        generation.generationId
+                    ]);
+                    usage = mergeOpenRouterRunUsage(task.u, generation);
+                    return [
+                        4,
+                        document.update({
+                            gi: generationIds,
+                            u: usage
+                        })
+                    ];
+                case 2:
+                    _state.sent();
+                    reconciled = true;
+                    _state.label = 3;
+                case 3:
+                    return [
+                        2,
+                        {
+                            reconciled: reconciled
+                        }
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Merges broadcast-reported usage into the usage already stored on a task.
+ *
+ * The broadcast value wins where it is present — it is the later, authoritative measurement — and the
+ * stored value is kept where the span is silent, so an incomplete span cannot erase what the runner knew.
+ *
+ * The filter MUST be `NULL`, not `mergeObjects`' default of `UNDEFINED`. Every field here is a `Maybe`, so a
+ * span reporting `cost: null` means "did not measure" — and under the default filter that `null` would win
+ * and erase the cost the runner actually recorded.
+ *
+ * `reasoningTokens` / `cachedTokens` / `isByok` are absent from the literal because a broadcast span carries
+ * none of them; they ride along from `existing` untouched.
+ *
+ * @param existing - Usage already stored.
+ * @param generation - The span's generation info.
+ * @returns The merged usage.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function mergeOpenRouterRunUsage(existing, generation) {
+    var inputTokens = generation.promptTokens, outputTokens = generation.completionTokens, totalTokens = generation.totalTokens, cost = generation.cost;
+    return util.mergeObjects([
+        existing,
+        {
+            inputTokens: inputTokens,
+            outputTokens: outputTokens,
+            totalTokens: totalTokens,
+            cost: cost
+        }
+    ], util.KeyValueTypleValueFilter.NULL);
+}
+
+function asyncGeneratorStep$6(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$6(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$6(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$6(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
+        };
+    }
+}
+/**
+ * Runs a prompt INLINE and returns the result, with no run task document.
+ *
+ * Use this wherever a call reliably finishes in a few seconds. The queue exists for calls that do not,
+ * and paying for a document, a lease, and a sweep interval on a two-second call buys nothing.
+ *
+ * @param params - The client, prompt service, prompt, and input.
+ * @returns The normalized call result.
+ */ function callModelForPrompt(params) {
+    return _async_to_generator$6(function() {
+        var client, promptService, promptKey, version, input, configOverrides, files, tools, 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, input = params.input, configOverrides = params.configOverrides, files = params.files, tools = params.tools, trace = params.trace;
+                    return [
+                        4,
+                        promptService.resolvePrompt({
+                            promptKey: promptKey,
+                            version: version
+                        })
+                    ];
+                case 1:
+                    prompt = _state.sent();
+                    request = openrouter.openRouterPromptRequest({
+                        prompt: prompt,
+                        input: input,
+                        overrides: configOverrides,
+                        files: files,
+                        trace: trace
+                    });
+                    return [
+                        2,
+                        openrouter.callModelForOpenRouterRequest({
+                            client: client,
+                            request: request,
+                            tools: tools !== null && tools !== void 0 ? tools : undefined
+                        })
+                    ];
+            }
+        });
+    })();
+}
+
+function asyncGeneratorStep$5(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$5(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$5(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$5(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
+        };
+    }
+}
+/**
+ * Default lifetime of a signed url minted for one attempt.
+ *
+ * Deliberately short. The url only has to survive the single request it is attached to, and every
+ * attempt gets a freshly signed one — so a short TTL costs nothing and narrows the window in which a
+ * third party holds a bearer credential to the object.
+ */ var DEFAULT_OPENROUTER_SIGNED_URL_TTL = util.MS_IN_MINUTE * 5;
+/**
+ * Cap on the size of a file carried inline.
+ *
+ * Base64 inflates the payload by roughly a third, and the cost is re-paid on EVERY attempt rather than
+ * amortized the way a url is — so this is a guard against turning a retry loop into a bandwidth bill,
+ * not a correctness limit.
+ */ var DEFAULT_OPENROUTER_MAX_INLINE_FILE_SIZE_BYTES = 256 * 1024;
+/**
+ * Content type assumed for an inlined object whose metadata reports none.
+ *
+ * Matches {@link openRouterInputFileDataPart}'s own default, so the two cannot disagree.
+ */ var DEFAULT_OPENROUTER_INLINE_FILE_CONTENT_TYPE = 'application/pdf';
+/**
+ * The mode a config resolves to.
+ *
+ * Order: the explicit override, then the environment service, then `signedUrl`.
+ *
+ * Gated on `isProduction` rather than `isTestingEnv`, because the question is whether OpenRouter can
+ * reach the object, not whether this is a test. Every non-production environment here is a localhost
+ * one — the emulator under `nx serve` as much as a spec run — and `isTestingEnv` is only
+ * `NODE_ENV === 'test'`, so it covered the spec run and left the emulator handing OpenRouter a
+ * `127.0.0.1` url that it rejects outright.
+ *
+ * @param config - The resolver config.
+ * @returns The mode.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterFileAttachmentModeForConfig(config) {
+    var mode = config.mode, envService = config.envService;
+    // `=== false` rather than a negation, so a config with no env service still resolves to `signedUrl`.
+    return mode !== null && mode !== void 0 ? mode : (envService === null || envService === void 0 ? void 0 : envService.isProduction) === false ? 'inlineData' : 'signedUrl';
+}
+/**
+ * Creates an {@link OpenRouterFileAttachmentResolver}.
+ *
+ * Called once per attempt, never at enqueue time: both transports produce something that is only valid
+ * for the request it is attached to.
+ *
+ * @param config - The storage context, environment service, and transport settings.
+ * @returns The resolver.
+ */ function openRouterFileAttachmentResolver(config) {
+    var storageContext = config.storageContext, signedUrlTtl = config.signedUrlTtl, maxInlineFileSizeBytes = config.maxInlineFileSizeBytes;
+    var mode = openRouterFileAttachmentModeForConfig(config);
+    var urlTtl = signedUrlTtl !== null && signedUrlTtl !== void 0 ? signedUrlTtl : DEFAULT_OPENROUTER_SIGNED_URL_TTL;
+    var maxInlineBytes = maxInlineFileSizeBytes !== null && maxInlineFileSizeBytes !== void 0 ? maxInlineFileSizeBytes : DEFAULT_OPENROUTER_MAX_INLINE_FILE_SIZE_BYTES;
+    return function resolveAttachments(files) {
+        return _async_to_generator$5(function() {
+            var result, defaultBucketId;
+            return _ts_generator$5(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        result = [];
+                        if (!(files != null && files.length > 0)) return [
+                            3,
+                            2
+                        ];
+                        if (storageContext == null) {
+                            throw new Error('An OpenRouterRunTask carries files but no storageContext was configured to attach them with.');
+                        }
+                        defaultBucketId = storageContext.defaultBucket();
+                        return [
+                            4,
+                            Promise.all(files.map(function(file) {
+                                return _async_to_generator$5(function() {
+                                    var _file_bucket, path, accessorFile, attached, _metadata_contentType, bytes, metadata, contentType, _tmp;
+                                    return _ts_generator$5(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                path = {
+                                                    bucketId: (_file_bucket = file.bucket) !== null && _file_bucket !== void 0 ? _file_bucket : defaultBucketId,
+                                                    pathString: file.storagePath
+                                                };
+                                                accessorFile = storageContext.file(path);
+                                                if (!(mode === 'inlineData')) return [
+                                                    3,
+                                                    3
+                                                ];
+                                                if (accessorFile.getBytes == null) {
+                                                    throw new Error('The configured FirebaseStorageContext cannot read file bytes, which inline file attachment requires.');
+                                                }
+                                                return [
+                                                    4,
+                                                    accessorFile.getBytes(maxInlineBytes)
+                                                ];
+                                            case 1:
+                                                bytes = _state.sent();
+                                                return [
+                                                    4,
+                                                    accessorFile.getMetadata()
+                                                ];
+                                            case 2:
+                                                metadata = _state.sent();
+                                                contentType = (_metadata_contentType = metadata.contentType) !== null && _metadata_contentType !== void 0 ? _metadata_contentType : DEFAULT_OPENROUTER_INLINE_FILE_CONTENT_TYPE;
+                                                attached = {
+                                                    file: file,
+                                                    fileData: "data:".concat(contentType, ";base64,").concat(Buffer.from(bytes).toString('base64'))
+                                                };
+                                                return [
+                                                    3,
+                                                    5
+                                                ];
+                                            case 3:
+                                                if (accessorFile.getSignedUrl == null) {
+                                                    throw new Error('The configured FirebaseStorageContext cannot mint signed urls.');
+                                                }
+                                                _tmp = {
+                                                    file: file
+                                                };
+                                                return [
+                                                    4,
+                                                    accessorFile.getSignedUrl({
+                                                        action: 'read',
+                                                        expiresIn: urlTtl
+                                                    })
+                                                ];
+                                            case 4:
+                                                attached = (_tmp.fileUrl = _state.sent(), _tmp);
+                                                _state.label = 5;
+                                            case 5:
+                                                return [
+                                                    2,
+                                                    attached
+                                                ];
+                                        }
+                                    });
+                                })();
+                            }))
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        _state.label = 2;
+                    case 2:
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        })();
+    };
+}
+
+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 _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+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 _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 _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);
+}
+/**
+ * Builds the module metadata for an app's OpenRouter module.
+ *
+ * @param config - The dependency module and server-actions provider.
+ * @returns The module metadata.
+ */ function appOpenRouterModuleMetadata(config) {
+    var dependencyModule = config.dependencyModule, serverActionsProvider = config.serverActionsProvider, providers = config.providers, exports = config.exports;
+    return {
+        imports: [
+            dependencyModule
+        ],
+        providers: [
+            serverActionsProvider
+        ].concat(_to_consumable_array$1(providers !== null && providers !== void 0 ? providers : [])),
+        exports: [
+            OpenRouterPromptServerActions
+        ].concat(_to_consumable_array$1(exports !== null && exports !== void 0 ? exports : []))
+    };
+}
+/**
+ * Base class an app's OpenRouter module extends.
+ */ var AbstractAppOpenRouterModule = function AbstractAppOpenRouterModule() {
+    _class_call_check$2(this, AbstractAppOpenRouterModule);
+};
+/**
+ * Injection token for the {@link OpenRouterPromptService}.
+ */ var OPENROUTER_PROMPT_SERVICE_TOKEN = 'OPENROUTER_PROMPT_SERVICE_TOKEN';
+/**
+ * Injection token for the {@link OpenRouterRunTaskService}.
+ */ var OPENROUTER_RUN_TASK_SERVICE_TOKEN = 'OPENROUTER_RUN_TASK_SERVICE_TOKEN';
+
+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$4(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$4(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$4(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$4(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$1(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) {
+        _construct = Reflect.construct;
+    } else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [
+                null
+            ];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+            if (Class) _set_prototype_of(instance, Class.prototype);
+            return instance;
+        };
+    }
+    return _construct.apply(null, arguments);
+}
+function _define_property$2(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            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 _possible_constructor_return(self, call) {
+    if (call && (_type_of$1(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 _type_of$1(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _wrap_native_super(Class) {
+    var _cache = typeof Map === "function" ? new Map() : undefined;
+    _wrap_native_super = function wrapNativeSuper(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);
+}
+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 _ts_generator$4(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
+        };
+    }
+}
+/**
+ * Error thrown when a prompt cannot be resolved.
+ */ var OpenRouterPromptResolutionError = /*#__PURE__*/ function(Error1) {
+    _inherits(OpenRouterPromptResolutionError, Error1);
+    function OpenRouterPromptResolutionError(promptKey, message, version) {
+        _class_call_check$1(this, OpenRouterPromptResolutionError);
+        var _this;
+        _this = _call_super(this, OpenRouterPromptResolutionError, [
+            'OpenRouter prompt "'.concat(promptKey, '"').concat(version == null ? '' : " version ".concat(version), ": ").concat(message)
+        ]), _define_property$2(_this, "promptKey", void 0), _define_property$2(_this, "version", void 0);
+        _this.promptKey = promptKey;
+        _this.version = version;
+        return _this;
+    }
+    return OpenRouterPromptResolutionError;
+}(_wrap_native_super(Error));
+/**
+ * Default time a resolved prompt is cached for.
+ *
+ * What can go stale is which version is active, and what the latest — still editable — version says.
+ * Neither is critical to serve to the second: a run that used the previous text for a few minutes is a
+ * run against a prompt that was live a few minutes ago, not a wrong run. Bounded rather than permanent
+ * is the requirement, so the change lands on its own rather than at the next cold start.
+ */ var OPENROUTER_PROMPT_CACHE_DURATION = util.MS_IN_MINUTE * 5;
+/**
+ * Loads prompts and resolves their versions.
+ */ var OpenRouterPromptService = function OpenRouterPromptService() {
+    _class_call_check$1(this, OpenRouterPromptService);
+};
+/**
+ * Creates an {@link OpenRouterPromptService}.
+ *
+ * @param config - The collections and cache configuration.
+ * @returns The service.
+ */ function openRouterPromptService(config) {
+    var collections = config.collections, definitions = config.definitions, cacheDuration = config.cacheDuration, rejectInvalidConfig = config.rejectInvalidConfig;
+    var openRouterPromptCollection = collections.openRouterPromptCollection, openRouterPromptVersionCollectionFactory = collections.openRouterPromptVersionCollectionFactory;
+    var duration = cacheDuration !== null && cacheDuration !== void 0 ? cacheDuration : OPENROUTER_PROMPT_CACHE_DURATION;
+    var definitionsByKey = util.arrayToMap(definitions !== null && definitions !== void 0 ? definitions : [], function(definition) {
+        return definition.promptKey;
+    });
+    var cache = new Map();
+    function loadPromptDefinitions() {
+        return _async_to_generator$4(function() {
+            return _ts_generator$4(this, function(_state) {
+                // A fresh array each call rather than one built at construction: the returned type is mutable, and
+                // handing every caller the same array would let a seeder's own filtering reach the registry
+                // resolution reads.
+                return [
+                    2,
+                    Array.from(definitionsByKey.values())
+                ];
+            });
+        })();
+    }
+    function loadPromptDocument(promptKey) {
+        return openRouterPromptCollection.documentAccessor().loadDocumentForId(promptKey);
+    }
+    function loadPrompt(promptKey) {
+        return _async_to_generator$4(function() {
+            return _ts_generator$4(this, function(_state) {
+                return [
+                    2,
+                    loadPromptDocument(promptKey).snapshotData()
+                ];
+            });
+        })();
+    }
+    /**
+     * Reads one published version.
+     *
+     * @param promptDocument - The parent prompt document.
+     * @param promptKey - The prompt's key, recorded on the resolution.
+     * @param version - The version to read.
+     * @returns The resolved version, or undefined when that version was never published.
+     */ function readStoredVersion(promptDocument, promptKey, version) {
+        return _async_to_generator$4(function() {
+            var versionDocument, versionData;
+            return _ts_generator$4(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        versionDocument = openRouterPromptVersionCollectionFactory(promptDocument).documentAccessor().loadDocumentForId(firebase.openRouterPromptVersionId(version));
+                        return [
+                            4,
+                            versionDocument.snapshotData()
+                        ];
+                    case 1:
+                        versionData = _state.sent();
+                        return [
+                            2,
+                            versionData == null ? undefined : firebase.openRouterResolvedPromptForVersion(promptKey, versionData)
+                        ];
+                }
+            });
+        })();
+    }
+    function resolveVersion(promptKey, inputVersion) {
+        return _async_to_generator$4(function() {
+            var definition, promptDocument, prompt, storedActiveVersion, resolved, _tmp, validation;
+            return _ts_generator$4(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        definition = definitionsByKey.get(promptKey);
+                        promptDocument = loadPromptDocument(promptKey);
+                        return [
+                            4,
+                            promptDocument.snapshotData()
+                        ];
+                    case 1:
+                        prompt = _state.sent();
+                        // The version the store would serve an unpinned caller. A prompt that is missing, not ACTIVE, or has
+                        // never had a version promoted cannot serve one — which is precisely when a code definition stands in.
+                        // A pinned caller is still allowed to read a draft/archived prompt: that is how a version is tested
+                        // before promotion, and how a historical run is replayed after retirement.
+                        storedActiveVersion = (prompt === null || prompt === void 0 ? void 0 : prompt.s) === firebase.OpenRouterPromptState.ACTIVE ? prompt.av : undefined;
+                        if (!(inputVersion != null)) return [
+                            3,
+                            5
+                        ];
+                        if (!(prompt == null)) return [
+                            3,
+                            2
+                        ];
+                        _tmp = undefined;
+                        return [
+                            3,
+                            4
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            readStoredVersion(promptDocument, promptKey, inputVersion)
+                        ];
+                    case 3:
+                        _tmp = _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        // Pinned. The store wins whenever it actually holds that version, so a version published under the
+                        // same number after a run was queued is picked up on the run's next attempt. The definition covers
+                        // the rest, which is what lets a run enqueued against a definition still dispatch.
+                        resolved = _tmp;
+                        if (resolved == null && (definition === null || definition === void 0 ? void 0 : definition.version) === inputVersion) {
+                            resolved = definition;
+                        }
+                        return [
+                            3,
+                            8
+                        ];
+                    case 5:
+                        if (!(definition != null && (storedActiveVersion == null || definition.version > storedActiveVersion))) return [
+                            3,
+                            6
+                        ];
+                        // Unpinned, and code is either standing in for the store or ahead of it.
+                        resolved = definition;
+                        return [
+                            3,
+                            8
+                        ];
+                    case 6:
+                        if (!(storedActiveVersion != null)) return [
+                            3,
+                            8
+                        ];
+                        return [
+                            4,
+                            readStoredVersion(promptDocument, promptKey, storedActiveVersion)
+                        ];
+                    case 7:
+                        resolved = _state.sent();
+                        _state.label = 8;
+                    case 8:
+                        if (resolved == null) {
+                            // Reported against what was actually missing, since "no prompt", "nothing promoted", and "that one
+                            // version is gone" need different fixes.
+                            if (prompt == null) {
+                                throw new OpenRouterPromptResolutionError(promptKey, 'does not exist.', inputVersion);
+                            } else if (inputVersion != null) {
+                                throw new OpenRouterPromptResolutionError(promptKey, 'version does not exist.', inputVersion);
+                            } else if (prompt.s === firebase.OpenRouterPromptState.ACTIVE) {
+                                throw new OpenRouterPromptResolutionError(promptKey, 'has no activeVersion, and no version was pinned.');
+                            } else {
+                                throw new OpenRouterPromptResolutionError(promptKey, "is not ACTIVE (state ".concat(prompt.s, "), and no version was pinned."));
+                            }
+                        }
+                        if (rejectInvalidConfig) {
+                            validation = openrouter.validateOpenRouterModelConfig(resolved.config);
+                            if (!validation.valid) {
+                                throw new OpenRouterPromptResolutionError(promptKey, "has an invalid config: ".concat(validation.errors.join(' ')), resolved.version);
+                            }
+                        }
+                        return [
+                            2,
+                            resolved
+                        ];
+                }
+            });
+        })();
+    }
+    function cacheKey(promptKey, version) {
+        return "".concat(promptKey, ":").concat(version !== null && version !== void 0 ? version : '_');
+    }
+    function resolvePrompt(params) {
+        return _async_to_generator$4(function() {
+            var promptKey, version, key, getter, load, result, e;
+            return _ts_generator$4(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        promptKey = params.promptKey, version = params.version;
+                        key = cacheKey(promptKey, version);
+                        getter = cache.get(key);
+                        if (getter == null) {
+                            load = function load() {
+                                return resolveVersion(promptKey, version);
+                            };
+                            // Everything expires, pinned resolutions included. A version is only immutable once it LOCKS, which
+                            // happens when the next version is created — until then the head version is editable in place, and
+                            // a permanently cached pin of it would serve the pre-edit text forever on every instance except the
+                            // one that handled the edit. Telling the two apart would cost a read of the lock, which is the same
+                            // read the expiry already pays for.
+                            getter = util.expiringCachedGetter({
+                                getter: load,
+                                ttl: duration
+                            });
+                            cache.set(key, getter);
+                        }
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            3,
+                            ,
+                            4
+                        ]);
+                        return [
+                            4,
+                            getter()
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            3,
+                            4
+                        ];
+                    case 3:
+                        e = _state.sent();
+                        // Never cache a rejected promise: a prompt created moments after a failed lookup would keep
+                        // failing for the whole cache window.
+                        cache.delete(key);
+                        throw e;
+                    case 4:
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        })();
+    }
+    function clearCachedPrompt(promptKey) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // Every version of the prompt goes, pinned entries included: a publish or promote can change what any
+            // of them resolve to. Deleting the current entry mid-iteration is well-defined for a Map iterator, so
+            // no snapshot copy is needed.
+            for(var _iterator = cache.keys()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var key = _step.value;
+                if (key.startsWith("".concat(promptKey, ":"))) {
+                    cache.delete(key);
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return {
+        loadPromptDefinitions: loadPromptDefinitions,
+        loadPrompt: loadPrompt,
+        resolvePrompt: resolvePrompt,
+        clearCachedPrompt: clearCachedPrompt
+    };
+}
+
+function asyncGeneratorStep$3(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$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$3(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$3(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$3(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
+        };
+    }
+}
+/**
+ * Classifies a run task into an outcome.
+ *
+ * `AWAITING_ASYNC_TOOLS` reports as `queued`: from the caller's side it is indistinguishable from
+ * waiting, because it is waiting — just on a tool result rather than on a sweep.
+ *
+ * @param task - The run task, or null when it does not exist.
+ * @returns The outcome.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterRunTaskOutcome(task) {
+    var result;
+    if (task == null) {
+        result = 'missing';
+    } else {
+        switch(task.s){
+            case firebase.OpenRouterRunTaskState.COMPLETE:
+                result = 'complete';
+                break;
+            case firebase.OpenRouterRunTaskState.FAILED:
+                result = 'failure';
+                break;
+            case firebase.OpenRouterRunTaskState.QUEUED:
+            case firebase.OpenRouterRunTaskState.RUNNING:
+            case firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS:
+            default:
+                result = 'queued';
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Creates a reusable dispatcher for a fixed set of handlers.
+ *
+ * @param handlers - The per-outcome handlers.
+ * @returns A function that dispatches a run task.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function handleOpenRouterRunTaskResultFactory(handlers) {
+    return function(task) {
+        return _async_to_generator$3(function() {
+            var outcome, result;
+            return _ts_generator$3(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        outcome = openRouterRunTaskOutcome(task);
+                        switch(outcome){
+                            case 'complete':
+                                return [
+                                    3,
+                                    1
+                                ];
+                            case 'queued':
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 'failure':
+                                return [
+                                    3,
+                                    5
+                                ];
+                            case 'missing':
+                                return [
+                                    3,
+                                    7
+                                ];
+                        }
+                        return [
+                            3,
+                            7
+                        ];
+                    case 1:
+                        return [
+                            4,
+                            handlers.onComplete(task)
+                        ];
+                    case 2:
+                        result = _state.sent();
+                        return [
+                            3,
+                            9
+                        ];
+                    case 3:
+                        return [
+                            4,
+                            handlers.onQueued(task)
+                        ];
+                    case 4:
+                        result = _state.sent();
+                        return [
+                            3,
+                            9
+                        ];
+                    case 5:
+                        return [
+                            4,
+                            handlers.onFailure(task)
+                        ];
+                    case 6:
+                        result = _state.sent();
+                        return [
+                            3,
+                            9
+                        ];
+                    case 7:
+                        return [
+                            4,
+                            handlers.onMissing()
+                        ];
+                    case 8:
+                        result = _state.sent();
+                        return [
+                            3,
+                            9
+                        ];
+                    case 9:
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        })();
+    };
+}
+
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _object_spread$1(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+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 _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
+        };
+    }
+}
+/**
+ * Maps a run task state to the SDK's conversation status.
+ *
+ * @param state - The run task state.
+ * @returns The conversation status.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function conversationStatusForOpenRouterRunTaskState(state) {
+    var result;
+    switch(state){
+        case firebase.OpenRouterRunTaskState.COMPLETE:
+            result = 'complete';
+            break;
+        case firebase.OpenRouterRunTaskState.FAILED:
+            result = 'interrupted';
+            break;
+        case firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS:
+            // The SDK's vocabulary for "paused holding tool calls we did not execute ourselves".
+            result = 'awaiting_approval';
+            break;
+        case firebase.OpenRouterRunTaskState.RUNNING:
+            result = 'in_progress';
+            break;
+        case firebase.OpenRouterRunTaskState.QUEUED:
+        default:
+            result = 'in_progress';
+            break;
+    }
+    return result;
+}
+/**
+ * Maps a conversation status back to the run task state to persist.
+ *
+ * @param status - The conversation status.
+ * @param hasPendingToolCalls - Whether the state carries tool calls this process cannot resolve.
+ * @returns The run task state.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterRunTaskStateForConversationStatus(status, hasPendingToolCalls) {
+    var result;
+    if (hasPendingToolCalls) {
+        // Pending calls win over the reported status: whatever the SDK called it, the run cannot proceed
+        // until something outside this process supplies those results.
+        result = firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS;
+    } else {
+        switch(status){
+            case 'complete':
+                result = firebase.OpenRouterRunTaskState.COMPLETE;
+                break;
+            case 'awaiting_approval':
+                result = firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS;
+                break;
+            case 'interrupted':
+            case 'in_progress':
+            default:
+                result = firebase.OpenRouterRunTaskState.RUNNING;
+                break;
+        }
+    }
+    return result;
+}
+/**
+ * Builds a {@link ConversationState} from a run task.
+ *
+ * `updatedAt` is derived rather than stored: the run task's existing timestamps already order the
+ * lifecycle (`fat` > `lat` > `sat` > `qat`), and the SDK uses the value informationally.
+ *
+ * @param key - The run task key, which is the conversation id.
+ * @param task - The run task.
+ * @returns The conversation state.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function conversationStateForOpenRouterRunTask(key, task) {
+    var _ref, _ref1, _task_fat, _task_msg, _task_ptc, _task_utr;
+    var updatedAt = (_ref = (_ref1 = (_task_fat = task.fat) !== null && _task_fat !== void 0 ? _task_fat : task.lat) !== null && _ref1 !== void 0 ? _ref1 : task.sat) !== null && _ref !== void 0 ? _ref : task.qat;
+    return {
+        id: key,
+        messages: (_task_msg = task.msg) !== null && _task_msg !== void 0 ? _task_msg : [],
+        pendingToolCalls: ((_task_ptc = task.ptc) !== null && _task_ptc !== void 0 ? _task_ptc : []).map(function(call) {
+            return {
+                id: call.callId,
+                name: call.name,
+                arguments: call.arguments
+            };
+        }),
+        unsentToolResults: ((_task_utr = task.utr) !== null && _task_utr !== void 0 ? _task_utr : []).map(function(result) {
+            var _result_error;
+            return {
+                callId: result.callId,
+                name: result.name,
+                output: result.output,
+                error: (_result_error = result.error) !== null && _result_error !== void 0 ? _result_error : undefined
+            };
+        }),
+        status: conversationStatusForOpenRouterRunTaskState(task.s),
+        createdAt: task.qat.getTime(),
+        updatedAt: updatedAt.getTime()
+    };
+}
+/**
+ * Builds the run task update for a conversation state.
+ *
+ * @param state - The conversation state to persist.
+ * @returns The fields to write.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterRunTaskUpdateForConversationState(state) {
+    var _state_pendingToolCalls, _state_messages, _state_unsentToolResults;
+    var pendingToolCalls = (_state_pendingToolCalls = state.pendingToolCalls) !== null && _state_pendingToolCalls !== void 0 ? _state_pendingToolCalls : [];
+    return {
+        s: openRouterRunTaskStateForConversationStatus(state.status, pendingToolCalls.length > 0),
+        // Attachment payloads are stripped on the way in. They are resolved per attempt — a signed url has
+        // already expired and inline base64 is the whole file — and `msg` is a Firestore field with a 1 MiB
+        // document budget behind it. `load()` re-points the stripped parts, so nothing is lost.
+        msg: openRouterConversationValueForFirestore(openrouter.openRouterMessagesWithoutFileAttachmentData((_state_messages = state.messages) !== null && _state_messages !== void 0 ? _state_messages : [])),
+        ptc: pendingToolCalls.map(function(call) {
+            var _openRouterConversationValueForFirestore;
+            return {
+                callId: call.id,
+                name: call.name,
+                taskId: call.id,
+                arguments: (_openRouterConversationValueForFirestore = openRouterConversationValueForFirestore(call.arguments)) !== null && _openRouterConversationValueForFirestore !== void 0 ? _openRouterConversationValueForFirestore : null
+            };
+        }),
+        utr: ((_state_unsentToolResults = state.unsentToolResults) !== null && _state_unsentToolResults !== void 0 ? _state_unsentToolResults : []).map(function(result) {
+            var _openRouterConversationValueForFirestore, _result_error;
+            return {
+                callId: result.callId,
+                name: result.name,
+                output: (_openRouterConversationValueForFirestore = openRouterConversationValueForFirestore(result.output)) !== null && _openRouterConversationValueForFirestore !== void 0 ? _openRouterConversationValueForFirestore : null,
+                error: (_result_error = result.error) !== null && _result_error !== void 0 ? _result_error : null
+            };
+        })
+    };
+}
+/**
+ * Strips `undefined` out of a value on its way into Firestore, at ANY DEPTH.
+ *
+ * Conversation state is whatever the SDK hands back, arbitrarily nested, and its response items carry
+ * explicit `undefined`s for absent optional fields at every level. Firestore rejects `undefined` outright,
+ * so persisting one unfiltered fails the whole write — and it fails inside the SDK's `saveStateSafely`,
+ * which surfaces as an opaque "Failed to persist conversation state" rather than as the run-task write it
+ * actually is.
+ *
+ * A JSON round-trip rather than `copyValueWithoutUndefinedValues` (which filters just as deeply, and is
+ * what the run task converter's passthrough-JSON fields use): the round-trip additionally flattens
+ * anything that is not wire json — a `Date`, a class instance with a `toJSON` — which is correct here
+ * precisely because this data IS json. It came off the wire, and `load()` hands it straight back to the
+ * SDK expecting the same shapes. The converter's fields, by contrast, must leave a `Date`/`Timestamp`
+ * intact for Firestore.
+ *
+ * @param value - The value to sanitize.
+ * @returns The value with every `undefined` removed.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterConversationValueForFirestore(value) {
+    // NOT `structuredClone`. It PRESERVES `undefined`-valued keys, which is the one thing this function
+    // exists to remove — so `unicorn/prefer-structured-clone`'s autofix would silently break it.
+    // eslint-disable-next-line unicorn/prefer-structured-clone
+    return value === undefined ? value : JSON.parse(JSON.stringify(value));
+}
+/**
+ * Creates a {@link StateAccessor} backed by a run task document.
+ *
+ * This is the persistent backend the SDK's docs ask for — its own example is a `Map`, with the note to
+ * "implement `StateAccessor` with a persistent backend". Because OpenRouter allocates no conversation
+ * id (and rejects `previous_response_id` outright), the conversation id is ours: the run task key.
+ *
+ * A single-shot run simply never populates `msg` / `ptc` / `utr`, so nothing is paid for not using it.
+ *
+ * @param document - The run task document to read and write.
+ * @param config - The initial conversation and this attempt's attached files.
+ * @returns The state accessor.
+ */ function firestoreOpenRouterStateAccessor(document, config) {
+    var _ref = config !== null && config !== void 0 ? config : {}, initialMessages = _ref.initialMessages, attachedFiles = _ref.attachedFiles;
+    return {
+        load: function load() {
+            return _async_to_generator$2(function() {
+                var task, result, _task_msg, stored, messages;
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                document.snapshotData()
+                            ];
+                        case 1:
+                            task = _state.sent();
+                            if (task != null) {
+                                stored = (_task_msg = task.msg) !== null && _task_msg !== void 0 ? _task_msg : [];
+                                messages = openrouter.openRouterMessagesWithFreshFileAttachments(stored.length > 0 ? stored : initialMessages !== null && initialMessages !== void 0 ? initialMessages : [], attachedFiles);
+                                result = conversationStateForOpenRouterRunTask(document.id, _object_spread_props$1(_object_spread$1({}, task), {
+                                    msg: messages
+                                }));
+                            }
+                            return [
+                                2,
+                                result !== null && result !== void 0 ? result : null
+                            ];
+                    }
+                });
+            })();
+        },
+        save: function save(state) {
+            return _async_to_generator$2(function() {
+                return _ts_generator$2(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            return [
+                                4,
+                                document.update(openRouterRunTaskUpdateForConversationState(state))
+                            ];
+                        case 1:
+                            _state.sent();
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    "@swc/helpers - instanceof";
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Default lease duration. A `RUNNING` task whose lease is older than this is reclaimable.
+ *
+ * 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 = util.MS_IN_MINUTE * 10;
+/**
+ * Default number of attempts before a task is marked FAILED.
+ *
+ * Spent only on a failure {@link isRetryableOpenRouterError} classifies as transient; a deterministic
+ * failure reaches `FAILED` on its first attempt.
+ */ var DEFAULT_OPENROUTER_MAX_ATTEMPTS = 3;
+/**
+ * Maximum tasks one retention page may delete.
+ *
+ * A page's deletes go out as a single Firestore write batch, and a batch takes at most 500 writes.
+ */ var OPENROUTER_MAX_EXPIRED_RUN_TASK_DELETE_PAGE_SIZE = 500;
+/**
+ * Manages the app-owned run-task queue: the replacement for OpenAI's `background: true` plus its
+ * server-side job store, neither of which OpenRouter has.
+ */ var OpenRouterRunTaskService = function OpenRouterRunTaskService() {
+    _class_call_check(this, OpenRouterRunTaskService);
+};
+/**
+ * Creates an {@link OpenRouterRunTaskService}.
+ *
+ * @param config - The collections, prompt service, client, and execution settings.
+ * @returns The service.
+ */ function openRouterRunTaskService(config) {
+    var collections = config.collections, promptService = config.promptService, client = config.client, storageContext = config.storageContext, envService = config.envService, fileAttachmentMode = config.fileAttachmentMode, maxInlineFileSizeBytes = config.maxInlineFileSizeBytes, tools = config.tools, onTerminalState = config.onTerminalState, signedUrlTtl = config.signedUrlTtl, inputMaxAttempts = config.maxAttempts, inputLeaseDuration = config.leaseDuration;
+    var openRouterRunTaskCollection = collections.openRouterRunTaskCollection;
+    var attachFilesForAttempt = openRouterFileAttachmentResolver({
+        storageContext: storageContext,
+        envService: envService,
+        mode: fileAttachmentMode,
+        signedUrlTtl: signedUrlTtl,
+        maxInlineFileSizeBytes: maxInlineFileSizeBytes
+    });
+    var maxAttempts = inputMaxAttempts !== null && inputMaxAttempts !== void 0 ? inputMaxAttempts : DEFAULT_OPENROUTER_MAX_ATTEMPTS;
+    var defaultLeaseDuration = inputLeaseDuration !== null && inputLeaseDuration !== void 0 ? inputLeaseDuration : DEFAULT_OPENROUTER_LEASE_DURATION;
+    function runTaskDocument(key) {
+        return openRouterRunTaskCollection.documentAccessor().loadDocumentForId(key);
+    }
+    function readRunTask(key) {
+        return _async_to_generator$1(function() {
+            return _ts_generator$1(this, function(_state) {
+                return [
+                    2,
+                    runTaskDocument(key).snapshotData()
+                ];
+            });
+        })();
+    }
+    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;
+            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;
+                        document = runTaskDocument(key);
+                        return [
+                            4,
+                            document.snapshotData()
+                        ];
+                    case 1:
+                        existing = _state.sent();
+                        if (!(existing != null && !restart)) return [
+                            3,
+                            2
+                        ];
+                        created = false;
+                        task = existing;
+                        return [
+                            3,
+                            8
+                        ];
+                    case 2:
+                        return [
+                            4,
+                            promptService.resolvePrompt({
+                                promptKey: promptKey,
+                                version: version
+                            })
+                        ];
+                    case 3:
+                        resolved = _state.sent();
+                        if (!(continueFrom == null)) return [
+                            3,
+                            4
+                        ];
+                        _tmp = undefined;
+                        return [
+                            3,
+                            6
+                        ];
+                    case 4:
+                        return [
+                            4,
+                            historyForRunTask(continueFrom)
+                        ];
+                    case 5:
+                        _tmp = _state.sent();
+                        _state.label = 6;
+                    case 6:
+                        history = _tmp;
+                        task = {
+                            s: firebase.OpenRouterRunTaskState.QUEUED,
+                            // Write-once from here on: the retention ceiling and the claim order both read it as the task's age.
+                            qat: new Date(),
+                            at: 0,
+                            pk: promptKey,
+                            pv: resolved.version,
+                            in: openrouter.openRouterInputMessages(input),
+                            fp: files,
+                            co: configOverrides,
+                            msg: history
+                        };
+                        created = true;
+                        return [
+                            4,
+                            document.accessor.set(task)
+                        ];
+                    case 7:
+                        _state.sent();
+                        _state.label = 8;
+                    case 8:
+                        return [
+                            2,
+                            {
+                                key: key,
+                                document: document,
+                                created: created,
+                                task: task
+                            }
+                        ];
+                }
+            });
+        })();
+    }
+    function historyForRunTask(key) {
+        return _async_to_generator$1(function() {
+            var prior, result, _prior_in, messages;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            readRunTask(key)
+                        ];
+                    case 1:
+                        prior = _state.sent();
+                        if (prior != null) {
+                            // Prefer the recorded conversation history; a single-shot prior run has none, in which case its
+                            // input plus its output text is the history.
+                            if (prior.msg != null && prior.msg.length > 0) {
+                                result = prior.msg;
+                            } else {
+                                messages = _to_consumable_array((_prior_in = prior.in) !== null && _prior_in !== void 0 ? _prior_in : []);
+                                if (prior.o) {
+                                    messages.push({
+                                        role: 'assistant',
+                                        content: prior.o
+                                    });
+                                }
+                                result = messages.length > 0 ? messages : undefined;
+                            }
+                        }
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        })();
+    }
+    function claimNextRunTasks(params) {
+        return _async_to_generator$1(function() {
+            var pageLimit, leaseOwner, leaseDuration, now, leaseCutoff, _ref, runnable, reclaimable, candidates, claimed;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        pageLimit = params.limit, leaseOwner = params.leaseOwner, leaseDuration = params.leaseDuration;
+                        now = new Date();
+                        leaseCutoff = util.addMilliseconds(now, -(leaseDuration !== null && leaseDuration !== void 0 ? leaseDuration : defaultLeaseDuration));
+                        return [
+                            4,
+                            Promise.all([
+                                openRouterRunTaskCollection.queryDocument(firebase.openRouterRunTasksRunnableQuery({
+                                    limit: pageLimit
+                                })).getDocs(),
+                                openRouterRunTaskCollection.queryDocument(firebase.openRouterRunTasksReclaimableQuery({
+                                    limit: pageLimit,
+                                    leaseCutoff: leaseCutoff
+                                })).getDocs()
+                            ])
+                        ];
+                    case 1:
+                        _ref = _sliced_to_array.apply(void 0, [
+                            _state.sent(),
+                            2
+                        ]), runnable = _ref[0], reclaimable = _ref[1];
+                        // A task can appear in both pages, so the merged list is de-duplicated by id. First occurrence wins,
+                        // which keeps the runnable page's queue order ahead of the reclaimable page's lease order.
+                        candidates = util.filterUniqueValues(util.mergeArrays([
+                            runnable,
+                            reclaimable
+                        ]), function(x) {
+                            return x.id;
+                        }).slice(0, pageLimit);
+                        return [
+                            4,
+                            Promise.all(candidates.map(function(document) {
+                                return claimRunTask(document, leaseOwner, now, leaseCutoff);
+                            }))
+                        ];
+                    case 2:
+                        claimed = _state.sent();
+                        return [
+                            2,
+                            util.filterMaybeArrayValues(claimed)
+                        ];
+                }
+            });
+        })();
+    }
+    function deleteExpiredRunTasks(params) {
+        return _async_to_generator$1(function() {
+            var inputLimit, before, pageLimit, cutoff, documents, keys, writeBatch, writeBatchAccessor;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        inputLimit = params.limit, before = params.before;
+                        pageLimit = Math.min(inputLimit, OPENROUTER_MAX_EXPIRED_RUN_TASK_DELETE_PAGE_SIZE);
+                        cutoff = before !== null && before !== void 0 ? before : util.addMilliseconds(new Date(), -firebase.OPENROUTER_RUN_TASK_MAX_AGE);
+                        return [
+                            4,
+                            openRouterRunTaskCollection.queryDocument(firebase.openRouterRunTasksExpiredQuery({
+                                before: cutoff,
+                                limit: pageLimit
+                            })).getDocs()
+                        ];
+                    case 1:
+                        documents = _state.sent();
+                        keys = documents.map(function(x) {
+                            return x.id;
+                        });
+                        if (!(documents.length > 0)) return [
+                            3,
+                            4
+                        ];
+                        // One write batch per page rather than N loose deletes: a page either goes away or it does not, and
+                        // one round trip replaces up to 500.
+                        writeBatch = openRouterRunTaskCollection.firestoreContext.batch();
+                        writeBatchAccessor = openRouterRunTaskCollection.documentAccessorForWriteBatch(writeBatch);
+                        return [
+                            4,
+                            Promise.all(documents.map(function(document) {
+                                return writeBatchAccessor.loadDocumentFrom(document).accessor.delete();
+                            }))
+                        ];
+                    case 2:
+                        _state.sent();
+                        return [
+                            4,
+                            writeBatch.commit()
+                        ];
+                    case 3:
+                        _state.sent();
+                        _state.label = 4;
+                    case 4:
+                        return [
+                            2,
+                            {
+                                deleted: keys.length,
+                                keys: keys
+                            }
+                        ];
+                }
+            });
+        })();
+    }
+    function claimRunTask(document, leaseOwner, now, leaseCutoff) {
+        return _async_to_generator$1(function() {
+            return _ts_generator$1(this, function(_state) {
+                return [
+                    2,
+                    openRouterRunTaskCollection.firestoreContext.runTransaction(function(transaction) {
+                        return _async_to_generator$1(function() {
+                            var transactionDocument, task, result;
+                            return _ts_generator$1(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        transactionDocument = runTaskDocumentInTransaction(document, transaction);
+                                        return [
+                                            4,
+                                            transactionDocument.snapshotData()
+                                        ];
+                                    case 1:
+                                        task = _state.sent();
+                                        if (!(task != null && isOpenRouterRunTaskClaimable(task, leaseCutoff))) return [
+                                            3,
+                                            3
+                                        ];
+                                        return [
+                                            4,
+                                            transactionDocument.update({
+                                                s: firebase.OpenRouterRunTaskState.RUNNING,
+                                                sat: now,
+                                                lat: now,
+                                                lo: leaseOwner,
+                                                at: task.at + 1
+                                            })
+                                        ];
+                                    case 2:
+                                        _state.sent();
+                                        result = document;
+                                        _state.label = 3;
+                                    case 3:
+                                        return [
+                                            2,
+                                            result
+                                        ];
+                                }
+                            });
+                        })();
+                    })
+                ];
+            });
+        })();
+    }
+    function runTaskDocumentInTransaction(document, transaction) {
+        return openRouterRunTaskCollection.documentAccessorForTransaction(transaction).loadDocumentFrom(document);
+    }
+    function executeRunTask(document) {
+        return _async_to_generator$1(function() {
+            var key, task, executionResult, e;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        key = document.id;
+                        return [
+                            4,
+                            document.snapshotData()
+                        ];
+                    case 1:
+                        task = _state.sent();
+                        if (!(task == null)) return [
+                            3,
+                            2
+                        ];
+                        executionResult = {
+                            key: key,
+                            state: firebase.OpenRouterRunTaskState.FAILED,
+                            error: new Error('The run task no longer exists.')
+                        };
+                        return [
+                            3,
+                            6
+                        ];
+                    case 2:
+                        _state.trys.push([
+                            2,
+                            4,
+                            ,
+                            6
+                        ]);
+                        return [
+                            4,
+                            executeRunTaskData(document, task)
+                        ];
+                    case 3:
+                        executionResult = _state.sent();
+                        return [
+                            3,
+                            6
+                        ];
+                    case 4:
+                        e = _state.sent();
+                        return [
+                            4,
+                            document.accessor.exists()
+                        ];
+                    case 5:
+                        // A task deleted mid-flight by the retention sweep is the expected cause: every write in
+                        // executeRunTaskData goes through `document.update()`, which throws NOT_FOUND on a deleted document —
+                        // including the write recordFailure() makes while handling the first throw, which is outside any try
+                        // and would otherwise reject the whole sweep and discard every result already collected.
+                        //
+                        // The existence re-read is what keeps this from swallowing real defects: anything thrown while the
+                        // document is still there is rethrown untouched.
+                        if (_state.sent()) {
+                            throw e;
+                        }
+                        executionResult = {
+                            key: key,
+                            state: firebase.OpenRouterRunTaskState.FAILED,
+                            error: e
+                        };
+                        return [
+                            3,
+                            6
+                        ];
+                    case 6:
+                        if (!(onTerminalState != null && firebase.isOpenRouterRunTaskStateTerminal(executionResult.state))) return [
+                            3,
+                            8
+                        ];
+                        return [
+                            4,
+                            onTerminalState(document, executionResult)
+                        ];
+                    case 7:
+                        _state.sent();
+                        _state.label = 8;
+                    case 8:
+                        return [
+                            2,
+                            executionResult
+                        ];
+                }
+            });
+        })();
+    }
+    function executeRunTaskData(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) {
+                switch(_state.label){
+                    case 0:
+                        key = document.id;
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            16,
+                            ,
+                            18
+                        ]);
+                        return [
+                            4,
+                            promptService.resolvePrompt({
+                                promptKey: task.pk,
+                                version: task.pv
+                            })
+                        ];
+                    case 2:
+                        resolved = _state.sent();
+                        return [
+                            4,
+                            attachFilesForAttempt(task.fp)
+                        ];
+                    case 3:
+                        attachedFiles = _state.sent();
+                        hasTools = tools != null && tools.length > 0;
+                        request = openrouter.openRouterPromptRequest({
+                            prompt: resolved,
+                            input: task.in,
+                            overrides: task.co,
+                            files: attachedFiles,
+                            fileAnnotations: task.fa,
+                            // With tools in play the conversation lives in the state accessor, which appends to it across
+                            // turns; passing it here as well would send every prior turn twice.
+                            history: hasTools ? undefined : task.msg,
+                            trace: {
+                                runTaskKey: key
+                            }
+                        });
+                        if (!hasTools) return [
+                            3,
+                            5
+                        ];
+                        return [
+                            4,
+                            appendDeferredToolResultsToConversation(document, task)
+                        ];
+                    case 4:
+                        _state.sent();
+                        _state.label = 5;
+                    case 5:
+                        return [
+                            4,
+                            openrouter.callModelForOpenRouterRequest({
+                                client: client,
+                                // The whole conversation is supplied through the state accessor, so the request carries no input
+                                // of its own — the SDK appends `input` to the loaded state, and the seeded state already is it.
+                                request: hasTools ? _object_spread_props(_object_spread({}, request), {
+                                    input: []
+                                }) : request,
+                                tools: tools !== null && tools !== void 0 ? tools : undefined,
+                                // The state accessor is only wired when tools are in play. For a single-shot run it would write
+                                // conversation history nobody reads, and on a doc whose state the runner is about to set anyway.
+                                state: hasTools ? firestoreOpenRouterStateAccessor(document, {
+                                    initialMessages: request.input,
+                                    attachedFiles: attachedFiles
+                                }) : undefined
+                            })
+                        ];
+                    case 6:
+                        result = _state.sent();
+                        if (!hasTools) return [
+                            3,
+                            8
+                        ];
+                        return [
+                            4,
+                            document.snapshotData()
+                        ];
+                    case 7:
+                        _tmp = _state.sent();
+                        return [
+                            3,
+                            9
+                        ];
+                    case 8:
+                        _tmp = task;
+                        _state.label = 9;
+                    case 9:
+                        afterCall = _tmp;
+                        pausedForTools = (afterCall === null || afterCall === void 0 ? void 0 : afterCall.s) === firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS;
+                        finishedAt = new Date();
+                        if (!pausedForTools) return [
+                            3,
+                            11
+                        ];
+                        return [
+                            4,
+                            document.update({
+                                lat: null,
+                                lo: null
+                            })
+                        ];
+                    case 10:
+                        _state.sent();
+                        executionResult = {
+                            key: key,
+                            state: firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS,
+                            result: result
+                        };
+                        return [
+                            3,
+                            15
+                        ];
+                    case 11:
+                        if (!(result.error == null)) return [
+                            3,
+                            13
+                        ];
+                        return [
+                            4,
+                            document.update({
+                                s: firebase.OpenRouterRunTaskState.COMPLETE,
+                                fat: finishedAt,
+                                o: result.outputText,
+                                j: result.outputJson,
+                                // Appended rather than replaced: a retried task produced real generations on its earlier attempts
+                                // too, and those are exactly what an audit of a flaky run needs.
+                                gi: util.concatArraysUnique(task.gi, result.generationIds),
+                                u: result.usage,
+                                e: null,
+                                lat: null,
+                                lo: null
+                            })
+                        ];
+                    case 12:
+                        _state.sent();
+                        executionResult = {
+                            key: key,
+                            state: firebase.OpenRouterRunTaskState.COMPLETE,
+                            result: result
+                        };
+                        return [
+                            3,
+                            15
+                        ];
+                    case 13:
+                        return [
+                            4,
+                            recordFailure({
+                                document: document,
+                                task: task,
+                                error: result.error,
+                                cause: result.error,
+                                at: finishedAt,
+                                result: result
+                            })
+                        ];
+                    case 14:
+                        executionResult = _state.sent();
+                        _state.label = 15;
+                    case 15:
+                        return [
+                            3,
+                            18
+                        ];
+                    case 16:
+                        e = _state.sent();
+                        return [
+                            4,
+                            recordFailure({
+                                document: document,
+                                task: task,
+                                error: {
+                                    code: openRouterErrorCode(e),
+                                    message: openRouterErrorMessage(e)
+                                },
+                                cause: e,
+                                at: new Date()
+                            })
+                        ];
+                    case 17:
+                        failure = _state.sent();
+                        executionResult = _object_spread_props(_object_spread({}, failure), {
+                            error: e
+                        });
+                        return [
+                            3,
+                            18
+                        ];
+                    case 18:
+                        return [
+                            2,
+                            executionResult
+                        ];
+                }
+            });
+        })();
+    }
+    /**
+     * Folds resolved deferred-tool results into the persisted conversation, so the resumed call sends the
+     * model the answers it was waiting on.
+     *
+     * Done here rather than through the SDK because `@openrouter/sdk@1.2.x` has no route back in for a
+     * result produced by another process: its only resume path re-runs the tool locally (a manual tool has
+     * no `execute`) or rejects it. Appending the `function_call_output` items to the conversation and
+     * re-sending it is the same thing the SDK would have put on the wire, minus the API it does not have.
+     *
+     * A no-op unless every pending call has a recorded result — a partially-resolved run has nothing new
+     * to say and must stay parked.
+     */ function appendDeferredToolResultsToConversation(document, task) {
+        return _async_to_generator$1(function() {
+            var _task_ptc, _task_utr, pending, unsent, allResolved, _task_msg, outputItems;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        pending = (_task_ptc = task.ptc) !== null && _task_ptc !== void 0 ? _task_ptc : [];
+                        unsent = (_task_utr = task.utr) !== null && _task_utr !== void 0 ? _task_utr : [];
+                        // The length guard means "and there is something to send" — an empty `ptc` satisfies the predicate
+                        // vacuously, and appending nothing would clear `ptc` / `utr` for no reason.
+                        allResolved = pending.length > 0 && !hasUnresolvedOpenRouterPendingToolCalls(pending, unsent);
+                        if (!allResolved) return [
+                            3,
+                            2
+                        ];
+                        outputItems = openrouter.openRouterFunctionCallOutputItems(unsent);
+                        return [
+                            4,
+                            document.update({
+                                msg: _to_consumable_array((_task_msg = task.msg) !== null && _task_msg !== void 0 ? _task_msg : []).concat(_to_consumable_array(outputItems)),
+                                ptc: null,
+                                utr: null
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        _state.label = 2;
+                    case 2:
+                        return [
+                            2
+                        ];
+                }
+            });
+        })();
+    }
+    function recordFailure(params) {
+        return _async_to_generator$1(function() {
+            var document, task, error, cause, at, result, retryable, attemptsExhausted, finished, state;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        document = params.document, task = params.task, error = params.error, cause = params.cause, at = params.at, result = params.result;
+                        // A deterministic failure — a bad key, a 402, a model id that does not exist — cannot succeed on a
+                        // second attempt, so it spends none of the budget and goes straight to FAILED.
+                        retryable = isRetryableOpenRouterError(cause);
+                        // The attempt counter was already incremented by the claim, so `task.at` is the number of attempts made
+                        // INCLUDING this one — which is why nothing is added to it here. Adding one would spend the budget a
+                        // tick early and mark a task FAILED with a retry still owed to it.
+                        attemptsExhausted = task.at >= maxAttempts;
+                        finished = !retryable || attemptsExhausted;
+                        state = finished ? firebase.OpenRouterRunTaskState.FAILED : firebase.OpenRouterRunTaskState.QUEUED;
+                        return [
+                            4,
+                            document.update({
+                                s: state,
+                                // Releasing the lease is what makes the task claimable again on the next sweep.
+                                lat: null,
+                                lo: null,
+                                fat: finished ? at : null,
+                                e: error,
+                                gi: result == null ? undefined : util.concatArraysUnique(task.gi, result.generationIds),
+                                u: result === null || result === void 0 ? void 0 : result.usage
+                            })
+                        ];
+                    case 1:
+                        _state.sent();
+                        return [
+                            2,
+                            {
+                                key: document.id,
+                                state: state,
+                                result: result
+                            }
+                        ];
+                }
+            });
+        })();
+    }
+    function resolveDeferredTool(params) {
+        return _async_to_generator$1(function() {
+            var key, taskId, output, error;
+            return _ts_generator$1(this, function(_state) {
+                key = params.key, taskId = params.taskId, output = params.output, error = params.error;
+                return [
+                    2,
+                    openRouterRunTaskCollection.firestoreContext.runTransaction(function(transaction) {
+                        return _async_to_generator$1(function() {
+                            var document, task, result, _task_ptc, _task_utr, pending, call, alreadySettled, _task_utr1, unsent, ready;
+                            return _ts_generator$1(this, function(_state) {
+                                switch(_state.label){
+                                    case 0:
+                                        document = openRouterRunTaskCollection.documentAccessorForTransaction(transaction).loadDocumentForId(key);
+                                        return [
+                                            4,
+                                            document.snapshotData()
+                                        ];
+                                    case 1:
+                                        task = _state.sent();
+                                        result = {
+                                            resolved: false,
+                                            ready: false
+                                        };
+                                        if (!(task != null)) return [
+                                            3,
+                                            3
+                                        ];
+                                        pending = (_task_ptc = task.ptc) !== null && _task_ptc !== void 0 ? _task_ptc : [];
+                                        call = pending.find(function(x) {
+                                            return x.taskId === taskId;
+                                        });
+                                        alreadySettled = ((_task_utr = task.utr) !== null && _task_utr !== void 0 ? _task_utr : []).some(function(x) {
+                                            return x.callId === (call === null || call === void 0 ? void 0 : call.callId);
+                                        });
+                                        if (!(call != null && !alreadySettled)) return [
+                                            3,
+                                            3
+                                        ];
+                                        // Preserves today's semantics exactly: an `output` of `null` is a real result and is kept, while an
+                                        // absent `error` is dropped rather than written as `undefined`, which Firestore rejects outright.
+                                        unsent = _to_consumable_array((_task_utr1 = task.utr) !== null && _task_utr1 !== void 0 ? _task_utr1 : []).concat([
+                                            util.filterUndefinedValues({
+                                                callId: call.callId,
+                                                name: call.name,
+                                                output: output,
+                                                error: error !== null && error !== void 0 ? error : undefined
+                                            })
+                                        ]);
+                                        ready = !hasUnresolvedOpenRouterPendingToolCalls(pending, unsent);
+                                        // `qat` is deliberately NOT moved. It is the task's age for retention, so a task cycling through
+                                        // tool resolutions would otherwise keep pushing its own age forward and never age out — and keeping
+                                        // the original also orders correctly: a run waiting on a tool since yesterday should be claimed
+                                        // ahead of one queued a minute ago.
+                                        return [
+                                            4,
+                                            document.update(_object_spread({
+                                                utr: unsent
+                                            }, ready ? {
+                                                s: firebase.OpenRouterRunTaskState.QUEUED
+                                            } : undefined))
+                                        ];
+                                    case 2:
+                                        _state.sent();
+                                        result = {
+                                            resolved: true,
+                                            ready: ready
+                                        };
+                                        _state.label = 3;
+                                    case 3:
+                                        return [
+                                            2,
+                                            result
+                                        ];
+                                }
+                            });
+                        })();
+                    })
+                ];
+            });
+        })();
+    }
+    return {
+        enqueueRunTask: enqueueRunTask,
+        readRunTask: readRunTask,
+        runTaskDocument: runTaskDocument,
+        claimNextRunTasks: claimNextRunTasks,
+        executeRunTask: executeRunTask,
+        resolveDeferredTool: resolveDeferredTool,
+        deleteExpiredRunTasks: deleteExpiredRunTasks,
+        attachFilesForAttempt: attachFilesForAttempt
+    };
+}
+/**
+ * Whether a task may be claimed by a sweep running at the given lease cutoff.
+ *
+ * A `RUNNING` task is claimable exactly when its lease has gone stale — that is crash recovery, and it
+ * generalises the ad-hoc "unstick anything processing for over an hour" logic it replaces.
+ *
+ * @param task - The task to check.
+ * @param leaseCutoff - Leases taken at or before this date are stale.
+ * @returns True when the task may be claimed.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function isOpenRouterRunTaskClaimable(task, leaseCutoff) {
+    var result;
+    switch(task.s){
+        case firebase.OpenRouterRunTaskState.QUEUED:
+            result = true;
+            break;
+        case firebase.OpenRouterRunTaskState.RUNNING:
+            result = task.lat == null || task.lat.getTime() <= leaseCutoff.getTime();
+            break;
+        case firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS:
+            // Only once every pending call has a recorded result; otherwise there is nothing new to send.
+            //
+            // Vacuously true for an EMPTY `ptc`, deliberately. Such a task gets claimed, no-ops the append, and can
+            // still complete — whereas refusing to claim it would strand it permanently with nothing able to move it.
+            result = !hasUnresolvedOpenRouterPendingToolCalls(task.ptc, task.utr);
+            break;
+        default:
+            result = false;
+            break;
+    }
+    return result;
+}
+/**
+ * Whether any pending deferred tool call is still missing its recorded result.
+ *
+ * The one predicate behind "is this run ready to resume": the claim check, the resolution's `ready` flag,
+ * and the conversation append all ask it, and three hand-written copies had already drifted apart.
+ *
+ * @param pending - The pending deferred tool calls.
+ * @param unsent - The recorded-but-unsent tool results.
+ * @returns True when at least one pending call has no recorded result.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function hasUnresolvedOpenRouterPendingToolCalls(pending, unsent) {
+    return (pending !== null && pending !== void 0 ? pending : []).some(function(call) {
+        return !(unsent !== null && unsent !== void 0 ? unsent : []).some(function(result) {
+            return result.callId === call.callId;
+        });
+    });
+}
+/**
+ * Extracts an error code from a thrown value.
+ *
+ * @param e - The thrown value.
+ * @returns The code, when one is discernible.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterErrorCode(e) {
+    var result;
+    if (e != null && (typeof e === "undefined" ? "undefined" : _type_of(e)) === 'object') {
+        var _e_code;
+        var candidate = (_e_code = e.code) !== null && _e_code !== void 0 ? _e_code : e.name;
+        if (candidate != null) {
+            result = String(candidate);
+        }
+    }
+    return result;
+}
+/**
+ * Extracts an error message from a thrown value.
+ *
+ * @param e - The thrown value.
+ * @returns The message.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterErrorMessage(e) {
+    return _instanceof(e, Error) ? e.message : String(e);
+}
+/**
+ * HTTP statuses a retry cannot fix.
+ *
+ * 400 is a malformed request (an invalid model id, a JSON schema the provider rejects), 401/403 are a
+ * credential problem, 402 is an empty account, and 404 is a route or resource that does not exist. Each of
+ * them answers identically on every attempt, so spending the budget on them only delays the FAILED that
+ * the owning work is waiting for.
+ */ var OPENROUTER_PERMANENT_ERROR_STATUSES = [
+    400,
+    401,
+    402,
+    403,
+    404
+];
+/**
+ * Whether a failure is worth another attempt.
+ *
+ * What this encodes is a whitelist of the KNOWN-PERMANENT, not a whitelist of the retryable: anything
+ * unrecognized defaults to RETRYABLE. An unknown failure is far more likely to be a transient upstream blip
+ * than a permanent one, and the attempt budget bounds the cost of being wrong either way — whereas
+ * defaulting the other way would turn one bad minute at a provider into a definitively failed run.
+ *
+ * So the retryable side needs no list of its own. 408 / 409 / 429 and every 5xx, socket-level failures
+ * (`ECONNRESET`, `ETIMEDOUT`, `ECONNREFUSED`, `EAI_AGAIN`), and the Google-infrastructure transients
+ * (`UNAVAILABLE`, `DEADLINE_EXCEEDED`, `ABORTED`) a Firestore or GCS call raises mid-run all reach the
+ * default and are retried.
+ *
+ * Permanent is two cases. {@link OPENROUTER_PERMANENT_ERROR_STATUSES}, read off `status` / `statusCode` /
+ * `code` — which covers both routes into `recordFailure`: a thrown SDK/HTTP error, and the numeric
+ * `error.code` OpenRouter reports in a response body without throwing at all. And an
+ * {@link OpenRouterPromptResolutionError}, which is deterministic by construction: the prompt either exists
+ * at that version or it never will, so re-resolving it is guaranteed to fail identically.
+ *
+ * @param e - The thrown value, or the error reported on a response.
+ * @returns True when another attempt could plausibly succeed.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function isRetryableOpenRouterError(e) {
+    var status = openRouterErrorStatus(e);
+    return !_instanceof(e, OpenRouterPromptResolutionError) && (status == null || !OPENROUTER_PERMANENT_ERROR_STATUSES.includes(status));
+}
+/**
+ * Extracts an HTTP status from a thrown value or a reported response error.
+ *
+ * `code` is read as a status too, because OpenRouter reports a NUMERIC code in a response body's `error`
+ * object where an SDK error would carry `status`.
+ *
+ * @param e - The thrown value.
+ * @returns The status, when the value carries a numeric one.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterErrorStatus(e) {
+    var result;
+    if (e != null && (typeof e === "undefined" ? "undefined" : _type_of(e)) === 'object') {
+        var _ref, _e_status;
+        var candidate = (_ref = (_e_status = e.status) !== null && _e_status !== void 0 ? _e_status : e.statusCode) !== null && _ref !== void 0 ? _ref : e.code;
+        if (typeof candidate === 'number') {
+            result = candidate;
+        } else if (typeof candidate === 'string' && /^\d{3}$/.test(candidate)) {
+            // A three-digit string is a status OpenRouter reported as text; anything else is a symbolic code
+            // (`ECONNRESET`, `server_error`) and is left for the default-retryable path.
+            result = Number(candidate);
+        }
+    }
+    return result;
+}
+/**
+ * The deferred-tool resolutions recorded on a task, in the form the core package's resolver consumes.
+ *
+ * @param task - The run task.
+ * @returns The resolutions.
+ *
+ * @__NO_SIDE_EFFECTS__
+ */ function openRouterDeferredToolResolutionsForRunTask(task) {
+    var _task_ptc, _task_utr;
+    var pending = (_task_ptc = task.ptc) !== null && _task_ptc !== void 0 ? _task_ptc : [];
+    return util.filterMaybeArrayValues(((_task_utr = task.utr) !== null && _task_utr !== void 0 ? _task_utr : []).map(function(unsent) {
+        var call = pending.find(function(x) {
+            return x.callId === unsent.callId;
+        });
+        var result;
+        if (call != null) {
+            result = unsent.error == null ? {
+                taskId: call.taskId,
+                output: unsent.output
+            } : {
+                taskId: call.taskId,
+                error: unsent.error
+            };
+        }
+        return result;
+    }));
+}
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Default number of tasks executed concurrently by one sweep.
+ */ var DEFAULT_OPENROUTER_SWEEP_MAX_PARALLEL_TASKS = 10;
+/**
+ * Default wall-clock budget for one sweep.
+ */ var DEFAULT_OPENROUTER_SWEEP_MAX_RUN_TIME = util.MS_IN_MINUTE * 4;
+/**
+ * Default number of tasks claimed per page.
+ */ var DEFAULT_OPENROUTER_SWEEP_PAGE_SIZE = 20;
+/**
+ * Default number of expired tasks deleted per retention page.
+ *
+ * Well under the 500-write batch ceiling: retention runs on its own far slower schedule, so there is
+ * nothing to gain from maximising a single page.
+ */ var DEFAULT_OPENROUTER_EXPIRATION_SWEEP_PAGE_SIZE = 200;
+/**
+ * Default wall-clock budget for one retention sweep.
+ */ var DEFAULT_OPENROUTER_EXPIRATION_SWEEP_MAX_RUN_TIME = util.MS_IN_MINUTE * 2;
+var randomSweepId = util.randomNumberFactory({
+    min: 0,
+    max: 1000000000,
+    round: 'floor'
+});
+/**
+ * Drains the run-task queue within a strict time budget.
+ *
+ * Claim a page by lease, run `maxParallelTasks` at a time, write results, repeat — until the queue is
+ * empty or the budget is spent. Mount it on a schedule the app already runs; it does not need one of its
+ * own, and it must not assume it is the only tenant of the one it gets.
+ *
+ * @param params - The service and budget settings.
+ * @returns What the sweep did.
+ */ function openRouterRunTaskSweep(params) {
+    return _async_to_generator(function() {
+        var service, maxParallelTasks, maxRunTimeMs, pageSize, inputLeaseOwner, leaseDuration, maxPages, startedAt, budget, parallelTasks, limitPerPage, leaseOwner, results, pages, stoppedForTimeBudget, elapsed, claimed, durationMs;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    service = params.service, maxParallelTasks = params.maxParallelTasks, maxRunTimeMs = params.maxRunTimeMs, pageSize = params.pageSize, inputLeaseOwner = params.leaseOwner, leaseDuration = params.leaseDuration, maxPages = params.maxPages;
+                    startedAt = Date.now();
+                    budget = maxRunTimeMs !== null && maxRunTimeMs !== void 0 ? maxRunTimeMs : DEFAULT_OPENROUTER_SWEEP_MAX_RUN_TIME;
+                    parallelTasks = maxParallelTasks !== null && maxParallelTasks !== void 0 ? maxParallelTasks : DEFAULT_OPENROUTER_SWEEP_MAX_PARALLEL_TASKS;
+                    limitPerPage = pageSize !== null && pageSize !== void 0 ? pageSize : DEFAULT_OPENROUTER_SWEEP_PAGE_SIZE;
+                    leaseOwner = inputLeaseOwner !== null && inputLeaseOwner !== void 0 ? inputLeaseOwner : "openRouterRunTaskSweep_".concat(startedAt, "_").concat(randomSweepId());
+                    results = [];
+                    pages = 0;
+                    stoppedForTimeBudget = false;
+                    elapsed = function elapsed() {
+                        return Date.now() - startedAt;
+                    };
+                    _state.label = 1;
+                case 1:
+                    if (elapsed() >= budget) {
+                        stoppedForTimeBudget = true;
+                        return [
+                            3,
+                            5
+                        ];
+                    }
+                    if (maxPages != null && pages >= maxPages) {
+                        return [
+                            3,
+                            5
+                        ];
+                    }
+                    return [
+                        4,
+                        service.claimNextRunTasks({
+                            limit: limitPerPage,
+                            leaseOwner: leaseOwner,
+                            leaseDuration: leaseDuration
+                        })
+                    ];
+                case 2:
+                    claimed = _state.sent();
+                    if (claimed.length === 0) {
+                        return [
+                            3,
+                            5
+                        ];
+                    }
+                    pages += 1;
+                    // Every claimed task IS executed, even if the budget expires mid-page: it already holds a lease and
+                    // its attempt counter is already spent, so abandoning it would leave a RUNNING document waiting on
+                    // lease reclamation for no reason.
+                    return [
+                        4,
+                        util.performTasksInParallel(claimed, {
+                            maxParallelTasks: parallelTasks,
+                            taskFactory: function taskFactory(document) {
+                                return _async_to_generator(function() {
+                                    var result;
+                                    return _ts_generator(this, function(_state) {
+                                        switch(_state.label){
+                                            case 0:
+                                                return [
+                                                    4,
+                                                    service.executeRunTask(document)
+                                                ];
+                                            case 1:
+                                                result = _state.sent();
+                                                results.push(result);
+                                                return [
+                                                    2
+                                                ];
+                                        }
+                                    });
+                                })();
+                            }
+                        })
+                    ];
+                case 3:
+                    _state.sent();
+                    _state.label = 4;
+                case 4:
+                    return [
+                        3,
+                        1
+                    ];
+                case 5:
+                    durationMs = elapsed();
+                    return [
+                        2,
+                        {
+                            executed: results.length,
+                            completed: results.filter(function(x) {
+                                return x.state === firebase.OpenRouterRunTaskState.COMPLETE;
+                            }).length,
+                            failed: results.filter(function(x) {
+                                return x.state === firebase.OpenRouterRunTaskState.FAILED;
+                            }).length,
+                            requeued: results.filter(function(x) {
+                                return x.state === firebase.OpenRouterRunTaskState.QUEUED;
+                            }).length,
+                            awaitingAsyncTools: results.filter(function(x) {
+                                return x.state === firebase.OpenRouterRunTaskState.AWAITING_ASYNC_TOOLS;
+                            }).length,
+                            pages: pages,
+                            stoppedForTimeBudget: stoppedForTimeBudget,
+                            durationMs: durationMs,
+                            results: results
+                        }
+                    ];
+            }
+        });
+    })();
+}
+/**
+ * Deletes every run task past its retention age, within a strict time budget.
+ *
+ * A SEPARATE sweep from {@link openRouterRunTaskSweep}, on a far slower schedule: the drain tick runs every
+ * minute and there is nothing a week-old document gains from being looked at that often.
+ *
+ * @param params - The service and budget settings.
+ * @returns What the sweep deleted.
+ */ function openRouterRunTaskExpirationSweep(params) {
+    return _async_to_generator(function() {
+        var service, before, pageSize, maxRunTimeMs, maxPages, startedAt, budget, limitPerPage, cutoff, deleted, pages, stoppedForTimeBudget, elapsed, page;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    service = params.service, before = params.before, pageSize = params.pageSize, maxRunTimeMs = params.maxRunTimeMs, maxPages = params.maxPages;
+                    startedAt = Date.now();
+                    budget = maxRunTimeMs !== null && maxRunTimeMs !== void 0 ? maxRunTimeMs : DEFAULT_OPENROUTER_EXPIRATION_SWEEP_MAX_RUN_TIME;
+                    limitPerPage = pageSize !== null && pageSize !== void 0 ? pageSize : DEFAULT_OPENROUTER_EXPIRATION_SWEEP_PAGE_SIZE;
+                    // The cutoff is PINNED once for the whole run rather than re-derived per page. A cutoff advancing with the
+                    // clock would let a task that ages mid-sweep join a page not yet reached, making the pass unbounded.
+                    cutoff = before !== null && before !== void 0 ? before : new Date(startedAt - firebase.OPENROUTER_RUN_TASK_MAX_AGE);
+                    deleted = 0;
+                    pages = 0;
+                    stoppedForTimeBudget = false;
+                    elapsed = function elapsed() {
+                        return Date.now() - startedAt;
+                    };
+                    _state.label = 1;
+                case 1:
+                    if (elapsed() >= budget) {
+                        stoppedForTimeBudget = true;
+                        return [
+                            3,
+                            4
+                        ];
+                    }
+                    if (maxPages != null && pages >= maxPages) {
+                        return [
+                            3,
+                            4
+                        ];
+                    }
+                    return [
+                        4,
+                        service.deleteExpiredRunTasks({
+                            limit: limitPerPage,
+                            before: cutoff
+                        })
+                    ];
+                case 2:
+                    page = _state.sent();
+                    if (page.deleted === 0) {
+                        return [
+                            3,
+                            4
+                        ];
+                    }
+                    deleted += page.deleted;
+                    pages += 1;
+                    _state.label = 3;
+                case 3:
+                    return [
+                        3,
+                        1
+                    ];
+                case 4:
+                    return [
+                        2,
+                        {
+                            deleted: deleted,
+                            pages: pages,
+                            stoppedForTimeBudget: stoppedForTimeBudget,
+                            durationMs: elapsed()
+                        }
+                    ];
+            }
+        });
+    })();
+}
+
+exports.AbstractAppOpenRouterModule = AbstractAppOpenRouterModule;
+exports.DEFAULT_OPENROUTER_EXPIRATION_SWEEP_MAX_RUN_TIME = DEFAULT_OPENROUTER_EXPIRATION_SWEEP_MAX_RUN_TIME;
+exports.DEFAULT_OPENROUTER_EXPIRATION_SWEEP_PAGE_SIZE = DEFAULT_OPENROUTER_EXPIRATION_SWEEP_PAGE_SIZE;
+exports.DEFAULT_OPENROUTER_INLINE_FILE_CONTENT_TYPE = DEFAULT_OPENROUTER_INLINE_FILE_CONTENT_TYPE;
+exports.DEFAULT_OPENROUTER_LEASE_DURATION = DEFAULT_OPENROUTER_LEASE_DURATION;
+exports.DEFAULT_OPENROUTER_MAX_ATTEMPTS = DEFAULT_OPENROUTER_MAX_ATTEMPTS;
+exports.DEFAULT_OPENROUTER_MAX_INLINE_FILE_SIZE_BYTES = DEFAULT_OPENROUTER_MAX_INLINE_FILE_SIZE_BYTES;
+exports.DEFAULT_OPENROUTER_SIGNED_URL_TTL = DEFAULT_OPENROUTER_SIGNED_URL_TTL;
+exports.DEFAULT_OPENROUTER_SWEEP_MAX_PARALLEL_TASKS = DEFAULT_OPENROUTER_SWEEP_MAX_PARALLEL_TASKS;
+exports.DEFAULT_OPENROUTER_SWEEP_MAX_RUN_TIME = DEFAULT_OPENROUTER_SWEEP_MAX_RUN_TIME;
+exports.DEFAULT_OPENROUTER_SWEEP_PAGE_SIZE = DEFAULT_OPENROUTER_SWEEP_PAGE_SIZE;
+exports.OPENROUTER_BROADCAST_RUN_TASK_KEY_ATTRIBUTES = OPENROUTER_BROADCAST_RUN_TASK_KEY_ATTRIBUTES;
+exports.OPENROUTER_MAX_EXPIRED_RUN_TASK_DELETE_PAGE_SIZE = OPENROUTER_MAX_EXPIRED_RUN_TASK_DELETE_PAGE_SIZE;
+exports.OPENROUTER_PERMANENT_ERROR_STATUSES = OPENROUTER_PERMANENT_ERROR_STATUSES;
+exports.OPENROUTER_PROMPT_CACHE_DURATION = OPENROUTER_PROMPT_CACHE_DURATION;
+exports.OPENROUTER_PROMPT_SERVICE_TOKEN = OPENROUTER_PROMPT_SERVICE_TOKEN;
+exports.OPENROUTER_RUN_TASK_SERVICE_TOKEN = OPENROUTER_RUN_TASK_SERVICE_TOKEN;
+exports.OPENROUTER_SEED_PROMPTS_MAX_PARALLEL_UPDATES = OPENROUTER_SEED_PROMPTS_MAX_PARALLEL_UPDATES;
+exports.OpenRouterPromptResolutionError = OpenRouterPromptResolutionError;
+exports.OpenRouterPromptServerActions = OpenRouterPromptServerActions;
+exports.OpenRouterPromptService = OpenRouterPromptService;
+exports.OpenRouterRunTaskService = OpenRouterRunTaskService;
+exports.appOpenRouterModuleMetadata = appOpenRouterModuleMetadata;
+exports.callModelForPrompt = callModelForPrompt;
+exports.conversationStateForOpenRouterRunTask = conversationStateForOpenRouterRunTask;
+exports.conversationStatusForOpenRouterRunTaskState = conversationStatusForOpenRouterRunTaskState;
+exports.createOpenRouterPromptFactory = createOpenRouterPromptFactory;
+exports.createOpenRouterPromptVersionFactory = createOpenRouterPromptVersionFactory;
+exports.firestoreOpenRouterStateAccessor = firestoreOpenRouterStateAccessor;
+exports.handleOpenRouterRunTaskResultFactory = handleOpenRouterRunTaskResultFactory;
+exports.hasUnresolvedOpenRouterPendingToolCalls = hasUnresolvedOpenRouterPendingToolCalls;
+exports.isOpenRouterRunTaskClaimable = isOpenRouterRunTaskClaimable;
+exports.isRetryableOpenRouterError = isRetryableOpenRouterError;
+exports.mergeOpenRouterRunUsage = mergeOpenRouterRunUsage;
+exports.openRouterConversationValueForFirestore = openRouterConversationValueForFirestore;
+exports.openRouterDeferredToolResolutionsForRunTask = openRouterDeferredToolResolutionsForRunTask;
+exports.openRouterErrorCode = openRouterErrorCode;
+exports.openRouterErrorMessage = openRouterErrorMessage;
+exports.openRouterFileAttachmentModeForConfig = openRouterFileAttachmentModeForConfig;
+exports.openRouterFileAttachmentResolver = openRouterFileAttachmentResolver;
+exports.openRouterPromptServerActions = openRouterPromptServerActions;
+exports.openRouterPromptService = openRouterPromptService;
+exports.openRouterRunTaskExpirationSweep = openRouterRunTaskExpirationSweep;
+exports.openRouterRunTaskKeyFromBroadcastAttributes = openRouterRunTaskKeyFromBroadcastAttributes;
+exports.openRouterRunTaskOutcome = openRouterRunTaskOutcome;
+exports.openRouterRunTaskService = openRouterRunTaskService;
+exports.openRouterRunTaskStateForConversationStatus = openRouterRunTaskStateForConversationStatus;
+exports.openRouterRunTaskSweep = openRouterRunTaskSweep;
+exports.openRouterRunTaskUpdateForConversationState = openRouterRunTaskUpdateForConversationState;
+exports.reconcileOpenRouterRunTaskFromBroadcast = reconcileOpenRouterRunTaskFromBroadcast;
+exports.seedOpenRouterPromptsFactory = seedOpenRouterPromptsFactory;
+exports.updateOpenRouterPromptFactory = updateOpenRouterPromptFactory;
+exports.updateOpenRouterPromptVersionFactory = updateOpenRouterPromptVersionFactory;