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

package/README.md

@@ -93,14 +93,23 @@ const result = await this.capabilityService
 ### 上下文覆盖
 
 ```typescript
+// 覆盖 userContext
 const result = await this.capabilityService
   .load('notify_task_created')
   .call('run', inputParams, {
     userContext: {
       userId: 'custom-user-id',
       tenantId: 'custom-tenant-id',
+      appId: 'custom-app-id',
     },
   });
+
+// 设置调试模式（插件可据此返回更详细的错误信息）
+const debugResult = await this.capabilityService
+  .load('ai_chat')
+  .call('chat', inputParams, {
+    isDebug: true,
+  });
 ```
 
 ## 能力配置
@@ -377,10 +386,17 @@ interface PluginActionContext {
   userContext: {
     userId: string;         // 用户 ID
     tenantId: string;       // 租户 ID
+    appId: string;          // 应用 ID
   };
+  isDebug: boolean;         // 是否为调试模式
 }
 ```
 
+**isDebug 说明：**
+- `DebugController` 调用时 `isDebug = true`
+- `WebhookController` 或其他调用时 `isDebug = false`
+- 插件可据此返回更详细的错误信息、调试日志等
+
 ## 错误类型
 
 | 错误 | 描述 |

package/dist/index.cjs

@@ -217,6 +217,28 @@ var import_common3 = require("@nestjs/common");
 var import_nestjs_common = require("@lark-apaas/nestjs-common");
 var fs = __toESM(require("fs"), 1);
 var path = __toESM(require("path"), 1);
+
+// src/utils/log-utils.ts
+var DEFAULT_MAX_LENGTH = 1e3;
+function truncateString(str, maxLength) {
+  if (str.length <= maxLength) {
+    return str;
+  }
+  return str.slice(0, maxLength) + `... [truncated, total ${str.length} chars]`;
+}
+__name(truncateString, "truncateString");
+function stringifyForLog(value, maxLength = DEFAULT_MAX_LENGTH) {
+  try {
+    const str = JSON.stringify(value, null, 2);
+    return truncateString(str, maxLength);
+  } catch {
+    const str = String(value);
+    return truncateString(str, maxLength);
+  }
+}
+__name(stringifyForLog, "stringifyForLog");
+
+// src/services/capability.service.ts
 function _ts_decorate3(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -257,15 +279,15 @@ var CapabilityService = class _CapabilityService {
     __name(this, "CapabilityService");
   }
   requestContextService;
-  httpClient;
+  platformHttpClient;
   pluginLoaderService;
   templateEngineService;
   logger = new import_common3.Logger(_CapabilityService.name);
   capabilities = /* @__PURE__ */ new Map();
   capabilitiesDir;
-  constructor(requestContextService, httpClient, pluginLoaderService, templateEngineService) {
+  constructor(requestContextService, platformHttpClient, pluginLoaderService, templateEngineService) {
     this.requestContextService = requestContextService;
-    this.httpClient = httpClient;
+    this.platformHttpClient = platformHttpClient;
     this.pluginLoaderService = pluginLoaderService;
     this.templateEngineService = templateEngineService;
     this.capabilitiesDir = path.join(process.cwd(), "server/capabilities");
@@ -353,20 +375,23 @@ var CapabilityService = class _CapabilityService {
   */
   async executeCall(config, actionName, input, contextOverride) {
     const startTime = Date.now();
+    const loggerContext = {
+      capability_id: config.id,
+      plugin_key: config.pluginKey,
+      action: actionName
+    };
     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 resolvedParams = config.formValue ? this.templateEngineService.resolve(config.formValue, input) : input;
       const context = this.buildActionContext(contextOverride);
       const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
-      this.logger.log({
-        message: "Executing capability",
-        capabilityId: config.id,
-        action: actionName,
-        pluginKey: config.pluginKey,
-        isStream
+      this.logger.log("Executing capability (call)", {
+        ...loggerContext,
+        is_stream: isStream,
+        input: stringifyForLog(input)
       });
       let result;
       if (isStream && pluginInstance.runStream) {
@@ -378,20 +403,17 @@ var CapabilityService = class _CapabilityService {
       } else {
         result = await pluginInstance.run(actionName, context, resolvedParams);
       }
-      this.logger.log({
-        message: "Capability executed successfully",
-        capabilityId: config.id,
-        action: actionName,
-        duration: Date.now() - startTime
+      this.logger.log("Capability (call) executed successfully", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        output: stringifyForLog(result)
       });
       return result;
     } catch (error) {
-      this.logger.error({
-        message: "Capability execution failed",
-        capabilityId: config.id,
-        action: actionName,
-        error: error instanceof Error ? error.message : String(error),
-        duration: Date.now() - startTime
+      this.logger.error("Capability (call) execution failed", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
       });
       throw error;
     }
@@ -403,40 +425,46 @@ var CapabilityService = class _CapabilityService {
   */
   async *executeCallStream(config, actionName, input, contextOverride) {
     const startTime = Date.now();
+    const loggerContext = {
+      capability_id: config.id,
+      plugin_key: config.pluginKey,
+      action: actionName
+    };
+    const chunks = [];
     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 resolvedParams = config.formValue ? this.templateEngineService.resolve(config.formValue, input) : input;
       const context = this.buildActionContext(contextOverride);
       const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
-      this.logger.log({
-        message: "Executing capability (stream)",
-        capabilityId: config.id,
-        action: actionName,
-        pluginKey: config.pluginKey,
-        isStream
+      this.logger.log("Executing capability (stream)", {
+        ...loggerContext,
+        is_stream: isStream,
+        input: stringifyForLog(input)
       });
       if (isStream && pluginInstance.runStream) {
-        yield* pluginInstance.runStream(actionName, context, resolvedParams);
+        for await (const chunk of pluginInstance.runStream(actionName, context, resolvedParams)) {
+          chunks.push(chunk);
+          yield chunk;
+        }
       } else {
         const result = await pluginInstance.run(actionName, context, resolvedParams);
+        chunks.push(result);
         yield result;
       }
-      this.logger.log({
-        message: "Capability stream completed",
-        capabilityId: config.id,
-        action: actionName,
-        duration: Date.now() - startTime
+      const aggregatedResult = pluginInstance.aggregate ? pluginInstance.aggregate(actionName, chunks) : chunks;
+      this.logger.log("Capability (stream) executed successfully", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        output: stringifyForLog(aggregatedResult)
       });
     } catch (error) {
-      this.logger.error({
-        message: "Capability stream execution failed",
-        capabilityId: config.id,
-        action: actionName,
-        error: error instanceof Error ? error.message : String(error),
-        duration: Date.now() - startTime
+      this.logger.error("Capability (stream) execution failed", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
       });
       throw error;
     }
@@ -448,27 +476,47 @@ var CapabilityService = class _CapabilityService {
   */
   async *executeCallStreamWithEvents(config, actionName, input, contextOverride) {
     const startTime = Date.now();
-    let chunkCount = 0;
+    const loggerContext = {
+      capability_id: config.id,
+      plugin_key: config.pluginKey,
+      action: actionName
+    };
+    const chunks = [];
     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 resolvedParams = config.formValue ? this.templateEngineService.resolve(config.formValue, input) : input;
       const context = this.buildActionContext(contextOverride);
-      this.logger.log({
-        message: "Executing capability (streamWithEvents)",
-        capabilityId: config.id,
-        action: actionName,
-        pluginKey: config.pluginKey
+      const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
+      this.logger.log("Executing capability (streamWithEvents)", {
+        ...loggerContext,
+        is_stream: isStream,
+        input: stringifyForLog(input)
       });
       if (pluginInstance.runStreamWithEvents) {
-        yield* pluginInstance.runStreamWithEvents(actionName, context, resolvedParams);
+        for await (const event of pluginInstance.runStreamWithEvents(actionName, context, resolvedParams)) {
+          if (event.type === "data") {
+            chunks.push(event.data);
+            yield event;
+          } else if (event.type === "done") {
+            const aggregatedResult2 = pluginInstance.aggregate ? pluginInstance.aggregate(actionName, chunks) : chunks;
+            yield {
+              type: "done",
+              metadata: {
+                ...event.metadata,
+                aggregated: aggregatedResult2
+              }
+            };
+          } else {
+            yield event;
+          }
+        }
       } else {
-        const isStream = pluginInstance.isStreamAction?.(actionName) ?? false;
         if (isStream && pluginInstance.runStream) {
           for await (const chunk of pluginInstance.runStream(actionName, context, resolvedParams)) {
-            chunkCount++;
+            chunks.push(chunk);
             yield {
               type: "data",
               data: chunk
@@ -476,34 +524,33 @@ var CapabilityService = class _CapabilityService {
           }
         } else {
           const result = await pluginInstance.run(actionName, context, resolvedParams);
-          chunkCount = 1;
+          chunks.push(result);
           yield {
             type: "data",
             data: result
           };
         }
+        const aggregatedResult2 = pluginInstance.aggregate ? pluginInstance.aggregate(actionName, chunks) : chunks;
         yield {
           type: "done",
           metadata: {
-            chunks: chunkCount,
-            duration: Date.now() - startTime
+            chunks: chunks.length,
+            duration: Date.now() - startTime,
+            aggregated: aggregatedResult2
           }
         };
       }
-      this.logger.log({
-        message: "Capability streamWithEvents completed",
-        capabilityId: config.id,
-        action: actionName,
-        duration: Date.now() - startTime,
-        chunks: chunkCount
+      const aggregatedResult = pluginInstance.aggregate ? pluginInstance.aggregate(actionName, chunks) : chunks;
+      this.logger.log("Capability (streamWithEvents) executed successfully", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        output: stringifyForLog(aggregatedResult)
       });
     } 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
+      this.logger.error("Capability (streamWithEvents) execution failed", {
+        ...loggerContext,
+        duration_ms: Date.now() - startTime,
+        error: error instanceof Error ? error.message : String(error)
       });
       yield {
         type: "error",
@@ -517,13 +564,15 @@ var CapabilityService = class _CapabilityService {
   buildActionContext(override) {
     return {
       logger: this.logger,
-      httpClient: this.httpClient,
-      userContext: override?.userContext ?? this.getUserContext()
+      platformHttpClient: this.platformHttpClient,
+      userContext: override?.userContext ?? this.getUserContext(),
+      isDebug: override?.isDebug ?? false
     };
   }
   getUserContext() {
     const ctx = this.requestContextService.getContext();
     return {
+      appId: ctx?.appId ?? "",
       userId: ctx?.userId ?? "",
       tenantId: ctx?.tenantId ?? ""
     };
@@ -560,13 +609,14 @@ function _ts_param2(paramIndex, decorator) {
   };
 }
 __name(_ts_param2, "_ts_param");
-var DebugController = class {
+var DebugController = class _DebugController {
   static {
     __name(this, "DebugController");
   }
   capabilityService;
   pluginLoaderService;
   templateEngineService;
+  logger = new import_common4.Logger(_DebugController.name);
   constructor(capabilityService, pluginLoaderService, templateEngineService) {
     this.capabilityService = capabilityService;
     this.pluginLoaderService = pluginLoaderService;
@@ -630,7 +680,9 @@ var DebugController = class {
     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);
+      const result = await this.capabilityService.loadWithConfig(config).call(action, params, {
+        isDebug: true
+      });
       return {
         status_code: ErrorCodes.SUCCESS,
         data: {
@@ -677,39 +729,61 @@ var DebugController = class {
     try {
       const config = this.getCapabilityConfig(capabilityId, body.capability);
       const action = await this.getActionName(config.pluginKey, body.action);
+      const loggerContext = {
+        capability_id: config.id,
+        plugin_key: config.pluginKey,
+        action
+      };
+      this.logger.log(`Executing capability (stream)`, {
+        ...loggerContext,
+        input: stringifyForLog(params)
+      });
       const capability = this.capabilityService.loadWithConfig(config);
-      const eventStream = capability.callStreamWithEvents(action, params);
+      const eventStream = capability.callStreamWithEvents(action, params, {
+        isDebug: true
+      });
+      let pendingChunk = null;
       for await (const event of eventStream) {
         switch (event.type) {
           case "data": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: event.data
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  }
                 }
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            pendingChunk = event.data;
             break;
           }
           case "done": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: null
-                },
-                finished: true
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  },
+                  finished: true
+                }
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            this.logger.log(`Capability (stream) executed successfully`, {
+              ...loggerContext,
+              duration_ms: event.metadata.duration,
+              output: stringifyForLog(event.metadata.aggregated)
+            });
             res.end();
             return;
           }
@@ -732,6 +806,21 @@ var DebugController = class {
           }
         }
       }
+      if (pendingChunk !== null) {
+        const response = {
+          status_code: ErrorCodes.SUCCESS,
+          data: {
+            type: "content",
+            delta: {
+              content: pendingChunk
+            },
+            finished: true
+          }
+        };
+        res.write(`data: ${JSON.stringify(response)}
+
+`);
+      }
       res.end();
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -811,11 +900,12 @@ function _ts_param3(paramIndex, decorator) {
   };
 }
 __name(_ts_param3, "_ts_param");
-var WebhookController = class {
+var WebhookController = class _WebhookController {
   static {
     __name(this, "WebhookController");
   }
   capabilityService;
+  logger = new import_common5.Logger(_WebhookController.name);
   constructor(capabilityService) {
     this.capabilityService = capabilityService;
   }
@@ -868,43 +958,62 @@ var WebhookController = class {
     }
   }
   async executeStream(capabilityId, body, res) {
+    const loggerContext = {
+      capability_id: capabilityId,
+      action: body.action
+    };
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
     res.setHeader("Connection", "keep-alive");
     try {
+      this.logger.log(`Executing capability (stream)`, {
+        ...loggerContext,
+        input: stringifyForLog(body.params)
+      });
       const capability = this.capabilityService.load(capabilityId);
       const eventStream = capability.callStreamWithEvents(body.action, body.params);
+      let pendingChunk = null;
       for await (const event of eventStream) {
         switch (event.type) {
           case "data": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: event.data
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  }
                 }
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            pendingChunk = event.data;
             break;
           }
           case "done": {
-            const response = {
-              status_code: ErrorCodes.SUCCESS,
-              data: {
-                type: "content",
-                delta: {
-                  content: null
-                },
-                finished: true
-              }
-            };
-            res.write(`data: ${JSON.stringify(response)}
+            if (pendingChunk !== null) {
+              const response = {
+                status_code: ErrorCodes.SUCCESS,
+                data: {
+                  type: "content",
+                  delta: {
+                    content: pendingChunk
+                  },
+                  finished: true
+                }
+              };
+              res.write(`data: ${JSON.stringify(response)}
 
 `);
+            }
+            this.logger.log(`Capability (stream) executed successfully`, {
+              ...loggerContext,
+              duration_ms: event.metadata.duration,
+              output: stringifyForLog(event.metadata.aggregated)
+            });
             res.end();
             return;
           }
@@ -927,6 +1036,21 @@ var WebhookController = class {
           }
         }
       }
+      if (pendingChunk !== null) {
+        const response = {
+          status_code: ErrorCodes.SUCCESS,
+          data: {
+            type: "content",
+            delta: {
+              content: pendingChunk
+            },
+            finished: true
+          }
+        };
+        res.write(`data: ${JSON.stringify(response)}
+
+`);
+      }
       res.end();
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
@@ -1014,6 +1138,9 @@ var CapabilityModule = class _CapabilityModule {
   static forRoot(options) {
     return {
       module: _CapabilityModule,
+      imports: [
+        import_nestjs_common2.CommonModule
+      ],
       controllers: getControllers(),
       providers: [
         {
@@ -1048,6 +1175,9 @@ var CapabilityModule = class _CapabilityModule {
 };
 CapabilityModule = _ts_decorate6([
   (0, import_common6.Module)({
+    imports: [
+      import_nestjs_common2.CommonModule
+    ],
     controllers: getControllers(),
     providers: [
       CapabilityService,