@xpert-ai/plugin-sdk 3.16.0 → 3.17.0

package/index.cjs.js

@@ -3,7 +3,7 @@
 var common = require('@nestjs/common');
 var constants = require('@nestjs/common/constants');
 var lodashEs = require('lodash-es');
-var collaborationClient = require('./collaboration-client.cjs2.js');
+var _extends = require('./_extends.cjs.js');
 var core = require('@nestjs/core');
 var rxjs = require('rxjs');
 var contracts = require('@xpert-ai/contracts');
@@ -15,8 +15,7 @@ var cqrs = require('@nestjs/cqrs');
 var fs = require('fs');
 var http = require('http');
 var https = require('https');
-var tools = require('@langchain/core/tools');
-var zod = require('zod');
+var modelProvider = require('./model-provider.cjs.js');
 var fsPromises = require('fs/promises');
 var path = require('path');
 var i18next = require('i18next');
@@ -25,14 +24,20 @@ var yaml = require('yaml');
 var Ajv = require('ajv');
 var schemaDraft04 = require('ajv/dist/refs/json-schema-draft-06.json');
 var _axios = require('axios');
+var base = require('@langchain/core/callbacks/base');
+var outputs = require('@langchain/core/outputs');
+var messages = require('@langchain/core/messages');
 var openai = require('@langchain/openai');
 var documents = require('@langchain/core/documents');
 var chat_models = require('@langchain/core/language_models/chat_models');
-var messages = require('@langchain/core/messages');
 var env = require('@langchain/core/utils/env');
+var modelProviderHttpClient = require('./model-provider-http-client.cjs.js');
 require('js-tiktoken');
-var base = require('@langchain/core/language_models/base');
+var base$1 = require('@langchain/core/language_models/base');
 var connector = require('./connector.cjs.js');
+var collaborationClient = require('./collaboration-client.cjs.js');
+require('@langchain/core/tools');
+require('zod');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -158,12 +163,12 @@ function createPluginLogger(scope, baseMeta = {}) {
     const wrap = (level, msg, meta)=>{
         var // Maintain alignment with the Nest Logger interface
         _nestLogger_level;
-        const payload = meta ? collaborationClient._extends({}, baseMeta, meta) : baseMeta;
+        const payload = meta ? _extends._extends({}, baseMeta, meta) : baseMeta;
         (_nestLogger_level = nestLogger[level]) == null ? void 0 : _nestLogger_level.call(nestLogger, msg + (Object.keys(payload).length ? ` ${JSON.stringify(payload)}` : ''));
     };
     return {
         child (meta) {
-            return createPluginLogger(scope, collaborationClient._extends({}, baseMeta, meta));
+            return createPluginLogger(scope, _extends._extends({}, baseMeta, meta));
         },
         debug: (msg, meta)=>wrap('debug', msg, meta),
         log: (msg, meta)=>wrap('log', msg, meta),
@@ -962,123 +967,6 @@ exports.ToolsetRegistry = __decorate([
     ])
 ], exports.ToolsetRegistry);
 
