@cloudbase/agent-adapter-adp 1.0.1-alpha.13 → 1.0.1-alpha.14

package/README.md

@@ -15,6 +15,7 @@ npm install @cloudbase/agent-agents @cloudbase/agent-adapter-adp
 - **Thinking Events**: Support for thinking/reasoning process events from the model
 - **Workflow Integration**: Support for ADP workflows with tool call events
 - **Custom Variables**: Pass custom parameters to workflows and knowledge base
+- **File Upload**: Upload images and documents to COS for multimodal conversations (**requires `enableUpload: true`**)
 
 ## Environment Variables
 
@@ -121,6 +122,55 @@ observable.subscribe({
 });
 ```
 
+### With File Upload (Images and Documents)
+
+When `enableUpload` is **set to `true`**, you can send images and documents in messages. Files are automatically uploaded to Tencent Cloud COS and processed by ADP.
+
+**Note:** File upload requires Tencent Cloud credentials (`TENCENTCLOUD_SECRETID` and `TENCENTCLOUD_SECRETKEY`).
+
+```typescript
+import { AdpAgent } from "@cloudbase/agent-adapter-adp";
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+
+const agent = new AdpAgent({
+  name: "my-adp-agent",
+  adpConfig: {
+    appKey: "your-app-key",
+    enableUpload: true, // Enable file upload
+    credential: {
+      secretId: "your-secret-id",
+      secretKey: "your-secret-key",
+    },
+  },
+});
+
+const observable = agent.run({
+  runId: randomUUID(),
+  threadId: randomUUID(),
+  messages: [
+    {
+      id: randomUUID(),
+      role: "user",
+      content: [
+        { type: "text", text: "What's in this image?" },
+        {
+          type: "binary",
+          mimeType: "image/png",
+          filename: "screenshot.png",
+          data: fs.readFileSync("./screenshot.png"),
+        },
+      ],
+    },
+  ],
+});
+```
+
+**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`
+
 ## API Reference
 
 ### AdpAgent
@@ -146,6 +196,7 @@ interface AdpConfig {
     token?: string; // Session token (optional if TENCENTCLOUD_SESSIONTOKEN env is set)
   };
   historyCount?: number; // Number of history messages to retrieve (reserved)
+  enableUpload?: boolean; // Enable file upload for images and documents (default: false)
   request?: {
     baseUrl?: string; // Base URL for ADP API (default: https://wss.lke.cloud.tencent.com)
     endpoint?: string; // API endpoint (default: /v1/qbot/chat/sse)
@@ -187,6 +238,7 @@ The adapter emits the following AG-UI events:
 - `axios`: HTTP client for API requests
 - `rxjs`: Reactive extensions for JavaScript
 - `tencentcloud-sdk-nodejs-lke`: Tencent Cloud LKE SDK
+- `cos-nodejs-sdk-v5`: Tencent Cloud COS SDK (for file upload)
 
 ## Related Resources
 

package/dist/index.d.mts

@@ -61,6 +61,7 @@ type AdpConfig = {
         body?: Partial<AdpChatRequest>;
     };
     historyCount?: number;
+    enableUpload?: boolean;
     appKey?: string;
     credential?: {
         secretId?: string;
@@ -282,6 +283,7 @@ declare class AdpAgent extends AbstractAgent {
     private reqLkeClient;
     protected adpConfig: AdpConfig;
     private finalAppKey;
+    private finalCloudCredential;
     constructor(config: AgentConfig & {
         adpConfig: AdpConfig;
     });

package/dist/index.d.ts

@@ -61,6 +61,7 @@ type AdpConfig = {
         body?: Partial<AdpChatRequest>;
     };
     historyCount?: number;
+    enableUpload?: boolean;
     appKey?: string;
     credential?: {
         secretId?: string;
@@ -282,6 +283,7 @@ declare class AdpAgent extends AbstractAgent {
     private reqLkeClient;
     protected adpConfig: AdpConfig;
     private finalAppKey;
+    private finalCloudCredential;
     constructor(config: AgentConfig & {
         adpConfig: AdpConfig;
     });

package/dist/index.js

@@ -129,18 +129,20 @@ 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({
@@ -170,7 +172,8 @@ var AdpAgent = class extends import_client.AbstractAgent {
   }
   async _run(subscriber, input) {
     try {
-      const { runId, threadId } = input;
+      const { runId, threadId: _threadId } = input;
+      const threadId = _threadId || (0, import_crypto.randomUUID)();
       subscriber.next({
         type: import_client.EventType.RUN_STARTED,
         runId,
@@ -436,47 +439,63 @@ var AdpAgent = class extends import_client.AbstractAgent {
         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}`
+          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"
                 );
-              },
-              (fileName, error) => {
+              }
+              if (!this.finalCloudCredential.secretKey) {
                 throw new AdpAgentError(
-                  `Upload image ${fileName} failed: ${error}`,
-                  "UPLOAD_IMAGE_FAILED"
+                  "TENCENTCLOUD_SECRETKEY is required, check your env variables or config passed with the adapter",
+                  "MISSING_SECRET_KEY"
                 );
               }
-            );
-          }
-          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;
+            }
+            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);
                 }
-              } else return acc;
-            } else {
-              return acc;
+              }
+            });
+            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"
+                  );
+                }
+              );
             }
-          }, "").trim();
+            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}`;
@@ -513,105 +532,121 @@ ${result}`;
     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: (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 (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) {
+        }
+      }
+      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);
+                }
               }
-              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}`
-                      });
+              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;
                   }
-                  break;
-                }
-                default: {
-                  break;
                 }
               }
             }
           }
-        }
-      });
+        });
+      }
     }
     return {
       messages: newMessages,