@xpert-ai/plugin-sdk 3.17.0 → 3.17.2

package/index.cjs.js

@@ -1669,145 +1669,6 @@ exports.AIModelProviderRegistry = __decorate([
     ])
 ], exports.AIModelProviderRegistry);
 
-class AiModelNotFoundException extends common.NotFoundException {
-}
-class CredentialsValidateFailedError extends common.ForbiddenException {
-}
-class AIModelProviderNotFoundException extends common.NotFoundException {
-}
-
-var ModelProvider_1;
-exports.ModelProvider = ModelProvider_1 = class ModelProvider {
-    get name() {
-        return this.getProviderSchema().provider;
-    }
-    async validateCredentials(credentials) {
-        await this.validateProviderCredentials(credentials);
-    }
-    /**
-     * Get provider lib root path.
-     *
-     * @returns Root of library
-     */ getProviderServerPath() {
-        return this.dir;
-    }
-    getProviderSchema() {
-        if (this._meta) {
-            return this._meta;
-        }
-        const yamlPath = path.join(this.getProviderServerPath(), `${this._name}.yaml`);
-        const yamlData = loadYamlFile(yamlPath, this.logger);
-        try {
-            this._meta = yamlData;
-        } catch (e) {
-            throw new Error(`Invalid provider schema for ${this.name}: ${e.message}`);
-        }
-        return this._meta;
-    }
-    async getModels(modelType) {
-        const providerSchema = this.getProviderSchema();
-        const supported = providerSchema.supported_model_types.includes(modelType) || modelType === contracts.AiModelTypeEnum.IMAGE && providerSchema.supported_model_types.includes(contracts.AiModelTypeEnum.TEXT2IMG);
-        if (!supported) {
-            return [];
-        }
-        var _this_modelManagers_get;
-        const modelInstance = modelType === contracts.AiModelTypeEnum.IMAGE ? (_this_modelManagers_get = this.modelManagers.get(contracts.AiModelTypeEnum.IMAGE)) != null ? _this_modelManagers_get : this.modelManagers.get(contracts.AiModelTypeEnum.TEXT2IMG) : this.modelManagers.get(modelType);
-        if (!modelInstance) {
-            throw new AiModelNotFoundException(`Missing AIModel instance for model type ${modelType}`);
-        }
-        return modelInstance.predefinedModels();
-    }
-    registerAIModelInstance(modelType, modelInstance) {
-        this.modelManagers.set(modelType, modelInstance);
-    }
-    getModelManager(modelType) {
-        const modelInstance = this.modelManagers.get(modelType);
-        if (!modelInstance) {
-            throw new AiModelNotFoundException(`Missing AIModel instance for model type ${modelType}`);
-        }
-        return modelInstance;
-    }
-    /**
-     * Get provider models.
-     * @param modelType - model type
-     * @param onlyActive - only active models
-     * @return provider models
-     */ getProviderModels(modelType, onlyActive = false) {
-        let modelTypes = [];
-        if (modelType) {
-            modelTypes.push(modelType);
-        } else {
-            modelTypes = this.getProviderSchema().supported_model_types;
-        }
-        const providerModels = this.getSystemProviderModels(modelTypes);
-        // Resort providerModels
-        return providerModels.sort((a, b)=>a.model_type.localeCompare(b.model_type));
-    }
-    getSystemProviderModels(modelTypes) {
-        const models = [];
-        modelTypes == null ? void 0 : modelTypes.forEach((modelType)=>{
-            var _this_modelManagers_get;
-            const modelManager = modelType === contracts.AiModelTypeEnum.IMAGE ? (_this_modelManagers_get = this.modelManagers.get(contracts.AiModelTypeEnum.IMAGE)) != null ? _this_modelManagers_get : this.modelManagers.get(contracts.AiModelTypeEnum.TEXT2IMG) : this.modelManagers.get(modelType);
-            if (modelManager) {
-                models.push(...modelManager.predefinedModels());
-            }
-        });
-        return models;
-    }
-    getChatModel(copilotModel, options) {
-        var _this_getModelManager;
-        return (_this_getModelManager = this.getModelManager(contracts.AiModelTypeEnum.LLM)) == null ? void 0 : _this_getModelManager.getChatModel(copilotModel, options);
-    }
-    async getModelInstance(type, copilotModel, options) {
-        switch(type){
-            case contracts.AiModelTypeEnum.LLM:
-                var _this_getModelManager;
-                return (_this_getModelManager = this.getModelManager(type)) == null ? void 0 : _this_getModelManager.getChatModel(copilotModel, options);
-            case contracts.AiModelTypeEnum.TEXT_EMBEDDING:
-                var _this_getModelManager1;
-                if (!copilotModel.options) {
-                    var _copilotModel_copilot_copilotModel, _predefinedModels_find;
-                    const predefinedModels = await this.getModels(contracts.AiModelTypeEnum.TEXT_EMBEDDING);
-                    const modelName = copilotModel.model || ((_copilotModel_copilot_copilotModel = copilotModel.copilot.copilotModel) == null ? void 0 : _copilotModel_copilot_copilotModel.model);
-                    copilotModel.options = (_predefinedModels_find = predefinedModels.find((_)=>_.model === modelName)) == null ? void 0 : _predefinedModels_find.model_properties;
-                }
-                return (_this_getModelManager1 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager1.getEmbeddingInstance(copilotModel, options);
-            case contracts.AiModelTypeEnum.TTS:
-                var _this_getModelManager2;
-                return (_this_getModelManager2 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager2.getChatModel(copilotModel, options);
-            case contracts.AiModelTypeEnum.SPEECH2TEXT:
-                var _this_getModelManager3;
-                return (_this_getModelManager3 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager3.getChatModel(copilotModel, options);
-            case contracts.AiModelTypeEnum.RERANK:
-                var _this_getModelManager4;
-                return (_this_getModelManager4 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager4.getReranker(copilotModel, options);
-            case contracts.AiModelTypeEnum.IMAGE:
-                var _this;
-                var _this_modelManagers_get;
-                return (_this = (_this_modelManagers_get = this.modelManagers.get(contracts.AiModelTypeEnum.IMAGE)) != null ? _this_modelManagers_get : this.modelManagers.get(contracts.AiModelTypeEnum.TEXT2IMG)) == null ? void 0 : _this.getAIGCModel(copilotModel, options);
-            case contracts.AiModelTypeEnum.TEXT2IMG:
-            case contracts.AiModelTypeEnum.VIDEO:
-                var _this_getModelManager5;
-                return (_this_getModelManager5 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager5.getAIGCModel(copilotModel, options);
-        }
-        return null;
-    }
-    constructor(){
-        this.logger = new common.Logger(ModelProvider_1.name);
-        // protected providerSchema: IAiProviderEntity | null = null
-        this.modelManagers = new Map();
-        const provider = Reflect.getMetadata(AI_MODEL_PROVIDER, this.constructor);
-        this._name = provider;
-        // Automatically retrieve provider DIR information from decorator metadata
-        const dir = Reflect.getMetadata(`${AI_MODEL_PROVIDER}_DIR`, this.constructor);
-        this.dir = dir;
-    }
-};
-exports.ModelProvider = ModelProvider_1 = __decorate([
-    common.Injectable(),
-    __metadata("design:paramtypes", [])
-], exports.ModelProvider);
-
 function valueOf(enumObj, value) {
     const enumValues = Object.values(enumObj);
     if (enumValues.includes(value)) {
@@ -1953,6 +1814,145 @@ const PARAMETER_RULE_TEMPLATE = {
     }
 };
 
+class AiModelNotFoundException extends common.NotFoundException {
+}
+class CredentialsValidateFailedError extends common.ForbiddenException {
+}
+class AIModelProviderNotFoundException extends common.NotFoundException {
+}
+
+var ModelProvider_1;
+exports.ModelProvider = ModelProvider_1 = class ModelProvider {
+    get name() {
+        return this.getProviderSchema().provider;
+    }
+    async validateCredentials(credentials) {
+        await this.validateProviderCredentials(credentials);
+    }
+    /**
+     * Get provider lib root path.
+     *
+     * @returns Root of library
+     */ getProviderServerPath() {
+        return this.dir;
+    }
+    getProviderSchema() {
+        if (this._meta) {
+            return this._meta;
+        }
+        const yamlPath = path.join(this.getProviderServerPath(), `${this._name}.yaml`);
+        const yamlData = loadYamlFile(yamlPath, this.logger);
+        try {
+            this._meta = yamlData;
+        } catch (e) {
+            throw new Error(`Invalid provider schema for ${this.name}: ${e.message}`);
+        }
+        return this._meta;
+    }
+    async getModels(modelType) {
+        const providerSchema = this.getProviderSchema();
+        const supported = providerSchema.supported_model_types.includes(modelType) || modelType === contracts.AiModelTypeEnum.IMAGE && providerSchema.supported_model_types.includes(contracts.AiModelTypeEnum.TEXT2IMG);
+        if (!supported) {
+            return [];
+        }
+        var _this_modelManagers_get;
+        const modelInstance = modelType === contracts.AiModelTypeEnum.IMAGE ? (_this_modelManagers_get = this.modelManagers.get(contracts.AiModelTypeEnum.IMAGE)) != null ? _this_modelManagers_get : this.modelManagers.get(contracts.AiModelTypeEnum.TEXT2IMG) : this.modelManagers.get(modelType);
+        if (!modelInstance) {
+            throw new AiModelNotFoundException(`Missing AIModel instance for model type ${modelType}`);
+        }
+        return modelInstance.predefinedModels();
+    }
+    registerAIModelInstance(modelType, modelInstance) {
+        this.modelManagers.set(modelType, modelInstance);
+    }
+    getModelManager(modelType) {
+        const modelInstance = this.modelManagers.get(modelType);
+        if (!modelInstance) {
+            throw new AiModelNotFoundException(`Missing AIModel instance for model type ${modelType}`);
+        }
+        return modelInstance;
+    }
+    /**
+     * Get provider models.
+     * @param modelType - model type
+     * @param onlyActive - only active models
+     * @return provider models
+     */ getProviderModels(modelType, onlyActive = false) {
+        let modelTypes = [];
+        if (modelType) {
+            modelTypes.push(modelType);
+        } else {
+            modelTypes = this.getProviderSchema().supported_model_types;
+        }
+        const providerModels = this.getSystemProviderModels(modelTypes);
+        // Resort providerModels
+        return providerModels.sort((a, b)=>a.model_type.localeCompare(b.model_type));
+    }
+    getSystemProviderModels(modelTypes) {
+        const models = [];
+        modelTypes == null ? void 0 : modelTypes.forEach((modelType)=>{
+            var _this_modelManagers_get;
+            const modelManager = modelType === contracts.AiModelTypeEnum.IMAGE ? (_this_modelManagers_get = this.modelManagers.get(contracts.AiModelTypeEnum.IMAGE)) != null ? _this_modelManagers_get : this.modelManagers.get(contracts.AiModelTypeEnum.TEXT2IMG) : this.modelManagers.get(modelType);
+            if (modelManager) {
+                models.push(...modelManager.predefinedModels());
+            }
+        });
+        return models;
+    }
+    getChatModel(copilotModel, options) {
+        var _this_getModelManager;
+        return (_this_getModelManager = this.getModelManager(contracts.AiModelTypeEnum.LLM)) == null ? void 0 : _this_getModelManager.getChatModel(copilotModel, options);
+    }
+    async getModelInstance(type, copilotModel, options) {
+        switch(type){
+            case contracts.AiModelTypeEnum.LLM:
+                var _this_getModelManager;
+                return (_this_getModelManager = this.getModelManager(type)) == null ? void 0 : _this_getModelManager.getChatModel(copilotModel, options);
+            case contracts.AiModelTypeEnum.TEXT_EMBEDDING:
+                var _this_getModelManager1;
+                if (!copilotModel.options) {
+                    var _copilotModel_copilot_copilotModel, _predefinedModels_find;
+                    const predefinedModels = await this.getModels(contracts.AiModelTypeEnum.TEXT_EMBEDDING);
+                    const modelName = copilotModel.model || ((_copilotModel_copilot_copilotModel = copilotModel.copilot.copilotModel) == null ? void 0 : _copilotModel_copilot_copilotModel.model);
+                    copilotModel.options = (_predefinedModels_find = predefinedModels.find((_)=>_.model === modelName)) == null ? void 0 : _predefinedModels_find.model_properties;
+                }
+                return (_this_getModelManager1 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager1.getEmbeddingInstance(copilotModel, options);
+            case contracts.AiModelTypeEnum.TTS:
+                var _this_getModelManager2;
+                return (_this_getModelManager2 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager2.getChatModel(copilotModel, options);
+            case contracts.AiModelTypeEnum.SPEECH2TEXT:
+                var _this_getModelManager3;
+                return (_this_getModelManager3 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager3.getChatModel(copilotModel, options);
+            case contracts.AiModelTypeEnum.RERANK:
+                var _this_getModelManager4;
+                return (_this_getModelManager4 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager4.getReranker(copilotModel, options);
+            case contracts.AiModelTypeEnum.IMAGE:
+                var _this;
+                var _this_modelManagers_get;
+                return (_this = (_this_modelManagers_get = this.modelManagers.get(contracts.AiModelTypeEnum.IMAGE)) != null ? _this_modelManagers_get : this.modelManagers.get(contracts.AiModelTypeEnum.TEXT2IMG)) == null ? void 0 : _this.getAIGCModel(copilotModel, options);
+            case contracts.AiModelTypeEnum.TEXT2IMG:
+            case contracts.AiModelTypeEnum.VIDEO:
+                var _this_getModelManager5;
+                return (_this_getModelManager5 = this.getModelManager(type)) == null ? void 0 : _this_getModelManager5.getAIGCModel(copilotModel, options);
+        }
+        return null;
+    }
+    constructor(){
+        this.logger = new common.Logger(ModelProvider_1.name);
+        // protected providerSchema: IAiProviderEntity | null = null
+        this.modelManagers = new Map();
+        const provider = Reflect.getMetadata(AI_MODEL_PROVIDER, this.constructor);
+        this._name = provider;
+        // Automatically retrieve provider DIR information from decorator metadata
+        const dir = Reflect.getMetadata(`${AI_MODEL_PROVIDER}_DIR`, this.constructor);
+        this.dir = dir;
+    }
+};
+exports.ModelProvider = ModelProvider_1 = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [])
+], exports.ModelProvider);
+
 const CommonParameterRules = [
     {
         name: 'temperature',
@@ -2014,33 +2014,143 @@ function calculateModelPrice(pricing, priceType, tokens, inputTokens = tokens) {
         currency: pricing.currency
     };
 }
+function calculateLLMUsagePrice(pricing, usage, context = {}) {
+    var _pricing_rules;
+    validateLLMPriceRules((_pricing_rules = pricing.rules) != null ? _pricing_rules : []);
+    const pricingContext = _extends._extends({}, context, {
+        pricingTime: resolvePricingTime(context.pricingTime)
+    });
+    const promptTokens = tokenCount(usage.promptTokens, 'promptTokens');
+    const completionTokens = tokenCount(usage.completionTokens, 'completionTokens');
+    var _usage_cacheReadInputTokens;
+    const cacheReadInputTokens = tokenCount((_usage_cacheReadInputTokens = usage.cacheReadInputTokens) != null ? _usage_cacheReadInputTokens : 0, 'cacheReadInputTokens');
+    var _usage_cacheWriteInputTokens;
+    const cacheWriteInputTokens = tokenCount((_usage_cacheWriteInputTokens = usage.cacheWriteInputTokens) != null ? _usage_cacheWriteInputTokens : 0, 'cacheWriteInputTokens');
+    const cacheTokens = cacheReadInputTokens + cacheWriteInputTokens;
+    const inputTokens = context.inputTokensIncludeCache === false ? promptTokens + cacheTokens : promptTokens;
+    let standardInputTokens = context.inputTokensIncludeCache === false ? promptTokens : promptTokens - cacheTokens;
+    if (standardInputTokens < 0) {
+        throw new Error('Cache read and write tokens cannot exceed prompt tokens when input includes cache tokens');
+    }
+    const selectionContext = {
+        inputTokens,
+        outputTokens: completionTokens,
+        context: pricingContext
+    };
+    const breakdown = [];
+    const cacheReadRule = selectLLMPriceRule(pricing.rules, 'cache_read_input', selectionContext);
+    if (cacheReadInputTokens > 0) {
+        if (cacheReadRule) {
+            breakdown.push(priceRuleComponent(cacheReadRule, cacheReadInputTokens, pricing.currency));
+        } else if (hasLLMPriceRule(pricing.rules, 'cache_read_input')) {
+            breakdown.push(unpricedComponent('cache_read_input', cacheReadInputTokens));
+        } else {
+            standardInputTokens += cacheReadInputTokens;
+        }
+    }
+    for (const cacheWrite of resolveCacheWriteInputTokens(cacheWriteInputTokens, context)){
+        const cacheWriteSelection = _extends._extends({}, selectionContext, {
+            context: _extends._extends({}, pricingContext, {
+                cacheWriteTtl: cacheWrite.cacheTtl
+            })
+        });
+        const cacheWriteRule = selectLLMPriceRule(pricing.rules, 'cache_write_input', cacheWriteSelection);
+        if (cacheWriteRule) {
+            breakdown.push(priceRuleComponent(cacheWriteRule, cacheWrite.quantity, pricing.currency, {
+                cacheTtl: cacheWrite.cacheTtl
+            }));
+        } else if (hasLLMPriceRule(pricing.rules, 'cache_write_input')) {
+            breakdown.push(unpricedComponent('cache_write_input', cacheWrite.quantity, {
+                cacheTtl: cacheWrite.cacheTtl
+            }));
+        } else {
+            standardInputTokens += cacheWrite.quantity;
+        }
+    }
+    if (standardInputTokens > 0) {
+        const inputRule = selectLLMPriceRule(pricing.rules, 'input', selectionContext);
+        breakdown.push(inputRule ? priceRuleComponent(inputRule, standardInputTokens, pricing.currency) : hasLLMPriceRule(pricing.rules, 'input') ? unpricedComponent('input', standardInputTokens) : legacyPriceComponent(pricing, contracts.PriceType.INPUT, standardInputTokens, inputTokens));
+    }
+    if (completionTokens > 0) {
+        const outputRule = selectLLMPriceRule(pricing.rules, 'output', selectionContext);
+        breakdown.push(outputRule ? priceRuleComponent(outputRule, completionTokens, pricing.currency) : hasLLMPriceRule(pricing.rules, 'output') ? unpricedComponent('output', completionTokens) : legacyPriceComponent(pricing, contracts.PriceType.OUTPUT, completionTokens, inputTokens));
+    }
+    const addOns = new Map();
+    var _context_addOns;
+    for (const addOn of (_context_addOns = context.addOns) != null ? _context_addOns : []){
+        const quantity = nonNegativeQuantity(addOn.quantity, `add-on '${addOn.type}'`);
+        if (quantity === 0) continue;
+        var _addOns_get;
+        addOns.set(addOn.type, ((_addOns_get = addOns.get(addOn.type)) != null ? _addOns_get : 0) + quantity);
+    }
+    for (const [addOn, quantity] of addOns){
+        const rule = selectLLMPriceRule(pricing.rules, 'request', selectionContext, addOn);
+        breakdown.push(rule ? priceRuleComponent(rule, quantity, pricing.currency, {
+            addOn
+        }) : unpricedComponent('request', quantity, {
+            addOn
+        }));
+    }
+    var _context_unpricedAddOns;
+    for (const addOn of (_context_unpricedAddOns = context.unpricedAddOns) != null ? _context_unpricedAddOns : []){
+        const quantity = nonNegativeQuantity(addOn.quantity, `unpriced add-on '${addOn.type}'`);
+        if (quantity === 0) continue;
+        breakdown.push(unpricedComponent('request', quantity, {
+            addOn: addOn.type,
+            addOnAuthority: addOn.authority
+        }));
+    }
+    if (context.cacheStorageTokenHours !== undefined) {
+        const quantity = nonNegativeQuantity(context.cacheStorageTokenHours, 'cacheStorageTokenHours');
+        if (quantity > 0) {
+            const rule = selectLLMPriceRule(pricing.rules, 'cache_storage', selectionContext);
+            breakdown.push(rule ? priceRuleComponent(rule, quantity, pricing.currency) : unpricedComponent('cache_storage', quantity));
+        }
+    }
+    return summarizeLLMPrice(pricing.currency, breakdown);
+}
 function resolveModelUsagePricingSnapshot(pricing, context) {
     var _normalizeDate;
     var _normalizeDate_toISOString;
     const capturedAt = (_normalizeDate_toISOString = (_normalizeDate = normalizeDate(context.startedAt)) == null ? void 0 : _normalizeDate.toISOString()) != null ? _normalizeDate_toISOString : new Date().toISOString();
     if (!isModelUsagePricingConfig(pricing)) {
-        return {
-            capturedAt,
+        return _extends._extends({
+            capturedAt
+        }, context.pricingDimensions ? {
+            pricingDimensions: context.pricingDimensions
+        } : {}, {
             rules: []
-        };
+        });
     }
     const at = new Date(capturedAt);
-    const rules = pricing.rules.filter((rule)=>matchesUsagePriceRule(rule, context, at));
-    const units = new Set();
-    for (const rule of rules){
+    const matchingRules = pricing.rules.filter((rule)=>matchesUsagePriceRule(rule, context, at));
+    const rules = [];
+    for (const rule of matchingRules){
         validateUsagePriceRule(rule);
-        if (units.has(rule.unit)) {
+        const selector = usagePriceRuleSelector(rule);
+        const existingIndex = rules.findIndex((candidate)=>usagePriceRuleSelector(candidate) === selector);
+        if (existingIndex < 0) {
+            rules.push(rule);
+            continue;
+        }
+        const existing = rules[existingIndex];
+        const existingHasWindow = Boolean(existing.daily_time_window);
+        const currentHasWindow = Boolean(rule.daily_time_window);
+        if (existingHasWindow === currentHasWindow) {
             throw new Error(`Ambiguous usage pricing rules for unit '${rule.unit}'`);
         }
-        units.add(rule.unit);
+        if (currentHasWindow) rules[existingIndex] = rule;
     }
-    return {
-        capturedAt,
+    return _extends._extends({
+        capturedAt
+    }, context.pricingDimensions ? {
+        pricingDimensions: context.pricingDimensions
+    } : {}, {
         rules
-    };
+    });
 }
 function calculateModelUsageCharge(snapshot, metric) {
-    const rule = snapshot == null ? void 0 : snapshot.rules.find((candidate)=>candidate.unit === metric.unit);
+    const rule = selectUsagePriceRule(snapshot, metric);
     const fallbackQuantity = metricQuantity(metric);
     if (!rule) {
         return {
@@ -2083,8 +2193,40 @@ function matchesUsagePriceRule(rule, context, at) {
     const effectiveTo = normalizeDate(rule.effective_to);
     if (!effectiveFrom || effectiveFrom > at || effectiveTo && effectiveTo <= at) return false;
     if (((_rule_operations = rule.operations) == null ? void 0 : _rule_operations.length) && !rule.operations.includes(context.operation)) return false;
+    if (rule.daily_time_window) {
+        validateRecurringDailyWindow(rule.daily_time_window);
+        if (!isInRecurringDailyWindow(rule.daily_time_window, at)) return false;
+    }
     var _context_pricingDimensions;
     const dimensions = (_context_pricingDimensions = context.pricingDimensions) != null ? _context_pricingDimensions : {};
+    var _rule_dimensions;
+    return Object.entries((_rule_dimensions = rule.dimensions) != null ? _rule_dimensions : {}).every(([key, value])=>{
+        if (key === 'resolution') return dimensions.resolution === undefined || dimensions.resolution === value;
+        if (key === 'audio') return dimensions.audio === undefined || dimensions.audio === value;
+        if (key === 'videoInput') return dimensions.videoInput === undefined || dimensions.videoInput === value;
+        if (key === 'mode') return dimensions.mode === undefined || dimensions.mode === value;
+        return false;
+    });
+}
+function selectUsagePriceRule(snapshot, metric) {
+    var _snapshot_pricingDimensions, _metric_pricingDimensions;
+    const dimensions = _extends._extends({}, (_snapshot_pricingDimensions = snapshot == null ? void 0 : snapshot.pricingDimensions) != null ? _snapshot_pricingDimensions : {}, (_metric_pricingDimensions = metric.pricingDimensions) != null ? _metric_pricingDimensions : {});
+    var _snapshot_rules;
+    const matches = ((_snapshot_rules = snapshot == null ? void 0 : snapshot.rules) != null ? _snapshot_rules : []).filter((rule)=>{
+        if (rule.unit !== metric.unit) return false;
+        if (rule.component && rule.component !== metric.component) return false;
+        return matchesUsagePriceDimensions(rule, dimensions);
+    });
+    if (!matches.length) return undefined;
+    const specificity = Math.max(...matches.map(usagePriceRuleSpecificity));
+    const mostSpecific = matches.filter((rule)=>usagePriceRuleSpecificity(rule) === specificity);
+    if (mostSpecific.length > 1) {
+        var _metric_key;
+        throw new Error(`Ambiguous usage pricing rules for metric '${(_metric_key = metric.key) != null ? _metric_key : metric.unit}'`);
+    }
+    return mostSpecific[0];
+}
+function matchesUsagePriceDimensions(rule, dimensions) {
     var _rule_dimensions;
     return Object.entries((_rule_dimensions = rule.dimensions) != null ? _rule_dimensions : {}).every(([key, value])=>{
         if (key === 'resolution') return dimensions.resolution === value;
@@ -2094,15 +2236,36 @@ function matchesUsagePriceRule(rule, context, at) {
         return false;
     });
 }
+function usagePriceRuleSpecificity(rule) {
+    var _rule_dimensions;
+    return (rule.component ? 1 : 0) + Object.keys((_rule_dimensions = rule.dimensions) != null ? _rule_dimensions : {}).length;
+}
+function usagePriceRuleSelector(rule) {
+    var _rule_token_type, _rule_component, _rule_dimensions;
+    return JSON.stringify([
+        rule.unit,
+        (_rule_token_type = rule.token_type) != null ? _rule_token_type : null,
+        (_rule_component = rule.component) != null ? _rule_component : null,
+        Object.entries((_rule_dimensions = rule.dimensions) != null ? _rule_dimensions : {}).sort(([left], [right])=>left.localeCompare(right))
+    ]);
+}
 function validateUsagePriceRule(rule) {
     var _rule_id, _rule_version;
     if (!((_rule_id = rule.id) == null ? void 0 : _rule_id.trim()) || !((_rule_version = rule.version) == null ? void 0 : _rule_version.trim())) throw new Error('Usage pricing rules require id and version');
+    if (rule.component && ![
+        'input',
+        'output',
+        'request'
+    ].includes(rule.component)) {
+        throw new Error(`Usage pricing rule '${rule.id}' has an invalid component`);
+    }
     if (!Number.isFinite(Number(rule.unit_size)) || Number(rule.unit_size) <= 0) {
         throw new Error(`Usage pricing rule '${rule.id}' requires a positive unit_size`);
     }
     if (rule.unit !== 'token' && rule.token_type) {
         throw new Error(`Usage pricing rule '${rule.id}' can only use token_type with token pricing`);
     }
+    if (rule.daily_time_window) validateRecurringDailyWindow(rule.daily_time_window);
     if (rule.charge_type === 'paid') {
         var _rule_currency;
         if (!Number.isFinite(Number(rule.unit_price)) || Number(rule.unit_price) <= 0 || !((_rule_currency = rule.currency) == null ? void 0 : _rule_currency.trim())) {
@@ -2133,9 +2296,237 @@ function normalizeDate(value) {
 function roundCharge(value) {
     return Number(value.toFixed(10));
 }
+function hasLLMPriceRule(rules, component) {
+    var _rules_some;
+    return (_rules_some = rules == null ? void 0 : rules.some((rule)=>rule.component === component)) != null ? _rules_some : false;
+}
+function selectLLMPriceRule(rules, component, selection, addOn) {
+    const matches = (rules != null ? rules : []).filter((rule)=>{
+        if (rule.component !== component) return false;
+        if (component === 'request' && rule.add_on !== addOn) return false;
+        if (rule.cache_ttl && rule.cache_ttl !== selection.context.cacheWriteTtl) return false;
+        if (rule.mode && rule.mode !== selection.context.mode) return false;
+        if (rule.region && rule.region !== selection.context.region) return false;
+        if (rule.service_tier && rule.service_tier !== selection.context.serviceTier) return false;
+        if (rule.daily_time_window && !isInRecurringDailyWindow(rule.daily_time_window, selection.context.pricingTime)) {
+            return false;
+        }
+        if (rule.min_input_tokens !== undefined && selection.inputTokens < Number(rule.min_input_tokens)) return false;
+        if (rule.max_input_tokens !== undefined && selection.inputTokens > Number(rule.max_input_tokens)) return false;
+        if (rule.min_output_tokens !== undefined && selection.outputTokens < Number(rule.min_output_tokens)) return false;
+        if (rule.max_output_tokens !== undefined && selection.outputTokens > Number(rule.max_output_tokens)) return false;
+        return true;
+    });
+    if (!matches.length) return undefined;
+    const specificity = Math.max(...matches.map(ruleSpecificity));
+    const mostSpecific = matches.filter((rule)=>ruleSpecificity(rule) === specificity);
+    if (mostSpecific.length > 1) {
+        throw new Error(`Ambiguous LLM pricing rules for component '${component}'`);
+    }
+    return mostSpecific[0];
+}
+function ruleSpecificity(rule) {
+    return [
+        rule.min_input_tokens,
+        rule.max_input_tokens,
+        rule.min_output_tokens,
+        rule.max_output_tokens,
+        rule.mode,
+        rule.region,
+        rule.service_tier,
+        rule.add_on,
+        rule.cache_ttl,
+        rule.daily_time_window
+    ].filter((value)=>value !== undefined).length;
+}
+function validateLLMPriceRules(rules) {
+    for (const rule of rules){
+        if (!Number.isFinite(Number(rule.unit_price)) || Number(rule.unit_price) < 0) {
+            throw new Error(`LLM pricing rule '${rule.component}' requires a non-negative unit_price`);
+        }
+        if (!Number.isFinite(Number(rule.unit_size)) || Number(rule.unit_size) <= 0) {
+            throw new Error(`LLM pricing rule '${rule.component}' requires a positive unit_size`);
+        }
+        if (rule.currency !== undefined && !rule.currency.trim()) {
+            throw new Error(`LLM pricing rule '${rule.component}' requires a non-empty currency when provided`);
+        }
+        validateTokenRange(rule, 'input', rule.min_input_tokens, rule.max_input_tokens);
+        validateTokenRange(rule, 'output', rule.min_output_tokens, rule.max_output_tokens);
+        if (rule.component === 'request' && !rule.add_on) {
+            throw new Error('LLM request pricing rules require add_on');
+        }
+        if (rule.component !== 'request' && rule.add_on) {
+            throw new Error(`LLM pricing rule '${rule.component}' cannot declare add_on`);
+        }
+        if (rule.component !== 'cache_write_input' && rule.cache_ttl) {
+            throw new Error(`LLM pricing rule '${rule.component}' cannot declare cache_ttl`);
+        }
+        if (rule.daily_time_window) validateRecurringDailyWindow(rule.daily_time_window);
+    }
+}
+function validateTokenRange(rule, name, min, max) {
+    const normalizedMin = min === undefined ? undefined : Number(min);
+    const normalizedMax = max === undefined ? undefined : Number(max);
+    if (normalizedMin !== undefined) tokenCount(normalizedMin, `min_${name}_tokens`);
+    if (normalizedMax !== undefined) tokenCount(normalizedMax, `max_${name}_tokens`);
+    if (normalizedMin !== undefined && normalizedMax !== undefined && normalizedMin > normalizedMax) {
+        throw new Error(`LLM pricing rule '${rule.component}' has an invalid ${name} token range`);
+    }
+}
+function validateRecurringDailyWindow(window) {
+    validateTimeZone(window.time_zone);
+    const start = parseLocalTime(window.start_time, 'start_time');
+    const end = parseLocalTime(window.end_time, 'end_time');
+    if (start === end) {
+        throw new Error('Recurring daily pricing window start_time and end_time must differ');
+    }
+}
+function validateTimeZone(timeZone) {
+    try {
+        new Intl.DateTimeFormat('en-US', {
+            timeZone
+        }).format();
+    } catch (e) {
+        throw new Error(`Invalid IANA time zone '${timeZone}'`);
+    }
+}
+function parseLocalTime(value, name) {
+    const match = /^(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(value);
+    if (!match) {
+        throw new Error(`Recurring daily pricing window ${name} must use HH:mm or HH:mm:ss`);
+    }
+    const hour = Number(match[1]);
+    const minute = Number(match[2]);
+    var _match_;
+    const second = Number((_match_ = match[3]) != null ? _match_ : 0);
+    if (hour > 23 || minute > 59 || second > 59) {
+        throw new Error(`Recurring daily pricing window ${name} must be a valid wall-clock time`);
+    }
+    return hour * 3600 + minute * 60 + second;
+}
+function isInRecurringDailyWindow(window, pricingTime) {
+    const instant = resolvePricingTime(pricingTime);
+    const formatter = new Intl.DateTimeFormat('en-GB', {
+        timeZone: window.time_zone,
+        hourCycle: 'h23',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit'
+    });
+    const values = Object.fromEntries(formatter.formatToParts(instant).filter((part)=>part.type === 'hour' || part.type === 'minute' || part.type === 'second').map((part)=>[
+            part.type,
+            Number(part.value)
+        ]));
+    const localTime = values['hour'] * 3600 + values['minute'] * 60 + values['second'];
+    const start = parseLocalTime(window.start_time, 'start_time');
+    const end = parseLocalTime(window.end_time, 'end_time');
+    return start < end ? localTime >= start && localTime < end : localTime >= start || localTime < end;
+}
+function resolvePricingTime(value) {
+    const instant = value instanceof Date ? new Date(value.getTime()) : value === undefined ? new Date() : new Date(value);
+    if (!Number.isFinite(instant.getTime())) {
+        throw new Error('pricingTime must be a valid date');
+    }
+    return instant;
+}
+function priceRuleComponent(rule, quantity, fallbackCurrency, qualifiers = {}) {
+    const unitPrice = Number(rule.unit_price);
+    const unit = 1 / Number(rule.unit_size);
+    const amount = roundCharge(quantity * unitPrice * unit);
+    var _rule_currency;
+    return _extends._extends({
+        component: rule.component,
+        quantity,
+        pricingStatus: unitPrice === 0 ? 'free' : 'priced',
+        unitPrice,
+        unit,
+        amount,
+        currency: normalizeCurrency((_rule_currency = rule.currency) != null ? _rule_currency : fallbackCurrency)
+    }, qualifiers, {
+        rule
+    });
+}
+function legacyPriceComponent(pricing, priceType, quantity, inputTokens) {
+    const price = calculateModelPrice(pricing, priceType, quantity, inputTokens);
+    return {
+        component: priceType,
+        quantity,
+        pricingStatus: price.unitPrice === 0 ? 'free' : 'priced',
+        unitPrice: price.unitPrice,
+        unit: price.unit,
+        amount: price.totalAmount,
+        currency: normalizeCurrency(price.currency)
+    };
+}
+function unpricedComponent(component, quantity, qualifiers = {}) {
+    return _extends._extends({
+        component,
+        quantity,
+        pricingStatus: 'unpriced'
+    }, qualifiers);
+}
+function tokenCount(value, name) {
+    if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${name} must be a finite non-negative integer`);
+    }
+    return value;
+}
+function nonNegativeQuantity(value, name) {
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${name} must be a non-negative number`);
+    }
+    return value;
+}
+function resolveCacheWriteInputTokens(total, context) {
+    if (!context.cacheWriteInputTokensByTtl) {
+        return total > 0 ? [
+            {
+                quantity: total,
+                cacheTtl: context.cacheWriteTtl
+            }
+        ] : [];
+    }
+    const cacheWrites = [
+        '5m',
+        '1h'
+    ].map((cacheTtl)=>{
+        var _context_cacheWriteInputTokensByTtl;
+        var _context_cacheWriteInputTokensByTtl_cacheTtl;
+        return {
+            cacheTtl,
+            quantity: tokenCount((_context_cacheWriteInputTokensByTtl_cacheTtl = (_context_cacheWriteInputTokensByTtl = context.cacheWriteInputTokensByTtl) == null ? void 0 : _context_cacheWriteInputTokensByTtl[cacheTtl]) != null ? _context_cacheWriteInputTokensByTtl_cacheTtl : 0, `cacheWriteInputTokensByTtl.${cacheTtl}`)
+        };
+    }).filter(({ quantity })=>quantity > 0);
+    const detailedTotal = cacheWrites.reduce((sum, item)=>sum + item.quantity, 0);
+    if (detailedTotal !== total) {
+        throw new Error('Cache write token counts by TTL must equal cacheWriteInputTokens');
+    }
+    return cacheWrites;
+}
+function summarizeLLMPrice(currency, breakdown) {
+    const hasUnpricedComponent = breakdown.some((item)=>item.pricingStatus === 'unpriced');
+    const hasPaidComponent = breakdown.some((item)=>item.pricingStatus === 'priced');
+    const currencies = new Set(breakdown.map((item)=>item.currency).filter((value)=>Boolean(value)).map(normalizeCurrency));
+    if (currencies.size > 1) {
+        throw new Error('LLM pricing calculation cannot mix currencies');
+    }
+    var _currencies_values_next_value;
+    return {
+        pricingStatus: hasUnpricedComponent ? 'unpriced' : hasPaidComponent ? 'priced' : 'free',
+        totalAmount: Number(breakdown.reduce((total, item)=>{
+            var _item_amount;
+            return total + ((_item_amount = item.amount) != null ? _item_amount : 0);
+        }, 0).toFixed(7)),
+        currency: (_currencies_values_next_value = currencies.values().next().value) != null ? _currencies_values_next_value : normalizeCurrency(currency),
+        breakdown
+    };
+}
+function normalizeCurrency(currency) {
+    return currency.trim().toUpperCase();
+}
 
 var AIModel_1;
-let AIModel = AIModel_1 = class AIModel {
+exports.AIModel = AIModel_1 = class AIModel {
     getChatModel(copilotModel, options) {
         throw new Error(`Unsupport chat model!`);
     }
@@ -2270,13 +2661,21 @@ let AIModel = AIModel_1 = class AIModel {
         ];
     }
     getModelProfile(model, credentials) {
-        var _modelSchema_model_properties, _modelSchema_features, _modelSchema_features1, _modelSchema_features2, _modelSchema_features3;
+        var _modelSchema_model_properties, _modelSchema_features, _modelSchema_features1, _modelSchema_features2, _modelSchema_features3, _modelSchema_features4, _modelSchema_features5, _modelSchema_parameter_rules;
         const modelSchema = this.getModelSchema(model, credentials);
-        return modelSchema && {
+        if (!modelSchema) return null;
+        const profile = {
             maxInputTokens: (_modelSchema_model_properties = modelSchema.model_properties) == null ? void 0 : _modelSchema_model_properties.context_size,
-            toolCalling: ((_modelSchema_features = modelSchema.features) == null ? void 0 : _modelSchema_features.includes(contracts.ModelFeature.TOOL_CALL)) || ((_modelSchema_features1 = modelSchema.features) == null ? void 0 : _modelSchema_features1.includes(contracts.ModelFeature.MULTI_TOOL_CALL)) || ((_modelSchema_features2 = modelSchema.features) == null ? void 0 : _modelSchema_features2.includes(contracts.ModelFeature.STREAM_TOOL_CALL)),
-            structuredOutput: (_modelSchema_features3 = modelSchema.features) == null ? void 0 : _modelSchema_features3.includes(contracts.ModelFeature.STRUCTURED_OUTPUT)
+            imageInputs: (_modelSchema_features = modelSchema.features) == null ? void 0 : _modelSchema_features.includes(contracts.ModelFeature.VISION),
+            videoInputs: (_modelSchema_features1 = modelSchema.features) == null ? void 0 : _modelSchema_features1.includes(contracts.ModelFeature.VIDEO),
+            toolCalling: ((_modelSchema_features2 = modelSchema.features) == null ? void 0 : _modelSchema_features2.includes(contracts.ModelFeature.TOOL_CALL)) || ((_modelSchema_features3 = modelSchema.features) == null ? void 0 : _modelSchema_features3.includes(contracts.ModelFeature.MULTI_TOOL_CALL)) || ((_modelSchema_features4 = modelSchema.features) == null ? void 0 : _modelSchema_features4.includes(contracts.ModelFeature.STREAM_TOOL_CALL)),
+            structuredOutput: (_modelSchema_features5 = modelSchema.features) == null ? void 0 : _modelSchema_features5.includes(contracts.ModelFeature.STRUCTURED_OUTPUT)
         };
+        const maxTokensRule = (_modelSchema_parameter_rules = modelSchema.parameter_rules) == null ? void 0 : _modelSchema_parameter_rules.find((rule)=>rule.name === 'max_tokens');
+        if (maxTokensRule) {
+            profile.maxOutputTokens = maxTokensRule.max;
+        }
+        return profile;
     }
     constructor(modelProvider, modelType){
         this.logger = new common.Logger(AIModel_1.name);
@@ -2287,13 +2686,13 @@ let AIModel = AIModel_1 = class AIModel {
         this.modelProvider.registerAIModelInstance(this.modelType, this);
     }
 };
-AIModel = AIModel_1 = __decorate([
+exports.AIModel = AIModel_1 = __decorate([
     common.Injectable(),
     __metadata("design:paramtypes", [
         exports.ModelProvider,
         String
     ])
-], AIModel);
+], exports.AIModel);
 function getDefaultParameterRuleVariableMap(name) {
     /**
      * Get default parameter rule for given name
@@ -2307,19 +2706,19 @@ function getDefaultParameterRuleVariableMap(name) {
     return defaultParameterRule;
 }
 
-class TextEmbeddingModelManager extends AIModel {
+class TextEmbeddingModelManager extends exports.AIModel {
 }
 
-class RerankModel extends AIModel {
+class RerankModel extends exports.AIModel {
     async validateCredentials(model, credentials) {
     //
     }
 }
 
-class SpeechToTextModel extends AIModel {
+class SpeechToTextModel extends exports.AIModel {
 }
 
-class TextToSpeechModel extends AIModel {
+class TextToSpeechModel extends exports.AIModel {
     getParameterRules(model, credentials) {
         var _this__commonParameterRules;
         const rules = (_this__commonParameterRules = this._commonParameterRules(model)) != null ? _this__commonParameterRules : [];
@@ -2347,9 +2746,9 @@ class TextToSpeechModel extends AIModel {
     }
 }
 
-class ImageGenerationModel extends AIModel {
+class ImageGenerationModel extends exports.AIModel {
 }
-class VideoGenerationModel extends AIModel {
+class VideoGenerationModel extends exports.AIModel {
 }
 
 const PROVIDE_AI_MODEL_LLM = 'provide_ai_model_llm';
@@ -2412,11 +2811,59 @@ class LLMUsage {
     }
 }
 var _logger = /*#__PURE__*/ _class_private_field_loose_key("_logger");
-class LargeLanguageModel extends AIModel {
+class LargeLanguageModel extends exports.AIModel {
     _commonParameterRules(model) {
         return CommonParameterRules;
     }
-    calcResponseUsage(model, credentials, promptTokens, completionTokens, startedAt = this.startedAt) {
+    calcResponseUsage(model, credentials, promptTokens, completionTokens, startedAt = this.startedAt, tokenUsage, pricingContext = {}) {
+        var _this_getModelSchema;
+        const resolvedTokenUsage = tokenUsage != null ? tokenUsage : {
+            promptTokens,
+            completionTokens,
+            totalTokens: promptTokens + completionTokens
+        };
+        const pricing = (_this_getModelSchema = this.getModelSchema(model, credentials)) == null ? void 0 : _this_getModelSchema.pricing;
+        if (pricing && !isModelUsagePricingConfig(pricing)) {
+            const calculation = calculateLLMUsagePrice(pricing, resolvedTokenUsage, pricingContext);
+            const promptBreakdown = calculation.breakdown.filter((item)=>[
+                    'input',
+                    'cache_read_input',
+                    'cache_write_input'
+                ].includes(item.component));
+            const completionBreakdown = calculation.breakdown.filter((item)=>item.component === 'output');
+            var _promptBreakdown_find;
+            const promptRate = (_promptBreakdown_find = promptBreakdown.find((item)=>item.component === 'input')) != null ? _promptBreakdown_find : promptBreakdown[0];
+            const completionRate = completionBreakdown[0];
+            var _promptRate_unitPrice, _promptRate_unit, _completionRate_unitPrice, _completionRate_unit;
+            return _extends._extends({
+                promptTokens,
+                promptUnitPrice: (_promptRate_unitPrice = promptRate == null ? void 0 : promptRate.unitPrice) != null ? _promptRate_unitPrice : 0,
+                promptPriceUnit: (_promptRate_unit = promptRate == null ? void 0 : promptRate.unit) != null ? _promptRate_unit : 0,
+                promptPrice: Number(promptBreakdown.reduce((total, item)=>{
+                    var _item_amount;
+                    return total + ((_item_amount = item.amount) != null ? _item_amount : 0);
+                }, 0).toFixed(7)),
+                completionTokens,
+                completionUnitPrice: (_completionRate_unitPrice = completionRate == null ? void 0 : completionRate.unitPrice) != null ? _completionRate_unitPrice : 0,
+                completionPriceUnit: (_completionRate_unit = completionRate == null ? void 0 : completionRate.unit) != null ? _completionRate_unit : 0,
+                completionPrice: Number(completionBreakdown.reduce((total, item)=>{
+                    var _item_amount;
+                    return total + ((_item_amount = item.amount) != null ? _item_amount : 0);
+                }, 0).toFixed(7)),
+                totalTokens: resolvedTokenUsage.totalTokens,
+                totalPrice: calculation.totalAmount,
+                currency: calculation.currency,
+                latency: performance.now() - startedAt
+            }, resolvedTokenUsage.cacheReadInputTokens ? {
+                cacheReadInputTokens: resolvedTokenUsage.cacheReadInputTokens
+            } : {}, resolvedTokenUsage.cacheWriteInputTokens ? {
+                cacheWriteInputTokens: resolvedTokenUsage.cacheWriteInputTokens
+            } : {}, {
+                pricingStatus: calculation.pricingStatus,
+                priceAuthority: 'catalog',
+                pricingBreakdown: calculation.breakdown
+            });
+        }
         const promptPriceInfo = this.getPrice(model, credentials, contracts.PriceType.INPUT, promptTokens, promptTokens);
         const completionPriceInfo = this.getPrice(model, credentials, contracts.PriceType.OUTPUT, completionTokens, promptTokens);
         const totalPrice = Number((promptPriceInfo.totalAmount + completionPriceInfo.totalAmount).toFixed(7));
@@ -2433,32 +2880,50 @@ class LargeLanguageModel extends AIModel {
             totalTokens: promptTokens + completionTokens,
             totalPrice,
             currency: promptPriceInfo.currency,
-            latency: performance.now() - startedAt
+            latency: performance.now() - startedAt,
+            pricingStatus: totalPrice === 0 ? 'free' : 'priced',
+            priceAuthority: 'catalog'
         };
         return usage;
     }
-    createHandleUsageCallbacks(copilot, model, credentials, handleLLMTokens) {
+    createHandleUsageCallbacks(copilot, model, credentials, handleLLMTokens, pricingConfiguration = {}) {
+        const pricingOptions = normalizeUsagePricingOptions(pricingConfiguration);
+        var _pricingOptions_context;
+        const basePricingContext = (_pricingOptions_context = pricingOptions.context) != null ? _pricingOptions_context : {};
         const runs = new Map();
-        const reportUsage = async (requestId, tokenUsage, startedAt, type)=>{
-            if (!handleLLMTokens || tokenUsage.totalTokens <= 0) {
+        const reportUsage = async (requestId, tokenUsage, startedAt, pricingTime, type, output)=>{
+            const pricingContext = _extends._extends({}, basePricingContext, output && pricingOptions.resolveContext ? pricingOptions.resolveContext(output) : {}, {
+                pricingTime
+            });
+            const normalizedTokenUsage = normalizeCacheTokenAccounting(tokenUsage, pricingContext);
+            if (!handleLLMTokens || normalizedTokenUsage.totalTokens <= 0) {
                 return;
             }
-            const usage = _extends._extends({}, this.calcResponseUsage(model, credentials, tokenUsage.promptTokens, tokenUsage.completionTokens, startedAt), type ? {
+            let usage = _extends._extends({}, this.calcResponseUsage(model, credentials, normalizedTokenUsage.promptTokens, normalizedTokenUsage.completionTokens, startedAt, normalizedTokenUsage, _extends._extends({}, pricingContext, {
+                inputTokensIncludeCache: true
+            })), type ? {
                 type
             } : {});
-            usage.totalTokens = tokenUsage.totalTokens;
+            const reportedPrice = output ? pricingOptions.resolveReportedPrice == null ? void 0 : pricingOptions.resolveReportedPrice.call(pricingOptions, output) : undefined;
+            if (reportedPrice) {
+                usage = applyProviderReportedPrice(usage, reportedPrice);
+            } else if (pricingOptions.reportedPriceRequired) {
+                usage = markUsagePriceUnpriced(usage, 'provider');
+            }
+            usage.totalTokens = normalizedTokenUsage.totalTokens;
             await handleLLMTokens({
                 copilot,
                 model,
                 requestId,
                 usage,
-                tokenUsed: tokenUsage.totalTokens
+                tokenUsed: normalizedTokenUsage.totalTokens
             });
         };
         const callback = base.BaseCallbackHandler.fromMethods({
             handleLLMStart: (_llm, prompts, runId)=>{
                 runs.set(runId, {
                     startedAt: performance.now(),
+                    pricingTime: new Date(),
                     prompts,
                     completion: ''
                 });
@@ -2474,11 +2939,11 @@ class LargeLanguageModel extends AIModel {
                 runs.delete(runId);
                 const resolved = resolveTokenUsageWithAuthority(output);
                 if (resolved.usage.totalTokens > 0) {
-                    var _run_startedAt;
-                    await reportUsage(runId, resolved.usage, (_run_startedAt = run == null ? void 0 : run.startedAt) != null ? _run_startedAt : performance.now(), resolved.type);
+                    var _run_startedAt, _run_pricingTime;
+                    await reportUsage(runId, resolved.usage, (_run_startedAt = run == null ? void 0 : run.startedAt) != null ? _run_startedAt : performance.now(), (_run_pricingTime = run == null ? void 0 : run.pricingTime) != null ? _run_pricingTime : new Date(), resolved.type, output);
                 } else {
-                    var _run_startedAt1;
-                    await reportUsage(runId, estimateFallbackUsage(run == null ? void 0 : run.prompts, (run == null ? void 0 : run.completion) || readCompletionText(output)), (_run_startedAt1 = run == null ? void 0 : run.startedAt) != null ? _run_startedAt1 : performance.now(), 'estimated');
+                    var _run_startedAt1, _run_pricingTime1;
+                    await reportUsage(runId, estimateFallbackUsage(run == null ? void 0 : run.prompts, (run == null ? void 0 : run.completion) || readCompletionText(output)), (_run_startedAt1 = run == null ? void 0 : run.startedAt) != null ? _run_startedAt1 : performance.now(), (_run_pricingTime1 = run == null ? void 0 : run.pricingTime) != null ? _run_pricingTime1 : new Date(), 'estimated', output);
                 }
             },
             handleLLMError: async (error, runId)=>{
@@ -2487,8 +2952,8 @@ class LargeLanguageModel extends AIModel {
                 if (!(run == null ? void 0 : run.completion) && !isAbortError(error)) {
                     return;
                 }
-                var _run_startedAt;
-                await reportUsage(runId, estimateFallbackUsage(run == null ? void 0 : run.prompts, run == null ? void 0 : run.completion), (_run_startedAt = run == null ? void 0 : run.startedAt) != null ? _run_startedAt : performance.now(), 'estimated');
+                var _run_startedAt, _run_pricingTime;
+                await reportUsage(runId, estimateFallbackUsage(run == null ? void 0 : run.prompts, run == null ? void 0 : run.completion), (_run_startedAt = run == null ? void 0 : run.startedAt) != null ? _run_startedAt : performance.now(), (_run_pricingTime = run == null ? void 0 : run.pricingTime) != null ? _run_pricingTime : new Date(), 'estimated');
             }
         });
         callback.awaitHandlers = true;
@@ -2631,6 +3096,37 @@ class LargeLanguageModel extends AIModel {
     }
 }
 _a = LargeLanguageModel;
+function normalizeUsagePricingOptions(configuration) {
+    if ('context' in configuration || 'resolveContext' in configuration || 'resolveReportedPrice' in configuration || 'reportedPriceRequired' in configuration) {
+        return configuration;
+    }
+    return {
+        context: configuration
+    };
+}
+function applyProviderReportedPrice(usage, reportedPrice) {
+    var _reportedPrice_currency;
+    const amount = Number(reportedPrice.amount);
+    const currency = (_reportedPrice_currency = reportedPrice.currency) == null ? void 0 : _reportedPrice_currency.trim();
+    if (!Number.isFinite(amount) || amount < 0 || !currency) {
+        throw new Error('Provider-reported price requires a non-negative amount and currency');
+    }
+    return _extends._extends({}, usage, {
+        totalPrice: amount,
+        currency: currency.toUpperCase(),
+        pricingStatus: amount === 0 ? 'free' : 'priced',
+        priceAuthority: 'provider',
+        pricingBreakdown: undefined
+    });
+}
+function markUsagePriceUnpriced(usage, priceAuthority) {
+    return _extends._extends({}, usage, {
+        totalPrice: 0,
+        pricingStatus: 'unpriced',
+        priceAuthority,
+        pricingBreakdown: undefined
+    });
+}
 function estimateFallbackUsage(prompts, completion) {
     if (!prompts) {
         return {
@@ -2687,16 +3183,25 @@ function calcTokenUsage(output) {
         completionTokens: 0,
         totalTokens: 0
     };
+    let cacheReadInputTokens = 0;
+    let cacheWriteInputTokens = 0;
     (_output_generations = output.generations) == null ? void 0 : _output_generations.forEach((generation)=>{
         generation.forEach((item)=>{
             const message = item.message;
             if (message.usage_metadata) {
+                var _message_usage_metadata_input_token_details, _message_usage_metadata_input_token_details1;
                 tokenUsage.promptTokens += message.usage_metadata.input_tokens;
                 tokenUsage.completionTokens += message.usage_metadata.output_tokens;
                 tokenUsage.totalTokens += message.usage_metadata.total_tokens;
+                var _message_usage_metadata_input_token_details_cache_read;
+                cacheReadInputTokens += (_message_usage_metadata_input_token_details_cache_read = (_message_usage_metadata_input_token_details = message.usage_metadata.input_token_details) == null ? void 0 : _message_usage_metadata_input_token_details.cache_read) != null ? _message_usage_metadata_input_token_details_cache_read : 0;
+                var _message_usage_metadata_input_token_details_cache_creation;
+                cacheWriteInputTokens += (_message_usage_metadata_input_token_details_cache_creation = (_message_usage_metadata_input_token_details1 = message.usage_metadata.input_token_details) == null ? void 0 : _message_usage_metadata_input_token_details1.cache_creation) != null ? _message_usage_metadata_input_token_details_cache_creation : 0;
             }
         });
     });
+    if (cacheReadInputTokens > 0) tokenUsage.cacheReadInputTokens = cacheReadInputTokens;
+    if (cacheWriteInputTokens > 0) tokenUsage.cacheWriteInputTokens = cacheWriteInputTokens;
     return tokenUsage;
 }
 function resolveTokenUsage(output) {
@@ -2743,15 +3248,36 @@ function normalizeTokenUsage(candidate) {
     if (promptTokens === 0 && completionTokens === 0 && totalTokens === 0) {
         return null;
     }
-    return {
+    var _candidate_cacheReadInputTokens;
+    const cacheReadInputTokens = (_candidate_cacheReadInputTokens = candidate.cacheReadInputTokens) != null ? _candidate_cacheReadInputTokens : 0;
+    var _candidate_cacheWriteInputTokens;
+    const cacheWriteInputTokens = (_candidate_cacheWriteInputTokens = candidate.cacheWriteInputTokens) != null ? _candidate_cacheWriteInputTokens : 0;
+    if (!isValidTokenCount(cacheReadInputTokens) || !isValidTokenCount(cacheWriteInputTokens)) {
+        return null;
+    }
+    return _extends._extends({
         promptTokens,
         completionTokens,
         totalTokens
-    };
+    }, cacheReadInputTokens > 0 ? {
+        cacheReadInputTokens
+    } : {}, cacheWriteInputTokens > 0 ? {
+        cacheWriteInputTokens
+    } : {});
 }
 function isValidTokenCount(value) {
     return value === undefined || Number.isFinite(value) && value >= 0;
 }
+function normalizeCacheTokenAccounting(tokenUsage, context) {
+    if (context.inputTokensIncludeCache !== false) return tokenUsage;
+    var _tokenUsage_cacheReadInputTokens, _tokenUsage_cacheWriteInputTokens;
+    const cacheTokens = ((_tokenUsage_cacheReadInputTokens = tokenUsage.cacheReadInputTokens) != null ? _tokenUsage_cacheReadInputTokens : 0) + ((_tokenUsage_cacheWriteInputTokens = tokenUsage.cacheWriteInputTokens) != null ? _tokenUsage_cacheWriteInputTokens : 0);
+    if (!cacheTokens) return tokenUsage;
+    return _extends._extends({}, tokenUsage, {
+        promptTokens: tokenUsage.promptTokens + cacheTokens,
+        totalTokens: tokenUsage.totalTokens + cacheTokens
+    });
+}
 /**
  * @deprecated use calcTokenUsage
  */ function sumTokenUsage(output) {
@@ -2776,6 +3302,19 @@ function isValidTokenCount(value) {
     let payload = job.data;
     if (payload.phase === 'succeeded' && payload.result !== undefined) return payload.result;
     if (payload.phase === 'failed') throw new Error(payload.errorCode || 'Provider generation task failed');
+    if (!payload.modelAccess && options.provider.resolveModelAccess) {
+        const modelAccess = await options.provider.resolveModelAccess({
+            requestId: payload.requestId,
+            model: payload.model,
+            operation: payload.operation,
+            modality: payload.modality,
+            pricingDimensions: payload.pricingDimensions,
+            startedAt: payload.startedAt
+        });
+        payload = await checkpoint(job, _extends._extends({}, payload, {
+            modelAccess
+        }));
+    }
     if (!payload.pricingSnapshot) {
         const pricingSnapshot = options.provider.resolvePricingSnapshot ? await options.provider.resolvePricingSnapshot({
             model: payload.model,
@@ -2850,7 +3389,7 @@ async function reportTerminalUsage(job, payload, metrics, provider) {
         pricingSnapshot: payload.pricingSnapshot,
         metrics,
         recordedAt: new Date().toISOString()
-    });
+    }, payload.modelAccess);
     return checkpoint(job, _extends._extends({}, payload, {
         usageReported: true
     }));
@@ -5228,6 +5767,7 @@ exports.BaseToolset = modelProvider.BaseToolset;
 exports.BuiltinToolset = modelProvider.BuiltinToolset;
 exports.DefaultAgentMiddlewareRuntimeCapabilityRegistry = modelProvider.DefaultRuntimeCapabilityRegistry;
 exports.DefaultRuntimeCapabilityRegistry = modelProvider.DefaultRuntimeCapabilityRegistry;
+exports.KnowledgeDocumentVisualAssetsRuntimeCapability = modelProvider.KnowledgeDocumentVisualAssetsRuntimeCapability;
 exports.KnowledgebaseDocumentsRuntimeCapability = modelProvider.KnowledgebaseDocumentsRuntimeCapability;
 exports.KnowledgebaseProvisioningRuntimeCapability = modelProvider.KnowledgebaseProvisioningRuntimeCapability;
 exports.KnowledgebaseRuntimeCapability = modelProvider.KnowledgebaseRuntimeCapability;
@@ -5402,6 +5942,7 @@ exports.als = als;
 exports.appendSandboxMessage = appendSandboxMessage;
 exports.buildSandboxTimeoutMessage = buildSandboxTimeoutMessage;
 exports.calcTokenUsage = calcTokenUsage;
+exports.calculateLLMUsagePrice = calculateLLMUsagePrice;
 exports.calculateModelPrice = calculateModelPrice;
 exports.calculateModelUsageCharge = calculateModelUsageCharge;
 exports.chunkText = chunkText;