@lark-apaas/nestjs-capability 0.0.1-alpha.3 → 0.0.1-alpha.6

package/dist/index.js

@@ -7,6 +7,22 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
+// src/interfaces/error-codes.ts
+var ErrorCodes = {
+  /** 成功 */
+  SUCCESS: "0",
+  /** 能力不存在 */
+  CAPABILITY_NOT_FOUND: "k_ec_cap_001",
+  /** 插件不存在 */
+  PLUGIN_NOT_FOUND: "k_ec_cap_002",
+  /** Action 不存在 */
+  ACTION_NOT_FOUND: "k_ec_cap_003",
+  /** 参数验证失败 */
+  PARAMS_VALIDATION_ERROR: "k_ec_cap_004",
+  /** 执行失败 */
+  EXECUTION_ERROR: "k_ec_cap_005"
+};
+
 // src/services/template-engine.service.ts
 import { Injectable } from "@nestjs/common";
 function _ts_decorate(decorators, target, key, desc) {
@@ -93,8 +109,8 @@ var PluginNotFoundError = class extends Error {
   static {
     __name(this, "PluginNotFoundError");
   }
-  constructor(pluginID) {
-    super(`Plugin not found: ${pluginID}`);
+  constructor(pluginKey) {
+    super(`Plugin not found: ${pluginKey}`);
     this.name = "PluginNotFoundError";
   }
 };
@@ -102,8 +118,8 @@ var PluginLoadError = class extends Error {
   static {
     __name(this, "PluginLoadError");
   }
-  constructor(pluginID, reason) {
-    super(`Failed to load plugin ${pluginID}: ${reason}`);
+  constructor(pluginKey, reason) {
+    super(`Failed to load plugin ${pluginKey}: ${reason}`);
     this.name = "PluginLoadError";
   }
 };
@@ -113,41 +129,41 @@ var PluginLoaderService = class _PluginLoaderService {
   }
   logger = new Logger(_PluginLoaderService.name);
   pluginInstances = /* @__PURE__ */ new Map();
-  async loadPlugin(pluginID) {
-    const cached = this.pluginInstances.get(pluginID);
+  async loadPlugin(pluginKey) {
+    const cached = this.pluginInstances.get(pluginKey);
     if (cached) {
-      this.logger.debug(`Using cached plugin instance: ${pluginID}`);
+      this.logger.debug(`Using cached plugin instance: ${pluginKey}`);
       return cached;
     }
-    this.logger.log(`Loading plugin: ${pluginID}`);
+    this.logger.log(`Loading plugin: ${pluginKey}`);
     try {
-      const pluginPackage = (await import(pluginID)).default;
+      const pluginPackage = (await import(pluginKey)).default;
       if (typeof pluginPackage.create !== "function") {
-        throw new PluginLoadError(pluginID, "Plugin does not export create() function");
+        throw new PluginLoadError(pluginKey, "Plugin does not export create() function");
       }
       const instance = pluginPackage.create();
-      this.pluginInstances.set(pluginID, instance);
-      this.logger.log(`Plugin loaded successfully: ${pluginID}`);
+      this.pluginInstances.set(pluginKey, instance);
+      this.logger.log(`Plugin loaded successfully: ${pluginKey}`);
       return instance;
     } catch (error) {
       if (error.code === "MODULE_NOT_FOUND") {
-        throw new PluginNotFoundError(pluginID);
+        throw new PluginNotFoundError(pluginKey);
       }
-      throw new PluginLoadError(pluginID, error instanceof Error ? error.message : String(error));
+      throw new PluginLoadError(pluginKey, error instanceof Error ? error.message : String(error));
     }
   }
-  isPluginInstalled(pluginID) {
+  isPluginInstalled(pluginKey) {
     try {
-      __require.resolve(pluginID);
+      __require.resolve(pluginKey);
       return true;
     } catch {
       return false;
     }
   }
-  clearCache(pluginID) {
-    if (pluginID) {
-      this.pluginInstances.delete(pluginID);
-      this.logger.log(`Cleared cache for plugin: ${pluginID}`);
+  clearCache(pluginKey) {
+    if (pluginKey) {
+      this.pluginInstances.delete(pluginKey);
+      this.logger.log(`Cleared cache for plugin: ${pluginKey}`);
     } else {
       this.pluginInstances.clear();
       this.logger.log("Cleared all plugin caches");
@@ -193,8 +209,8 @@ var ActionNotFoundError = class extends Error {
   static {
     __name(this, "ActionNotFoundError");
   }
-  constructor(pluginID, actionName) {
-    super(`Action '${actionName}' not found in plugin ${pluginID}`);
+  constructor(pluginKey, actionName) {
+    super(`Action '${actionName}' not found in plugin ${pluginKey}`);
     this.name = "ActionNotFoundError";
   }
 };
@@ -274,6 +290,9 @@ var CapabilityService = class _CapabilityService {
       callStream: /* @__PURE__ */ __name((actionName, input, contextOverride) => {
         return this.executeCallStream(config, actionName, input, contextOverride);
       }, "callStream"),
+      callStreamWithEvents: /* @__PURE__ */ __name((actionName, input, contextOverride) => {
+        return this.executeCallStreamWithEvents(config, actionName, input, contextOverride);
+      }, "callStreamWithEvents"),
       isStream: /* @__PURE__ */ __name(async (actionName) => {
         return this.checkIsStream(config, actionName);
       }, "isStream")
@@ -283,9 +302,9 @@ var CapabilityService = class _CapabilityService {
   * 检查 action 是否为流式
   */
   async checkIsStream(config, actionName) {
-    const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginID);
+    const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginKey);
     if (!pluginInstance.hasAction(actionName)) {
-      throw new ActionNotFoundError(config.pluginID, actionName);
+      throw new ActionNotFoundError(config.pluginKey, actionName);
     }
     return pluginInstance.isStreamAction?.(actionName) ?? false;
   }
@@ -297,9 +316,9 @@ var CapabilityService = class _CapabilityService {
   async executeCall(config, actionName, input, contextOverride) {
     const startTime = Date.now();
     try {
-      const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginID);
+      const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginKey);
       if (!pluginInstance.hasAction(actionName)) {
-        throw new ActionNotFoundError(config.pluginID, actionName);
+        throw new ActionNotFoundError(config.pluginKey, actionName);
       }
       const resolvedParams = this.templateEngineService.resolve(config.formValue, input);
       const context = this.buildActionContext(contextOverride);
@@ -308,7 +327,7 @@ var CapabilityService = class _CapabilityService {
         message: "Executing capability",
         capabilityId: config.id,
         action: actionName,
-        pluginID: config.pluginID,
+        pluginKey: config.pluginKey,
         isStream
       });
       let result;
@@ -347,9 +366,9 @@ var CapabilityService = class _CapabilityService {
   async *executeCallStream(config, actionName, input, contextOverride) {
     const startTime = Date.now();
     try {
-      const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginID);
+      const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginKey);
       if (!pluginInstance.hasAction(actionName)) {
-        throw new ActionNotFoundError(config.pluginID, actionName);
+        throw new ActionNotFoundError(config.pluginKey, actionName);
       }
       const resolvedParams = this.templateEngineService.resolve(config.formValue, input);
       const context = this.buildActionContext(contextOverride);
@@ -358,7 +377,7 @@ var CapabilityService = class _CapabilityService {
         message: "Executing capability (stream)",
         capabilityId: config.id,
         action: actionName,
-        pluginID: config.pluginID,
+        pluginKey: config.pluginKey,
         isStream
       });
       if (isStream && pluginInstance.runStream) {
@@ -384,6 +403,79 @@ var CapabilityService = class _CapabilityService {
       throw error;
     }
   }
+  /**
+  * 流式执行 capability，返回带事件协议的流
+  * - 优先使用 pluginInstance.runStreamWithEvents
+  * - 如果插件不支持，则包装 runStream/run 为 StreamEvent
+  */
+  async *executeCallStreamWithEvents(config, actionName, input, contextOverride) {
+    const startTime = Date.now();
+    let chunkCount = 0;
+    try {
+      const pluginInstance = await this.pluginLoaderService.loadPlugin(config.pluginKey);
+      if (!pluginInstance.hasAction(actionName)) {
+        throw new ActionNotFoundError(config.pluginKey, actionName);
+      }
+      const resolvedParams = this.templateEngineService.resolve(config.formValue, input);
+      const context = this.buildActionContext(contextOverride);
+      this.logger.log({
+        message: "Executing capability (streamWithEvents)",
+        capabilityId: config.id,
+        action: actionName,
+        pluginKey: config.pluginKey
+      });
+      if (pluginInstance.runStreamWithEvents) {
+        yield* pluginInstance.runStreamWithEvents(actionName, context, resolvedParams);
+      } else {
+        const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
+        if (isStream && pluginInstance.runStream) {
+          for await (const chunk of pluginInstance.runStream(actionName, context, resolvedParams)) {
+            chunkCount++;
+            yield {
+              type: "data",
+              data: chunk
+            };
+          }
+        } else {
+          const result = await pluginInstance.run(actionName, context, resolvedParams);
+          chunkCount = 1;
+          yield {
+            type: "data",
+            data: result
+          };
+        }
+        yield {
+          type: "done",
+          metadata: {
+            chunks: chunkCount,
+            duration: Date.now() - startTime
+          }
+        };
+      }
+      this.logger.log({
+        message: "Capability streamWithEvents completed",
+        capabilityId: config.id,
+        action: actionName,
+        duration: Date.now() - startTime,
+        chunks: chunkCount
+      });
+    } catch (error) {
+      this.logger.error({
+        message: "Capability streamWithEvents execution failed",
+        capabilityId: config.id,
+        action: actionName,
+        error: error instanceof Error ? error.message : String(error),
+        duration: Date.now() - startTime
+      });
+      yield {
+        type: "error",
+        error: {
+          code: "EXECUTION_ERROR",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
   buildActionContext(override) {
     return {
       logger: this.logger,
@@ -445,14 +537,15 @@ var DebugController = class {
   list() {
     const capabilities = this.capabilityService.listCapabilities();
     return {
-      code: 0,
-      message: "success",
-      data: capabilities.map((c) => ({
-        id: c.id,
-        name: c.name,
-        pluginID: c.pluginID,
-        pluginVersion: c.pluginVersion
-      }))
+      status_code: ErrorCodes.SUCCESS,
+      data: {
+        capabilities: capabilities.map((c) => ({
+          id: c.id,
+          name: c.name,
+          pluginID: c.pluginKey,
+          pluginVersion: c.pluginVersion
+        }))
+      }
     };
   }
   /**
@@ -477,16 +570,16 @@ var DebugController = class {
   * 获取 action 名称
   * 优先使用传入的 action，否则使用插件第一个 action
   */
-  async getActionName(pluginID, bodyAction) {
+  async getActionName(pluginKey, bodyAction) {
     if (bodyAction) {
       return bodyAction;
     }
-    const pluginInstance = await this.pluginLoaderService.loadPlugin(pluginID);
+    const pluginInstance = await this.pluginLoaderService.loadPlugin(pluginKey);
     const actions = pluginInstance.listActions();
     if (actions.length === 0) {
       throw new HttpException({
         code: 1,
-        message: `Plugin ${pluginID} has no actions`,
+        message: `Plugin ${pluginKey} has no actions`,
         error: "NO_ACTIONS"
       }, HttpStatus.BAD_REQUEST);
     }
@@ -496,68 +589,45 @@ var DebugController = class {
     const startTime = Date.now();
     const params = body.params ?? {};
     const config = this.getCapabilityConfig(capabilityId, body.capability);
-    const action = await this.getActionName(config.pluginID, body.action);
+    const action = await this.getActionName(config.pluginKey, body.action);
     const resolvedParams = this.templateEngineService.resolve(config.formValue, params);
     try {
       const result = await this.capabilityService.loadWithConfig(config).call(action, params);
       return {
-        code: 0,
-        message: "success",
-        data: result,
-        debug: {
-          capabilityConfig: config,
-          resolvedParams,
-          duration: Date.now() - startTime,
-          pluginID: config.pluginID,
-          action
+        status_code: ErrorCodes.SUCCESS,
+        data: {
+          output: result,
+          debug: {
+            capabilityConfig: config,
+            resolvedParams,
+            duration: Date.now() - startTime,
+            pluginID: config.pluginKey,
+            action
+          }
         }
       };
     } catch (error) {
-      const duration = Date.now() - startTime;
       if (error instanceof CapabilityNotFoundError) {
         throw new HttpException({
-          code: 1,
-          message: error.message,
-          error: "CAPABILITY_NOT_FOUND",
-          debug: {
-            duration
-          }
+          status_code: ErrorCodes.CAPABILITY_NOT_FOUND,
+          error_msg: `Capability not found: ${capabilityId}`
         }, HttpStatus.NOT_FOUND);
       }
       if (error instanceof PluginNotFoundError) {
         throw new HttpException({
-          code: 1,
-          message: error.message,
-          error: "PLUGIN_NOT_FOUND",
-          debug: {
-            duration,
-            pluginID: config.pluginID,
-            action
-          }
+          status_code: ErrorCodes.PLUGIN_NOT_FOUND,
+          error_msg: `Plugin not found: ${config.pluginKey}`
         }, HttpStatus.INTERNAL_SERVER_ERROR);
       }
       if (error instanceof ActionNotFoundError) {
         throw new HttpException({
-          code: 1,
-          message: error.message,
-          error: "ACTION_NOT_FOUND",
-          debug: {
-            duration,
-            pluginID: config.pluginID,
-            action
-          }
+          status_code: ErrorCodes.ACTION_NOT_FOUND,
+          error_msg: `Action '${action}' not found in plugin ${config.pluginKey}`
         }, HttpStatus.BAD_REQUEST);
       }
       throw new HttpException({
-        code: 1,
-        message: error instanceof Error ? error.message : String(error),
-        error: "EXECUTION_ERROR",
-        debug: {
-          duration,
-          pluginID: config.pluginID,
-          action,
-          resolvedParams
-        }
+        status_code: ErrorCodes.EXECUTION_ERROR,
+        error_msg: `Execution failed: ${error instanceof Error ? error.message : String(error)}`
       }, HttpStatus.INTERNAL_SERVER_ERROR);
     }
   }
@@ -568,35 +638,78 @@ var DebugController = class {
     res.setHeader("Connection", "keep-alive");
     try {
       const config = this.getCapabilityConfig(capabilityId, body.capability);
-      const action = await this.getActionName(config.pluginID, body.action);
+      const action = await this.getActionName(config.pluginKey, body.action);
       const capability = this.capabilityService.loadWithConfig(config);
-      const stream = capability.callStream(action, params);
-      for await (const chunk of stream) {
-        res.write(`data: ${JSON.stringify(chunk)}
+      const eventStream = capability.callStreamWithEvents(action, params);
+      for await (const event of eventStream) {
+        switch (event.type) {
+          case "data": {
+            const response = {
+              status_code: ErrorCodes.SUCCESS,
+              data: {
+                type: "content",
+                delta: {
+                  content: event.data
+                }
+              }
+            };
+            res.write(`data: ${JSON.stringify(response)}
+
+`);
+            break;
+          }
+          case "done": {
+            const response = {
+              status_code: ErrorCodes.SUCCESS,
+              data: {
+                type: "content",
+                delta: {
+                  content: null
+                },
+                finished: true
+              }
+            };
+            res.write(`data: ${JSON.stringify(response)}
 
 `);
+            res.end();
+            return;
+          }
+          case "error": {
+            const response = {
+              status_code: ErrorCodes.SUCCESS,
+              data: {
+                type: "error",
+                error: {
+                  code: 0,
+                  message: event.error.message
+                }
+              }
+            };
+            res.write(`data: ${JSON.stringify(response)}
+
+`);
+            res.end();
+            return;
+          }
+        }
       }
-      res.write("data: [DONE]\n\n");
+      res.end();
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      let errorCode = "EXECUTION_ERROR";
-      if (error instanceof CapabilityNotFoundError) {
-        errorCode = "CAPABILITY_NOT_FOUND";
-      } else if (error instanceof PluginNotFoundError) {
-        errorCode = "PLUGIN_NOT_FOUND";
-      } else if (error instanceof ActionNotFoundError) {
-        errorCode = "ACTION_NOT_FOUND";
-      } else if (error instanceof HttpException) {
-        const response = error.getResponse();
-        errorCode = response.error ?? "EXECUTION_ERROR";
-      }
-      res.write(`data: ${JSON.stringify({
-        error: message,
-        code: errorCode
-      })}
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      const response = {
+        status_code: ErrorCodes.SUCCESS,
+        data: {
+          type: "error",
+          error: {
+            code: 0,
+            message: errorMsg
+          }
+        }
+      };
+      res.write(`data: ${JSON.stringify(response)}
 
 `);
-    } finally {
       res.end();
     }
   }
@@ -605,7 +718,7 @@ _ts_decorate4([
   Get("list"),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", []),
-  _ts_metadata2("design:returntype", typeof ListResponse === "undefined" ? Object : ListResponse)
+  _ts_metadata2("design:returntype", typeof SuccessResponse === "undefined" ? Object : SuccessResponse)
 ], DebugController.prototype, "list", null);
 _ts_decorate4([
   Post("debug/:capability_id"),
@@ -671,51 +784,48 @@ var WebhookController = class {
   list() {
     const capabilities = this.capabilityService.listCapabilities();
     return {
-      code: 0,
-      message: "success",
-      data: capabilities.map((c) => ({
-        id: c.id,
-        name: c.name,
-        description: c.description,
-        pluginID: c.pluginID,
-        pluginVersion: c.pluginVersion
-      }))
+      status_code: ErrorCodes.SUCCESS,
+      data: {
+        capabilities: capabilities.map((c) => ({
+          id: c.id,
+          name: c.name,
+          pluginID: c.pluginKey,
+          pluginVersion: c.pluginVersion
+        }))
+      }
     };
   }
   async execute(capabilityId, body) {
     try {
       const result = await this.capabilityService.load(capabilityId).call(body.action, body.params);
       return {
-        code: 0,
-        message: "success",
-        data: result
+        status_code: ErrorCodes.SUCCESS,
+        data: {
+          output: result
+        }
       };
     } catch (error) {
       if (error instanceof CapabilityNotFoundError) {
         throw new HttpException2({
-          code: 1,
-          message: error.message,
-          error: "CAPABILITY_NOT_FOUND"
+          status_code: ErrorCodes.CAPABILITY_NOT_FOUND,
+          error_msg: `Capability not found: ${capabilityId}`
         }, HttpStatus2.NOT_FOUND);
       }
       if (error instanceof PluginNotFoundError) {
         throw new HttpException2({
-          code: 1,
-          message: error.message,
-          error: "PLUGIN_NOT_FOUND"
+          status_code: ErrorCodes.PLUGIN_NOT_FOUND,
+          error_msg: `Plugin not found`
         }, HttpStatus2.INTERNAL_SERVER_ERROR);
       }
       if (error instanceof ActionNotFoundError) {
         throw new HttpException2({
-          code: 1,
-          message: error.message,
-          error: "ACTION_NOT_FOUND"
+          status_code: ErrorCodes.ACTION_NOT_FOUND,
+          error_msg: `Action '${body.action}' not found`
         }, HttpStatus2.BAD_REQUEST);
       }
       throw new HttpException2({
-        code: 1,
-        message: error instanceof Error ? error.message : String(error),
-        error: "EXECUTION_ERROR"
+        status_code: ErrorCodes.EXECUTION_ERROR,
+        error_msg: `Execution failed: ${error instanceof Error ? error.message : String(error)}`
       }, HttpStatus2.INTERNAL_SERVER_ERROR);
     }
   }
@@ -725,30 +835,76 @@ var WebhookController = class {
     res.setHeader("Connection", "keep-alive");
     try {
       const capability = this.capabilityService.load(capabilityId);
-      const stream = capability.callStream(body.action, body.params);
-      for await (const chunk of stream) {
-        res.write(`data: ${JSON.stringify(chunk)}
+      const eventStream = capability.callStreamWithEvents(body.action, body.params);
+      for await (const event of eventStream) {
+        switch (event.type) {
+          case "data": {
+            const response = {
+              status_code: ErrorCodes.SUCCESS,
+              data: {
+                type: "content",
+                delta: {
+                  content: event.data
+                }
+              }
+            };
+            res.write(`data: ${JSON.stringify(response)}
 
 `);
+            break;
+          }
+          case "done": {
+            const response = {
+              status_code: ErrorCodes.SUCCESS,
+              data: {
+                type: "content",
+                delta: {
+                  content: null
+                },
+                finished: true
+              }
+            };
+            res.write(`data: ${JSON.stringify(response)}
+
+`);
+            res.end();
+            return;
+          }
+          case "error": {
+            const response = {
+              status_code: ErrorCodes.SUCCESS,
+              data: {
+                type: "error",
+                error: {
+                  code: 0,
+                  message: event.error.message
+                }
+              }
+            };
+            res.write(`data: ${JSON.stringify(response)}
+
+`);
+            res.end();
+            return;
+          }
+        }
       }
-      res.write("data: [DONE]\n\n");
+      res.end();
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      let errorCode = "EXECUTION_ERROR";
-      if (error instanceof CapabilityNotFoundError) {
-        errorCode = "CAPABILITY_NOT_FOUND";
-      } else if (error instanceof PluginNotFoundError) {
-        errorCode = "PLUGIN_NOT_FOUND";
-      } else if (error instanceof ActionNotFoundError) {
-        errorCode = "ACTION_NOT_FOUND";
-      }
-      res.write(`data: ${JSON.stringify({
-        error: message,
-        code: errorCode
-      })}
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      const response = {
+        status_code: ErrorCodes.SUCCESS,
+        data: {
+          type: "error",
+          error: {
+            code: 0,
+            message: errorMsg
+          }
+        }
+      };
+      res.write(`data: ${JSON.stringify(response)}
 
 `);
-    } finally {
       res.end();
     }
   }
@@ -757,7 +913,7 @@ _ts_decorate5([
   Get2("list"),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", []),
-  _ts_metadata3("design:returntype", typeof ListResponse === "undefined" ? Object : ListResponse)
+  _ts_metadata3("design:returntype", typeof SuccessResponse === "undefined" ? Object : SuccessResponse)
 ], WebhookController.prototype, "list", null);
 _ts_decorate5([
   Post2(":capability_id"),
@@ -871,6 +1027,7 @@ export {
   CapabilityNotFoundError,
   CapabilityService,
   DebugController,
+  ErrorCodes,
   PluginLoadError,
   PluginLoaderService,
   PluginNotFoundError,