@xpert-ai/plugin-sdk 3.16.1 → 3.17.0

package/model-provider.esm.js

@@ -0,0 +1,328 @@
+import { AiModelTypeEnum } from '@xpert-ai/contracts';
+import { _ as _extends } from './_extends.esm.js';
+import { Logger } from '@nestjs/common';
+import { BaseToolkit, StructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+
+/**
+ * Base ability for all toolsets
+ */ class BaseToolset extends 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 StructuredTool {
+    constructor(...args){
+        super(...args);
+        this.schema = z.object({
+            input: 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({}, 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 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' ? AiModelTypeEnum.IMAGE : 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' ? AiModelTypeEnum.IMAGE : 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;
+}
+
+export { ActorTokenRuntimeCapability as A, BaseTool as B, DefaultRuntimeCapabilityRegistry as D, KnowledgebaseDocumentsRuntimeCapability as K, ModelProviderBuiltinToolset as M, SANDBOX_JOB_ERROR_CODES as S, WORKSPACE_FILES_SOURCE as W, XPERT_RUNTIME_CAPABILITIES_TOKEN as X, ArtifactsRuntimeCapability as a, BaseToolset as b, createRuntimeCapability as c, BuiltinToolset as d, KnowledgebaseProvisioningRuntimeCapability as e, KnowledgebaseRuntimeCapability as f, SANDBOX_JOB_PROGRESS_PREFIX as g, SandboxJobRuntimeError as h, SandboxJobsRuntimeCapability as i, WorkspaceFilesRuntimeCapability as j, isSandboxJobRuntimeError as k };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xpert-ai/plugin-sdk",
-  "version": "3.16.1",
+  "version": "3.17.0",
   "license": "AGPL-3.0",
   "repository": {
     "type": "git",
@@ -17,7 +17,7 @@
   },
   "dependencies": {
     "@langchain/openai": "0.6.9",
-    "@xpert-ai/contracts": "3.16.0",
+    "@xpert-ai/contracts": "3.17.0",
     "express": "^4.22.1",
     "js-tiktoken": "^1.0.21"
   },
@@ -56,6 +56,18 @@
       "types": "./connector.d.ts",
       "import": "./connector.cjs.mjs",
       "default": "./connector.cjs.js"
+    },
+    "./model-provider-toolset": {
+      "module": "./model-provider-toolset.esm.js",
+      "types": "./model-provider-toolset.d.ts",
+      "import": "./model-provider-toolset.cjs.mjs",
+      "default": "./model-provider-toolset.cjs.js"
+    },
+    "./model-provider-http-client": {
+      "module": "./model-provider-http-client.esm.js",
+      "types": "./model-provider-http-client.d.ts",
+      "import": "./model-provider-http-client.cjs.mjs",
+      "default": "./model-provider-http-client.cjs.js"
     }
   },
   "types": "./index.d.ts"

package/src/index.d.ts

@@ -24,3 +24,4 @@ export * from './lib/managed-connection/index';
 export * from './lib/managed-queue/index';
 export * from './lib/view-extension/index';
 export * from './lib/collaboration/index';
+export * from './lib/evolution/index';

package/src/lib/agent/middleware/capabilities/assistant-task.d.ts

@@ -1,3 +1,4 @@
+import type { JSONValue } from '@xpert-ai/contracts';
 export type AgentMiddlewareAssistantTaskStatus = 'queued' | 'running' | 'succeeded' | 'failed' | 'interrupted' | 'unknown';
 export type AgentMiddlewareAssistantTaskFile = {
     id?: string;
@@ -21,6 +22,8 @@ export type AgentMiddlewareAssistantTaskInput = {
     clientMessageId?: string;
     prompt: string;
     files?: AgentMiddlewareAssistantTaskFile[];
+    /** Additional bounded human-input fields exposed to runtime-state fixed filters. */
+    humanInput?: Record<string, JSONValue>;
     context?: Record<string, unknown>;
 };
 export type AgentMiddlewareAssistantTaskResult = {

package/src/lib/agent/middleware/index.d.ts

@@ -3,3 +3,4 @@ export * from './strategy.interface';
 export * from './strategy.registry';
 export * from './types';
 export * from './runtime';
+export * from './model-output-validation-error';

package/src/lib/agent/middleware/model-output-validation-error.d.ts

@@ -0,0 +1,27 @@
+export declare const MODEL_OUTPUT_VALIDATION_ERROR_CODE: "MODEL_OUTPUT_VALIDATION_ERROR";
+export type ModelOutputValidationIssue = {
+    toolName?: string;
+    error: string;
+    fieldName?: string;
+    characterOffset?: number;
+    hint?: string;
+};
+export type ModelOutputRepairContext = {
+    kind: 'invalid_tool_calls';
+    issues: ModelOutputValidationIssue[];
+};
+/**
+ * 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.
+ */
+export declare class ModelOutputValidationError extends Error {
+    readonly repairContext: ModelOutputRepairContext;
+    readonly code: "MODEL_OUTPUT_VALIDATION_ERROR";
+    readonly retryable = true;
+    constructor(message: string, repairContext: ModelOutputRepairContext);
+}
+export declare function isModelOutputValidationError(error: unknown): error is ModelOutputValidationError;

package/src/lib/agent/middleware/runtime.d.ts

@@ -3,9 +3,9 @@ import { BaseLanguageModel } from '@langchain/core/language_models/base';
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
 import type { Runtime as LangGraphRuntime } from '@langchain/langgraph';
 import type { BaseMessage } from '@langchain/core/messages';
-import { ICopilotModel, ILLMUsage, IXpertAgentExecution, JSONValue, TSandboxConfigurable } from '@xpert-ai/contracts';
+import { ICopilotModel, IXpertAgentExecution, JSONValue, ModelUsagePricingSnapshot, ModelUsageReport, ModelUsageReportResult, ModelUsagePricingContext, TSandboxConfigurable } from '@xpert-ai/contracts';
 import { Subscriber } from 'rxjs';
-import { IRerank } from '../../ai-model/types';
+import { AIGCModelClient, AsyncAIGCModelClient, IRerank, TLLMUsage } from '../../ai-model/types';
 import type { RuntimeCapabilityRegistry } from '../../core';
 export * from './runtime-capability';
 export * from './capabilities';
@@ -64,11 +64,48 @@ export type Runtime<TContext = unknown> = Partial<Omit<LangGraphRuntime<TContext
         [key: string]: unknown;
     };
 };
-export type AgentMiddlewareModelClient = BaseLanguageModel | BaseChatModel | Embeddings | IRerank;
+export type AgentMiddlewareModelClient = BaseLanguageModel | BaseChatModel | Embeddings | IRerank | AIGCModelClient | AsyncAIGCModelClient;
 export type AgentMiddlewareCreateModelClientOptions = {
     abortController?: AbortController;
-    usageCallback: (tokens: ILLMUsage) => void;
+    usageCallback?: (tokens: TLLMUsage) => void | Promise<void>;
+    /** `observe` reads an existing asynchronous task and must not consume generation quota. */
+    purpose?: 'invoke' | 'observe';
 };
+export type AgentMiddlewareModelProviderConnection = {
+    /** Stable host-owned model provider configuration boundary. */
+    providerScopeId: string;
+    /** Host-owned Copilot identity used for usage accounting. */
+    copilotId?: string;
+    /** Ownership scope of the resolved Provider configuration. */
+    organizationId?: string | null;
+    provider: string;
+    baseURL: string;
+    authorization: string;
+    /** Resolve the model YAML price rule and freeze it for one invocation. */
+    resolvePricingSnapshot?: (context: ModelUsagePricingContext) => Promise<ModelUsagePricingSnapshot>;
+    /** Persist final authoritative usage and calculate its charge exactly once. */
+    reportUsage(report: ModelUsageReport): Promise<ModelUsageReportResult>;
+};
+export type AgentMiddlewareRuntimeScope = {
+    tenantId?: string | null;
+    organizationId?: string | null;
+    providerScopeId?: string | null;
+    userId?: string | null;
+    workspaceId?: string | null;
+    projectId?: string | null;
+    xpertId?: string | null;
+    xpertName?: string | null;
+    conversationId?: string | null;
+    agentKey?: string | null;
+    executionId?: string | null;
+    usageCallback?: (usage: TLLMUsage) => void | Promise<void>;
+    workspaceRoot?: string | null;
+    workspacePath?: string | null;
+};
+export interface AgentMiddlewareRuntimeServiceApi {
+    createScopedApi(scope?: AgentMiddlewareRuntimeScope): AgentMiddlewareRuntimeApi;
+}
+export declare const XPERT_AGENT_MIDDLEWARE_RUNTIME_TOKEN = "XPERT_AGENT_MIDDLEWARE_RUNTIME";
 export type AgentMiddlewareWrapWorkflowNodeExecutionResult<T> = {
     output?: string | JSONValue;
     state: T;
@@ -97,6 +134,8 @@ export type AgentMiddlewareEvent = {
 };
 export interface AgentMiddlewareRuntimeApi {
     createModelClient<T = AgentMiddlewareModelClient>(copilotModel: ICopilotModel, options: AgentMiddlewareCreateModelClientOptions): Promise<T>;
+    /** Resolve an enabled model provider connection in the current tenant and organization scope. */
+    getModelProvider?(provider: string): Promise<AgentMiddlewareModelProviderConnection>;
     wrapWorkflowNodeExecution<T>(run: (execution: Partial<IXpertAgentExecution>) => Promise<AgentMiddlewareWrapWorkflowNodeExecutionResult<T>>, params: AgentMiddlewareWrapWorkflowNodeExecutionParams): Promise<T>;
     emitMiddlewareEvent?(event: AgentMiddlewareEvent): Promise<void> | void;
     capabilities?: RuntimeCapabilityRegistry;

package/src/lib/ai-model/abstract-provider.d.ts

@@ -5,7 +5,7 @@ import { AIModelEntity, AiModelTypeEnum, IAiProviderEntity, ICopilotModel, Provi
 import { Logger } from '@nestjs/common';
 import { AIModel } from './ai-model';
 import { IAIModelProviderStrategy } from './ai-model-provider.interface';
-import { TChatModelOptions, IRerank } from './types/';
+import { AIGCModelClient, AsyncAIGCModelClient, TChatModelOptions, IRerank } from './types/';
 export declare abstract class ModelProvider implements IAIModelProviderStrategy {
     readonly logger: Logger;
     protected _name?: string;
@@ -37,5 +37,5 @@ export declare abstract class ModelProvider implements IAIModelProviderStrategy
     getProviderModels(modelType?: AiModelTypeEnum, onlyActive?: boolean): ProviderModel[];
     getSystemProviderModels(modelTypes: AiModelTypeEnum[]): any[];
     getChatModel(copilotModel: ICopilotModel, options?: TChatModelOptions): BaseChatModel<import("@langchain/core/language_models/chat_models").BaseChatModelCallOptions, import("@langchain/core/messages").AIMessageChunk>;
-    getModelInstance(type: AiModelTypeEnum, copilotModel: ICopilotModel, options?: TChatModelOptions): Promise<BaseLanguageModel | BaseChatModel | Embeddings | IRerank>;
+    getModelInstance(type: AiModelTypeEnum, copilotModel: ICopilotModel, options?: TChatModelOptions): Promise<BaseLanguageModel | BaseChatModel | Embeddings | IRerank | AIGCModelClient | AsyncAIGCModelClient>;
 }

package/src/lib/ai-model/ai-model-provider.interface.d.ts

@@ -2,7 +2,7 @@ import { AiModelTypeEnum, IAiProviderEntity, ICopilotModel, ProviderModel, AIMod
 import { BaseLanguageModel } from '@langchain/core/language_models/base';
 import { Embeddings } from '@langchain/core/embeddings';
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { IRerank } from './types';
+import { AIGCModelClient, AsyncAIGCModelClient, IRerank } from './types';
 import { AIModel } from './ai-model';
 export interface IAIModelProviderStrategy {
     /**
@@ -29,9 +29,9 @@ export interface IAIModelProviderStrategy {
      */
     getModels(modelType: AiModelTypeEnum): Promise<AIModelEntity[]>;
     /**
-     * Return a directly usable model instance (LLM / Embedding / TTS / Rerank)
+     * Return a directly usable model instance (LLM / Embedding / TTS / Rerank / AIGC)
      */
-    getModelInstance(type: AiModelTypeEnum, copilotModel: ICopilotModel, options?: Record<string, any>): Promise<BaseLanguageModel | BaseChatModel | Embeddings | IRerank>;
+    getModelInstance(type: AiModelTypeEnum, copilotModel: ICopilotModel, options?: Record<string, any>): Promise<BaseLanguageModel | BaseChatModel | Embeddings | IRerank | AIGCModelClient | AsyncAIGCModelClient>;
     /**
      * Return the defined provider models (metadata)
      */

package/src/lib/ai-model/ai-model.d.ts

@@ -1,7 +1,8 @@
 import { BaseChatModel } from '@langchain/core/language_models/chat_models';
-import { AIModelEntity, AiModelTypeEnum, ICopilotModel, ParameterRule, PriceInfo, PriceType } from '@xpert-ai/contracts';
+import { AIModelEntity, AiModelTypeEnum, ICopilotModel, ModelUsagePricingContext, ModelUsagePricingSnapshot, ParameterRule, PriceInfo, PriceType } from '@xpert-ai/contracts';
 import { Logger } from '@nestjs/common';
 import { ModelProvider } from './abstract-provider';
+import type { AIGCModelClient, AsyncAIGCModelClient } from './types/aigc';
 import { IAIModel, TChatModelOptions } from './types/model';
 import { ModelProfile } from './types/profile';
 export declare abstract class AIModel implements IAIModel {
@@ -13,7 +14,9 @@ export declare abstract class AIModel implements IAIModel {
     constructor(modelProvider: ModelProvider, modelType: AiModelTypeEnum);
     abstract validateCredentials(model: string, credentials: Record<string, any>): Promise<void>;
     getChatModel(copilotModel: ICopilotModel, options?: TChatModelOptions): BaseChatModel;
+    getAIGCModel(copilotModel: ICopilotModel, options?: TChatModelOptions): AIGCModelClient | AsyncAIGCModelClient;
     getPrice(model: string, credentials: Record<string, any>, priceType: PriceType, tokens: number, inputTokens?: number): PriceInfo;
+    getUsagePricingSnapshot(model: string, credentials: Record<string, any>, context: ModelUsagePricingContext): ModelUsagePricingSnapshot;
     protected getModelPath(): string;
     predefinedModels(): AIModelEntity[];
     getModelSchema(model: string, credentials?: Record<string, any>): AIModelEntity | null;

package/src/lib/ai-model/index.d.ts

@@ -5,7 +5,9 @@ export * from './abstract-provider';
 export * from './types';
 export * from './llm';
 export * from './pricing';
+export * from './managed-aigc-job';
 export * from './errors';
 export * from './openai-compatible';
+export * from './model-provider-http-client';
 export * from './utils/index';
 export * from './commands/index';

package/src/lib/ai-model/llm.d.ts

@@ -1,5 +1,6 @@
 import { AIModelEntity, ICopilot, ILLMUsage, ParameterRule, TTokenUsage } from '@xpert-ai/contracts';
 import { Logger } from '@nestjs/common';
+import { BaseCallbackHandler } from '@langchain/core/callbacks/base';
 import { LLMResult } from '@langchain/core/outputs';
 import { AIModel } from './ai-model';
 import { TChatModelOptions } from './types/';
@@ -32,10 +33,55 @@ export declare abstract class LargeLanguageModel extends AIModel {
     #private;
     protected startedAt: DOMHighResTimeStamp;
     protected _commonParameterRules(model: string): ParameterRule[];
-    protected calcResponseUsage(model: string, credentials: Record<string, any>, promptTokens: number, completionTokens: number): ILLMUsage;
+    protected calcResponseUsage(model: string, credentials: Record<string, any>, promptTokens: number, completionTokens: number, startedAt?: number): ILLMUsage;
     createHandleUsageCallbacks(copilot: ICopilot, model: string, credentials: any, handleLLMTokens: TChatModelOptions['handleLLMTokens']): {
-        handleLLMStart: () => void;
-        handleLLMEnd: (output: any) => void;
+        name: string;
+        lc_serializable: boolean;
+        readonly lc_namespace: ["langchain_core", "callbacks", string];
+        readonly lc_secrets: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_attributes: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_aliases: {
+            [key: string]: string;
+        } | undefined;
+        readonly lc_serializable_keys: string[] | undefined;
+        readonly lc_id: string[];
+        lc_kwargs: import("@langchain/core/dist/load/map_keys").SerializedFields;
+        ignoreLLM: boolean;
+        ignoreChain: boolean;
+        ignoreAgent: boolean;
+        ignoreRetriever: boolean;
+        ignoreCustomEvent: boolean;
+        raiseError: boolean;
+        awaitHandlers: boolean;
+        copy(): BaseCallbackHandler;
+        toJSON(): import("@langchain/core/load/serializable").Serialized;
+        toJSONNotImplemented(): import("@langchain/core/load/serializable").SerializedNotImplemented;
+        handleLLMStart?(llm: import("@langchain/core/load/serializable").Serialized, prompts: string[], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<any> | any;
+        handleLLMNewToken?(token: string, idx: import("@langchain/core/callbacks/base").NewTokenIndices, runId: string, parentRunId?: string, tags?: string[], fields?: import("@langchain/core/callbacks/base").HandleLLMNewTokenCallbackFields): Promise<any> | any;
+        handleLLMError?(err: any, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): Promise<any> | any;
+        handleLLMEnd?(output: LLMResult, runId: string, parentRunId?: string, tags?: string[], extraParams?: Record<string, unknown>): Promise<any> | any;
+        handleChatModelStart?(llm: import("@langchain/core/load/serializable").Serialized, messages: import("@langchain/core/messages").BaseMessage[][], runId: string, parentRunId?: string, extraParams?: Record<string, unknown>, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<any> | any;
+        handleChainStart?(chain: import("@langchain/core/load/serializable").Serialized, inputs: import("@langchain/core/utils/types").ChainValues, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runType?: string, runName?: string): Promise<any> | any;
+        handleChainError?(err: any, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+            inputs?: Record<string, unknown>;
+        }): Promise<any> | any;
+        handleChainEnd?(outputs: import("@langchain/core/utils/types").ChainValues, runId: string, parentRunId?: string, tags?: string[], kwargs?: {
+            inputs?: Record<string, unknown>;
+        }): Promise<any> | any;
+        handleToolStart?(tool: import("@langchain/core/load/serializable").Serialized, input: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, runName?: string): Promise<any> | any;
+        handleToolError?(err: any, runId: string, parentRunId?: string, tags?: string[]): Promise<any> | any;
+        handleToolEnd?(output: any, runId: string, parentRunId?: string, tags?: string[]): Promise<any> | any;
+        handleText?(text: string, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+        handleAgentAction?(action: import("@langchain/core/dist/agents").AgentAction, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+        handleAgentEnd?(action: import("@langchain/core/dist/agents").AgentFinish, runId: string, parentRunId?: string, tags?: string[]): Promise<void> | void;
+        handleRetrieverStart?(retriever: import("@langchain/core/load/serializable").Serialized, query: string, runId: string, parentRunId?: string, tags?: string[], metadata?: Record<string, unknown>, name?: string): Promise<any> | any;
+        handleRetrieverEnd?(documents: import("@langchain/core/documents").DocumentInterface[], runId: string, parentRunId?: string, tags?: string[]): Promise<any> | any;
+        handleRetrieverError?(err: any, runId: string, parentRunId?: string, tags?: string[]): Promise<any> | any;
+        handleCustomEvent?(eventName: string, data: any, runId: string, tags?: string[], metadata?: Record<string, any>): Promise<any> | any;
     }[];
     createHandleLLMErrorCallbacks(fields: any, logger?: Logger): {
         handleLLMError: (err: any) => void;