@dereekb/nestjs 13.16.0 → 13.18.0

package/openrouter/index.cjs.js

@@ -0,0 +1,1200 @@
+'use strict';
+
+var util = require('@dereekb/util');
+var common = require('@nestjs/common');
+var node_crypto = require('node:crypto');
+var config = require('@nestjs/config');
+var sdk = require('@openrouter/sdk');
+
+function _define_property$5(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(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$5(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;
+}
+// MARK: Attribute Keys
+/**
+ * Candidate attribute keys for the request model. OpenRouter follows the OpenTelemetry GenAI
+ * semantic conventions (`gen_ai.*`).
+ */ var OPENROUTER_SPAN_ATTRIBUTE_MODEL_KEYS = [
+    'gen_ai.request.model',
+    'gen_ai.response.model'
+];
+var OPENROUTER_SPAN_ATTRIBUTE_PROVIDER_KEYS = [
+    'gen_ai.provider.name',
+    'gen_ai.system'
+];
+var OPENROUTER_SPAN_ATTRIBUTE_PROMPT_TOKENS_KEYS = [
+    'gen_ai.usage.prompt_tokens',
+    'gen_ai.usage.input_tokens'
+];
+var OPENROUTER_SPAN_ATTRIBUTE_COMPLETION_TOKENS_KEYS = [
+    'gen_ai.usage.completion_tokens',
+    'gen_ai.usage.output_tokens'
+];
+var OPENROUTER_SPAN_ATTRIBUTE_TOTAL_TOKENS_KEYS = [
+    'gen_ai.usage.total_tokens'
+];
+var OPENROUTER_SPAN_ATTRIBUTE_COST_KEYS = [
+    'gen_ai.usage.cost',
+    'gen_ai.response.cost'
+];
+var OPENROUTER_SPAN_ATTRIBUTE_GENERATION_ID_KEYS = [
+    'gen_ai.response.id'
+];
+/**
+ * Extracts the primitive value from an OTLP `AnyValue`. Integer values encoded as strings are
+ * parsed to numbers; nested array/kvlist/bytes values are ignored.
+ *
+ * @param value - The OTLP AnyValue to read.
+ * @returns The primitive value, or undefined when none of the modeled variants are present.
+ */ function readOpenRouterAnyValue(value) {
+    var result;
+    if (value != null) {
+        if (value.stringValue != null) {
+            result = value.stringValue;
+        } else if (value.boolValue != null) {
+            result = value.boolValue;
+        } else if (value.doubleValue != null) {
+            result = value.doubleValue;
+        } else if (value.intValue != null) {
+            result = typeof value.intValue === 'number' ? value.intValue : Number(value.intValue);
+        }
+    }
+    return result;
+}
+/**
+ * Builds a flat attribute map from a list of OTLP key/value pairs.
+ *
+ * @param attributes - The OTLP attributes to flatten.
+ * @returns The attribute values indexed by name for direct lookup.
+ */ function openRouterAttributeMap(attributes) {
+    var map = new Map();
+    attributes === null || attributes === void 0 ? void 0 : attributes.forEach(function(attribute) {
+        var value = readOpenRouterAnyValue(attribute.value);
+        if (value != null) {
+            map.set(attribute.key, value);
+        }
+    });
+    return map;
+}
+function firstStringAttribute(map, keys) {
+    var result;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            var value = map.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;
+}
+function firstNumberAttribute(map, keys) {
+    var result;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            var value = map.get(key);
+            if (value != null) {
+                var asNumber = typeof value === 'number' ? value : Number(value);
+                if (!Number.isNaN(asNumber)) {
+                    result = asNumber;
+                    break;
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Extracts the commonly-used generation fields (model, provider, token usage, cost, generation id)
+ * from a flattened attribute map.
+ *
+ * @param map - The flattened span attribute map.
+ * @returns The extracted generation info.
+ */ function openRouterGenerationInfoFromAttributes(map) {
+    return {
+        generationId: firstStringAttribute(map, OPENROUTER_SPAN_ATTRIBUTE_GENERATION_ID_KEYS),
+        model: firstStringAttribute(map, OPENROUTER_SPAN_ATTRIBUTE_MODEL_KEYS),
+        provider: firstStringAttribute(map, OPENROUTER_SPAN_ATTRIBUTE_PROVIDER_KEYS),
+        promptTokens: firstNumberAttribute(map, OPENROUTER_SPAN_ATTRIBUTE_PROMPT_TOKENS_KEYS),
+        completionTokens: firstNumberAttribute(map, OPENROUTER_SPAN_ATTRIBUTE_COMPLETION_TOKENS_KEYS),
+        totalTokens: firstNumberAttribute(map, OPENROUTER_SPAN_ATTRIBUTE_TOTAL_TOKENS_KEYS),
+        cost: firstNumberAttribute(map, OPENROUTER_SPAN_ATTRIBUTE_COST_KEYS)
+    };
+}
+/**
+ * Flattens a broadcast payload into a list of {@link OpenRouterBroadcastSpan}s, extracting
+ * attributes and generation info from each span.
+ *
+ * @param payload - The OTLP broadcast payload.
+ * @returns The flattened broadcast spans (empty for an empty / test-connection payload).
+ */ function openRouterBroadcastSpansFromPayload(payload) {
+    var _payload_resourceSpans;
+    var result = [];
+    payload === null || payload === void 0 ? void 0 : (_payload_resourceSpans = payload.resourceSpans) === null || _payload_resourceSpans === void 0 ? void 0 : _payload_resourceSpans.forEach(function(resourceSpan) {
+        var _resourceSpan_resource, _resourceSpan_scopeSpans;
+        var resourceAttributes = openRouterAttributeMap((_resourceSpan_resource = resourceSpan.resource) === null || _resourceSpan_resource === void 0 ? void 0 : _resourceSpan_resource.attributes);
+        (_resourceSpan_scopeSpans = resourceSpan.scopeSpans) === null || _resourceSpan_scopeSpans === void 0 ? void 0 : _resourceSpan_scopeSpans.forEach(function(scopeSpan) {
+            var _scopeSpan_spans;
+            (_scopeSpan_spans = scopeSpan.spans) === null || _scopeSpan_spans === void 0 ? void 0 : _scopeSpan_spans.forEach(function(span) {
+                var attributes = openRouterAttributeMap(span.attributes);
+                result.push({
+                    span: span,
+                    name: span.name,
+                    attributes: attributes,
+                    resourceAttributes: resourceAttributes,
+                    generation: openRouterGenerationInfoFromAttributes(attributes)
+                });
+            });
+        });
+    });
+    return result;
+}
+/**
+ * Creates a handler that dispatches broadcast spans by their span name.
+ */ var openRouterEventHandlerFactory = util.handlerFactory(function(x) {
+    return x.name;
+});
+/**
+ * Identity map for broadcast spans, used by the handler configurer.
+ *
+ * @param span - The broadcast span.
+ * @returns The same broadcast span.
+ */ function openRouterBroadcastSpan(span) {
+    return span;
+}
+var openRouterEventHandlerConfigurerFactory = util.handlerConfigurerFactory({
+    configurerForAccessor: function configurerForAccessor(accessor) {
+        var fnWithKey = util.handlerMappedSetFunctionFactory(accessor, openRouterBroadcastSpan);
+        var configurer = _object_spread_props(_object_spread({}, accessor), {
+            handleSpanName: fnWithKey,
+            handleAnySpan: fnWithKey(util.catchAllHandlerKey())
+        });
+        return configurer;
+    }
+});
+
+function _class_call_check$6(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$3(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$3(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties$3(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property$4(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;
+}
+var OPENROUTER_WEBHOOK_SECRET_TOKEN_ENV_VAR = 'OPENROUTER_WEBHOOK_SECRET_TOKEN';
+var OPENROUTER_WEBHOOK_HEADER_ENV_VAR = 'OPENROUTER_WEBHOOK_HEADER';
+var OPENROUTER_WEBHOOK_SCHEME_ENV_VAR = 'OPENROUTER_WEBHOOK_SCHEME';
+/**
+ * Default request header that carries the OpenRouter webhook secret.
+ *
+ * OpenRouter broadcast webhooks send a user-configured header (commonly `Authorization`)
+ * verbatim with each request. Express lower-cases incoming header names.
+ */ var DEFAULT_OPENROUTER_WEBHOOK_HEADER = 'authorization';
+/**
+ * Default scheme prefix expected on the secret-bearing header value (e.g. `Bearer <secret>`).
+ */ var DEFAULT_OPENROUTER_WEBHOOK_SCHEME = 'Bearer';
+/**
+ * Configuration for OpenRouterWebhookService.
+ */ var OpenRouterWebhookServiceConfig = /*#__PURE__*/ function() {
+    function OpenRouterWebhookServiceConfig() {
+        _class_call_check$6(this, OpenRouterWebhookServiceConfig);
+        _define_property$4(this, "openrouterWebhook", void 0);
+    }
+    _create_class$3(OpenRouterWebhookServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.openrouterWebhook.webhookSecret) {
+                    throw new Error('No OpenRouter webhook secret specified.');
+                }
+            }
+        }
+    ]);
+    return OpenRouterWebhookServiceConfig;
+} 
+();
+
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ((typeof Reflect === "undefined" ? "undefined" : _type_of(Reflect)) === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Constant-time comparison of two secret tokens.
+ *
+ * Guards against the length-mismatch exception thrown by `crypto.timingSafeEqual` by
+ * returning false up front when lengths differ.
+ *
+ * @param provided - The token presented on the request.
+ * @param expected - The configured expected secret token.
+ * @returns True when the tokens are byte-for-byte equal.
+ */ function safeCompareOpenRouterWebhookToken(provided, expected) {
+    var providedBuffer = Buffer.from(provided, 'utf8');
+    var expectedBuffer = Buffer.from(expected, 'utf8');
+    var valid = false;
+    if (providedBuffer.length === expectedBuffer.length) {
+        valid = node_crypto.timingSafeEqual(providedBuffer, expectedBuffer);
+    }
+    return valid;
+}
+/**
+ * Reads a single header value from the request, normalizing array-valued headers to their first entry.
+ *
+ * @param req - The incoming request.
+ * @param header - The (case-insensitive) header name to read.
+ * @returns The header value, or undefined when absent.
+ */ function readOpenRouterWebhookHeader(req, header) {
+    var value = req.headers[header.toLowerCase()];
+    return Array.isArray(value) ? value[0] : value;
+}
+/**
+ * Strips a scheme prefix (e.g. `Bearer `) from a header value, case-insensitively.
+ *
+ * @param value - The raw header value.
+ * @param scheme - The scheme prefix to strip, or null/empty to leave the value untouched.
+ * @returns The token portion of the header value, trimmed.
+ */ function stripOpenRouterWebhookScheme(value, scheme) {
+    var token = value.trim();
+    if (scheme) {
+        var prefix = "".concat(scheme.toLowerCase(), " ");
+        if (token.toLowerCase().startsWith(prefix)) {
+            token = token.slice(prefix.length).trim();
+        }
+    }
+    return token;
+}
+/**
+ * Creates a verifier for OpenRouter broadcast webhook requests.
+ *
+ * OpenRouter broadcast webhooks have no HMAC signature scheme. Authentication is a
+ * user-configured custom header (e.g. `Authorization: Bearer <secret>`) sent verbatim on every
+ * request. This verifier extracts the configured header, strips the scheme prefix, and compares
+ * the token to the expected secret using a constant-time comparison.
+ *
+ * @param config - Verification config containing the secret, header, and scheme.
+ * @returns A verifier function that validates each request's secret token.
+ */ function openRouterWebhookEventVerifier(config) {
+    var secret = config.secret;
+    var header = config.header || DEFAULT_OPENROUTER_WEBHOOK_HEADER;
+    var scheme = config.scheme === undefined ? DEFAULT_OPENROUTER_WEBHOOK_SCHEME : config.scheme;
+    return function(req) {
+        var headerValue = readOpenRouterWebhookHeader(req, header);
+        var valid = false;
+        if (headerValue) {
+            var token = stripOpenRouterWebhookScheme(headerValue, scheme);
+            valid = safeCompareOpenRouterWebhookToken(token, secret);
+        }
+        var result = {
+            valid: valid
+        };
+        return result;
+    };
+}
+
+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$5(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$2(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$2(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$2(Constructor.prototype, protoProps);
+    return Constructor;
+}
+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 _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
+        };
+    }
+}
+/**
+ * Service that makes system changes based on OpenRouter broadcast webhook events.
+ */ exports.OpenRouterWebhookService = /*#__PURE__*/ function() {
+    function OpenRouterWebhookService(openRouterWebhookServiceConfig) {
+        _class_call_check$5(this, OpenRouterWebhookService);
+        _define_property$3(this, "logger", new common.Logger('OpenRouterWebhookService'));
+        _define_property$3(this, "_verifier", void 0);
+        _define_property$3(this, "handler", openRouterEventHandlerFactory());
+        _define_property$3(this, "configure", openRouterEventHandlerConfigurerFactory(this.handler));
+        var _openRouterWebhookServiceConfig_openrouterWebhook = openRouterWebhookServiceConfig.openrouterWebhook, webhookSecret = _openRouterWebhookServiceConfig_openrouterWebhook.webhookSecret, header = _openRouterWebhookServiceConfig_openrouterWebhook.header, scheme = _openRouterWebhookServiceConfig_openrouterWebhook.scheme;
+        this._verifier = openRouterWebhookEventVerifier({
+            secret: webhookSecret,
+            header: header,
+            scheme: scheme
+        });
+    }
+    _create_class$2(OpenRouterWebhookService, [
+        {
+            key: "updateForWebhook",
+            value: function updateForWebhook(req, body) {
+                return _async_to_generator$1(function() {
+                    var valid, result;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                valid = this._verifier(req).valid;
+                                if (!valid) return [
+                                    3,
+                                    2
+                                ];
+                                return [
+                                    4,
+                                    this.updateForBroadcast(body)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                return [
+                                    3,
+                                    3
+                                ];
+                            case 2:
+                                this.logger.warn('Received OpenRouter webhook with an invalid secret token.');
+                                result = {
+                                    valid: false,
+                                    totalSpans: 0,
+                                    handledSpans: 0
+                                };
+                                _state.label = 3;
+                            case 3:
+                                return [
+                                    2,
+                                    result
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "updateForBroadcast",
+            value: function updateForBroadcast(payload) {
+                return _async_to_generator$1(function() {
+                    var spans, handledSpans, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, span, handled, err;
+                    return _ts_generator$1(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                spans = openRouterBroadcastSpansFromPayload(payload);
+                                handledSpans = 0;
+                                _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                                _state.label = 1;
+                            case 1:
+                                _state.trys.push([
+                                    1,
+                                    6,
+                                    7,
+                                    8
+                                ]);
+                                _iterator = spans[Symbol.iterator]();
+                                _state.label = 2;
+                            case 2:
+                                if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                                    3,
+                                    5
+                                ];
+                                span = _step.value;
+                                return [
+                                    4,
+                                    this.handler(span)
+                                ];
+                            case 3:
+                                handled = _state.sent();
+                                if (handled) {
+                                    handledSpans += 1;
+                                }
+                                _state.label = 4;
+                            case 4:
+                                _iteratorNormalCompletion = true;
+                                return [
+                                    3,
+                                    2
+                                ];
+                            case 5:
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 6:
+                                err = _state.sent();
+                                _didIteratorError = true;
+                                _iteratorError = err;
+                                return [
+                                    3,
+                                    8
+                                ];
+                            case 7:
+                                try {
+                                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                        _iterator.return();
+                                    }
+                                } finally{
+                                    if (_didIteratorError) {
+                                        throw _iteratorError;
+                                    }
+                                }
+                                return [
+                                    7
+                                ];
+                            case 8:
+                                return [
+                                    2,
+                                    {
+                                        valid: true,
+                                        totalSpans: spans.length,
+                                        handledSpans: handledSpans
+                                    }
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return OpenRouterWebhookService;
+}();
+exports.OpenRouterWebhookService = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(OpenRouterWebhookServiceConfig))
+], exports.OpenRouterWebhookService);
+
+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 _class_call_check$4(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties$1(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class$1(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
+    return Constructor;
+}
+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 _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
+        };
+    }
+}
+/**
+ * Controller for incoming OpenRouter broadcast webhook requests.
+ *
+ * OpenRouter can be configured to deliver broadcast traces via POST (default) or PUT, so both
+ * verbs are handled. Authentication is a user-configured header carrying a shared secret, so a
+ * plain `@Body()` (parsed JSON) is sufficient — no raw-body middleware is required.
+ */ exports.OpenRouterWebhookController = /*#__PURE__*/ function() {
+    function OpenRouterWebhookController(openrouterWebhookService) {
+        _class_call_check$4(this, OpenRouterWebhookController);
+        _define_property$2(this, "_openrouterWebhookService", void 0);
+        this._openrouterWebhookService = openrouterWebhookService;
+    }
+    _create_class$1(OpenRouterWebhookController, [
+        {
+            key: "handleOpenRouterWebhookPost",
+            value: function handleOpenRouterWebhookPost(req, body) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.handleOpenRouterWebhook(req, body)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "handleOpenRouterWebhookPut",
+            value: function handleOpenRouterWebhookPut(req, body) {
+                return _async_to_generator(function() {
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this.handleOpenRouterWebhook(req, body)
+                                ];
+                            case 1:
+                                _state.sent();
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        },
+        {
+            key: "handleOpenRouterWebhook",
+            value: function handleOpenRouterWebhook(req, body) {
+                return _async_to_generator(function() {
+                    var result;
+                    return _ts_generator(this, function(_state) {
+                        switch(_state.label){
+                            case 0:
+                                return [
+                                    4,
+                                    this._openrouterWebhookService.updateForWebhook(req, body)
+                                ];
+                            case 1:
+                                result = _state.sent();
+                                if (!result.valid) {
+                                    throw new common.UnauthorizedException('Invalid OpenRouter webhook token.');
+                                }
+                                return [
+                                    2
+                                ];
+                        }
+                    });
+                }).call(this);
+            }
+        }
+    ]);
+    return OpenRouterWebhookController;
+}();
+__decorate([
+    common.Post(),
+    __param(0, common.Req()),
+    __param(1, common.Body())
+], exports.OpenRouterWebhookController.prototype, "handleOpenRouterWebhookPost", null);
+__decorate([
+    common.Put(),
+    __param(0, common.Req()),
+    __param(1, common.Body())
+], exports.OpenRouterWebhookController.prototype, "handleOpenRouterWebhookPut", null);
+exports.OpenRouterWebhookController = __decorate([
+    common.Controller('/webhook/openrouter'),
+    __param(0, common.Inject(exports.OpenRouterWebhookService))
+], exports.OpenRouterWebhookController);
+
+function _class_call_check$3(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+/**
+ * Factory that creates an OpenRouterWebhookServiceConfig from environment variables.
+ *
+ * Reads the OpenRouter webhook secret token, and the optional header name and scheme, from
+ * environment variables.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @returns A validated OpenRouterWebhookServiceConfig.
+ */ function openRouterWebhookServiceConfigFactory(configService) {
+    var _configService_get, _configService_get1;
+    var config = {
+        openrouterWebhook: {
+            webhookSecret: configService.get(OPENROUTER_WEBHOOK_SECRET_TOKEN_ENV_VAR),
+            header: (_configService_get = configService.get(OPENROUTER_WEBHOOK_HEADER_ENV_VAR)) !== null && _configService_get !== void 0 ? _configService_get : undefined,
+            scheme: (_configService_get1 = configService.get(OPENROUTER_WEBHOOK_SCHEME_ENV_VAR)) !== null && _configService_get1 !== void 0 ? _configService_get1 : undefined
+        }
+    };
+    OpenRouterWebhookServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * NestJS module that handles incoming OpenRouter broadcast webhook events.
+ *
+ * Standalone — does not depend on OpenRouterModule (no API key needed). Verification is a
+ * constant-time comparison of the user-configured secret header, so the SDK client is unused here.
+ * Provides the OpenRouterWebhookService and controller for verifying and processing broadcast payloads.
+ */ exports.OpenRouterWebhookModule = function OpenRouterWebhookModule() {
+    _class_call_check$3(this, OpenRouterWebhookModule);
+};
+exports.OpenRouterWebhookModule = __decorate([
+    common.Module({
+        imports: [
+            config.ConfigModule
+        ],
+        controllers: [
+            exports.OpenRouterWebhookController
+        ],
+        providers: [
+            {
+                provide: OpenRouterWebhookServiceConfig,
+                inject: [
+                    config.ConfigService
+                ],
+                useFactory: openRouterWebhookServiceConfigFactory
+            },
+            exports.OpenRouterWebhookService
+        ],
+        exports: [
+            exports.OpenRouterWebhookService
+        ]
+    })
+], exports.OpenRouterWebhookModule);
+
+function _class_call_check$2(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+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;
+}
+/**
+ * Default environment variable for the OpenRouter API key.
+ */ var OPENROUTER_API_KEY_ENV_VAR = 'OPENROUTER_API_KEY';
+/**
+ * Optional environment variable for overriding the OpenRouter server/base URL.
+ */ var OPENROUTER_SERVER_URL_ENV_VAR = 'OPENROUTER_SERVER_URL';
+/**
+ * Configuration for OpenRouterApi.
+ */ var OpenRouterServiceConfig = /*#__PURE__*/ function() {
+    function OpenRouterServiceConfig() {
+        _class_call_check$2(this, OpenRouterServiceConfig);
+        _define_property$1(this, "openrouter", void 0);
+    }
+    _create_class(OpenRouterServiceConfig, null, [
+        {
+            key: "assertValidConfig",
+            value: function assertValidConfig(config) {
+                if (!config.openrouter.apiKey) {
+                    throw new Error('No OpenRouter API key specified.');
+                }
+            }
+        }
+    ]);
+    return OpenRouterServiceConfig;
+} 
+();
+
+function _class_call_check$1(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;
+}
+exports.OpenRouterApi = function OpenRouterApi(config) {
+    _class_call_check$1(this, OpenRouterApi);
+    _define_property(this, "config", void 0);
+    _define_property(this, "openRouterClient", void 0);
+    this.config = config;
+    var _config_openrouter = config.openrouter, apiKey = _config_openrouter.apiKey, serverURL = _config_openrouter.serverURL;
+    this.openRouterClient = new sdk.OpenRouter({
+        apiKey: apiKey,
+        serverURL: serverURL
+    });
+};
+exports.OpenRouterApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(OpenRouterServiceConfig))
+], exports.OpenRouterApi);
+
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+/**
+ * Factory that creates an OpenRouterServiceConfig from environment variables.
+ *
+ * Reads the API key and optional server/base URL override from environment variables.
+ *
+ * @param configService - NestJS config service for reading environment variables.
+ * @returns A validated OpenRouterServiceConfig.
+ */ function openRouterServiceConfigFactory(configService) {
+    var _configService_get;
+    var config = {
+        openrouter: {
+            apiKey: configService.get(OPENROUTER_API_KEY_ENV_VAR),
+            serverURL: (_configService_get = configService.get(OPENROUTER_SERVER_URL_ENV_VAR)) !== null && _configService_get !== void 0 ? _configService_get : undefined
+        }
+    };
+    OpenRouterServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * NestJS module that provides the OpenRouterApi service.
+ *
+ * Reads the OpenRouter API key and optional server URL override from environment variables.
+ */ exports.OpenRouterModule = function OpenRouterModule() {
+    _class_call_check(this, OpenRouterModule);
+};
+exports.OpenRouterModule = __decorate([
+    common.Module({
+        imports: [
+            config.ConfigModule
+        ],
+        providers: [
+            {
+                provide: OpenRouterServiceConfig,
+                inject: [
+                    config.ConfigService
+                ],
+                useFactory: openRouterServiceConfigFactory
+            },
+            exports.OpenRouterApi
+        ],
+        exports: [
+            exports.OpenRouterApi
+        ]
+    })
+], exports.OpenRouterModule);
+
+exports.DEFAULT_OPENROUTER_WEBHOOK_HEADER = DEFAULT_OPENROUTER_WEBHOOK_HEADER;
+exports.DEFAULT_OPENROUTER_WEBHOOK_SCHEME = DEFAULT_OPENROUTER_WEBHOOK_SCHEME;
+exports.OPENROUTER_API_KEY_ENV_VAR = OPENROUTER_API_KEY_ENV_VAR;
+exports.OPENROUTER_SERVER_URL_ENV_VAR = OPENROUTER_SERVER_URL_ENV_VAR;
+exports.OPENROUTER_SPAN_ATTRIBUTE_COMPLETION_TOKENS_KEYS = OPENROUTER_SPAN_ATTRIBUTE_COMPLETION_TOKENS_KEYS;
+exports.OPENROUTER_SPAN_ATTRIBUTE_COST_KEYS = OPENROUTER_SPAN_ATTRIBUTE_COST_KEYS;
+exports.OPENROUTER_SPAN_ATTRIBUTE_GENERATION_ID_KEYS = OPENROUTER_SPAN_ATTRIBUTE_GENERATION_ID_KEYS;
+exports.OPENROUTER_SPAN_ATTRIBUTE_MODEL_KEYS = OPENROUTER_SPAN_ATTRIBUTE_MODEL_KEYS;
+exports.OPENROUTER_SPAN_ATTRIBUTE_PROMPT_TOKENS_KEYS = OPENROUTER_SPAN_ATTRIBUTE_PROMPT_TOKENS_KEYS;
+exports.OPENROUTER_SPAN_ATTRIBUTE_PROVIDER_KEYS = OPENROUTER_SPAN_ATTRIBUTE_PROVIDER_KEYS;
+exports.OPENROUTER_SPAN_ATTRIBUTE_TOTAL_TOKENS_KEYS = OPENROUTER_SPAN_ATTRIBUTE_TOTAL_TOKENS_KEYS;
+exports.OPENROUTER_WEBHOOK_HEADER_ENV_VAR = OPENROUTER_WEBHOOK_HEADER_ENV_VAR;
+exports.OPENROUTER_WEBHOOK_SCHEME_ENV_VAR = OPENROUTER_WEBHOOK_SCHEME_ENV_VAR;
+exports.OPENROUTER_WEBHOOK_SECRET_TOKEN_ENV_VAR = OPENROUTER_WEBHOOK_SECRET_TOKEN_ENV_VAR;
+exports.OpenRouterServiceConfig = OpenRouterServiceConfig;
+exports.OpenRouterWebhookServiceConfig = OpenRouterWebhookServiceConfig;
+exports.openRouterAttributeMap = openRouterAttributeMap;
+exports.openRouterBroadcastSpan = openRouterBroadcastSpan;
+exports.openRouterBroadcastSpansFromPayload = openRouterBroadcastSpansFromPayload;
+exports.openRouterEventHandlerConfigurerFactory = openRouterEventHandlerConfigurerFactory;
+exports.openRouterEventHandlerFactory = openRouterEventHandlerFactory;
+exports.openRouterGenerationInfoFromAttributes = openRouterGenerationInfoFromAttributes;
+exports.openRouterServiceConfigFactory = openRouterServiceConfigFactory;
+exports.openRouterWebhookEventVerifier = openRouterWebhookEventVerifier;
+exports.openRouterWebhookServiceConfigFactory = openRouterWebhookServiceConfigFactory;
+exports.readOpenRouterAnyValue = readOpenRouterAnyValue;
+exports.readOpenRouterWebhookHeader = readOpenRouterWebhookHeader;
+exports.safeCompareOpenRouterWebhookToken = safeCompareOpenRouterWebhookToken;
+exports.stripOpenRouterWebhookScheme = stripOpenRouterWebhookScheme;