@cloudbase/agent-adapter-adp 1.0.1-alpha.11 → 1.0.1-alpha.12

package/dist/index.d.mts

@@ -1,5 +1,6 @@
 import { AbstractAgent, AgentConfig, RunAgentInput, EventType } from '@ag-ui/client';
 import { Observable } from 'rxjs';
+import { lke } from 'tencentcloud-sdk-nodejs-lke';
 
 /**
  * 文件信息
@@ -244,24 +245,50 @@ interface ThoughtProcedure {
 interface Debugging {
     content: string;
 }
+interface DocumentParseRequest {
+    sessionId: string;
+    botAppKey: string;
+    requestId: string;
+    cosBucket: string;
+    fileType: string;
+    fileName: string;
+    cosUrl: string;
+    cosHash: string;
+    eTag: string;
+    size: string;
+}
+interface DocumentParseChunk {
+    type: "parsing";
+    payload: ParsingEvent;
+}
+interface ParsingEvent {
+    session_id: string;
+    trace_id: string;
+    is_final: boolean;
+    doc_id: string;
+    process: number;
+    status: string;
+    timestamp: number;
+    error_message: string;
+}
 
 declare class AdpAgentError extends Error {
     code?: string;
     constructor(message: string, code?: string);
 }
+type CosParams = Awaited<ReturnType<typeof lke.v20231130.Client.prototype.DescribeStorageCredential>>;
 declare class AdpAgent extends AbstractAgent {
     private reqAppClient;
     private reqLkeClient;
     protected adpConfig: AdpConfig;
+    private finalAppKey;
     constructor(config: AgentConfig & {
         adpConfig: AdpConfig;
     });
-    generateRequestBody({ message, fileInfos, runId, threadId, forwardedProps, }: {
+    generateRequestBody({ message, fileInfos, input, }: {
         message: string;
         fileInfos: FileInfo[];
-        runId: string;
-        threadId: string;
-        forwardedProps: Record<string, string>;
+        input: RunAgentInput;
     }): AdpChatRequest;
     run(input: RunAgentInput): Observable<{
         type: EventType;
@@ -269,6 +296,10 @@ declare class AdpAgent extends AbstractAgent {
         rawEvent?: any;
     }>;
     private _run;
+    private convertAGUIMessagesToAdpMessages;
+    private extractDocuments;
+    private getCosParams;
+    private uploadToCos;
 }
 
-export { AdpAgent, AdpAgentError, type AdpChatRequest, type AdpChunk, type AdpConfig, type CurrentNode, CurrentNodeStatus, type Debugging, type ErrorInfo, type FileInfo, type Knowledge, type QuoteInfo, type Reference, type ReferenceEvent, type ReplyEvent, ReplyMethod, type StatisticInfo, type TaskFlow, type ThoughtEvent, type ThoughtProcedure, type TokenStatEvent, type TokenStatProcedure, type WorkFlow };
+export { AdpAgent, AdpAgentError, type AdpChatRequest, type AdpChunk, type AdpConfig, type CosParams, type CurrentNode, CurrentNodeStatus, type Debugging, type DocumentParseChunk, type DocumentParseRequest, type ErrorInfo, type FileInfo, type Knowledge, type ParsingEvent, type QuoteInfo, type Reference, type ReferenceEvent, type ReplyEvent, ReplyMethod, type StatisticInfo, type TaskFlow, type ThoughtEvent, type ThoughtProcedure, type TokenStatEvent, type TokenStatProcedure, type WorkFlow };

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { AbstractAgent, AgentConfig, RunAgentInput, EventType } from '@ag-ui/client';
 import { Observable } from 'rxjs';
+import { lke } from 'tencentcloud-sdk-nodejs-lke';
 
 /**
  * 文件信息
@@ -244,24 +245,50 @@ interface ThoughtProcedure {
 interface Debugging {
     content: string;
 }
+interface DocumentParseRequest {
+    sessionId: string;
+    botAppKey: string;
+    requestId: string;
+    cosBucket: string;
+    fileType: string;
+    fileName: string;
+    cosUrl: string;
+    cosHash: string;
+    eTag: string;
+    size: string;
+}
+interface DocumentParseChunk {
+    type: "parsing";
+    payload: ParsingEvent;
+}
+interface ParsingEvent {
+    session_id: string;
+    trace_id: string;
+    is_final: boolean;
+    doc_id: string;
+    process: number;
+    status: string;
+    timestamp: number;
+    error_message: string;
+}
 
 declare class AdpAgentError extends Error {
     code?: string;
     constructor(message: string, code?: string);
 }
+type CosParams = Awaited<ReturnType<typeof lke.v20231130.Client.prototype.DescribeStorageCredential>>;
 declare class AdpAgent extends AbstractAgent {
     private reqAppClient;
     private reqLkeClient;
     protected adpConfig: AdpConfig;
+    private finalAppKey;
     constructor(config: AgentConfig & {
         adpConfig: AdpConfig;
     });
-    generateRequestBody({ message, fileInfos, runId, threadId, forwardedProps, }: {
+    generateRequestBody({ message, fileInfos, input, }: {
         message: string;
         fileInfos: FileInfo[];
-        runId: string;
-        threadId: string;
-        forwardedProps: Record<string, string>;
+        input: RunAgentInput;
     }): AdpChatRequest;
     run(input: RunAgentInput): Observable<{
         type: EventType;
@@ -269,6 +296,10 @@ declare class AdpAgent extends AbstractAgent {
         rawEvent?: any;
     }>;
     private _run;
+    private convertAGUIMessagesToAdpMessages;
+    private extractDocuments;
+    private getCosParams;
+    private uploadToCos;
 }
 
-export { AdpAgent, AdpAgentError, type AdpChatRequest, type AdpChunk, type AdpConfig, type CurrentNode, CurrentNodeStatus, type Debugging, type ErrorInfo, type FileInfo, type Knowledge, type QuoteInfo, type Reference, type ReferenceEvent, type ReplyEvent, ReplyMethod, type StatisticInfo, type TaskFlow, type ThoughtEvent, type ThoughtProcedure, type TokenStatEvent, type TokenStatProcedure, type WorkFlow };
+export { AdpAgent, AdpAgentError, type AdpChatRequest, type AdpChunk, type AdpConfig, type CosParams, type CurrentNode, CurrentNodeStatus, type Debugging, type DocumentParseChunk, type DocumentParseRequest, type ErrorInfo, type FileInfo, type Knowledge, type ParsingEvent, type QuoteInfo, type Reference, type ReferenceEvent, type ReplyEvent, ReplyMethod, type StatisticInfo, type TaskFlow, type ThoughtEvent, type ThoughtProcedure, type TokenStatEvent, type TokenStatProcedure, type WorkFlow };

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,7 +128,9 @@ var AdpAgentError = class extends Error {
 var AdpAgent = class extends import_client.AbstractAgent {
   constructor(config) {
     super(config);
+    this.finalAppKey = "";
     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"
     });
@@ -134,25 +146,23 @@ var AdpAgent = class extends import_client.AbstractAgent {
   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);
@@ -160,24 +170,24 @@ var AdpAgent = class extends import_client.AbstractAgent {
   }
   async _run(subscriber, input) {
     try {
-      const { messages, runId, threadId, forwardedProps } = input;
+      const { runId, threadId } = input;
       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 { messages: docExtractedMessages, fileInfos } = await this.extractDocuments(input, subscriber);
+      const { message, trimmed } = await this.convertAGUIMessagesToAdpMessages(docExtractedMessages);
       if (!message) {
         throw new AdpAgentError(
           "Message content format error, or empty content",
-          "INVALID_MESSAGE_CONTENT"
+          "INVALID_MESSAGE_FORMAT"
         );
       }
       if (trimmed > 0) {
@@ -192,9 +202,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",
@@ -363,7 +371,7 @@ var AdpAgent = class extends import_client.AbstractAgent {
                 console.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": {
@@ -415,66 +423,261 @@ var AdpAgent = class extends import_client.AbstractAgent {
       subscriber.complete();
     }
   }
-};
-function convertAGUIMessagesToAdpMessages(messages) {
-  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 {
-        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;
-          }
-        }, "").trim();
+  async convertAGUIMessagesToAdpMessages(messages) {
+    let result = "";
+    let trimmed = messages.length;
+    for (const message of messages.reverse()) {
+      if (message.role === "assistant") {
+        break;
       }
-      result = `${message.role}: ${content}
+      if (message.role === "user") {
+        trimmed--;
+        let content = "";
+        if (typeof message.content === "string") {
+          content = message.content;
+        } else {
+          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}`;
-    } else {
-      result = `${message.role}: ${message.content}
+      } else {
+        result = `${message.role}: ${message.content}
 ${result}`;
+      }
     }
+    return { message: result.trim(), trimmed };
   }
-  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)) {
-      let newContent = [];
-      msg.content.forEach((item) => {
-        if (item.type === "text") {
-          newContent.push(item);
-        } else if (item.type === "binary") {
-          if (Object.keys(MIME_TYPES).includes(item.mimeType)) {
-            documentFiles.push(item);
+  async extractDocuments(input, subscriber) {
+    const { messages, runId, threadId } = input;
+    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") {
+            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;
+    });
+    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 (successedFiles.length) {
+      successedFiles.forEach(async ({ data: cosData, cosParams, file }) => {
+        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?.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 (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 {
-        ...msg,
-        content: newContent
-      };
-    } else return msg;
-  });
-  const documentAddresses = [];
-  const fileInfos = [];
-  return {
-    messages: newMessages,
-    fileInfos
-  };
-}
+    }
+    return {
+      messages: newMessages,
+      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,