@cloudbase/agent-adapter-adp 0.0.16 → 0.0.19

package/dist/index.mjs

@@ -93,18 +93,20 @@ var AdpAgent = class extends 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 = axios.create({
       baseURL: this.adpConfig.request?.baseUrl || "https://wss.lke.cloud.tencent.com"
     });
     const LkeClient = 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({
@@ -133,9 +135,11 @@ var AdpAgent = class extends AbstractAgent {
     });
   }
   async _run(subscriber, input) {
+    let thinkingMessageSet = /* @__PURE__ */ new Set();
+    let thinkFinishedMessageSet = /* @__PURE__ */ new Set();
     try {
-      const { runId, threadId: _threadId } = input;
-      const threadId = _threadId || randomUUID();
+      const { runId } = input;
+      const threadId = input.threadId || randomUUID();
       subscriber.next({
         type: EventType.RUN_STARTED,
         runId,
@@ -147,19 +151,26 @@ var AdpAgent = class extends AbstractAgent {
           "MISSING_APP_KEY"
         );
       }
-      const { messages: docExtractedMessages, fileInfos } = await this.extractDocuments(input, subscriber);
-      const { message, trimmed } = await this.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_FORMAT"
         );
       }
-      if (trimmed > 0) {
+      if (input.messages.length > 1) {
         subscriber.next({
           type: 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"
           }
         });
@@ -178,7 +189,6 @@ var AdpAgent = class extends 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");
@@ -205,6 +215,22 @@ var AdpAgent = class extends 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: EventType.THINKING_TEXT_MESSAGE_END,
+                      messageId: `${messageId}-think-${index}`
+                    });
+                  }
+                  thinkingMessageSet.clear();
+                  subscriber.next({
+                    type: EventType.THINKING_END,
+                    messageId
+                  });
+                }
                 if (data.payload.is_from_self) {
                   if (data.payload.is_evil) {
                     throw new AdpAgentError(
@@ -215,8 +241,6 @@ var AdpAgent = class extends 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"
@@ -296,51 +320,47 @@ var AdpAgent = class extends 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: EventType.THINKING_TEXT_MESSAGE_START,
-                      messageId,
+                      messageId: `${messageId}-think-${index}`,
                       delta: procedure.debugging.content
                     });
                   } else {
                     if (procedure.status === "processing") {
                       subscriber.next({
                         type: EventType.THINKING_TEXT_MESSAGE_CONTENT,
-                        messageId,
+                        messageId: `${messageId}-think-${index}`,
                         delta: procedure.debugging.content
                       });
                     } else {
-                      thinkingMessageSet.delete(messageId);
-                      subscriber.next({
-                        type: EventType.THINKING_TEXT_MESSAGE_END,
-                        messageId
-                      });
+                      thinkingMessageSet.delete(index);
+                      if (!thinkFinishedMessageSet.has(index)) {
+                        thinkFinishedMessageSet.add(index);
+                        subscriber.next({
+                          type: 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: 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,
                   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": {
@@ -370,7 +390,7 @@ var AdpAgent = class extends 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 AxiosError) {
@@ -386,21 +406,33 @@ var AdpAgent = class extends AbstractAgent {
         message: `Sorry, an error occurred while running the agent: Error code ${code}, ${message}`
       });
       subscriber.complete();
+    } finally {
+      thinkingMessageSet.clear();
+      thinkFinishedMessageSet.clear();
     }
   }
-  async convertAGUIMessagesToAdpMessages(messages) {
+  async convertAGUIMessagesToAdpMessages(message) {
     let result = "";
-    let trimmed = messages.length;
-    for (const message of messages.reverse()) {
-      if (message.role === "assistant") {
-        break;
-      }
-      if (message.role === "user") {
-        trimmed--;
-        let content = "";
-        if (typeof message.content === "string") {
-          content = message.content;
-        } else {
+    if (message.role === "user") {
+      let content = "";
+      if (typeof message.content === "string") {
+        content = message.content;
+      } else {
+        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"
+              );
+            }
+          }
           const imageMap = /* @__PURE__ */ new Map();
           const imagesToUpload = [];
           message.content.forEach((item) => {
@@ -443,143 +475,158 @@ var AdpAgent = class extends AbstractAgent {
             }
           }, "").trim();
         }
-        result = `${message.role}: ${content}
+      }
+      result = `${message.role}: ${content}
 ${result}`;
-      } else {
-        result = `${message.role}: ${message.content}
+    } else {
+      result = `${message.role}: ${message.content}
 ${result}`;
-      }
     }
-    return { message: result.trim(), trimmed };
+    return result.trim();
   }
-  async extractDocuments(input, subscriber) {
-    const { messages, runId, threadId } = input;
+  async extractDocuments(message, threadId, subscriber) {
     const documentFiles = [];
-    const newMessages = messages.map((msg) => {
-      if (msg.role === "user" && Array.isArray(msg.content)) {
-        let newContent = [];
-        msg.content.forEach((item) => {
-          if (item.type === "text") {
+    let newMessage;
+    if (message.role === "user" && Array.isArray(message.content)) {
+      let newContent = [];
+      message.content.forEach((item) => {
+        if (item.type === "text") {
+          newContent.push(item);
+        } else if (item.type === "binary") {
+          if (Object.keys(DOCUMENT_MIME_TYPES).includes(item.mimeType)) {
+            documentFiles.push(item);
+          } else {
             newContent.push(item);
-          } else if (item.type === "binary") {
-            if (Object.keys(DOCUMENT_MIME_TYPES).includes(item.mimeType)) {
-              documentFiles.push(item);
-            } else {
-              newContent.push(item);
-            }
           }
-        });
-        return {
-          ...msg,
-          content: newContent
-        };
-      } else return msg;
-    });
+        }
+      });
+      newMessage = {
+        ...message,
+        content: newContent
+      };
+    } else newMessage = message;
     const fileInfos = [];
     const successedFiles = [];
     const failedFiles = [];
-    if (documentFiles.length) {
-      try {
-        await this.uploadToCos(
-          documentFiles,
-          (data, cosParams, file) => {
-            successedFiles.push({ data, cosParams, file });
-          },
-          (fileName, error) => {
-            failedFiles.push({ fileName, error });
-          }
-        );
-      } catch (e) {
+    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 (successedFiles.length) {
-      successedFiles.forEach(async ({ data: cosData, cosParams, file }) => {
-        const extName = MIME_TYPES[file.mimeType];
-        const requestBody = {
-          sessionId: threadId,
-          botAppKey: this.finalAppKey,
-          requestId: 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?.endpoint || "/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 (documentFiles.length) {
+        try {
+          await this.uploadToCos(
+            documentFiles,
+            (data, cosParams, file) => {
+              successedFiles.push({ data, cosParams, file });
+            },
+            (fileName, error) => {
+              failedFiles.push({ fileName, error });
             }
-            if (event.data) {
-              let data;
-              try {
-                data = JSON.parse(event.data);
-              } catch (e) {
-                throw new AdpAgentError(
-                  `ADP returned invalid data: ${event.data}`,
-                  "INVALID_DATA"
-                );
+          );
+        } 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: 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);
+                }
               }
-              switch (data.type) {
-                case "parsing": {
-                  subscriber.next({
-                    type: 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: 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}`
-                      });
+              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: 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: 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;
                   }
-                  break;
-                }
-                default: {
-                  break;
                 }
               }
             }
           }
         }
-      });
+      }
     }
     return {
-      messages: newMessages,
+      message: newMessage,
       fileInfos,
       failedFiles
     };