@cloudbase/agent-adapter-adp 1.0.1-alpha.23 → 1.0.1-alpha.25

package/README.md

@@ -168,8 +168,8 @@ const observable = agent.run({
 
 **Supported file types:**
 
-- **Images**: `image/png`, `image/jpeg`, `image/gif`, `image/webp`, `image/bmp`
-- **Documents**: `application/pdf`, `application/msword`, `application/vnd.openxmlformats-officedocument.wordprocessingml.document`, `text/markdown`, `text/plain`
+- **Images**: `image/png`, `image/jpeg`, `image/bmp`
+- **Documents**: `application/pdf`, `application/msword`, `application/vnd.openxmlformats-officedocument.wordprocessingml.document`, `application/vnd.ms-powerpoint`, `application/vnd.openxmlformats-officedocument.presentationml.presentation`, `text/plain`
 
 ## API Reference
 
@@ -200,6 +200,7 @@ interface AdpConfig {
   request?: {
     baseUrl?: string; // Base URL for ADP API (default: https://wss.lke.cloud.tencent.com)
     endpoint?: string; // API endpoint (default: /v1/qbot/chat/sse)
+    docParseEndpoint?: string; // Document parse API endpoint (default: /v1/qbot/chat/docParse)
     body?: Partial<AdpChatRequest>; // Additional request body options
   };
 }

package/dist/index.d.mts

@@ -59,6 +59,7 @@ type AdpConfig = {
         baseUrl?: string;
         endpoint?: string;
         body?: Partial<AdpChatRequest>;
+        docParseEndpoint?: string;
     };
     historyCount?: number;
     enableUpload?: boolean;

package/dist/index.d.ts

@@ -59,6 +59,7 @@ type AdpConfig = {
         baseUrl?: string;
         endpoint?: string;
         body?: Partial<AdpChatRequest>;
+        docParseEndpoint?: string;
     };
     historyCount?: number;
     enableUpload?: boolean;

package/dist/index.js

@@ -171,9 +171,11 @@ var AdpAgent = class extends import_client.AbstractAgent {
     });
   }
   async _run(subscriber, input) {
+    let thinkingMessageSet = /* @__PURE__ */ new Set();
+    let thinkFinishedMessageSet = /* @__PURE__ */ new Set();
     try {
-      const { runId, threadId: _threadId } = input;
-      const threadId = _threadId || (0, import_crypto.randomUUID)();
+      const { runId } = input;
+      const threadId = input.threadId || (0, import_crypto.randomUUID)();
       subscriber.next({
         type: import_client.EventType.RUN_STARTED,
         runId,
@@ -185,19 +187,26 @@ var AdpAgent = class extends import_client.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: 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"
           }
         });
@@ -216,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");
@@ -243,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(
@@ -253,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"
@@ -334,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,
                   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": {
@@ -408,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) {
@@ -424,111 +442,105 @@ 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();
     }
   }
-  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 (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 (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) => {
+            if (item.type === "binary") {
+              if (Object.keys(IMAGE_MIME_TYPES).includes(item.mimeType)) {
+                imagesToUpload.push(item);
               }
-              if (!this.finalCloudCredential.secretKey) {
+            }
+          });
+          if (imagesToUpload.length) {
+            await this.uploadToCos(
+              imagesToUpload,
+              (data, _, file) => {
+                imageMap.set(
+                  file.id || file.filename,
+                  `https://${data.Location}`
+                );
+              },
+              (fileName, error) => {
                 throw new AdpAgentError(
-                  "TENCENTCLOUD_SECRETKEY is required, check your env variables or config passed with the adapter",
-                  "MISSING_SECRET_KEY"
+                  `Upload image ${fileName} failed: ${error}`,
+                  "UPLOAD_IMAGE_FAILED"
                 );
               }
-            }
-            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;
             }
-            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();
-          }
+          }, "").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 = [];
@@ -559,10 +571,11 @@ ${result}`;
             }
           );
         } catch (e) {
+          console.error("Document upload failed: ", JSON.stringify(e));
         }
       }
       if (successedFiles.length) {
-        successedFiles.forEach(async ({ data: cosData, cosParams, file }) => {
+        for (const { data: cosData, cosParams, file } of successedFiles) {
           const extName = MIME_TYPES[file.mimeType];
           const requestBody = {
             sessionId: threadId,
@@ -577,7 +590,7 @@ ${result}`;
             size: file.data?.length.toString() || "0"
           };
           const response = await this.reqAppClient.post(
-            this.adpConfig.request?.endpoint || "/v1/qbot/chat/docParse",
+            this.adpConfig.request?.docParseEndpoint || "/v1/qbot/chat/docParse",
             camelToSnakeKeys(requestBody),
             { responseType: "stream" }
           );
@@ -645,11 +658,11 @@ ${result}`;
               }
             }
           }
-        });
+        }
       }
     }
     return {
-      messages: newMessages,
+      message: newMessage,
       fileInfos,
       failedFiles
     };