@xpert-ai/plugin-sdk 3.6.7 → 3.7.0

package/SCHEMA_SPECIFICATION.md

@@ -22,7 +22,8 @@
 
 | 字段名            | 类型     | 说明                                                                                                                       |
 | -------------- | ------ | ------------------------------------------------------------------------------------------------------------------------ |
-| `component`    | string | 指定 UI 组件类型，如 `textInput`, `textarea`, `select`, `switch`, `slider`, `promptEditor`, `modelProviderSelect`, `modelSelect` |
+| `component`    | string | 指定 UI 组件类型，如 `textInput`, `textarea`, `select`, `switch`, `slider`, `prompt-editor`, `ai-model-select` |
+| `inputs`       | object | 自定义组件的额外输入属性值  |
 | `label`        | string | UI 展示的标签                                                                                                                 |
 | `description`  | string | UI 展示的帮助文本，优先覆盖 schema.description                                                                                       |
 | `help`         | string | 额外提示信息，如 tooltip，前端会按需展示小问号或工具提示                                                                             |

package/index.cjs.js

@@ -4,6 +4,7 @@ var common = require('@nestjs/common');
 var constants = require('@nestjs/common/constants');
 var lodashEs = require('lodash-es');
 var core = require('@nestjs/core');
+var cqrs = require('@nestjs/cqrs');
 var fs = require('fs');
 var http = require('http');
 var https = require('https');
@@ -210,6 +211,17 @@ exports.WorkflowNodeRegistry = __decorate([
     ])
 ], exports.WorkflowNodeRegistry);
 
+/**
+ * Wrap Workflow Node Execution Command
+ */ class WrapWorkflowNodeExecutionCommand extends cqrs.Command {
+    constructor(fuc, params){
+        super();
+        this.fuc = fuc;
+        this.params = params;
+    }
+}
+WrapWorkflowNodeExecutionCommand.type = '[Workflow] Wrap Workflow Node Execution';
+
 const VECTOR_STORE_STRATEGY = 'VECTOR_STORE_STRATEGY';
 const VectorStoreStrategy = (provider)=>common.SetMetadata(VECTOR_STORE_STRATEGY, provider);
 
