@xpert-ai/plugin-sdk 3.16.1 → 3.17.0

package/model-provider-http-client.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./model-provider-http-client.cjs.js').default;

package/model-provider-http-client.cjs.js

@@ -0,0 +1,118 @@
+'use strict';
+
+var _extends = require('./_extends.cjs.js');
+
+class ModelProviderHttpError extends Error {
+    constructor(message, status){
+        super(message);
+        this.status = status;
+        this.name = 'ModelProviderHttpError';
+    }
+}
+/**
+ * Shared HTTP transport for model Provider adapters.
+ *
+ * Provider-specific authentication headers are supplied at construction time;
+ * response parsing, task semantics, and download URL policy stay in each adapter.
+ */ class ModelProviderHttpClient {
+    async requestJson(pathOrUrl, init, parse) {
+        const response = await this.fetchResponse(this.resolveRequestUrl(pathOrUrl), _extends._extends({}, init, {
+            headers: this.mergeHeaders(init.headers)
+        }), this.requestTimeoutMs);
+        if (!response.ok) {
+            throw await this.createHttpError(response);
+        }
+        return parse(await response.json());
+    }
+    async fetchResponse(input, init = {}, timeoutMs) {
+        var _init_signal;
+        if (!timeoutMs) {
+            return this.fetchImpl(input, init);
+        }
+        const controller = new AbortController();
+        let timedOut = false;
+        const abortFromCaller = ()=>{
+            var _init_signal;
+            return controller.abort((_init_signal = init.signal) == null ? void 0 : _init_signal.reason);
+        };
+        if ((_init_signal = init.signal) == null ? void 0 : _init_signal.aborted) {
+            abortFromCaller();
+        } else {
+            var _init_signal1;
+            (_init_signal1 = init.signal) == null ? void 0 : _init_signal1.addEventListener('abort', abortFromCaller, {
+                once: true
+            });
+        }
+        const timeout = setTimeout(()=>{
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+        try {
+            return await this.fetchImpl(input, _extends._extends({}, init, {
+                signal: controller.signal
+            }));
+        } catch (error) {
+            if (timedOut) {
+                throw this.createTimeoutError(timeoutMs);
+            }
+            throw error;
+        } finally{
+            var _init_signal2;
+            clearTimeout(timeout);
+            (_init_signal2 = init.signal) == null ? void 0 : _init_signal2.removeEventListener('abort', abortFromCaller);
+        }
+    }
+    async readBufferResponse(response, options = {}) {
+        var _response_headers_get_split_, _response_headers_get;
+        const contentLength = response.headers.get('content-length');
+        const declaredBytes = contentLength && /^\d+$/u.test(contentLength) ? Number(contentLength) : undefined;
+        if (options.maxBytes && declaredBytes && declaredBytes > options.maxBytes) {
+            var _options_maxBytesError;
+            throw new Error((_options_maxBytesError = options.maxBytesError) != null ? _options_maxBytesError : `${this.provider} result exceeds the download limit`);
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (options.maxBytes && buffer.length > options.maxBytes) {
+            var _options_maxBytesError1;
+            throw new Error((_options_maxBytesError1 = options.maxBytesError) != null ? _options_maxBytesError1 : `${this.provider} result exceeds the download limit`);
+        }
+        return {
+            buffer,
+            mimeType: ((_response_headers_get = response.headers.get('content-type')) == null ? void 0 : (_response_headers_get_split_ = _response_headers_get.split(';')[0]) == null ? void 0 : _response_headers_get_split_.trim()) || options.defaultMimeType || undefined
+        };
+    }
+    async createHttpError(response) {
+        const text = await response.text().catch(()=>'');
+        return new ModelProviderHttpError(`${this.provider} API error ${response.status}: ${text || response.statusText}`, response.status);
+    }
+    createTimeoutError(timeoutMs) {
+        return new Error(`${this.provider} request timed out after ${timeoutMs}ms`);
+    }
+    resolveRequestUrl(pathOrUrl) {
+        return /^https?:\/\//iu.test(pathOrUrl) ? pathOrUrl : `${this.baseUrl}${pathOrUrl.startsWith('/') ? '' : '/'}${pathOrUrl}`;
+    }
+    mergeHeaders(headers) {
+        const merged = _extends._extends({}, this.defaultHeaders);
+        const headerNames = new Map(Object.keys(merged).map((key)=>[
+                key.toLowerCase(),
+                key
+            ]));
+        new Headers(headers).forEach((value, key)=>{
+            var _headerNames_get;
+            const targetKey = (_headerNames_get = headerNames.get(key)) != null ? _headerNames_get : key;
+            merged[targetKey] = value;
+        });
+        return merged;
+    }
+    constructor(options){
+        this.provider = options.provider;
+        this.baseUrl = options.baseUrl.replace(/\/$/u, '');
+        var _options_defaultHeaders;
+        this.defaultHeaders = (_options_defaultHeaders = options.defaultHeaders) != null ? _options_defaultHeaders : {};
+        var _options_fetchImpl;
+        this.fetchImpl = (_options_fetchImpl = options.fetchImpl) != null ? _options_fetchImpl : fetch;
+        this.requestTimeoutMs = options.requestTimeoutMs;
+    }
+}
+
+exports.ModelProviderHttpClient = ModelProviderHttpClient;
+exports.ModelProviderHttpError = ModelProviderHttpError;

package/model-provider-http-client.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './model-provider-http-client.cjs.js';
+export { _default as default } from './model-provider-http-client.cjs.default.js';

package/model-provider-http-client.d.ts

@@ -0,0 +1 @@
+export * from "./src/model-provider-http-client";

package/model-provider-http-client.esm.js

@@ -0,0 +1,115 @@
+import { _ as _extends } from './_extends.esm.js';
+
+class ModelProviderHttpError extends Error {
+    constructor(message, status){
+        super(message);
+        this.status = status;
+        this.name = 'ModelProviderHttpError';
+    }
+}
+/**
+ * Shared HTTP transport for model Provider adapters.
+ *
+ * Provider-specific authentication headers are supplied at construction time;
+ * response parsing, task semantics, and download URL policy stay in each adapter.
+ */ class ModelProviderHttpClient {
+    async requestJson(pathOrUrl, init, parse) {
+        const response = await this.fetchResponse(this.resolveRequestUrl(pathOrUrl), _extends({}, init, {
+            headers: this.mergeHeaders(init.headers)
+        }), this.requestTimeoutMs);
+        if (!response.ok) {
+            throw await this.createHttpError(response);
+        }
+        return parse(await response.json());
+    }
+    async fetchResponse(input, init = {}, timeoutMs) {
+        var _init_signal;
+        if (!timeoutMs) {
+            return this.fetchImpl(input, init);
+        }
+        const controller = new AbortController();
+        let timedOut = false;
+        const abortFromCaller = ()=>{
+            var _init_signal;
+            return controller.abort((_init_signal = init.signal) == null ? void 0 : _init_signal.reason);
+        };
+        if ((_init_signal = init.signal) == null ? void 0 : _init_signal.aborted) {
+            abortFromCaller();
+        } else {
+            var _init_signal1;
+            (_init_signal1 = init.signal) == null ? void 0 : _init_signal1.addEventListener('abort', abortFromCaller, {
+                once: true
+            });
+        }
+        const timeout = setTimeout(()=>{
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+        try {
+            return await this.fetchImpl(input, _extends({}, init, {
+                signal: controller.signal
+            }));
+        } catch (error) {
+            if (timedOut) {
+                throw this.createTimeoutError(timeoutMs);
+            }
+            throw error;
+        } finally{
+            var _init_signal2;
+            clearTimeout(timeout);
+            (_init_signal2 = init.signal) == null ? void 0 : _init_signal2.removeEventListener('abort', abortFromCaller);
+        }
+    }
+    async readBufferResponse(response, options = {}) {
+        var _response_headers_get_split_, _response_headers_get;
+        const contentLength = response.headers.get('content-length');
+        const declaredBytes = contentLength && /^\d+$/u.test(contentLength) ? Number(contentLength) : undefined;
+        if (options.maxBytes && declaredBytes && declaredBytes > options.maxBytes) {
+            var _options_maxBytesError;
+            throw new Error((_options_maxBytesError = options.maxBytesError) != null ? _options_maxBytesError : `${this.provider} result exceeds the download limit`);
+        }
+        const buffer = Buffer.from(await response.arrayBuffer());
+        if (options.maxBytes && buffer.length > options.maxBytes) {
+            var _options_maxBytesError1;
+            throw new Error((_options_maxBytesError1 = options.maxBytesError) != null ? _options_maxBytesError1 : `${this.provider} result exceeds the download limit`);
+        }
+        return {
+            buffer,
+            mimeType: ((_response_headers_get = response.headers.get('content-type')) == null ? void 0 : (_response_headers_get_split_ = _response_headers_get.split(';')[0]) == null ? void 0 : _response_headers_get_split_.trim()) || options.defaultMimeType || undefined
+        };
+    }
+    async createHttpError(response) {
+        const text = await response.text().catch(()=>'');
+        return new ModelProviderHttpError(`${this.provider} API error ${response.status}: ${text || response.statusText}`, response.status);
+    }
+    createTimeoutError(timeoutMs) {
+        return new Error(`${this.provider} request timed out after ${timeoutMs}ms`);
+    }
+    resolveRequestUrl(pathOrUrl) {
+        return /^https?:\/\//iu.test(pathOrUrl) ? pathOrUrl : `${this.baseUrl}${pathOrUrl.startsWith('/') ? '' : '/'}${pathOrUrl}`;
+    }
+    mergeHeaders(headers) {
+        const merged = _extends({}, this.defaultHeaders);
+        const headerNames = new Map(Object.keys(merged).map((key)=>[
+                key.toLowerCase(),
+                key
+            ]));
+        new Headers(headers).forEach((value, key)=>{
+            var _headerNames_get;
+            const targetKey = (_headerNames_get = headerNames.get(key)) != null ? _headerNames_get : key;
+            merged[targetKey] = value;
+        });
+        return merged;
+    }
+    constructor(options){
+        this.provider = options.provider;
+        this.baseUrl = options.baseUrl.replace(/\/$/u, '');
+        var _options_defaultHeaders;
+        this.defaultHeaders = (_options_defaultHeaders = options.defaultHeaders) != null ? _options_defaultHeaders : {};
+        var _options_fetchImpl;
+        this.fetchImpl = (_options_fetchImpl = options.fetchImpl) != null ? _options_fetchImpl : fetch;
+        this.requestTimeoutMs = options.requestTimeoutMs;
+    }
+}
+
+export { ModelProviderHttpClient, ModelProviderHttpError };

package/model-provider-toolset.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./model-provider-toolset.cjs.js').default;

package/model-provider-toolset.cjs.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var modelProvider = require('./model-provider.cjs.js');
+require('@xpert-ai/contracts');
+require('./_extends.cjs.js');
+require('@nestjs/common');
+require('@langchain/core/tools');
+require('zod');
+
+
+
+exports.ModelProviderBuiltinToolset = modelProvider.ModelProviderBuiltinToolset;

package/model-provider-toolset.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './model-provider-toolset.cjs.js';
+export { _default as default } from './model-provider-toolset.cjs.default.js';

package/model-provider-toolset.d.ts

@@ -0,0 +1 @@
+export * from "./src/model-provider-toolset";

package/model-provider-toolset.esm.js

@@ -0,0 +1,6 @@
+export { M as ModelProviderBuiltinToolset } from './model-provider.esm.js';
+import '@xpert-ai/contracts';
+import './_extends.esm.js';
+import '@nestjs/common';
+import '@langchain/core/tools';
+import 'zod';

package/model-provider.cjs.js

@@ -0,0 +1,348 @@
+'use strict';
+
+var contracts = require('@xpert-ai/contracts');
+var _extends = require('./_extends.cjs.js');
+var common = require('@nestjs/common');
+var tools = require('@langchain/core/tools');
+var zod = require('zod');
+
+/**
+ * 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;
+    }
+    get modelRuntime() {
+        var _this_params;
+        return (_this_params = this.params) == null ? void 0 : _this_params.modelRuntime;
+    }
+    get managedQueue() {
+        var _this_params;
+        return (_this_params = this.params) == null ? void 0 : _this_params.managedQueue;
+    }
+    get pluginScopeKey() {
+        var _this_params;
+        return (_this_params = this.params) == null ? void 0 : _this_params.pluginScopeKey;
+    }
+    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 _extends._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 = '';
+
+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 KnowledgebaseRuntimeCapability = createRuntimeCapability('platform.knowledgebase', {
+    description: 'List, search, and write chunks in platform knowledgebases.'
+});
+const KnowledgebaseProvisioningRuntimeCapability = createRuntimeCapability('platform.knowledgebase.provisioning', {
+    description: 'Idempotently provision managed platform knowledgebases and connect them to an Agent.'
+});
+
+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.'
+});
+
+/**
+ * Shared host-runtime plumbing for built-in tools backed by a configured model provider.
+ * Provider request/response semantics remain owned by each plugin.
+ */ class ModelProviderBuiltinToolset extends BuiltinToolset {
+    async _validateCredentials(_credentials) {
+        await this.getModelProviderRuntime();
+    }
+    getModelProviderRuntime() {
+        var _this_modelRuntime;
+        if (!((_this_modelRuntime = this.modelRuntime) == null ? void 0 : _this_modelRuntime.getModelProvider)) {
+            throw new Error(this.modelProviderOptions.missingProviderMessage);
+        }
+        var _this_modelProvider;
+        (_this_modelProvider = this.modelProvider) != null ? _this_modelProvider : this.modelProvider = this.modelRuntime.getModelProvider(this.modelProviderOptions.modelProviderName);
+        return this.modelProvider;
+    }
+    getModelProviderCredential(modelProvider) {
+        const scheme = this.modelProviderOptions.authorizationScheme;
+        const match = new RegExp(`^${scheme}\\s+(.+)$`, 'i').exec(modelProvider.authorization.trim());
+        if (!(match == null ? void 0 : match[1])) {
+            throw new Error(this.modelProviderOptions.invalidCredentialsMessage);
+        }
+        return match[1];
+    }
+    getWorkspaceFiles() {
+        var _this_runtimeCapabilities;
+        const workspaceFiles = (_this_runtimeCapabilities = this.runtimeCapabilities) == null ? void 0 : _this_runtimeCapabilities.get(WorkspaceFilesRuntimeCapability);
+        if (!workspaceFiles) {
+            throw new Error(this.modelProviderOptions.missingWorkspaceMessage);
+        }
+        return workspaceFiles;
+    }
+    createWorkspaceScope() {
+        var _this_params, _this_params1, _this_params2;
+        const projectId = normalizeOptionalString((_this_params = this.params) == null ? void 0 : _this_params.projectId);
+        if (projectId) {
+            var _this_params3, _this_params4;
+            return {
+                tenantId: normalizeOptionalString((_this_params3 = this.params) == null ? void 0 : _this_params3.tenantId),
+                userId: normalizeOptionalString((_this_params4 = this.params) == null ? void 0 : _this_params4.userId),
+                catalog: 'projects',
+                scopeId: projectId,
+                projectId
+            };
+        }
+        const xpertId = normalizeOptionalString(this.xpertId);
+        if (!xpertId) return undefined;
+        return {
+            tenantId: normalizeOptionalString((_this_params1 = this.params) == null ? void 0 : _this_params1.tenantId),
+            userId: normalizeOptionalString((_this_params2 = this.params) == null ? void 0 : _this_params2.userId),
+            catalog: 'xperts',
+            scopeId: xpertId,
+            xpertId,
+            isolateByUser: false
+        };
+    }
+    async createAsyncModelClient(model, modality, purpose = 'invoke') {
+        const modelProvider = await this.getModelProviderRuntime();
+        const copilotId = normalizeOptionalString(modelProvider.copilotId);
+        if (!copilotId) {
+            throw new Error(this.modelProviderOptions.missingProviderMessage);
+        }
+        const modelType = modality === 'image' ? contracts.AiModelTypeEnum.IMAGE : contracts.AiModelTypeEnum.VIDEO;
+        return this.modelRuntime.createModelClient({
+            copilotId,
+            model,
+            modelType
+        }, {
+            purpose
+        });
+    }
+    async createModelClient(model, modality) {
+        const modelProvider = await this.getModelProviderRuntime();
+        const copilotId = normalizeOptionalString(modelProvider.copilotId);
+        if (!copilotId) {
+            throw new Error(this.modelProviderOptions.missingProviderMessage);
+        }
+        const modelType = modality === 'image' ? contracts.AiModelTypeEnum.IMAGE : contracts.AiModelTypeEnum.VIDEO;
+        return this.modelRuntime.createModelClient({
+            copilotId,
+            model,
+            modelType
+        }, {});
+    }
+    constructor(modelProviderOptions, toolset, runtimeCapabilities, params){
+        super(modelProviderOptions.toolsetProviderName, toolset, params);
+        this.modelProviderOptions = modelProviderOptions;
+        this.runtimeCapabilities = runtimeCapabilities;
+    }
+}
+function normalizeOptionalString(value) {
+    const normalized = value == null ? void 0 : value.trim();
+    return normalized || undefined;
+}
+
+exports.ActorTokenRuntimeCapability = ActorTokenRuntimeCapability;
+exports.ArtifactsRuntimeCapability = ArtifactsRuntimeCapability;
+exports.BaseTool = BaseTool;
+exports.BaseToolset = BaseToolset;
+exports.BuiltinToolset = BuiltinToolset;
+exports.DefaultRuntimeCapabilityRegistry = DefaultRuntimeCapabilityRegistry;
+exports.KnowledgebaseDocumentsRuntimeCapability = KnowledgebaseDocumentsRuntimeCapability;
+exports.KnowledgebaseProvisioningRuntimeCapability = KnowledgebaseProvisioningRuntimeCapability;
+exports.KnowledgebaseRuntimeCapability = KnowledgebaseRuntimeCapability;
+exports.ModelProviderBuiltinToolset = ModelProviderBuiltinToolset;
+exports.SANDBOX_JOB_ERROR_CODES = SANDBOX_JOB_ERROR_CODES;
+exports.SANDBOX_JOB_PROGRESS_PREFIX = SANDBOX_JOB_PROGRESS_PREFIX;
+exports.SandboxJobRuntimeError = SandboxJobRuntimeError;
+exports.SandboxJobsRuntimeCapability = SandboxJobsRuntimeCapability;
+exports.WORKSPACE_FILES_SOURCE = WORKSPACE_FILES_SOURCE;
+exports.WorkspaceFilesRuntimeCapability = WorkspaceFilesRuntimeCapability;
+exports.XPERT_RUNTIME_CAPABILITIES_TOKEN = XPERT_RUNTIME_CAPABILITIES_TOKEN;
+exports.createRuntimeCapability = createRuntimeCapability;
+exports.isSandboxJobRuntimeError = isSandboxJobRuntimeError;