-/**
- * Base ability for all toolsets
- */ class BaseToolset extends tools.BaseToolkit {
-    /**
-     * Async init tools
-     *
-     * @returns
-     */ async initTools() {
-        return this.tools;
-    }
-    /**
-     * Get one tool
-     *
-     * @param toolName
-     * @returns
-     */ getTool(toolName) {
-        var _this_getTools;
-        return (_this_getTools = this.getTools()) == null ? void 0 : _this_getTools.find((tool)=>tool.name === toolName);
-    }
-    /**
-     * Get state variables config
-     *
-     * @returns State variables
-     */ async getVariables() {
-        return null;
-    }
-    /**
-     * Close all (connections).
-     */ async close() {
-    //
-    }
-    constructor(params){
-        super();
-        this.params = params;
-    }
-}
-class BaseTool extends tools.StructuredTool {
-    constructor(...args){
-        super(...args);
-        this.schema = zod.z.object({
-            input: zod.z.string().optional()
-        }).transform((obj)=>obj.input);
-    }
-}
-
-class BuiltinToolset extends BaseToolset {
-    get tenantId() {
-        var _this_params;
-        return (_this_params = this.params) == null ? void 0 : _this_params.tenantId;
-    }
-    get organizationId() {
-        var _this_params;
-        return (_this_params = this.params) == null ? void 0 : _this_params.organizationId;
-    }
-    get commandBus() {
-        var _this_params;
-        return (_this_params = this.params) == null ? void 0 : _this_params.commandBus;
-    }
-    get queryBus() {
-        var _this_params;
-        return (_this_params = this.params) == null ? void 0 : _this_params.queryBus;
-    }
-    get xpertId() {
-        var _this_params;
-        return (_this_params = this.params) == null ? void 0 : _this_params.xpertId;
-    }
-    async validateCredentials(credentials) {
-        await this._validateCredentials(credentials);
-    }
-    async _validateCredentials(credentials) {
-        throw new Error('Method not implemented.');
-    }
-    getId() {
-        var _this_toolset;
-        return (_this_toolset = this.toolset) == null ? void 0 : _this_toolset.id;
-    }
-    getCredentials() {
-        var _this_toolset;
-        return (_this_toolset = this.toolset) == null ? void 0 : _this_toolset.credentials;
-    }
-    getToolTitle(name) {
-        var _this_toolset_tools, _this_toolset, _tool_schema;
-        const tool = (_this_toolset = this.toolset) == null ? void 0 : (_this_toolset_tools = _this_toolset.tools) == null ? void 0 : _this_toolset_tools.find((tool)=>tool.name === name);
-        const identity = tool == null ? void 0 : (_tool_schema = tool.schema) == null ? void 0 : _tool_schema.identity;
-        if (identity) {
-            return identity.label;
-        }
-        return null;
-    }
-    /**
-     * Get credentials schema
-     *
-     * @returns Credentials schema
-     */ getCredentialsSchema() {
-        return collaborationClient._extends({}, this.credentialsSchema);
-    }
-    /**
-     * Get toolset entity
-     *
-     * @returns XpertToolset
-     */ getToolset() {
-        return this.toolset;
-    }
-    getName() {
-        var _this_getToolset;
-        return (_this_getToolset = this.getToolset()) == null ? void 0 : _this_getToolset.name;
-    }
-    constructor(providerName, toolset, params){
-        super(params);
-        this.logger = new common.Logger(this.constructor.name);
-        this.providerName = providerName;
-        this.toolset = toolset;
-        this.params = params;
-    }
-} 
-BuiltinToolset.provider = '';
-
 /**
  * Restricted FileSystem based on granted permissions
  */ class XpFileSystem {
@@ -1373,7 +1261,7 @@ class JsonSchemaValidator {
 const PLUGIN_WEBHOOK_AUTH_METADATA_KEY = 'xpert:plugin:webhook-auth';
 const PLUGIN_WEBHOOK_AUTH_SERVICE_TOKEN = 'XPERT_PLUGIN_WEBHOOK_AUTH_SERVICE';
 function PluginWebhookAuth(metadata = {}) {
-    return common.SetMetadata(PLUGIN_WEBHOOK_AUTH_METADATA_KEY, collaborationClient._extends({
+    return common.SetMetadata(PLUGIN_WEBHOOK_AUTH_METADATA_KEY, _extends._extends({
         integrationParam: 'id',
         secretQueryParam: 'secret'
     }, metadata));
@@ -1407,7 +1295,7 @@ exports.PluginWebhookAuthGuard = class PluginWebhookAuthGuard {
         }
         request.user = principalContext.user;
         var _request_headers;
-        request.headers = collaborationClient._extends({}, (_request_headers = request.headers) != null ? _request_headers : {}, principalContext.headers);
+        request.headers = _extends._extends({}, (_request_headers = request.headers) != null ? _request_headers : {}, principalContext.headers);
         return true;
     }
     resolveMetadata(context) {
@@ -1433,40 +1321,6 @@ exports.PluginWebhookAuthGuard = __decorate([
     ])
 ], exports.PluginWebhookAuthGuard);
 
-function createRuntimeCapability(id, options = {}) {
-    return Object.freeze({
-        id,
-        description: options.description
-    });
-}
-const XPERT_RUNTIME_CAPABILITIES_TOKEN = 'XPERT_RUNTIME_CAPABILITIES';
-class DefaultRuntimeCapabilityRegistry {
-    register(key, implementation) {
-        this.capabilities.set(runtimeCapabilityId(key), implementation);
-        return this;
-    }
-    has(key) {
-        return this.capabilities.has(runtimeCapabilityId(key));
-    }
-    get(key) {
-        return this.capabilities.get(runtimeCapabilityId(key));
-    }
-    require(key) {
-        const implementation = this.get(key);
-        if (!implementation) {
-            throw new Error(`Runtime capability '${runtimeCapabilityId(key)}' is not available`);
-        }
-        return implementation;
-    }
-    constructor(entries = []){
-        this.capabilities = new Map();
-        entries.forEach(([key, implementation])=>this.register(key, implementation));
-    }
-}
-function runtimeCapabilityId(key) {
-    return typeof key === 'string' ? key : key.id;
-}
-
 const DATASOURCE_STRATEGY = 'DATASOURCE_STRATEGY';
 const DataSourceStrategy = (provider)=>common.applyDecorators(common.SetMetadata(DATASOURCE_STRATEGY, provider), common.SetMetadata(STRATEGY_META_KEY, DATASOURCE_STRATEGY));
 
@@ -1852,10 +1706,15 @@ exports.ModelProvider = ModelProvider_1 = class ModelProvider {
     }
     async getModels(modelType) {
         const providerSchema = this.getProviderSchema();
-        if (!providerSchema.supported_model_types.includes(modelType)) {
+        const supported = providerSchema.supported_model_types.includes(modelType) || modelType === contracts.AiModelTypeEnum.IMAGE && providerSchema.supported_model_types.includes(contracts.AiModelTypeEnum.TEXT2IMG);
+        if (!supported) {
             return [];
         }
-        const modelInstance = this.getModelManager(modelType);
+        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) {
@@ -1887,7 +1746,8 @@ exports.ModelProvider = ModelProvider_1 = class ModelProvider {
     getSystemProviderModels(modelTypes) {
         const models = [];
         modelTypes == null ? void 0 : modelTypes.forEach((modelType)=>{
-            const modelManager = this.modelManagers.get(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());
             }
@@ -1921,6 +1781,14 @@ exports.ModelProvider = ModelProvider_1 = class ModelProvider {
             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;
     }
@@ -2122,7 +1990,7 @@ const CommonParameterRules = [
     }
 ];
 function mergeCredentials(credentials, modelProperties) {
-    return collaborationClient._extends({}, credentials != null ? credentials : {}, modelProperties != null ? modelProperties : {});
+    return _extends._extends({}, credentials != null ? credentials : {}, modelProperties != null ? modelProperties : {});
 }
 
 function calculateModelPrice(pricing, priceType, tokens, inputTokens = tokens) {
@@ -2146,15 +2014,137 @@ function calculateModelPrice(pricing, priceType, tokens, inputTokens = tokens) {
         currency: pricing.currency
     };
 }
+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,
+            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){
+        validateUsagePriceRule(rule);
+        if (units.has(rule.unit)) {
+            throw new Error(`Ambiguous usage pricing rules for unit '${rule.unit}'`);
+        }
+        units.add(rule.unit);
+    }
+    return {
+        capturedAt,
+        rules
+    };
+}
+function calculateModelUsageCharge(snapshot, metric) {
+    const rule = snapshot == null ? void 0 : snapshot.rules.find((candidate)=>candidate.unit === metric.unit);
+    const fallbackQuantity = metricQuantity(metric);
+    if (!rule) {
+        return {
+            pricingStatus: 'unpriced',
+            quantity: fallbackQuantity
+        };
+    }
+    const quantity = rule.unit === 'token' ? tokenQuantity(metric, rule.token_type) : fallbackQuantity;
+    if (rule.charge_type === 'free') {
+        return _extends._extends({
+            pricingStatus: 'free',
+            pricingRule: rule,
+            quantity,
+            unitSize: rule.unit_size,
+            unitPrice: 0
+        }, rule.currency ? {
+            currency: rule.currency
+        } : {}, {
+            amount: 0
+        });
+    }
+    const unitPrice = Number(rule.unit_price);
+    const unitSize = Number(rule.unit_size);
+    return {
+        pricingStatus: 'priced',
+        pricingRule: rule,
+        quantity,
+        unitSize,
+        unitPrice,
+        currency: rule.currency,
+        amount: roundCharge(quantity / unitSize * unitPrice)
+    };
+}
+function isModelUsagePricingConfig(pricing) {
+    return pricing !== undefined && 'type' in pricing && pricing.type === 'usage' && Array.isArray(pricing.rules);
+}
+function matchesUsagePriceRule(rule, context, at) {
+    var _rule_operations;
+    const effectiveFrom = normalizeDate(rule.effective_from);
+    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;
+    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 === value;
+        if (key === 'audio') return dimensions.audio === value;
+        if (key === 'videoInput') return dimensions.videoInput === value;
+        if (key === 'mode') return dimensions.mode === value;
+        return false;
+    });
+}
+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 (!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.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())) {
+            throw new Error(`Paid usage pricing rule '${rule.id}' requires unit_price and currency`);
+        }
+    }
+}
+function metricQuantity(metric) {
+    if (metric.unit !== 'token') return finiteQuantity(metric.quantity);
+    var _metric_totalTokens, _ref;
+    return finiteQuantity((_ref = (_metric_totalTokens = metric.totalTokens) != null ? _metric_totalTokens : metric.promptTokens) != null ? _ref : metric.completionTokens);
+}
+function tokenQuantity(metric, tokenType) {
+    if (metric.unit !== 'token') return 0;
+    if (tokenType === 'prompt') return finiteQuantity(metric.promptTokens);
+    if (tokenType === 'completion') return finiteQuantity(metric.completionTokens);
+    return finiteQuantity(metric.totalTokens);
+}
+function finiteQuantity(value) {
+    const quantity = Number(value);
+    return Number.isFinite(quantity) && quantity > 0 ? quantity : 0;
+}
+function normalizeDate(value) {
+    if (!value) return undefined;
+    const date = value instanceof Date ? value : new Date(value);
+    return Number.isNaN(date.getTime()) ? undefined : date;
+}
+function roundCharge(value) {
+    return Number(value.toFixed(10));
+}
 
 var AIModel_1;
 let AIModel = AIModel_1 = class AIModel {
     getChatModel(copilotModel, options) {
         throw new Error(`Unsupport chat model!`);
     }
+    getAIGCModel(copilotModel, options) {
+        throw new Error(`Unsupported AIGC model!`);
+    }
     getPrice(model, credentials, priceType, tokens, inputTokens = tokens) {
         const modelSchema = this.getModelSchema(model, credentials);
-        if (!modelSchema || !modelSchema.pricing) {
+        if (!modelSchema || !modelSchema.pricing || isModelUsagePricingConfig(modelSchema.pricing)) {
             return {
                 unitPrice: 0,
                 unit: 0,
@@ -2164,6 +2154,10 @@ let AIModel = AIModel_1 = class AIModel {
         }
         return calculateModelPrice(modelSchema.pricing, priceType, tokens, inputTokens);
     }
+    getUsagePricingSnapshot(model, credentials, context) {
+        var _this_getModelSchema;
+        return resolveModelUsagePricingSnapshot((_this_getModelSchema = this.getModelSchema(model, credentials)) == null ? void 0 : _this_getModelSchema.pricing, context);
+    }
     getModelPath() {
         const modelType = this.modelType.toLowerCase();
         return path__namespace.join(this.modelProvider.getProviderServerPath(), modelType);
@@ -2224,7 +2218,7 @@ let AIModel = AIModel_1 = class AIModel {
                 try {
                     const defaultParameterName = valueOf(DefaultParameterName, parameterRule.use_template);
                     const defaultParameterRule = getDefaultParameterRuleVariableMap(defaultParameterName);
-                    const copyDefaultParameterRule = collaborationClient._extends({}, defaultParameterRule, parameterRule);
+                    const copyDefaultParameterRule = _extends._extends({}, defaultParameterRule, parameterRule);
                     parameterRule = copyDefaultParameterRule;
                 } catch (error) {
                 // Handle error if necessary
@@ -2353,6 +2347,11 @@ class TextToSpeechModel extends AIModel {
     }
 }
 
+class ImageGenerationModel extends AIModel {
+}
+class VideoGenerationModel extends AIModel {
+}
+
 const PROVIDE_AI_MODEL_LLM = 'provide_ai_model_llm';
 const PROVIDE_AI_MODEL_MODERATION = 'provide_ai_model_moderation';
 const PROVIDE_AI_MODEL_SPEECH2TEXT = 'provide_ai_model_speech2text';
@@ -2417,7 +2416,7 @@ class LargeLanguageModel extends AIModel {
     _commonParameterRules(model) {
         return CommonParameterRules;
     }
-    calcResponseUsage(model, credentials, promptTokens, completionTokens) {
+    calcResponseUsage(model, credentials, promptTokens, completionTokens, startedAt = this.startedAt) {
         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));
@@ -2434,30 +2433,68 @@ class LargeLanguageModel extends AIModel {
             totalTokens: promptTokens + completionTokens,
             totalPrice,
             currency: promptPriceInfo.currency,
-            latency: performance.now() - this.startedAt
+            latency: performance.now() - startedAt
         };
         return usage;
     }
     createHandleUsageCallbacks(copilot, model, credentials, handleLLMTokens) {
-        return [
-            {
-                handleLLMStart: ()=>{
-                    this.startedAt = performance.now();
-                },
-                handleLLMEnd: (output)=>{
-                    const tokenUsage = resolveTokenUsage(output);
-                    if (handleLLMTokens) {
-                        const usage = this.calcResponseUsage(model, credentials, tokenUsage.promptTokens, tokenUsage.completionTokens);
-                        usage.totalTokens = tokenUsage.totalTokens;
-                        handleLLMTokens({
-                            copilot,
-                            model,
-                            usage,
-                            tokenUsed: tokenUsage.totalTokens
-                        });
-                    }
+        const runs = new Map();
+        const reportUsage = async (requestId, tokenUsage, startedAt, type)=>{
+            if (!handleLLMTokens || tokenUsage.totalTokens <= 0) {
+                return;
+            }
+            const usage = _extends._extends({}, this.calcResponseUsage(model, credentials, tokenUsage.promptTokens, tokenUsage.completionTokens, startedAt), type ? {
+                type
+            } : {});
+            usage.totalTokens = tokenUsage.totalTokens;
+            await handleLLMTokens({
+                copilot,
+                model,
+                requestId,
+                usage,
+                tokenUsed: tokenUsage.totalTokens
+            });
+        };
+        const callback = base.BaseCallbackHandler.fromMethods({
+            handleLLMStart: (_llm, prompts, runId)=>{
+                runs.set(runId, {
+                    startedAt: performance.now(),
+                    prompts,
+                    completion: ''
+                });
+            },
+            handleLLMNewToken: (token, _idx, runId, _parentRunId, _tags, fields)=>{
+                const run = runs.get(runId);
+                if (run) {
+                    run.completion += token + readToolCallChunkText(fields == null ? void 0 : fields.chunk);
                 }
+            },
+            handleLLMEnd: async (output, runId)=>{
+                const run = runs.get(runId);
+                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);
+                } 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');
+                }
+            },
+            handleLLMError: async (error, runId)=>{
+                const run = runs.get(runId);
+                runs.delete(runId);
+                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');
             }
+        });
+        callback.awaitHandlers = true;
+        callback.raiseError = true;
+        return [
+            callback
         ];
     }
     createHandleLLMErrorCallbacks(fields, logger) {
@@ -2594,6 +2631,55 @@ class LargeLanguageModel extends AIModel {
     }
 }
 _a = LargeLanguageModel;
+function estimateFallbackUsage(prompts, completion) {
+    if (!prompts) {
+        return {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+        };
+    }
+    const promptTokens = estimateTokens(prompts.join('\n'));
+    const completionTokens = estimateTokens(completion != null ? completion : '');
+    return {
+        promptTokens,
+        completionTokens,
+        totalTokens: promptTokens + completionTokens
+    };
+}
+function readCompletionText(output) {
+    var _output_generations;
+    return (_output_generations = output.generations) == null ? void 0 : _output_generations.flat().map((generation)=>generation.text).filter(Boolean).join('\n');
+}
+function estimateTokens(text) {
+    const estimatedText = text.replace(/data:image\/[a-zA-Z0-9.+-]+;base64,[a-zA-Z0-9+/_=-]+/g, '[image]');
+    let cjkCharacters = 0;
+    let otherCharacters = 0;
+    for (const character of estimatedText){
+        if (RegExp("\\p{Script=Han}", "u").test(character)) {
+            cjkCharacters++;
+        } else {
+            otherCharacters++;
+        }
+    }
+    return Math.ceil(cjkCharacters / 1.5 + otherCharacters / 4);
+}
+function readToolCallChunkText(chunk) {
+    if (!(chunk instanceof outputs.ChatGenerationChunk) || !messages.isAIMessageChunk(chunk.message)) {
+        return '';
+    }
+    var _chunk_message_tool_call_chunks;
+    return ((_chunk_message_tool_call_chunks = chunk.message.tool_call_chunks) != null ? _chunk_message_tool_call_chunks : []).map((toolCall)=>{
+        var _toolCall_name, _toolCall_args;
+        return `${(_toolCall_name = toolCall.name) != null ? _toolCall_name : ''}${(_toolCall_args = toolCall.args) != null ? _toolCall_args : ''}`;
+    }).join('');
+}
+function isAbortError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    return error.name === 'AbortError' || /\babort(?:ed)?\b/i.test(error.message);
+}
 function calcTokenUsage(output) {
     var _output_generations;
     const tokenUsage = {
@@ -2614,14 +2700,32 @@ function calcTokenUsage(output) {
     return tokenUsage;
 }
 function resolveTokenUsage(output) {
+    return resolveTokenUsageWithAuthority(output).usage;
+}
+function resolveTokenUsageWithAuthority(output) {
     var _output_llmOutput, _output_llmOutput1, _output_llmOutput2;
-    var _normalizeTokenUsage, _ref, _ref1, _ref2;
-    return (_ref2 = (_ref1 = (_ref = (_normalizeTokenUsage = normalizeTokenUsage(calcTokenUsage(output))) != null ? _normalizeTokenUsage : normalizeTokenUsage((_output_llmOutput = output.llmOutput) == null ? void 0 : _output_llmOutput['tokenUsage'])) != null ? _ref : normalizeTokenUsage((_output_llmOutput1 = output.llmOutput) == null ? void 0 : _output_llmOutput1['estimatedTokenUsage'])) != null ? _ref1 : normalizeTokenUsage({
-        totalTokens: (_output_llmOutput2 = output.llmOutput) == null ? void 0 : _output_llmOutput2['totalTokens']
-    })) != null ? _ref2 : {
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0
+    var _normalizeTokenUsage, _ref;
+    const actualUsage = (_ref = (_normalizeTokenUsage = normalizeTokenUsage(calcTokenUsage(output))) != null ? _normalizeTokenUsage : normalizeTokenUsage((_output_llmOutput = output.llmOutput) == null ? void 0 : _output_llmOutput['tokenUsage'])) != null ? _ref : normalizeTokenUsage({
+        totalTokens: (_output_llmOutput1 = output.llmOutput) == null ? void 0 : _output_llmOutput1['totalTokens']
+    });
+    if (actualUsage) {
+        return {
+            usage: actualUsage
+        };
+    }
+    const estimatedUsage = normalizeTokenUsage((_output_llmOutput2 = output.llmOutput) == null ? void 0 : _output_llmOutput2['estimatedTokenUsage']);
+    if (estimatedUsage) {
+        return {
+            usage: estimatedUsage,
+            type: 'estimated'
+        };
+    }
+    return {
+        usage: {
+            promptTokens: 0,
+            completionTokens: 0,
+            totalTokens: 0
+        }
     };
 }
 function normalizeTokenUsage(candidate) {
@@ -2664,6 +2768,109 @@ function isValidTokenCount(value) {
     return tokenUsed;
 }
 
+/**
+ * Runs one asynchronous provider request inside a Managed Queue job.
+ * Provider acceptance, terminal usage reporting, and result delivery are checkpointed so a queue retry resumes
+ * from the last durable provider request instead of intentionally submitting a second request.
+ */ async function processAsyncAIGCManagedJob(job, options) {
+    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.pricingSnapshot) {
+        const pricingSnapshot = options.provider.resolvePricingSnapshot ? await options.provider.resolvePricingSnapshot({
+            model: payload.model,
+            operation: payload.operation,
+            modality: payload.modality,
+            pricingDimensions: payload.pricingDimensions,
+            startedAt: payload.startedAt
+        }) : {
+            capturedAt: new Date().toISOString(),
+            rules: []
+        };
+        payload = await checkpoint(job, _extends._extends({}, payload, {
+            pricingSnapshot
+        }));
+    }
+    if (!payload.providerRequestId) {
+        const submission = await options.client.submit(payload.input);
+        payload = await checkpoint(job, _extends._extends({}, payload, {
+            providerRequestId: submission.providerRequestId,
+            phase: 'submitted',
+            providerState: 'submitted'
+        }));
+    }
+    const providerRequestId = payload.providerRequestId;
+    var _options_sleep;
+    const sleep = (_options_sleep = options.sleep) != null ? _options_sleep : delay;
+    const pollIntervalMs = normalizePollInterval(options.pollIntervalMs);
+    while(true){
+        const query = await options.client.query(providerRequestId, {
+            operation: payload.operation,
+            pricingDimensions: payload.pricingDimensions
+        });
+        const observation = query.observation;
+        payload = await checkpoint(job, _extends._extends({}, payload, {
+            providerState: observation.state,
+            phase: toJobPhase(observation.state)
+        }, observation.errorCode ? {
+            errorCode: observation.errorCode
+        } : {}));
+        if (observation.state === 'succeeded') {
+            payload = await reportTerminalUsage(job, payload, observation.metrics, options.provider);
+            const result = await options.finalize(query.data);
+            payload = await checkpoint(job, _extends._extends({}, payload, {
+                phase: 'succeeded',
+                result
+            }));
+            return result;
+        }
+        if (observation.state === 'failed' || observation.state === 'cancelled') {
+            payload = await reportTerminalUsage(job, payload, observation.metrics, options.provider);
+            var _options_failureMessage, _ref;
+            const message = (_ref = (_options_failureMessage = options.failureMessage == null ? void 0 : options.failureMessage.call(options, query.data, observation)) != null ? _options_failureMessage : observation.errorCode) != null ? _ref : `Provider generation task ${providerRequestId} ${observation.state}`;
+            await checkpoint(job, _extends._extends({}, payload, {
+                phase: 'failed',
+                errorCode: message
+            }));
+            throw new Error(message);
+        }
+        await sleep(pollIntervalMs);
+    }
+}
+async function reportTerminalUsage(job, payload, metrics, provider) {
+    if (payload.usageReported || !(metrics == null ? void 0 : metrics.length)) return payload;
+    await provider.reportUsage({
+        requestId: payload.requestId,
+        model: payload.model,
+        modelType: payload.modality === 'image' ? contracts.AiModelTypeEnum.IMAGE : contracts.AiModelTypeEnum.VIDEO,
+        toolName: payload.toolName,
+        operation: payload.operation,
+        modality: payload.modality,
+        pricingDimensions: payload.pricingDimensions,
+        pricingSnapshot: payload.pricingSnapshot,
+        metrics,
+        recordedAt: new Date().toISOString()
+    });
+    return checkpoint(job, _extends._extends({}, payload, {
+        usageReported: true
+    }));
+}
+async function checkpoint(job, payload) {
+    await job.updateData(payload);
+    return payload;
+}
+function toJobPhase(state) {
+    if (state === 'succeeded') return 'succeeded';
+    if (state === 'failed' || state === 'cancelled') return 'failed';
+    return state === 'submitted' ? 'submitted' : 'processing';
+}
+function normalizePollInterval(value) {
+    return Number.isFinite(value) && Number(value) > 0 ? Math.trunc(Number(value)) : 5000;
+}
+function delay(milliseconds) {
+    return new Promise((resolve)=>setTimeout(resolve, milliseconds));
+}
+
 /**
  * A model extended from ChatOpenAICompletions, compatible with OpenAI-style chat completions,
  * and supports structuring content within `<think>` reasoning tags into the `reasoning_content` field.
@@ -2679,7 +2886,12 @@ function isValidTokenCount(value) {
      *
      */ _convertCompletionsDeltaToBaseMessageChunk(// eslint-disable-next-line @typescript-eslint/no-explicit-any
     delta, rawResponse, defaultRole) {
-        const messageChunk = super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole);
+        // Some OpenAI-compatible providers omit `delta.role` on the final usage
+        // chunk. Without a role, LangChain creates a generic ChatMessageChunk;
+        // persisting that chunk makes the next request contain `role: undefined`.
+        // Treat role-less completion deltas as assistant output so they remain
+        // valid both in the current stream and when the conversation is resumed.
+        const messageChunk = super._convertCompletionsDeltaToBaseMessageChunk(delta, rawResponse, defaultRole != null ? defaultRole : 'assistant');
         if (delta['content'] === '<think>') {
             this.thinking = true;
             messageChunk.content = '';
@@ -2695,7 +2907,14 @@ function isValidTokenCount(value) {
         return messageChunk;
     }
     _convertCompletionsMessageToBaseMessage(message, rawResponse) {
-        const langChainMessage = super._convertCompletionsMessageToBaseMessage(message, rawResponse);
+        var _message_role;
+        // Some compatible providers also omit the role on non-stream responses.
+        // Normalize that response before LangChain falls back to a generic
+        // message with role `unknown`.
+        const normalizedMessage = _extends._extends({}, message, {
+            role: (_message_role = message.role) != null ? _message_role : 'assistant'
+        });
+        const langChainMessage = super._convertCompletionsMessageToBaseMessage(normalizedMessage, rawResponse);
         console.log(langChainMessage.content);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         if (message.reasoning_content) {
@@ -2807,7 +3026,7 @@ class Speech2TextChatModel extends chat_models.BaseChatModel {
         if (!apiKey) {
             throw new Error(`Tongyi API key not found. Please set the DASHSCOPE_API_KEY environment variable or pass the key into "apiKey" field.`);
         }
-        super(collaborationClient._extends({}, fields));
+        super(_extends._extends({}, fields));
         this.fields = fields;
         this.apiKey = apiKey;
     }
@@ -2840,10 +3059,10 @@ function getModelContextSize(input) {
         return (_input_profile_maxInputTokens = input.profile.maxInputTokens) != null ? _input_profile_maxInputTokens : undefined;
     }
     if ("model" in input && typeof input.model === "string") {
-        return base.getModelContextSize(input.model);
+        return base$1.getModelContextSize(input.model);
     }
     if ("modelName" in input && typeof input.modelName === "string") {
-        return base.getModelContextSize(input.modelName);
+        return base$1.getModelContextSize(input.modelName);
     }
     return undefined;
 }
@@ -2880,66 +3099,6 @@ Reflect.defineMetadata(COMMAND_METADATA$1, {
     id: CreateModelClientCommand.type
 }, CreateModelClientCommand);
 
-const KnowledgebaseRuntimeCapability = createRuntimeCapability('platform.knowledgebase', {
-    description: 'List, search, and write chunks in platform knowledgebases.'
-});
-
-const KnowledgebaseDocumentsRuntimeCapability = createRuntimeCapability('platform.knowledgebase.documents', {
-    description: 'Upload, import, create, process, inspect, and delete persistent knowledgebase documents.'
-});
-
-const ActorTokenRuntimeCapability = createRuntimeCapability('platform.actor-token', {
-    description: 'Mint a short-lived host-issued actor bearer token for outbound API calls.'
-});
-
-const ArtifactsRuntimeCapability = createRuntimeCapability('platform.artifacts', {
-    description: 'Create, version, preview, download, share, archive, and delete platform-managed plugin and Agent artifacts.'
-});
-
-/** Stable source identifier for portable workspace file references. */ const WORKSPACE_FILES_SOURCE = 'platform.workspace.files';
-const WorkspaceFilesRuntimeCapability = createRuntimeCapability('platform.workspace.files', {
-    description: 'Upload, understand, resolve, read, and delete raw files in Xpert workspace volumes.'
-});
-
-/** Stable machine-readable failures emitted by the Sandbox Jobs capability. */ const SANDBOX_JOB_ERROR_CODES = [
-    'SANDBOX_ACTION_UNAVAILABLE',
-    'SANDBOX_ACTION_INVALID',
-    'SANDBOX_PROFILE_UNAVAILABLE',
-    'SANDBOX_RUNTIME_UNAVAILABLE',
-    'SANDBOX_VERSION_MISMATCH',
-    'SANDBOX_CAPACITY_UNAVAILABLE',
-    'SANDBOX_START_FAILED',
-    'BROWSER_LAUNCH_FAILED',
-    'EXPORT_TIMEOUT',
-    'EXPORT_OOM',
-    'EXPORT_MEDIA_FAILED',
-    'EXPORT_INPUT_INVALID',
-    'EXPORT_OUTPUT_INVALID',
-    'SANDBOX_CANCELLED'
-];
-/** Line prefix used by trusted Actions to report structured, provider-neutral progress. */ const SANDBOX_JOB_PROGRESS_PREFIX = 'XPERT_SANDBOX_PROGRESS ';
-/** Error carrying retry policy and Job identity across plugin queue handlers. */ class SandboxJobRuntimeError extends Error {
-    constructor(code, message, retryable, jobId){
-        super(message);
-        this.code = code;
-        this.retryable = retryable;
-        this.jobId = jobId;
-        this.name = 'SandboxJobRuntimeError';
-    }
-}
-const SANDBOX_JOB_ERROR_CODE_SET = new Set(SANDBOX_JOB_ERROR_CODES);
-/** Narrows an unknown failure to the structured Sandbox Jobs runtime error contract. */ function isSandboxJobRuntimeError(error) {
-    if (error instanceof SandboxJobRuntimeError) return true;
-    if (typeof error !== 'object' || error === null) return false;
-    // Dynamically loaded plugins may resolve another Plugin SDK module instance,
-    // so class identity is not a reliable runtime boundary. Validate the stable shape.
-    const candidate = error;
-    return candidate.name === 'SandboxJobRuntimeError' && typeof candidate.message === 'string' && typeof candidate.code === 'string' && SANDBOX_JOB_ERROR_CODE_SET.has(candidate.code) && typeof candidate.retryable === 'boolean' && (candidate.jobId === undefined || typeof candidate.jobId === 'string');
-}
-/** Runtime capability key used to resolve SandboxJobsApi from the platform registry. */ const SandboxJobsRuntimeCapability = createRuntimeCapability('platform.sandbox.jobs', {
-    description: 'Run registered plugin actions in isolated, short-lived Sandbox Runtime jobs.'
-});
-
 const SKILL_SOURCE_PROVIDER = 'SKILL_SOURCE_PROVIDER';
 const SkillSourceProviderStrategy = (provider)=>common.applyDecorators(common.SetMetadata(SKILL_SOURCE_PROVIDER, provider), common.SetMetadata(STRATEGY_META_KEY, SKILL_SOURCE_PROVIDER));
 
@@ -2980,14 +3139,40 @@ exports.AgentMiddlewareRegistry = __decorate([
     'end'
 ];
 
-const AssistantTaskRuntimeCapability = createRuntimeCapability('platform.assistant_task', {
+const AssistantTaskRuntimeCapability = modelProvider.createRuntimeCapability('platform.assistant_task', {
     description: 'Start asynchronous tasks on the current platform assistant.'
 });
 
-const FileRuntimeCapability = createRuntimeCapability('platform.file', {
+const FileRuntimeCapability = modelProvider.createRuntimeCapability('platform.file', {
     description: 'Resolve platform file handles into previewable file URLs.'
 });
 
+const XPERT_AGENT_MIDDLEWARE_RUNTIME_TOKEN = 'XPERT_AGENT_MIDDLEWARE_RUNTIME';
+
+const MODEL_OUTPUT_VALIDATION_ERROR_CODE = 'MODEL_OUTPUT_VALIDATION_ERROR';
+/**
+ * Signals that the provider returned a model response which could not be
+ * accepted, but can be regenerated safely because no tool was executed.
+ *
+ * Keep `repairContext` compact and free of raw tool arguments. Model
+ * middleware may use it as retry-local feedback, so it must never contain
+ * credentials, complete documents, or other unbounded model output.
+ */ class ModelOutputValidationError extends Error {
+    constructor(message, repairContext){
+        super(message);
+        this.code = MODEL_OUTPUT_VALIDATION_ERROR_CODE;
+        this.retryable = true;
+        this.repairContext = repairContext;
+        this.name = 'ModelOutputValidationError';
+    }
+}
+function isModelOutputValidationError(error) {
+    var _candidate_repairContext;
+    if (!error || typeof error !== 'object') return false;
+    const candidate = error;
+    return candidate.code === MODEL_OUTPUT_VALIDATION_ERROR_CODE && candidate.retryable === true && ((_candidate_repairContext = candidate.repairContext) == null ? void 0 : _candidate_repairContext.kind) === 'invalid_tool_calls' && Array.isArray(candidate.repairContext.issues);
+}
+
 const SEGMENT_PATTERN = /^[a-z][a-z0-9_-]*$/i;
 const VERSION_PATTERN = /^v[1-9][0-9]*$/;
 function assertSegment(input, name) {
@@ -3261,7 +3446,7 @@ exports.SSOProviderRegistry = __decorate([
     ])
 ], exports.SSOProviderRegistry);
 
-const ConnectorRuntimeCapability = createRuntimeCapability('platform.connector', {
+const ConnectorRuntimeCapability = modelProvider.createRuntimeCapability('platform.connector', {
     description: 'Resolve connector credentials for agent middleware.'
 });
 
@@ -4460,7 +4645,7 @@ function normalizePluginJobProcessorMetadata(options) {
     if (concurrency !== undefined && (!Number.isFinite(concurrency) || concurrency <= 0)) {
         throw new Error('PluginJobProcessor concurrency must be a positive number');
     }
-    return collaborationClient._extends({
+    return _extends._extends({
         pluginName,
         queueName,
         jobName
@@ -4984,7 +5169,7 @@ function escapeInlineScript(value) {
 
 const VIEW_EXTENSION_CACHE_SERVICE_TOKEN = 'XPERT_PLUGIN_VIEW_EXTENSION_CACHE_SERVICE';
 
-/** Platform-owned real-time collaboration capability available to scoped plugin runtimes. */ const CollaborationRuntimeCapability = createRuntimeCapability('platform.collaboration', {
+/** Platform-owned real-time collaboration capability available to scoped plugin runtimes. */ const CollaborationRuntimeCapability = modelProvider.createRuntimeCapability('platform.collaboration', {
     description: 'Create, synchronize, persist, authorize, and observe platform-managed real-time collaboration documents.'
 });
 
@@ -5004,12 +5189,30 @@ exports.CollaborationDocumentProviderRegistry = __decorate([
     ])
 ], exports.CollaborationDocumentProviderRegistry);
 
-exports.base64ToBytes = collaborationClient.base64ToBytes;
-exports.bytesToBase64 = collaborationClient.bytesToBase64;
-exports.createCollaborationClient = collaborationClient.createCollaborationClient;
-exports.createCollaborationPresenceStore = collaborationClient.createCollaborationPresenceStore;
-exports.createSocketIoTransportAdapter = collaborationClient.createSocketIoTransportAdapter;
-exports.createYjsDocumentAdapter = collaborationClient.createYjsDocumentAdapter;
+const EVOLUTION_TARGET_PROVIDER = 'EVOLUTION_TARGET_PROVIDER';
+const EvolutionTargetProviderStrategy = (providerKey)=>common.applyDecorators(common.SetMetadata(EVOLUTION_TARGET_PROVIDER, providerKey), common.SetMetadata(STRATEGY_META_KEY, EVOLUTION_TARGET_PROVIDER));
+
+exports.EvolutionTargetProviderRegistry = class EvolutionTargetProviderRegistry extends BaseStrategyRegistry {
+    listDescriptors(organizationId) {
+        return this.list(organizationId).map((provider)=>provider.descriptor);
+    }
+    constructor(discoveryService, reflector){
+        super(EVOLUTION_TARGET_PROVIDER, discoveryService, reflector);
+    }
+};
+exports.EvolutionTargetProviderRegistry = __decorate([
+    common.Injectable(),
+    __metadata("design:paramtypes", [
+        core.DiscoveryService,
+        core.Reflector
+    ])
+], exports.EvolutionTargetProviderRegistry);
+
+const EVOLUTION_RUNTIME_SERVICE_TOKEN = 'XPERT_EVOLUTION_RUNTIME_SERVICE';
+const EvolutionRuntimeCapability = modelProvider.createRuntimeCapability('platform.agent-evolution', {
+    description: 'Ingest learning signals and resolve immutable capability versions for domain runtimes.'
+});
+
 Object.defineProperty(exports, "ASSISTANT_CHAT_SEND_MESSAGE_COMMAND", {
     enumerable: true,
     get: function () { return contracts.ASSISTANT_CHAT_SEND_MESSAGE_COMMAND; }
@@ -5018,8 +5221,36 @@ Object.defineProperty(exports, "ASSISTANT_CONTEXT_SET_COMMAND", {
     enumerable: true,
     get: function () { return contracts.ASSISTANT_CONTEXT_SET_COMMAND; }
 });
+exports.ActorTokenRuntimeCapability = modelProvider.ActorTokenRuntimeCapability;
+exports.ArtifactsRuntimeCapability = modelProvider.ArtifactsRuntimeCapability;
+exports.BaseTool = modelProvider.BaseTool;
+exports.BaseToolset = modelProvider.BaseToolset;
+exports.BuiltinToolset = modelProvider.BuiltinToolset;
+exports.DefaultAgentMiddlewareRuntimeCapabilityRegistry = modelProvider.DefaultRuntimeCapabilityRegistry;
+exports.DefaultRuntimeCapabilityRegistry = modelProvider.DefaultRuntimeCapabilityRegistry;
+exports.KnowledgebaseDocumentsRuntimeCapability = modelProvider.KnowledgebaseDocumentsRuntimeCapability;
+exports.KnowledgebaseProvisioningRuntimeCapability = modelProvider.KnowledgebaseProvisioningRuntimeCapability;
+exports.KnowledgebaseRuntimeCapability = modelProvider.KnowledgebaseRuntimeCapability;
+exports.ModelProviderBuiltinToolset = modelProvider.ModelProviderBuiltinToolset;
+exports.SANDBOX_JOB_ERROR_CODES = modelProvider.SANDBOX_JOB_ERROR_CODES;
+exports.SANDBOX_JOB_PROGRESS_PREFIX = modelProvider.SANDBOX_JOB_PROGRESS_PREFIX;
+exports.SandboxJobRuntimeError = modelProvider.SandboxJobRuntimeError;
+exports.SandboxJobsRuntimeCapability = modelProvider.SandboxJobsRuntimeCapability;
+exports.WORKSPACE_FILES_SOURCE = modelProvider.WORKSPACE_FILES_SOURCE;
+exports.WorkspaceFilesRuntimeCapability = modelProvider.WorkspaceFilesRuntimeCapability;
+exports.XPERT_RUNTIME_CAPABILITIES_TOKEN = modelProvider.XPERT_RUNTIME_CAPABILITIES_TOKEN;
+exports.createRuntimeCapability = modelProvider.createRuntimeCapability;
+exports.isSandboxJobRuntimeError = modelProvider.isSandboxJobRuntimeError;
+exports.ModelProviderHttpClient = modelProviderHttpClient.ModelProviderHttpClient;
+exports.ModelProviderHttpError = modelProviderHttpClient.ModelProviderHttpError;
 exports.assertConnectorDefinition = connector.assertConnectorDefinition;
 exports.getConnectorAuthMethods = connector.getConnectorAuthMethods;
+exports.base64ToBytes = collaborationClient.base64ToBytes;
+exports.bytesToBase64 = collaborationClient.bytesToBase64;
+exports.createCollaborationClient = collaborationClient.createCollaborationClient;
+exports.createCollaborationPresenceStore = collaborationClient.createCollaborationPresenceStore;
+exports.createSocketIoTransportAdapter = collaborationClient.createSocketIoTransportAdapter;
+exports.createYjsDocumentAdapter = collaborationClient.createYjsDocumentAdapter;
 exports.ACCOUNT_BINDING_PERMISSION_SERVICE_TOKEN = ACCOUNT_BINDING_PERMISSION_SERVICE_TOKEN;
 exports.AGENT_CHAT_DISPATCH_ERROR_STEER_TARGET_NOT_RUNNING = AGENT_CHAT_DISPATCH_ERROR_STEER_TARGET_NOT_RUNNING;
 exports.AGENT_CHAT_DISPATCH_MESSAGE_TYPE = AGENT_CHAT_DISPATCH_MESSAGE_TYPE;
@@ -5027,11 +5258,9 @@ exports.AGENT_MIDDLEWARE_STRATEGY = AGENT_MIDDLEWARE_STRATEGY;
 exports.AIModelProviderNotFoundException = AIModelProviderNotFoundException;
 exports.AIModelProviderStrategy = AIModelProviderStrategy;
 exports.AI_MODEL_PROVIDER = AI_MODEL_PROVIDER;
-exports.ActorTokenRuntimeCapability = ActorTokenRuntimeCapability;
 exports.AdapterDataSourceStrategy = AdapterDataSourceStrategy;
 exports.AgentMiddlewareStrategy = AgentMiddlewareStrategy;
 exports.AiModelNotFoundException = AiModelNotFoundException;
-exports.ArtifactsRuntimeCapability = ArtifactsRuntimeCapability;
 exports.AssistantTaskRuntimeCapability = AssistantTaskRuntimeCapability;
 exports.BOUND_IDENTITY_LOGIN_PERMISSION_SERVICE_TOKEN = BOUND_IDENTITY_LOGIN_PERMISSION_SERVICE_TOKEN;
 exports.BUILTIN_GLOBAL_SCOPE = BUILTIN_GLOBAL_SCOPE;
@@ -5040,9 +5269,6 @@ exports.BaseQueryRunner = BaseQueryRunner;
 exports.BaseSQLQueryRunner = BaseSQLQueryRunner;
 exports.BaseSandbox = BaseSandbox;
 exports.BaseStrategyRegistry = BaseStrategyRegistry;
-exports.BaseTool = BaseTool;
-exports.BaseToolset = BaseToolset;
-exports.BuiltinToolset = BuiltinToolset;
 exports.CHAT_CHANNEL = CHAT_CHANNEL;
 exports.CHAT_CHANNEL_TEXT_LIMITS = CHAT_CHANNEL_TEXT_LIMITS;
 exports.COLLABORATION_DOCUMENT_PROVIDER = COLLABORATION_DOCUMENT_PROVIDER;
@@ -5073,10 +5299,12 @@ exports.DEFAULT_SANDBOX_SHELL_TIMEOUT_SEC = DEFAULT_SANDBOX_SHELL_TIMEOUT_SEC;
 exports.DOCUMENT_SOURCE_STRATEGY = DOCUMENT_SOURCE_STRATEGY;
 exports.DOCUMENT_TRANSFORMER_STRATEGY = DOCUMENT_TRANSFORMER_STRATEGY;
 exports.DataSourceStrategy = DataSourceStrategy;
-exports.DefaultAgentMiddlewareRuntimeCapabilityRegistry = DefaultRuntimeCapabilityRegistry;
-exports.DefaultRuntimeCapabilityRegistry = DefaultRuntimeCapabilityRegistry;
 exports.DocumentSourceStrategy = DocumentSourceStrategy;
 exports.DocumentTransformerStrategy = DocumentTransformerStrategy;
+exports.EVOLUTION_RUNTIME_SERVICE_TOKEN = EVOLUTION_RUNTIME_SERVICE_TOKEN;
+exports.EVOLUTION_TARGET_PROVIDER = EVOLUTION_TARGET_PROVIDER;
+exports.EvolutionRuntimeCapability = EvolutionRuntimeCapability;
+exports.EvolutionTargetProviderStrategy = EvolutionTargetProviderStrategy;
 exports.FILE_STORAGE_PROVIDER = FILE_STORAGE_PROVIDER;
 exports.FILE_UPLOAD_TARGET_STRATEGY = FILE_UPLOAD_TARGET_STRATEGY;
 exports.FileRuntimeCapability = FileRuntimeCapability;
@@ -5090,19 +5318,20 @@ exports.HandoffProcessorStrategy = HandoffProcessorStrategy;
 exports.IMAGE_UNDERSTANDING_STRATEGY = IMAGE_UNDERSTANDING_STRATEGY;
 exports.INTEGRATION_PERMISSION_SERVICE_TOKEN = INTEGRATION_PERMISSION_SERVICE_TOKEN;
 exports.INTEGRATION_STRATEGY = INTEGRATION_STRATEGY;
+exports.ImageGenerationModel = ImageGenerationModel;
 exports.ImageUnderstandingStrategy = ImageUnderstandingStrategy;
 exports.IntegrationStrategyKey = IntegrationStrategyKey;
 exports.JUMP_TO_TARGETS = JUMP_TO_TARGETS;
 exports.JsonSchemaValidator = JsonSchemaValidator;
 exports.KNOWLEDGE_STRATEGY = KNOWLEDGE_STRATEGY;
 exports.KnowledgeStrategyKey = KnowledgeStrategyKey;
-exports.KnowledgebaseDocumentsRuntimeCapability = KnowledgebaseDocumentsRuntimeCapability;
-exports.KnowledgebaseRuntimeCapability = KnowledgebaseRuntimeCapability;
 exports.LLMUsage = LLMUsage;
 exports.LargeLanguageModel = LargeLanguageModel;
 exports.MANAGED_CONNECTION_REGISTRY_TOKEN = MANAGED_CONNECTION_REGISTRY_TOKEN;
 exports.MANAGED_QUEUE_HANDLER_REGISTRY_TOKEN = MANAGED_QUEUE_HANDLER_REGISTRY_TOKEN;
 exports.MANAGED_QUEUE_SERVICE_TOKEN = MANAGED_QUEUE_SERVICE_TOKEN;
+exports.MODEL_OUTPUT_VALIDATION_ERROR_CODE = MODEL_OUTPUT_VALIDATION_ERROR_CODE;
+exports.ModelOutputValidationError = ModelOutputValidationError;
 exports.ORGANIZATION_METADATA_KEY = ORGANIZATION_METADATA_KEY;
 exports.OpenAICompatibleReranker = OpenAICompatibleReranker;
 exports.PERMISSION_OPERATION_METADATA_KEY = PERMISSION_OPERATION_METADATA_KEY;
@@ -5125,8 +5354,6 @@ exports.RequestContext = RequestContext;
 exports.RequirePermissionOperation = RequirePermissionOperation;
 exports.RerankModel = RerankModel;
 exports.RetrieverStrategy = RetrieverStrategy;
-exports.SANDBOX_JOB_ERROR_CODES = SANDBOX_JOB_ERROR_CODES;
-exports.SANDBOX_JOB_PROGRESS_PREFIX = SANDBOX_JOB_PROGRESS_PREFIX;
 exports.SANDBOX_PROVIDER = SANDBOX_PROVIDER;
 exports.SANDBOX_RUNTIME_PROVIDER = SANDBOX_RUNTIME_PROVIDER;
 exports.SANDBOX_SHELL_TIMEOUT_LIMITS_SEC = SANDBOX_SHELL_TIMEOUT_LIMITS_SEC;
@@ -5139,8 +5366,6 @@ exports.SSO_BINDING_PERMISSION_SERVICE_TOKEN = SSO_BINDING_PERMISSION_SERVICE_TO
 exports.SSO_PROVIDER = SSO_PROVIDER;
 exports.STRATEGY_META_KEY = STRATEGY_META_KEY;
 exports.SYSTEM_GLOBAL_SCOPE = SYSTEM_GLOBAL_SCOPE;
-exports.SandboxJobRuntimeError = SandboxJobRuntimeError;
-exports.SandboxJobsRuntimeCapability = SandboxJobsRuntimeCapability;
 exports.SandboxProviderStrategy = SandboxProviderStrategy;
 exports.SandboxRuntimeProviderStrategy = SandboxRuntimeProviderStrategy;
 exports.SandboxWorkspaceMapperStrategy = SandboxWorkspaceMapperStrategy;
@@ -5163,15 +5388,14 @@ exports.VIDEO_GENERATOR_FAMILIES = VIDEO_GENERATOR_FAMILIES;
 exports.VIEW_EXTENSION_CACHE_SERVICE_TOKEN = VIEW_EXTENSION_CACHE_SERVICE_TOKEN;
 exports.VIEW_EXTENSION_PROVIDER = VIEW_EXTENSION_PROVIDER;
 exports.VectorStoreStrategy = VectorStoreStrategy;
+exports.VideoGenerationModel = VideoGenerationModel;
 exports.ViewExtensionProvider = ViewExtensionProvider;
 exports.WORKFLOW_NODE_STRATEGY = WORKFLOW_NODE_STRATEGY;
 exports.WORKFLOW_TRIGGER_STRATEGY = WORKFLOW_TRIGGER_STRATEGY;
-exports.WORKSPACE_FILES_SOURCE = WORKSPACE_FILES_SOURCE;
 exports.WorkflowNodeStrategy = WorkflowNodeStrategy;
 exports.WorkflowTriggerStrategy = WorkflowTriggerStrategy;
-exports.WorkspaceFilesRuntimeCapability = WorkspaceFilesRuntimeCapability;
 exports.WrapWorkflowNodeExecutionCommand = WrapWorkflowNodeExecutionCommand;
-exports.XPERT_RUNTIME_CAPABILITIES_TOKEN = XPERT_RUNTIME_CAPABILITIES_TOKEN;
+exports.XPERT_AGENT_MIDDLEWARE_RUNTIME_TOKEN = XPERT_AGENT_MIDDLEWARE_RUNTIME_TOKEN;
 exports.XpFileSystem = XpFileSystem;
 exports.XpertServerPlugin = XpertServerPlugin;
 exports.als = als;
@@ -5179,11 +5403,11 @@ exports.appendSandboxMessage = appendSandboxMessage;
 exports.buildSandboxTimeoutMessage = buildSandboxTimeoutMessage;
 exports.calcTokenUsage = calcTokenUsage;
 exports.calculateModelPrice = calculateModelPrice;
+exports.calculateModelUsageCharge = calculateModelUsageCharge;
 exports.chunkText = chunkText;
 exports.countTokensSafe = countTokensSafe;
 exports.createI18nInstance = createI18nInstance;
 exports.createPluginLogger = createPluginLogger;
-exports.createRuntimeCapability = createRuntimeCapability;
 exports.defineAgentMessageType = defineAgentMessageType;
 exports.defineChannelMessageType = defineChannelMessageType;
 exports.derivePluginArtifactNamespace = derivePluginArtifactNamespace;
@@ -5199,9 +5423,10 @@ exports.getRequestContext = getRequestContext;
 exports.getRequiredPermissionOperation = getRequiredPermissionOperation;
 exports.getTenantGlobalScopeKey = getTenantGlobalScopeKey;
 exports.isDevelopmentSandboxRuntimeEnvironment = isDevelopmentSandboxRuntimeEnvironment;
+exports.isModelOutputValidationError = isModelOutputValidationError;
+exports.isModelUsagePricingConfig = isModelUsagePricingConfig;
 exports.isRemoteFile = isRemoteFile;
 exports.isSandboxBackend = isSandboxBackend;
-exports.isSandboxJobRuntimeError = isSandboxJobRuntimeError;
 exports.isSandboxManagedServiceAdapter = isSandboxManagedServiceAdapter;
 exports.isSandboxServiceProxyAdapter = isSandboxServiceProxyAdapter;
 exports.isSandboxTerminalAdapter = isSandboxTerminalAdapter;
@@ -5213,9 +5438,11 @@ exports.mergeCredentials = mergeCredentials;
 exports.mergeParentChildChunks = mergeParentChildChunks;
 exports.normalizeContextSize = normalizeContextSize;
 exports.pluginArtifactTableName = pluginArtifactTableName;
+exports.processAsyncAIGCManagedJob = processAsyncAIGCManagedJob;
 exports.renderRemoteModuleIframeHtml = renderRemoteModuleIframeHtml;
 exports.renderRemoteReactIframeHtml = renderRemoteReactIframeHtml;
 exports.renderRemoteVueIframeHtml = renderRemoteVueIframeHtml;
+exports.resolveModelUsagePricingSnapshot = resolveModelUsagePricingSnapshot;
 exports.resolveSandboxBackend = resolveSandboxBackend;
 exports.resolveSandboxExecutionOptions = resolveSandboxExecutionOptions;
 exports.resolveSandboxManagedServiceAdapter = resolveSandboxManagedServiceAdapter;