@@ -1080,6 +1092,93 @@ class BaseSQLQueryRunner extends BaseQueryRunner {
     async ping() {
         await this.runQuery(`SELECT 1`);
     }
+    /**
+   * Default implementation for table operations
+   */ async tableOp(action, params, options) {
+        switch(action){
+            case "createTable":
+                {
+                    // Default implementation for creating table (generic SQL syntax)
+                    const { schema, table, columns, createMode = "error" } = params;
+                    const tableName = schema ? `${schema}.${table}` : table;
+                    // Check if table exists (try to query table info)
+                    let exists = false;
+                    try {
+                        const result = await this.runQuery(`SELECT * FROM ${tableName} WHERE 1=0`, options);
+                        exists = true;
+                    } catch (error) {
+                        // Table does not exist
+                        exists = false;
+                    }
+                    // --- MODE: ERROR → throw error if table exists ---
+                    if (exists && createMode === "error") {
+                        throw new Error(`Table "${tableName}" already exists`);
+                    }
+                    // --- MODE: IGNORE → do nothing if exists ---
+                    if (exists && createMode === "ignore") {
+                        return;
+                    }
+                    // --- MODE: UPGRADE → auto upgrade (simple implementation: only add new columns) ---
+                    // Note: This default implementation does not support modifying column types, 
+                    //       recommend each database to implement its own version
+                    if (exists && createMode === "upgrade") {
+                        console.warn(`[BaseSQLQueryRunner] UPGRADE mode uses basic implementation. Consider implementing tableOp for better support.`);
+                        // Try to add new columns (will fail if column already exists, but doesn't affect)
+                        for (const col of columns){
+                            try {
+                                const colType = this.mapColumnType(col.type, col.isKey, col.length);
+                                await this.runQuery(`ALTER TABLE ${tableName} ADD COLUMN ${col.fieldName} ${colType}`, options);
+                            } catch (error) {
+                                // Field might already exist, ignore error
+                                console.debug(`Failed to add column ${col.fieldName}:`, error instanceof Error ? error.message : String(error));
+                            }
+                        }
+                        return;
+                    }
+                    // --- MODE: CREATE NEW TABLE ---
+                    const columnsDDL = columns.map((col)=>{
+                        const colType = this.mapColumnType(col.type, col.isKey, col.length);
+                        const pk = col.isKey ? ' PRIMARY KEY' : '';
+                        const notNull = col.required ? ' NOT NULL' : '';
+                        return `${col.fieldName} ${colType}${pk}${notNull}`;
+                    }).join(', ');
+                    const createTableStatement = `CREATE TABLE ${tableName} (${columnsDDL})`;
+                    await this.runQuery(createTableStatement, options);
+                    return;
+                }
+            case "dropTable":
+                {
+                    // Default implementation for dropping table
+                    const { schema, table } = params;
+                    const tableName = schema ? `${schema}.${table}` : table;
+                    await this.runQuery(`DROP TABLE IF EXISTS ${tableName}`, options);
+                    return;
+                }
+            default:
+                // Throw error for other unimplemented operations
+                throw new Error(`Unsupported table action: ${action}`);
+        }
+    }
+    /**
+   * Generic type mapping (subclasses can override)
+   */ mapColumnType(type, isKey, length) {
+        switch(type == null ? void 0 : type.toLowerCase()){
+            case 'string':
+                return length ? `VARCHAR(${length})` : isKey ? 'VARCHAR(255)' : 'VARCHAR(1000)';
+            case 'number':
+                return 'INT';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'date':
+                return 'DATE';
+            case 'datetime':
+                return 'TIMESTAMP';
+            case 'object':
+                return 'TEXT';
+            default:
+                return 'VARCHAR(1000)';
+        }
+    }
     constructor(...args){
         super(...args);
         this.syntax = "sql";
@@ -2049,6 +2148,42 @@ class Speech2TextChatModel extends chat_models.BaseChatModel {
     return 0;
 }
 
+/**
+ * Get a Chat Model of copilot model and check it's token limitation, record the token usage
+ */ class CreateModelClientCommand extends cqrs.Command {
+    constructor(copilotModel, options){
+        super();
+        this.copilotModel = copilotModel;
+        this.options = options;
+    }
+}
+CreateModelClientCommand.type = '[AI Model] Create Model Client';
+
+const AGENT_MIDDLEWARE_STRATEGY = 'AGENT_MIDDLEWARE_STRATEGY';
+const AgentMiddlewareStrategy = (provider)=>common.SetMetadata(AGENT_MIDDLEWARE_STRATEGY, provider);
+
+exports.AgentMiddlewareRegistry = class AgentMiddlewareRegistry extends BaseStrategyRegistry {
+    constructor(discoveryService, reflector){
+        super(AGENT_MIDDLEWARE_STRATEGY, discoveryService, reflector);
+    }
+};
+exports.AgentMiddlewareRegistry = __decorate([
+    common.Injectable(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        typeof core.DiscoveryService === "undefined" ? Object : core.DiscoveryService,
+        typeof core.Reflector === "undefined" ? Object : core.Reflector
+    ])
+], exports.AgentMiddlewareRegistry);
+
+/**
+ * jump targets (user facing)
+ */ const JUMP_TO_TARGETS = [
+    "model",
+    "tools",
+    "end"
+];
+
 Object.defineProperty(exports, "IColumnDef", {
 	enumerable: true,
 	get: function () { return contracts.IColumnDef; }
@@ -2065,10 +2200,12 @@ Object.defineProperty(exports, "TDocumentAsset", {
 	enumerable: true,
 	get: function () { return contracts.TDocumentAsset; }
 });
+exports.AGENT_MIDDLEWARE_STRATEGY = AGENT_MIDDLEWARE_STRATEGY;
 exports.AIModelProviderNotFoundException = AIModelProviderNotFoundException;
 exports.AIModelProviderStrategy = AIModelProviderStrategy;
 exports.AI_MODEL_PROVIDER = AI_MODEL_PROVIDER;
 exports.AdapterDataSourceStrategy = AdapterDataSourceStrategy;
+exports.AgentMiddlewareStrategy = AgentMiddlewareStrategy;
 exports.AiModelNotFoundException = AiModelNotFoundException;
 exports.BaseHTTPQueryRunner = BaseHTTPQueryRunner;
 exports.BaseQueryRunner = BaseQueryRunner;
@@ -2078,6 +2215,7 @@ exports.BaseToolset = BaseToolset;
 exports.BuiltinToolset = BuiltinToolset;
 exports.ChatOAICompatReasoningModel = ChatOAICompatReasoningModel;
 exports.CommonParameterRules = CommonParameterRules;
+exports.CreateModelClientCommand = CreateModelClientCommand;
 exports.CredentialsValidateFailedError = CredentialsValidateFailedError;
 exports.DATASOURCE_STRATEGY = DATASOURCE_STRATEGY;
 exports.DOCUMENT_SOURCE_STRATEGY = DOCUMENT_SOURCE_STRATEGY;
@@ -2089,6 +2227,7 @@ exports.IMAGE_UNDERSTANDING_STRATEGY = IMAGE_UNDERSTANDING_STRATEGY;
 exports.INTEGRATION_STRATEGY = INTEGRATION_STRATEGY;
 exports.ImageUnderstandingStrategy = ImageUnderstandingStrategy;
 exports.IntegrationStrategyKey = IntegrationStrategyKey;
+exports.JUMP_TO_TARGETS = JUMP_TO_TARGETS;
 exports.KNOWLEDGE_STRATEGY = KNOWLEDGE_STRATEGY;
 exports.KnowledgeStrategyKey = KnowledgeStrategyKey;
 exports.LLMUsage = LLMUsage;
@@ -2119,6 +2258,7 @@ exports.WORKFLOW_NODE_STRATEGY = WORKFLOW_NODE_STRATEGY;
 exports.WORKFLOW_TRIGGER_STRATEGY = WORKFLOW_TRIGGER_STRATEGY;
 exports.WorkflowNodeStrategy = WorkflowNodeStrategy;
 exports.WorkflowTriggerStrategy = WorkflowTriggerStrategy;
+exports.WrapWorkflowNodeExecutionCommand = WrapWorkflowNodeExecutionCommand;
 exports.XpFileSystem = XpFileSystem;
 exports.XpertServerPlugin = XpertServerPlugin;
 exports.als = als;

package/index.esm.js

@@ -2,6 +2,7 @@ import { Module, Logger, SetMetadata, Injectable, HttpException, HttpStatus, Not
 import { MODULE_METADATA } from '@nestjs/common/constants';
 import { pick } from 'lodash-es';
 import { DiscoveryService, Reflector } from '@nestjs/core';
+import { Command } from '@nestjs/cqrs';
 import * as fs from 'fs';
 import fs__default from 'fs';
 import http from 'http';
@@ -190,6 +191,17 @@ WorkflowNodeRegistry = __decorate([
     ])
 ], WorkflowNodeRegistry);
 
+/**
+ * Wrap Workflow Node Execution Command
+ */ class WrapWorkflowNodeExecutionCommand extends Command {
+    constructor(fuc, params){
+        super();
+        this.fuc = fuc;
+        this.params = params;
+    }
+}
+WrapWorkflowNodeExecutionCommand.type = '[Workflow] Wrap Workflow Node Execution';
+
 const VECTOR_STORE_STRATEGY = 'VECTOR_STORE_STRATEGY';
 const VectorStoreStrategy = (provider)=>SetMetadata(VECTOR_STORE_STRATEGY, provider);
 
@@ -1060,6 +1072,93 @@ class BaseSQLQueryRunner extends BaseQueryRunner {
     async ping() {
         await this.runQuery(`SELECT 1`);
     }
+    /**
+   * Default implementation for table operations
+   */ async tableOp(action, params, options) {
+        switch(action){
+            case "createTable":
+                {
+                    // Default implementation for creating table (generic SQL syntax)
+                    const { schema, table, columns, createMode = "error" } = params;
+                    const tableName = schema ? `${schema}.${table}` : table;
+                    // Check if table exists (try to query table info)
+                    let exists = false;
+                    try {
+                        const result = await this.runQuery(`SELECT * FROM ${tableName} WHERE 1=0`, options);
+                        exists = true;
+                    } catch (error) {
+                        // Table does not exist
+                        exists = false;
+                    }
+                    // --- MODE: ERROR → throw error if table exists ---
+                    if (exists && createMode === "error") {
+                        throw new Error(`Table "${tableName}" already exists`);
+                    }
+                    // --- MODE: IGNORE → do nothing if exists ---
+                    if (exists && createMode === "ignore") {
+                        return;
+                    }
+                    // --- MODE: UPGRADE → auto upgrade (simple implementation: only add new columns) ---
+                    // Note: This default implementation does not support modifying column types, 
+                    //       recommend each database to implement its own version
+                    if (exists && createMode === "upgrade") {
+                        console.warn(`[BaseSQLQueryRunner] UPGRADE mode uses basic implementation. Consider implementing tableOp for better support.`);
+                        // Try to add new columns (will fail if column already exists, but doesn't affect)
+                        for (const col of columns){
+                            try {
+                                const colType = this.mapColumnType(col.type, col.isKey, col.length);
+                                await this.runQuery(`ALTER TABLE ${tableName} ADD COLUMN ${col.fieldName} ${colType}`, options);
+                            } catch (error) {
+                                // Field might already exist, ignore error
+                                console.debug(`Failed to add column ${col.fieldName}:`, error instanceof Error ? error.message : String(error));
+                            }
+                        }
+                        return;
+                    }
+                    // --- MODE: CREATE NEW TABLE ---
+                    const columnsDDL = columns.map((col)=>{
+                        const colType = this.mapColumnType(col.type, col.isKey, col.length);
+                        const pk = col.isKey ? ' PRIMARY KEY' : '';
+                        const notNull = col.required ? ' NOT NULL' : '';
+                        return `${col.fieldName} ${colType}${pk}${notNull}`;
+                    }).join(', ');
+                    const createTableStatement = `CREATE TABLE ${tableName} (${columnsDDL})`;
+                    await this.runQuery(createTableStatement, options);
+                    return;
+                }
+            case "dropTable":
+                {
+                    // Default implementation for dropping table
+                    const { schema, table } = params;
+                    const tableName = schema ? `${schema}.${table}` : table;
+                    await this.runQuery(`DROP TABLE IF EXISTS ${tableName}`, options);
+                    return;
+                }
+            default:
+                // Throw error for other unimplemented operations
+                throw new Error(`Unsupported table action: ${action}`);
+        }
+    }
+    /**
+   * Generic type mapping (subclasses can override)
+   */ mapColumnType(type, isKey, length) {
+        switch(type == null ? void 0 : type.toLowerCase()){
+            case 'string':
+                return length ? `VARCHAR(${length})` : isKey ? 'VARCHAR(255)' : 'VARCHAR(1000)';
+            case 'number':
+                return 'INT';
+            case 'boolean':
+                return 'BOOLEAN';
+            case 'date':
+                return 'DATE';
+            case 'datetime':
+                return 'TIMESTAMP';
+            case 'object':
+                return 'TEXT';
+            default:
+                return 'VARCHAR(1000)';
+        }
+    }
     constructor(...args){
         super(...args);
         this.syntax = "sql";
@@ -2029,4 +2128,40 @@ class Speech2TextChatModel extends BaseChatModel {
     return 0;
 }
 
-export { AIModelProviderNotFoundException, AIModelProviderRegistry, AIModelProviderStrategy, AI_MODEL_PROVIDER, AdapterDataSourceStrategy, AiModelNotFoundException, BaseHTTPQueryRunner, BaseQueryRunner, BaseSQLQueryRunner, BaseTool, BaseToolset, BuiltinToolset, ChatOAICompatReasoningModel, CommonParameterRules, CredentialsValidateFailedError, DATASOURCE_STRATEGY, DBCreateTableMode, DBProtocolEnum, DBSyntaxEnum, DBTableAction, DBTableDataAction, DOCUMENT_SOURCE_STRATEGY, DOCUMENT_TRANSFORMER_STRATEGY, DataSourceStrategy, DataSourceStrategyRegistry, DocumentSourceRegistry, DocumentSourceStrategy, DocumentTransformerRegistry, DocumentTransformerStrategy, IMAGE_UNDERSTANDING_STRATEGY, INTEGRATION_STRATEGY, ImageUnderstandingRegistry, ImageUnderstandingStrategy, IntegrationStrategyKey, IntegrationStrategyRegistry, KNOWLEDGE_STRATEGY, KnowledgeStrategyKey, KnowledgeStrategyRegistry, LLMUsage, LargeLanguageModel, ModelProvider, OpenAICompatibleReranker, PLUGIN_METADATA, PROVIDE_AI_MODEL_LLM, PROVIDE_AI_MODEL_MODERATION, PROVIDE_AI_MODEL_RERANK, PROVIDE_AI_MODEL_SPEECH2TEXT, PROVIDE_AI_MODEL_TEXT_EMBEDDING, PROVIDE_AI_MODEL_TTS, RETRIEVER_STRATEGY, RequestContext, RequestContextMiddleware, RerankModel, RetrieverRegistry, RetrieverStrategy, Speech2TextChatModel, SpeechToTextModel, TEXT_SPLITTER_STRATEGY, TOOLSET_STRATEGY, TextEmbeddingModelManager, TextSplitterRegistry, TextSplitterStrategy, TextToSpeechModel, ToolsetRegistry, ToolsetStrategy, VECTOR_STORE_STRATEGY, VectorStoreRegistry, VectorStoreStrategy, WORKFLOW_NODE_STRATEGY, WORKFLOW_TRIGGER_STRATEGY, WorkflowNodeRegistry, WorkflowNodeStrategy, WorkflowTriggerRegistry, WorkflowTriggerStrategy, XpFileSystem, XpertServerPlugin, als, calcTokenUsage, countTokensSafe, createI18nInstance, createPluginLogger, downloadRemoteFile, getErrorMessage, getPositionList, getPositionMap, getRequestContext, isRemoteFile, loadYamlFile, mergeCredentials, mergeParentChildChunks, runWithRequestContext, sumTokenUsage };
+/**
+ * Get a Chat Model of copilot model and check it's token limitation, record the token usage
+ */ class CreateModelClientCommand extends Command {
+    constructor(copilotModel, options){
+        super();
+        this.copilotModel = copilotModel;
+        this.options = options;
+    }
+}
+CreateModelClientCommand.type = '[AI Model] Create Model Client';
+
+const AGENT_MIDDLEWARE_STRATEGY = 'AGENT_MIDDLEWARE_STRATEGY';
+const AgentMiddlewareStrategy = (provider)=>SetMetadata(AGENT_MIDDLEWARE_STRATEGY, provider);
+
+let AgentMiddlewareRegistry = class AgentMiddlewareRegistry extends BaseStrategyRegistry {
+    constructor(discoveryService, reflector){
+        super(AGENT_MIDDLEWARE_STRATEGY, discoveryService, reflector);
+    }
+};
+AgentMiddlewareRegistry = __decorate([
+    Injectable(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        typeof DiscoveryService === "undefined" ? Object : DiscoveryService,
+        typeof Reflector === "undefined" ? Object : Reflector
+    ])
+], AgentMiddlewareRegistry);
+
+/**
+ * jump targets (user facing)
+ */ const JUMP_TO_TARGETS = [
+    "model",
+    "tools",
+    "end"
+];
+
+export { AGENT_MIDDLEWARE_STRATEGY, AIModelProviderNotFoundException, AIModelProviderRegistry, AIModelProviderStrategy, AI_MODEL_PROVIDER, AdapterDataSourceStrategy, AgentMiddlewareRegistry, AgentMiddlewareStrategy, AiModelNotFoundException, BaseHTTPQueryRunner, BaseQueryRunner, BaseSQLQueryRunner, BaseTool, BaseToolset, BuiltinToolset, ChatOAICompatReasoningModel, CommonParameterRules, CreateModelClientCommand, CredentialsValidateFailedError, DATASOURCE_STRATEGY, DBCreateTableMode, DBProtocolEnum, DBSyntaxEnum, DBTableAction, DBTableDataAction, DOCUMENT_SOURCE_STRATEGY, DOCUMENT_TRANSFORMER_STRATEGY, DataSourceStrategy, DataSourceStrategyRegistry, DocumentSourceRegistry, DocumentSourceStrategy, DocumentTransformerRegistry, DocumentTransformerStrategy, IMAGE_UNDERSTANDING_STRATEGY, INTEGRATION_STRATEGY, ImageUnderstandingRegistry, ImageUnderstandingStrategy, IntegrationStrategyKey, IntegrationStrategyRegistry, JUMP_TO_TARGETS, KNOWLEDGE_STRATEGY, KnowledgeStrategyKey, KnowledgeStrategyRegistry, LLMUsage, LargeLanguageModel, ModelProvider, OpenAICompatibleReranker, PLUGIN_METADATA, PROVIDE_AI_MODEL_LLM, PROVIDE_AI_MODEL_MODERATION, PROVIDE_AI_MODEL_RERANK, PROVIDE_AI_MODEL_SPEECH2TEXT, PROVIDE_AI_MODEL_TEXT_EMBEDDING, PROVIDE_AI_MODEL_TTS, RETRIEVER_STRATEGY, RequestContext, RequestContextMiddleware, RerankModel, RetrieverRegistry, RetrieverStrategy, Speech2TextChatModel, SpeechToTextModel, TEXT_SPLITTER_STRATEGY, TOOLSET_STRATEGY, TextEmbeddingModelManager, TextSplitterRegistry, TextSplitterStrategy, TextToSpeechModel, ToolsetRegistry, ToolsetStrategy, VECTOR_STORE_STRATEGY, VectorStoreRegistry, VectorStoreStrategy, WORKFLOW_NODE_STRATEGY, WORKFLOW_TRIGGER_STRATEGY, WorkflowNodeRegistry, WorkflowNodeStrategy, WorkflowTriggerRegistry, WorkflowTriggerStrategy, WrapWorkflowNodeExecutionCommand, XpFileSystem, XpertServerPlugin, als, calcTokenUsage, countTokensSafe, createI18nInstance, createPluginLogger, downloadRemoteFile, getErrorMessage, getPositionList, getPositionMap, getRequestContext, isRemoteFile, loadYamlFile, mergeCredentials, mergeParentChildChunks, runWithRequestContext, sumTokenUsage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xpert-ai/plugin-sdk",
-  "version": "3.6.7",
+  "version": "3.7.0",
   "license": "AGPL-3.0",
   "repository": {
     "type": "git",
@@ -22,6 +22,7 @@
     "@metad/contracts": "*",
     "@nestjs/common": "*",
     "@nestjs/core": "*",
+    "@nestjs/cqrs": "*",
     "lodash-es": "*",
     "i18next-fs-backend": "*",
     "i18next": "*",

package/src/index.d.ts

@@ -11,3 +11,4 @@ export * from './lib/toolset/index';
 export * from './lib/core/index';
 export * from './lib/data/index';
 export * from './lib/ai-model/index';
+export * from './lib/agent/index';

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

@@ -0,0 +1 @@
+export * from './middleware';

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

@@ -0,0 +1,4 @@
+export * from './strategy.decorator';
+export * from './strategy.interface';
+export * from './strategy.registry';
+export * from './types';

package/src/lib/agent/middleware/strategy.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const AGENT_MIDDLEWARE_STRATEGY = "AGENT_MIDDLEWARE_STRATEGY";
+export declare const AgentMiddlewareStrategy: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/agent/middleware/strategy.interface.d.ts

@@ -0,0 +1,16 @@
+import { IWFNMiddleware, TAgentMiddlewareMeta } from '@metad/contracts';
+import { AgentMiddleware, PromiseOrValue } from './types';
+export interface IAgentMiddlewareContext {
+    tenantId: string;
+    userId: string;
+    workspaceId?: string;
+    projectId?: string;
+    conversationId?: string;
+    xpertId?: string;
+    agentKey?: string;
+    node: IWFNMiddleware;
+}
+export interface IAgentMiddlewareStrategy<T = unknown> {
+    meta: TAgentMiddlewareMeta;
+    createMiddleware(options: T, context: IAgentMiddlewareContext): PromiseOrValue<AgentMiddleware>;
+}

package/src/lib/agent/middleware/strategy.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { IAgentMiddlewareStrategy } from './strategy.interface';
+export declare class AgentMiddlewareRegistry extends BaseStrategyRegistry<IAgentMiddlewareStrategy> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

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

@@ -0,0 +1,249 @@
+import { LanguageModelLike } from '@langchain/core/language_models/base';
+import { AIMessage, BaseMessage, SystemMessage } from '@langchain/core/messages';
+import { DynamicStructuredTool } from '@langchain/core/tools';
+import { InteropZodObject } from '@langchain/core/utils/types';
+/**
+ * jump targets (user facing)
+ */
+export declare const JUMP_TO_TARGETS: readonly ["model", "tools", "end"];
+export type JumpToTarget = (typeof JUMP_TO_TARGETS)[number];
+export type PromiseOrValue<T> = T | Promise<T>;
+/**
+ * Result type for middleware functions.
+ */
+export type MiddlewareResult<TState> = (TState & {
+    jumpTo?: JumpToTarget;
+}) | void;
+/**
+ * Handler function type for the beforeAgent hook.
+ * Called once at the start of agent invocation before any model calls or tool executions.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type BeforeAgentHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the beforeAgent lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called once at the start of the agent invocation.
+ */
+export type BeforeAgentHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = BeforeAgentHandler<TSchema, TContext> | {
+    hook: BeforeAgentHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the beforeModel hook.
+ * Called before the model is invoked and before the wrapModelCall hook.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+export type BeforeModelHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the beforeModel lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called before each model invocation.
+ */
+export type BeforeModelHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = BeforeModelHandler<TSchema, TContext> | {
+    hook: BeforeModelHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the afterModel hook.
+ * Called after the model is invoked and before any tools are called.
+ * Allows modifying the agent state after model invocation, e.g., to update tool call parameters.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+export type AfterModelHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the afterModel lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called after each model invocation.
+ */
+export type AfterModelHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = AfterModelHandler<TSchema, TContext> | {
+    hook: AfterModelHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Handler function type for the afterAgent hook.
+ * Called once at the end of agent invocation after all model calls and tool executions are complete.
+ *
+ * @param state - The current agent state (includes both middleware state and built-in state)
+ * @param runtime - The runtime context containing metadata, signal, writer, interrupt, etc.
+ * @returns A middleware result containing partial state updates or undefined to pass through
+ */
+type AfterAgentHandler<TSchema, TContext> = (state: TSchema, runtime: TContext) => PromiseOrValue<MiddlewareResult<Partial<TSchema>>>;
+/**
+ * Hook type for the afterAgent lifecycle event.
+ * Can be either a handler function or an object with a handler and optional jump targets.
+ * This hook is called once at the end of the agent invocation.
+ */
+export type AfterAgentHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = AfterAgentHandler<TSchema, TContext> | {
+    hook: AfterAgentHandler<TSchema, TContext>;
+    canJumpTo?: JumpToTarget[];
+};
+/**
+ * Configuration for modifying a model call at runtime.
+ * All fields are optional and only provided fields will override defaults.
+ *
+ * @template TState - The agent's state type, must extend Record<string, unknown>. Defaults to Record<string, unknown>.
+ * @template TContext - The runtime context type for accessing metadata and control flow. Defaults to unknown.
+ */
+export interface ModelRequest<TState = any, TContext = unknown> {
+    /**
+     * The model to use for this step.
+     */
+    model: LanguageModelLike;
+    /**
+     * The messages to send to the model.
+     */
+    messages: BaseMessage[];
+    systemMessage?: SystemMessage;
+}
+/**
+ * Handler function type for wrapping model calls.
+ * Takes a model request and returns the AI message response.
+ *
+ * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime
+ * @returns The AI message response from the model
+ */
+export type WrapModelCallHandler<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = (request: ModelRequest<TSchema, TContext>) => PromiseOrValue<AIMessage>;
+/**
+ * Wrapper function type for the wrapModelCall hook.
+ * Allows middleware to intercept and modify model execution.
+ * This enables you to:
+ * - Modify the request before calling the model (e.g., change system prompt, add/remove tools)
+ * - Handle errors and retry with different parameters
+ * - Post-process the response
+ * - Implement custom caching, logging, or other cross-cutting concerns
+ *
+ * @param request - The model request containing all parameters needed for the model call
+ * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response
+ * @returns The AI message response from the model (or a modified version)
+ */
+export type WrapModelCallHook<TSchema extends InteropZodObject | undefined = undefined, TContext = unknown> = (request: ModelRequest<TSchema, TContext>, handler: WrapModelCallHandler<TSchema, TContext>) => PromiseOrValue<AIMessage>;
+export interface AgentMiddleware<TSchema extends InteropZodObject | undefined = any, TContextSchema extends InteropZodObject | undefined = any, TFullContext = any> {
+    /**
+     * The name of the middleware.
+     */
+    name: string;
+    /**
+     * The schema of the middleware state. Middleware state is persisted between multiple invocations. It can be either:
+     * - A Zod object
+     * - A Zod optional object
+     * - A Zod default object
+     * - Undefined
+     */
+    stateSchema?: TSchema;
+    /**
+     * The schema of the middleware context. Middleware context is read-only and not persisted between multiple invocations. It can be either:
+     * - A Zod object
+     * - A Zod optional object
+     * - A Zod default object
+     * - Undefined
+     */
+    contextSchema?: TContextSchema;
+    tools?: DynamicStructuredTool[];
+    beforeAgent?: BeforeAgentHook<TSchema, TFullContext>;
+    beforeModel?: BeforeModelHook<TSchema, TFullContext>;
+    afterModel?: AfterModelHook<TSchema, TFullContext>;
+    afterAgent?: AfterAgentHook<TSchema, TFullContext>;
+    /**
+     * Wraps the model invocation with custom logic. This allows you to:
+     * - Modify the request before calling the model
+     * - Handle errors and retry with different parameters
+     * - Post-process the response
+     * - Implement custom caching, logging, or other cross-cutting concerns
+     *
+     * @param request - The model request containing model, messages, systemPrompt, tools, state, and runtime.
+     * @param handler - The function that invokes the model. Call this with a ModelRequest to get the response.
+     * @returns The response from the model (or a modified version).
+     *
+     * @example
+     * ```ts
+     * wrapModelCall: async (request, handler) => {
+     *   // Modify request before calling
+     *   const modifiedRequest = { ...request, systemPrompt: "You are helpful" };
+     *
+     *   try {
+     *     // Call the model
+     *     return await handler(modifiedRequest);
+     *   } catch (error) {
+     *     // Handle errors and retry with fallback
+     *     const fallbackRequest = { ...request, model: fallbackModel };
+     *     return await handler(fallbackRequest);
+     *   }
+     * }
+     * ```
+     */
+    wrapModelCall?: WrapModelCallHook<TSchema, TFullContext>;
+    /**
+     * Wraps tool execution with custom logic. This allows you to:
+     * - Modify tool call parameters before execution
+     * - Handle errors and retry with different parameters
+     * - Post-process tool results
+     * - Implement caching, logging, authentication, or other cross-cutting concerns
+     * - Return Command objects for advanced control flow
+     *
+     * The handler receives a ToolCallRequest containing the tool call, state, and runtime,
+     * along with a handler function to execute the actual tool.
+     *
+     * @param request - The tool call request containing toolCall, state, and runtime.
+     * @param handler - The function that executes the tool. Call this with a ToolCallRequest to get the result.
+     * @returns The tool result as a ToolMessage or a Command for advanced control flow.
+     *
+     * @example
+     * ```ts
+     * wrapToolCall: async (request, handler) => {
+     *   console.log(`Calling tool: ${request.tool.name}`);
+     *   console.log(`Tool description: ${request.tool.description}`);
+     *
+     *   try {
+     *     // Execute the tool
+     *     const result = await handler(request);
+     *     console.log(`Tool ${request.tool.name} succeeded`);
+     *     return result;
+     *   } catch (error) {
+     *     console.error(`Tool ${request.tool.name} failed:`, error);
+     *     // Could return a custom error message or retry
+     *     throw error;
+     *   }
+     * }
+     * ```
+     *
+     * @example Authentication
+     * ```ts
+     * wrapToolCall: async (request, handler) => {
+     *   // Check if user is authorized for this tool
+     *   if (!request.runtime.context.isAuthorized(request.tool.name)) {
+     *     return new ToolMessage({
+     *       content: "Unauthorized to call this tool",
+     *       tool_call_id: request.toolCall.id,
+     *     });
+     *   }
+     *   return handler(request);
+     * }
+     * ```
+     *
+     * @example Caching
+     * ```ts
+     * const cache = new Map();
+     * wrapToolCall: async (request, handler) => {
+     *   const cacheKey = `${request.tool.name}:${JSON.stringify(request.toolCall.args)}`;
+     *   if (cache.has(cacheKey)) {
+     *     return cache.get(cacheKey);
+     *   }
+     *   const result = await handler(request);
+     *   cache.set(cacheKey, result);
+     *   return result;
+     * }
+     * ```
+     */
+    wrapToolCall?: (request: ModelRequest<TSchema, TFullContext>, handler: WrapModelCallHandler<TSchema, TFullContext>) => PromiseOrValue<AIMessage>;
+}
+export {};

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

@@ -0,0 +1,3 @@
+export * from './skill-source-provider.interface';
+export * from './skill-source-provider.registry';
+export * from './skill-source-provider.decorator';

package/src/lib/agent/skill/skill-source-provider.decorator.d.ts

@@ -0,0 +1,2 @@
+export declare const SKILL_SOURCE_PROVIDER = "SKILL_SOURCE_PROVIDER";
+export declare const SkillSourceProviderStrategy: (provider: string) => import("@nestjs/common").CustomDecorator<string>;

package/src/lib/agent/skill/skill-source-provider.interface.d.ts

@@ -0,0 +1,23 @@
+import { ISkillRepository, ISkillRepositoryIndex, TSkillSourceMeta } from "@metad/contracts";
+export interface ISkillSourceProvider {
+    type: string;
+    meta: TSkillSourceMeta;
+    /**
+     * Whether the provider can handle a given source type
+     */
+    canHandle(sourceType: string): boolean;
+    /**
+     * List skill index entries from a source
+     */
+    listSkills(config: ISkillRepository): Promise<ISkillRepositoryIndex[]>;
+    /**
+     * Fetch a concrete skill package into a temporary directory
+     */
+    installSkillPackage(index: ISkillRepositoryIndex, installDir: string): Promise<string>;
+    /**
+     * Uninstall a skill package from a given path.
+     *
+     * @param path
+     */
+    uninstallSkillPackage(path: string): Promise<void>;
+}

package/src/lib/agent/skill/skill-source-provider.registry.d.ts

@@ -0,0 +1,6 @@
+import { DiscoveryService, Reflector } from '@nestjs/core';
+import { BaseStrategyRegistry } from '../../strategy';
+import { ISkillSourceProvider } from './skill-source-provider.interface';
+export declare class SkillSourceProviderRegistry extends BaseStrategyRegistry<ISkillSourceProvider> {
+    constructor(discoveryService: DiscoveryService, reflector: Reflector);
+}

package/src/lib/ai-model/commands/create-model-client.command.d.ts

@@ -0,0 +1,21 @@
+import { Embeddings } from '@langchain/core/embeddings';
+import { BaseLanguageModel } from '@langchain/core/language_models/base';
+import { BaseChatModel } from '@langchain/core/language_models/chat_models';
+import { ICopilotModel, ILLMUsage } from '@metad/contracts';
+import { Command } from '@nestjs/cqrs';
+import { IRerank } from '../types';
+/**
+ * Get a Chat Model of copilot model and check it's token limitation, record the token usage
+ */
+export declare class CreateModelClientCommand<T = BaseLanguageModel | BaseChatModel | Embeddings | IRerank> extends Command<T> {
+    readonly copilotModel: ICopilotModel;
+    readonly options: {
+        abortController?: AbortController;
+        usageCallback: (tokens: ILLMUsage) => void;
+    };
+    static readonly type = "[AI Model] Create Model Client";
+    constructor(copilotModel: ICopilotModel, options: {
+        abortController?: AbortController;
+        usageCallback: (tokens: ILLMUsage) => void;
+    });
+}

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

@@ -0,0 +1 @@
+export * from './create-model-client.command';

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

@@ -7,3 +7,4 @@ export * from './llm';
 export * from './errors';
 export * from './openai-compatible';
 export * from './utils/index';
+export * from './commands/index';

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

@@ -3,6 +3,7 @@ export * from './rerank';
 export * from './model';
 export * from './speech2text';
 export * from './tts';
+export * from './profile';
 export declare const PROVIDE_AI_MODEL_LLM = "provide_ai_model_llm";
 export declare const PROVIDE_AI_MODEL_MODERATION = "provide_ai_model_moderation";
 export declare const PROVIDE_AI_MODEL_SPEECH2TEXT = "provide_ai_model_speech2text";

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

@@ -1,5 +1,5 @@
 import { BaseChatModel } from "@langchain/core/language_models/chat_models";
-import { AIModelEntity, ICopilot, ICopilotModel, ILLMUsage, ParameterType } from "@metad/contracts";
+import { AIModelEntity, ICopilot, ICopilotModel, ILLMUsage, ParameterType, PriceInfo, PriceType } from "@metad/contracts";
 export type TChatModelOptions = {
     modelProperties: Record<string, any>;
     handleLLMTokens: (input: {
@@ -17,6 +17,7 @@ export interface IAIModel {
     validateCredentials(model: string, credentials: Record<string, any>): Promise<void>;
     getChatModel(copilotModel: ICopilotModel, options?: TChatModelOptions): BaseChatModel;
     predefinedModels(): AIModelEntity[];
+    getPrice(model: string, credentials: Record<string, any>, priceType: PriceType, tokens: number): PriceInfo;
 }
 export declare const CommonParameterRules: {
     name: string;

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

@@ -0,0 +1,172 @@
+/**
+ * @deprecated Migrate to langchain v1
+ *
+ * Represents the capabilities and constraints of a language model.
+ *
+ * This interface defines the various features and limitations that a model may have,
+ * including input/output constraints, multimodal support, and advanced capabilities
+ * like tool calling and structured output.
+ */
+export interface ModelProfile {
+    /**
+     * Maximum number of tokens that can be included in the input context window.
+     *
+     * This represents the total token budget for the model's input, including
+     * the prompt, system messages, conversation history, and any other context.
+     *
+     * @example
+     * ```typescript
+     * const profile: ModelProfile = {
+     *   maxInputTokens: 128000 // Model supports up to 128k tokens
+     * };
+     * ```
+     */
+    maxInputTokens?: number;
+    /**
+     * Whether the model supports image inputs.
+     *
+     * When `true`, the model can process images as part of its input, enabling
+     * multimodal interactions where visual content can be analyzed alongside text.
+     *
+     * @see {@link imageUrlInputs} for URL-based image input support
+     */
+    imageInputs?: boolean;
+    /**
+     * Whether the model supports image URL inputs.
+     *
+     * When `true`, the model can accept URLs pointing to images rather than
+     * requiring the image data to be embedded directly in the request. This can
+     * be more efficient for large images or when images are already hosted.
+     *
+     * @see {@link imageInputs} for direct image input support
+     */
+    imageUrlInputs?: boolean;
+    /**
+     * Whether the model supports PDF document inputs.
+     *
+     * When `true`, the model can process PDF files as input, allowing it to
+     * analyze document content, extract information, or answer questions about
+     * PDF documents.
+     */
+    pdfInputs?: boolean;
+    /**
+     * Whether the model supports audio inputs.
+     *
+     * When `true`, the model can process audio data as input, enabling
+     * capabilities like speech recognition, audio analysis, or multimodal
+     * interactions involving sound.
+     */
+    audioInputs?: boolean;
+    /**
+     * Whether the model supports video inputs.
+     *
+     * When `true`, the model can process video data as input, enabling
+     * capabilities like video analysis, scene understanding, or multimodal
+     * interactions involving moving images.
+     */
+    videoInputs?: boolean;
+    /**
+     * Whether the model supports image content in tool messages.
+     *
+     * When `true`, tool responses can include images that the model can process
+     * and reason about. This enables workflows where tools return visual data
+     * that the model needs to interpret.
+     */
+    imageToolMessage?: boolean;
+    /**
+     * Whether the model supports PDF content in tool messages.
+     *
+     * When `true`, tool responses can include PDF documents that the model can
+     * process and reason about. This enables workflows where tools return
+     * document data that the model needs to interpret.
+     */
+    pdfToolMessage?: boolean;
+    /**
+     * Maximum number of tokens the model can generate in its output.
+     *
+     * This represents the upper limit on the length of the model's response.
+     * The actual output may be shorter depending on the completion criteria
+     * (e.g., natural stopping point, stop sequences).
+     *
+     * @example
+     * ```typescript
+     * const profile: ModelProfile = {
+     *   maxOutputTokens: 4096 // Model can generate up to 4k tokens
+     * };
+     * ```
+     */
+    maxOutputTokens?: number;
+    /**
+     * Whether the model supports reasoning or chain-of-thought output.
+     *
+     * When `true`, the model can produce explicit reasoning steps or
+     * chain-of-thought explanations as part of its output. This is useful
+     * for understanding the model's decision-making process and improving
+     * transparency in complex reasoning tasks.
+     */
+    reasoningOutput?: boolean;
+    /**
+     * Whether the model can generate image outputs.
+     *
+     * When `true`, the model can produce images as part of its response,
+     * enabling capabilities like image generation, editing, or visual
+     * content creation.
+     */
+    imageOutputs?: boolean;
+    /**
+     * Whether the model can generate audio outputs.
+     *
+     * When `true`, the model can produce audio data as part of its response,
+     * enabling capabilities like text-to-speech, audio generation, or
+     * sound synthesis.
+     */
+    audioOutputs?: boolean;
+    /**
+     * Whether the model can generate video outputs.
+     *
+     * When `true`, the model can produce video data as part of its response,
+     * enabling capabilities like video generation, editing, or visual
+     * content creation with motion.
+     */
+    videoOutputs?: boolean;
+    /**
+     * Whether the model supports tool calling (function calling).
+     *
+     * When `true`, the model can invoke external tools or functions during
+     * its reasoning process. The model can decide which tools to call,
+     * with what arguments, and can incorporate the tool results into its
+     * final response.
+     *
+     * @see {@link toolChoice} for controlling tool selection behavior
+     * @see {@link https://docs.langchain.com/oss/javascript/langchain/models#tool-calling}
+     */
+    toolCalling?: boolean;
+    /**
+     * Whether the model supports tool choice control.
+     *
+     * When `true`, the caller can specify how the model should select tools,
+     * such as forcing the use of a specific tool, allowing any tool, or
+     * preventing tool use entirely. This provides fine-grained control over
+     * the model's tool-calling behavior.
+     *
+     * @see {@link toolCalling} for basic tool calling support
+     */
+    toolChoice?: boolean;
+    /**
+     * Whether the model supports structured output generation.
+     *
+     * When `true`, the model can generate responses that conform to a
+     * specified schema or structure (e.g., JSON with a particular format).
+     * This is useful for ensuring the model's output can be reliably parsed
+     * and processed programmatically.
+     *
+     * @example
+     * ```typescript
+     * // Model can be instructed to return JSON matching a schema
+     * const profile: ModelProfile = {
+     *   structuredOutput: true
+     * };
+     * ```
+     */
+    structuredOutput?: boolean;
+}

package/src/lib/data/datasource/types.d.ts

@@ -155,9 +155,21 @@ export interface ColumnDef {
      */
     isKey: boolean;
     /**
-     * Is required column
+     * Is required column (NOT NULL)
      */
     required?: boolean;
+    /**
+     * Is unique column
+     */
+    unique?: boolean;
+    /**
+     * Auto increment (for number type)
+     */
+    autoIncrement?: boolean;
+    /**
+     * Default value
+     */
+    defaultValue?: string;
     /**
      * length of type for column: varchar, decimal ...
      */
@@ -166,6 +178,14 @@ export interface ColumnDef {
      * fraction of type for decimal
      */
     fraction?: number;
+    /**
+     * Enum values (for ENUM type)
+     */
+    enumValues?: string[];
+    /**
+     * Set values (for SET type)
+     */
+    setValues?: string[];
 }
 export interface CreationTable {
     catalog?: string;
@@ -242,6 +262,14 @@ export declare abstract class BaseSQLQueryRunner<T extends SQLAdapterOptions = S
     get port(): string | number;
     abstract createCatalog?(catalog: string): Promise<void>;
     ping(): Promise<void>;
+    /**
+     * Default implementation for table operations
+     */
+    tableOp(action: DBTableAction, params: DBTableOperationParams, options?: QueryOptions): Promise<any>;
+    /**
+     * Generic type mapping (subclasses can override)
+     */
+    protected mapColumnType(type: string, isKey: boolean, length?: number): string;
 }
 export interface File {
     /** Name of the form field associated with this file. */

package/src/lib/workflow/commands/index.d.ts

@@ -0,0 +1 @@
+export * from './wrap-workflow-node-execution.command';

package/src/lib/workflow/commands/wrap-workflow-node-execution.command.d.ts

@@ -0,0 +1,26 @@
+import { IXpertAgentExecution, JSONValue } from '@metad/contracts';
+import { Command } from '@nestjs/cqrs';
+import { Subscriber } from 'rxjs';
+/**
+ * Wrap Workflow Node Execution Command
+ */
+export declare class WrapWorkflowNodeExecutionCommand<T = any> extends Command<T> {
+    readonly fuc: (execution: Partial<IXpertAgentExecution>) => Promise<{
+        output?: string | JSONValue;
+        state: T;
+    }>;
+    readonly params: {
+        execution: Partial<IXpertAgentExecution>;
+        subscriber?: Subscriber<MessageEvent>;
+        catchError?: (error: Error) => Promise<void>;
+    };
+    static readonly type = "[Workflow] Wrap Workflow Node Execution";
+    constructor(fuc: (execution: Partial<IXpertAgentExecution>) => Promise<{
+        output?: string | JSONValue;
+        state: T;
+    }>, params: {
+        execution: Partial<IXpertAgentExecution>;
+        subscriber?: Subscriber<MessageEvent>;
+        catchError?: (error: Error) => Promise<void>;
+    });
+}

package/src/lib/workflow/index.d.ts

@@ -1,2 +1,3 @@
 export * from './trigger/index';
 export * from './node/index';
+export * from './commands/index';