@cloudbase/agent-adapter-adp 0.0.15 → 0.0.18

package/dist/index.js

@@ -65,7 +65,7 @@ function camelToSnakeKeys(obj) {
 }
 
 // src/constant.ts
-var MIME_TYPES = {
+var DOCUMENT_MIME_TYPES = {
   "text/plain": "txt",
   "application/msword": "doc",
   "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
@@ -73,6 +73,15 @@ var MIME_TYPES = {
   "application/vnd.ms-powerpoint": "ppt",
   "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx"
 };
+var IMAGE_MIME_TYPES = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/bmp": "bmp"
+};
+var MIME_TYPES = {
+  ...DOCUMENT_MIME_TYPES,
+  ...IMAGE_MIME_TYPES
+};
 
 // src/types.ts
 var ReplyMethod = /* @__PURE__ */ ((ReplyMethod2) => {
@@ -108,6 +117,7 @@ var CurrentNodeStatus = /* @__PURE__ */ ((CurrentNodeStatus2) => {
 // src/agent.ts
 var import_crypto = require("crypto");
 var import_tencentcloud_sdk_nodejs_lke = require("tencentcloud-sdk-nodejs-lke");
+var import_cos_nodejs_sdk_v5 = __toESM(require("cos-nodejs-sdk-v5"));
 var AdpAgentError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -118,73 +128,85 @@ var AdpAgentError = class extends Error {
 var AdpAgent = class extends import_client.AbstractAgent {
   constructor(config) {
     super(config);
+    this.finalAppKey = "";
+    this.finalCloudCredential = {};
     this.adpConfig = config.adpConfig;
+    this.finalAppKey = this.adpConfig.appKey || this.adpConfig.request?.body?.botAppKey || process.env.ADP_APP_KEY || "";
     this.reqAppClient = import_axios.default.create({
       baseURL: this.adpConfig.request?.baseUrl || "https://wss.lke.cloud.tencent.com"
     });
     const LkeClient = import_tencentcloud_sdk_nodejs_lke.lke.v20231130.Client;
+    this.finalCloudCredential = {
+      secretId: this.adpConfig.credential?.secretId || process.env.TENCENTCLOUD_SECRETID,
+      secretKey: this.adpConfig.credential?.secretKey || process.env.TENCENTCLOUD_SECRETKEY,
+      token: this.adpConfig.credential?.token || process.env.TENCENTCLOUD_SESSIONTOKEN
+    };
     this.reqLkeClient = new LkeClient({
-      credential: {
-        secretId: this.adpConfig.credential?.secretId || process.env.TENCENTCLOUD_SECRETID,
-        secretKey: this.adpConfig.credential?.secretKey || process.env.TENCENTCLOUD_SECRETKEY,
-        token: this.adpConfig.credential?.token || process.env.TENCENTCLOUD_SESSIONTOKEN
-      }
+      credential: this.finalCloudCredential
     });
   }
   generateRequestBody({
     message,
     fileInfos,
-    runId,
-    threadId,
-    forwardedProps
+    input
   }) {
+    const { state, runId, threadId, forwardedProps } = input;
     const requestBody = {
       incremental: true,
       stream: "enable",
       ...this.adpConfig.request?.body || {},
       ...forwardedProps || {},
-      botAppKey: this.adpConfig.appKey || this.adpConfig.request?.body?.botAppKey || process.env.ADP_APP_KEY,
-      visitorBizId: forwardedProps?.visitorBizId || (0, import_crypto.randomUUID)(),
+      botAppKey: this.finalAppKey,
+      visitorBizId: state?.__request_context__?.id || forwardedProps?.visitorBizId || (0, import_crypto.randomUUID)(),
       requestId: runId,
-      sessionId: threadId || (0, import_crypto.randomUUID)(),
+      sessionId: threadId,
       content: message,
       fileInfos
     };
     return requestBody;
   }
-  // @ts-ignore
   run(input) {
     return new import_rxjs.Observable((subscriber) => {
       this._run(subscriber, input);
     });
   }
   async _run(subscriber, input) {
+    let thinkingMessageSet = /* @__PURE__ */ new Set();
+    let thinkFinishedMessageSet = /* @__PURE__ */ new Set();
     try {
-      const { messages, runId, threadId, forwardedProps } = input;
+      const { runId } = input;
+      const threadId = input.threadId || (0, import_crypto.randomUUID)();
       subscriber.next({
         type: import_client.EventType.RUN_STARTED,
         runId,
         threadId
       });
-      if (!this.adpConfig.appKey && !process.env.ADP_APP_KEY) {
+      if (!this.finalAppKey) {
         throw new AdpAgentError(
-          "ADP app key is required, check your env variables or config passed with the adapter",
+          "ADP_APP_KEY is required, check your env variables or config passed with the adapter",
           "MISSING_APP_KEY"
         );
       }
-      const { messages: docExtractedMessages, fileInfos } = await extractDocuments(messages, this.adpConfig, this.reqLkeClient);
-      const { message, trimmed } = convertAGUIMessagesToAdpMessages(docExtractedMessages);
+      const latestUserMessage = input.messages.filter((m) => m.role === "user").pop();
+      if (!latestUserMessage) {
+        throw new AdpAgentError(
+          "Message content format error, or empty content",
+          "INVALID_MESSAGE_FORMAT"
+        );
+      }
+      const { message: docExtractedMessage, fileInfos } = await this.extractDocuments(latestUserMessage, threadId, subscriber);
+      const message = await this.convertAGUIMessagesToAdpMessages(docExtractedMessage);
       if (!message) {
         throw new AdpAgentError(
           "Message content format error, or empty content",
-          "INVALID_MESSAGE_CONTENT"
+          "INVALID_MESSAGE_FORMAT"
         );
       }
-      if (trimmed > 0) {
+      if (input.messages.length > 1) {
         subscriber.next({
           type: import_client.EventType.RAW,
           rawEvent: {
-            message: `ADP handles message history itself, so that a total of ${trimmed} messages before and including last assistant message will be trimmed.`,
+            message: `ADP handles message history itself, so that a total of ${input.messages.length - 1} messages before and including last assistant message will be trimmed.`,
             type: "warn"
           }
         });
@@ -192,9 +214,7 @@ var AdpAgent = class extends import_client.AbstractAgent {
       const requestBody = this.generateRequestBody({
         message,
         fileInfos,
-        runId,
-        threadId,
-        forwardedProps
+        input
       });
       const response = await this.reqAppClient.post(
         this.adpConfig.request?.endpoint || "/v1/qbot/chat/sse",
@@ -205,7 +225,6 @@ var AdpAgent = class extends import_client.AbstractAgent {
       let buffer = "";
       let interruptRequested = false;
       let thinkingStart = false;
-      let thinkingMessageSet = /* @__PURE__ */ new Set();
       for await (const chunk of sseStream) {
         buffer += chunk.toString();
         const parts = buffer.split("\n\n");
@@ -232,6 +251,22 @@ var AdpAgent = class extends import_client.AbstractAgent {
             }
             switch (data.type) {
               case "reply": {
+                const messageId = data.payload.record_id;
+                const isFinal = data.payload.is_final;
+                if (thinkingStart) {
+                  thinkingStart = false;
+                  for (const index of thinkingMessageSet) {
+                    subscriber.next({
+                      type: import_client.EventType.THINKING_TEXT_MESSAGE_END,
+                      messageId: `${messageId}-think-${index}`
+                    });
+                  }
+                  thinkingMessageSet.clear();
+                  subscriber.next({
+                    type: import_client.EventType.THINKING_END,
+                    messageId
+                  });
+                }
                 if (data.payload.is_from_self) {
                   if (data.payload.is_evil) {
                     throw new AdpAgentError(
@@ -242,8 +277,6 @@ var AdpAgent = class extends import_client.AbstractAgent {
                     continue;
                   }
                 }
-                const messageId = data.payload.record_id;
-                const isFinal = data.payload.is_final;
                 data.payload.content = data.payload.content.replace(
                   /\\n/g,
                   "\n\n"
@@ -323,51 +356,47 @@ var AdpAgent = class extends import_client.AbstractAgent {
                   });
                 }
                 data.payload.procedures.forEach((procedure) => {
-                  if (!thinkingMessageSet.has(messageId)) {
-                    thinkingMessageSet.add(messageId);
+                  const index = procedure.index.toString();
+                  if (!thinkingMessageSet.has(index) && !thinkFinishedMessageSet.has(index)) {
+                    thinkingMessageSet.add(index);
                     subscriber.next({
                       type: import_client.EventType.THINKING_TEXT_MESSAGE_START,
-                      messageId,
+                      messageId: `${messageId}-think-${index}`,
                       delta: procedure.debugging.content
                     });
                   } else {
                     if (procedure.status === "processing") {
                       subscriber.next({
                         type: import_client.EventType.THINKING_TEXT_MESSAGE_CONTENT,
-                        messageId,
+                        messageId: `${messageId}-think-${index}`,
                         delta: procedure.debugging.content
                       });
                     } else {
-                      thinkingMessageSet.delete(messageId);
-                      subscriber.next({
-                        type: import_client.EventType.THINKING_TEXT_MESSAGE_END,
-                        messageId
-                      });
+                      thinkingMessageSet.delete(index);
+                      if (!thinkFinishedMessageSet.has(index)) {
+                        thinkFinishedMessageSet.add(index);
+                        subscriber.next({
+                          type: import_client.EventType.THINKING_TEXT_MESSAGE_END,
+                          messageId: `${messageId}-think-${index}`
+                        });
+                      }
                     }
                   }
                 });
-                const allFinished = data.payload.procedures.every(
-                  (procedure) => procedure.status !== "processing"
-                );
-                if (allFinished) {
-                  thinkingStart = false;
-                  thinkingMessageSet.clear();
-                  subscriber.next({
-                    type: import_client.EventType.THINKING_END,
-                    messageId
-                  });
-                }
                 break;
               }
               case "error": {
-                console.error(JSON.stringify(data));
+                console.error(
+                  "[ERROR] ADP throws error: ",
+                  JSON.stringify(data)
+                );
                 throw new AdpAgentError(
                   data.error.message,
-                  `ADP_ERROR_${data.error.code}` || "ADP_ERROR_0"
+                  data.error.code ? `ADP_ERROR_${data.error.code}` : "ADP_ERROR_-1"
                 );
               }
               case "token_stat": {
-                console.debug(JSON.stringify(data));
+                console.debug("[DEBUG] ADP token stat: ", JSON.stringify(data));
                 break;
               }
               case "reference": {
@@ -397,7 +426,7 @@ var AdpAgent = class extends import_client.AbstractAgent {
       }
       subscriber.complete();
     } catch (e) {
-      console.error(JSON.stringify(e));
+      console.error("[ERROR] Uncaught error: ", JSON.stringify(e));
       let code = "UNKNOWN_ERROR";
       let message = JSON.stringify(e);
       if (e instanceof import_axios.AxiosError) {
@@ -413,31 +442,75 @@ var AdpAgent = class extends import_client.AbstractAgent {
         message: `Sorry, an error occurred while running the agent: Error code ${code}, ${message}`
       });
       subscriber.complete();
+    } finally {
+      thinkingMessageSet.clear();
+      thinkFinishedMessageSet.clear();
     }
   }
-};
-function convertAGUIMessagesToAdpMessages(messages) {
-  let result = "";
-  let trimmed = messages.length;
-  for (const message of messages.reverse()) {
-    if (message.role === "assistant") {
-      break;
-    }
+  async convertAGUIMessagesToAdpMessages(message) {
+    let result = "";
     if (message.role === "user") {
-      trimmed--;
       let content = "";
       if (typeof message.content === "string") {
         content = message.content;
       } else {
-        content = message.content.reduce((acc, cur) => {
-          if (cur.type === "text") {
-            return acc + `${cur.text} `;
-          } else if (cur.type === "binary") {
-            return acc + `![${cur.filename}](${cur.url}) `;
-          } else {
-            return acc;
+        if (this.adpConfig.enableUpload) {
+          if (!this.finalCloudCredential.token) {
+            if (!this.finalCloudCredential.secretId) {
+              throw new AdpAgentError(
+                "TENCENTCLOUD_SECRETID is required, check your env variables or config passed with the adapter",
+                "MISSING_SECRET_ID"
+              );
+            }
+            if (!this.finalCloudCredential.secretKey) {
+              throw new AdpAgentError(
+                "TENCENTCLOUD_SECRETKEY is required, check your env variables or config passed with the adapter",
+                "MISSING_SECRET_KEY"
+              );
+            }
           }
-        }, "").trim();
+          const imageMap = /* @__PURE__ */ new Map();
+          const imagesToUpload = [];
+          message.content.forEach((item) => {
+            if (item.type === "binary") {
+              if (Object.keys(IMAGE_MIME_TYPES).includes(item.mimeType)) {
+                imagesToUpload.push(item);
+              }
+            }
+          });
+          if (imagesToUpload.length) {
+            await this.uploadToCos(
+              imagesToUpload,
+              (data, _, file) => {
+                imageMap.set(
+                  file.id || file.filename,
+                  `https://${data.Location}`
+                );
+              },
+              (fileName, error) => {
+                throw new AdpAgentError(
+                  `Upload image ${fileName} failed: ${error}`,
+                  "UPLOAD_IMAGE_FAILED"
+                );
+              }
+            );
+          }
+          content = message.content.reduce((acc, cur) => {
+            if (cur.type === "text") {
+              return acc + `${cur.text} `;
+            } else if (cur.type === "binary") {
+              if (Object.keys(IMAGE_MIME_TYPES).includes(cur.mimeType)) {
+                if (imageMap.has(cur.id || cur.filename)) {
+                  return acc + `![${cur.filename}](${imageMap.get(cur.id || cur.filename)}) `;
+                } else {
+                  return acc;
+                }
+              } else return acc;
+            } else {
+              return acc;
+            }
+          }, "").trim();
+        }
       }
       result = `${message.role}: ${content}
 ${result}`;
@@ -445,36 +518,214 @@ ${result}`;
       result = `${message.role}: ${message.content}
 ${result}`;
     }
+    return result.trim();
   }
-  return { message: result.trim(), trimmed };
-}
-async function extractDocuments(messages, config, reqLkeClient) {
-  const documentFiles = [];
-  const newMessages = messages.map((msg) => {
-    if (msg.role === "user" && Array.isArray(msg.content)) {
+  async extractDocuments(message, threadId, subscriber) {
+    const documentFiles = [];
+    let newMessage;
+    if (message.role === "user" && Array.isArray(message.content)) {
       let newContent = [];
-      msg.content.forEach((item) => {
+      message.content.forEach((item) => {
         if (item.type === "text") {
           newContent.push(item);
         } else if (item.type === "binary") {
-          if (Object.keys(MIME_TYPES).includes(item.mimeType)) {
+          if (Object.keys(DOCUMENT_MIME_TYPES).includes(item.mimeType)) {
             documentFiles.push(item);
+          } else {
+            newContent.push(item);
           }
         }
       });
-      return {
-        ...msg,
+      newMessage = {
+        ...message,
         content: newContent
       };
-    } else return msg;
-  });
-  const documentAddresses = [];
-  const fileInfos = [];
-  return {
-    messages: newMessages,
-    fileInfos
-  };
-}
+    } else newMessage = message;
+    const fileInfos = [];
+    const successedFiles = [];
+    const failedFiles = [];
+    if (this.adpConfig.enableUpload) {
+      if (!this.finalCloudCredential.token) {
+        if (!this.finalCloudCredential.secretId) {
+          throw new AdpAgentError(
+            "TENCENTCLOUD_SECRETID is required, check your env variables or config passed with the adapter",
+            "MISSING_SECRET_ID"
+          );
+        }
+        if (!this.finalCloudCredential.secretKey) {
+          throw new AdpAgentError(
+            "TENCENTCLOUD_SECRETKEY is required, check your env variables or config passed with the adapter",
+            "MISSING_SECRET_KEY"
+          );
+        }
+      }
+      if (documentFiles.length) {
+        try {
+          await this.uploadToCos(
+            documentFiles,
+            (data, cosParams, file) => {
+              successedFiles.push({ data, cosParams, file });
+            },
+            (fileName, error) => {
+              failedFiles.push({ fileName, error });
+            }
+          );
+        } catch (e) {
+          console.error("Document upload failed: ", JSON.stringify(e));
+        }
+      }
+      if (successedFiles.length) {
+        for (const { data: cosData, cosParams, file } of successedFiles) {
+          const extName = MIME_TYPES[file.mimeType];
+          const requestBody = {
+            sessionId: threadId,
+            botAppKey: this.finalAppKey,
+            requestId: (0, import_crypto.randomUUID)(),
+            cosBucket: cosParams.Bucket,
+            fileType: extName,
+            fileName: file.filename,
+            cosUrl: cosParams.UploadPath,
+            cosHash: cosData.headers?.["x-cos-hash-crc64ecma"] || "",
+            eTag: cosData.ETag,
+            size: file.data?.length.toString() || "0"
+          };
+          const response = await this.reqAppClient.post(
+            this.adpConfig.request?.docParseEndpoint || "/v1/qbot/chat/docParse",
+            camelToSnakeKeys(requestBody),
+            { responseType: "stream" }
+          );
+          const sseStream = response.data;
+          let buffer = "";
+          for await (const chunk of sseStream) {
+            buffer += chunk.toString();
+            const parts = buffer.split("\n\n");
+            buffer = parts.pop() || "";
+            for (const part of parts) {
+              if (!part.trim()) continue;
+              const event = { data: "", event: "" };
+              for (const line of part.split("\n")) {
+                if (line.startsWith("data:")) {
+                  event.data += line.slice(5);
+                } else if (line.startsWith("event:")) {
+                  event.event = line.slice(6);
+                }
+              }
+              if (event.data) {
+                let data;
+                try {
+                  data = JSON.parse(event.data);
+                } catch (e) {
+                  throw new AdpAgentError(
+                    `ADP returned invalid data: ${event.data}`,
+                    "INVALID_DATA"
+                  );
+                }
+                switch (data.type) {
+                  case "parsing": {
+                    subscriber.next({
+                      type: import_client.EventType.RAW,
+                      rawEvent: {
+                        message: `Parsing document ${file.filename}: ${data.payload.process}%`,
+                        type: "info"
+                      }
+                    });
+                    if (data.payload.is_final) {
+                      if (data.payload.error_message) {
+                        subscriber.next({
+                          type: import_client.EventType.RAW,
+                          rawEvent: {
+                            message: `Parsing document ${file.filename} failed: ${data.payload.error_message}`,
+                            type: "error"
+                          }
+                        });
+                      } else {
+                        const fileNameNoExt = file.filename.split(".").splice(0, -1).join(".");
+                        fileInfos.push({
+                          docId: data.payload.doc_id,
+                          fileName: fileNameNoExt,
+                          fileType: extName,
+                          fileSize: file.data?.length.toString() || "0",
+                          fileUrl: `https://${cosData.Location}`
+                        });
+                      }
+                    }
+                    break;
+                  }
+                  default: {
+                    break;
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+    return {
+      message: newMessage,
+      fileInfos,
+      failedFiles
+    };
+  }
+  async getCosParams(mimeType) {
+    const extName = MIME_TYPES?.[mimeType];
+    if (!extName) {
+      throw new Error(`Unsupported mime type: ${mimeType}`);
+    }
+    const isPicture = Object.keys(IMAGE_MIME_TYPES).includes(mimeType);
+    const bizIdRes = await this.reqLkeClient.DescribeRobotBizIDByAppKey({
+      AppKey: this.finalAppKey
+    });
+    const storageRes = await this.reqLkeClient.DescribeStorageCredential({
+      BotBizId: bizIdRes.BotBizId,
+      FileType: extName,
+      IsPublic: isPicture,
+      TypeKey: "realtime"
+    });
+    return storageRes;
+  }
+  async uploadToCos(files, onSuccess, onError) {
+    const promises = [];
+    for (const file of files) {
+      const extName = MIME_TYPES?.[file.mimeType];
+      if (!extName) {
+        onError(file.filename || "unknown-file", "Unsupported file type");
+        continue;
+      }
+      const cosParams = await this.getCosParams(file.mimeType);
+      const cosClient = new import_cos_nodejs_sdk_v5.default({
+        SecretId: cosParams.Credentials?.TmpSecretId,
+        SecretKey: cosParams.Credentials?.TmpSecretKey,
+        SecurityToken: cosParams.Credentials?.Token
+      });
+      if (!cosParams.Bucket || !cosParams.Region || !cosParams.UploadPath) {
+        onError(file.filename || "unknown-file", "Failed to get COS params");
+        continue;
+      }
+      const promise = new Promise((resolve, reject) => {
+        cosClient.putObject(
+          {
+            Bucket: cosParams.Bucket,
+            Region: cosParams.Region,
+            Key: cosParams.UploadPath,
+            Body: file.data
+          },
+          (err, data) => {
+            if (err) {
+              onError(file.filename || "unknown-file", err.message);
+              reject();
+            } else {
+              onSuccess(data, cosParams, file);
+              resolve();
+            }
+          }
+        );
+      });
+      promises.push(promise);
+    }
+    await Promise.allSettled(promises);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AdpAgent,