web-dc-api 0.0.58 → 0.0.60

package/dist/esm/implements/aiproxy/client.js

@@ -0,0 +1,249 @@
+import { Libp2pGrpcClient } from 'grpc-libp2p-client';
+import { dcnet } from '../../proto/dcnet_proto.js';
+import { Errors } from '../../common/error.js';
+import { AIStreamResponseFlag } from '../../common/types/types.js';
+
+class AIProxyClient {
+  constructor(dcClient, context) {
+    Object.defineProperty(this, "client", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.client = dcClient;
+    this.context = context;
+  }
+  async GetAIProxyConfig(appId, themeAuthor, configTheme) {
+    const message = new dcnet.pb.GetAIProxyConfigRequest({});
+    message.appId = new TextEncoder().encode(appId);
+    message.themeAuthor = new TextEncoder().encode(themeAuthor);
+    message.theme = new TextEncoder().encode(configTheme);
+    const messageBytes = dcnet.pb.GetAIProxyConfigRequest.encode(message).finish();
+    const grpcClient = new Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+    try {
+      const reply = await grpcClient.unaryCall("/dcnet.pb.Service/GetAIProxyConfig", messageBytes, 30000);
+      console.log("GetAIProxyConfig reply", reply);
+      const decoded = dcnet.pb.GetAIProxyConfigReply.decode(reply);
+      if (decoded.flag != 0) {
+        throw new Error(Errors.INVALID_TOKEN.message + " flag:" + decoded.flag);
+      }
+      const proxyConfigCid = new TextDecoder().decode(decoded.proxyConfigCid);
+      const aesKey = new TextDecoder().decode(decoded.aeskey);
+      return [proxyConfigCid, aesKey, null];
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" && error.message.indexOf(Errors.INVALID_TOKEN.message) != -1) {
+        // try to get token
+        const token = await this.client.GetToken(this.context.appInfo.appId || "", this.context.getPublicKey().string(), payload => {
+          return this.context.sign(payload);
+        });
+        if (!token) {
+          throw new Error(Errors.INVALID_TOKEN.message);
+        }
+        const reply = await grpcClient.unaryCall("/dcnet.pb.Service/GetAIProxyConfig", messageBytes, 30000);
+        console.log("GetAIProxyConfig reply", reply);
+        const decoded = dcnet.pb.GetAIProxyConfigReply.decode(reply);
+        console.log("GetAIProxyConfig decoded", decoded);
+        if (decoded.flag != 0) {
+          throw new Error(Errors.INVALID_TOKEN.message + " flag:" + decoded.flag);
+        }
+        const proxyConfigCid = new TextDecoder().decode(decoded.proxyConfigCid);
+        const aesKey = new TextDecoder().decode(decoded.aeskey);
+        return [proxyConfigCid, aesKey, null];
+      }
+      console.error("GetAIProxyConfig error:", error);
+      throw error;
+    }
+  }
+  async GetUserOwnAIProxyAuth(appId, themeAuthor, configTheme) {
+    const message = new dcnet.pb.GetUserOwnAIProxyAuthRequest({});
+    message.appId = new TextEncoder().encode(appId);
+    message.themeAuthor = new TextEncoder().encode(themeAuthor);
+    message.theme = new TextEncoder().encode(configTheme);
+    const messageBytes = dcnet.pb.GetUserOwnAIProxyAuthRequest.encode(message).finish();
+    const grpcClient = new Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+    try {
+      const reply = await grpcClient.unaryCall("/dcnet.pb.Service/GetUserOwnAIProxyAuth", messageBytes, 30000);
+      console.log("GetUserOwnAIProxyAuth reply", reply);
+      const decoded = dcnet.pb.GetUserOwnAIProxyAuthReply.decode(reply);
+      if (decoded.flag != 0) {
+        throw new Error(Errors.INVALID_TOKEN.message + " flag:" + decoded.flag);
+      }
+      const authInfo = new TextDecoder().decode(decoded.authInfo);
+      return [authInfo, null];
+    } catch (error) {
+      if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string" && error.message.indexOf(Errors.INVALID_TOKEN.message) != -1) {
+        // try to get token
+        const token = await this.client.GetToken(this.context.appInfo.appId || "", this.context.getPublicKey().string(), payload => {
+          return this.context.sign(payload);
+        });
+        if (!token) {
+          throw new Error(Errors.INVALID_TOKEN.message);
+        }
+        const reply = await grpcClient.unaryCall("/dcnet.pb.Service/GetUserOwnAIProxyAuth", messageBytes, 30000);
+        console.log("GetUserOwnAIProxyAuth reply", reply);
+        const decoded = dcnet.pb.GetUserOwnAIProxyAuthReply.decode(reply);
+        console.log("GetUserOwnAIProxyAuth decoded", decoded);
+        if (decoded.flag != 0) {
+          return ["", new Error(Errors.INVALID_TOKEN.message + " flag:" + decoded.flag)];
+        }
+        const authInfo = new TextDecoder().decode(decoded.authInfo);
+        return [authInfo, null];
+      }
+      return ["", error instanceof Error ? error : new Error(String(error))];
+    }
+  }
+  async DoAIProxyCall(context, appId, themeAuthor, configTheme, serviceName, path, headers, reqBody, model, forceRefresh, blockHeight, signature) {
+    let onStreamResponse = arguments.length > 12 && arguments[12] !== undefined ? arguments[12] : null;
+    const message = new dcnet.pb.DoAIProxyCallRequest({});
+    message.appId = new TextEncoder().encode(appId);
+    message.themeAuthor = new TextEncoder().encode(themeAuthor);
+    message.theme = new TextEncoder().encode(configTheme);
+    message.configKey = new TextEncoder().encode(serviceName);
+    message.path = new TextEncoder().encode(path);
+    message.headers = new TextEncoder().encode(headers);
+    message.reqBody = new TextEncoder().encode(reqBody);
+    message.modelConfig = new TextEncoder().encode(model);
+    message.forceRefresh = forceRefresh;
+    message.blockheight = blockHeight;
+    message.signature = signature;
+    const messageBytes = dcnet.pb.DoAIProxyCallRequest.encode(message).finish();
+    const grpcClient = new Libp2pGrpcClient(this.client.p2pNode, this.client.peerAddr, this.client.token, this.client.protocol);
+    // 添加超时检测相关变量
+    let hasStartedReceiving = false;
+    let timeoutTimer = null;
+    let isCompleted = false;
+    let isAborted = false;
+    // 清理定时器的函数
+    const clearTimeoutTimer = () => {
+      if (timeoutTimer) {
+        clearTimeout(timeoutTimer);
+        timeoutTimer = null;
+      }
+    };
+    // 设置超时检测定时器
+    const setTimeoutTimer = () => {
+      clearTimeoutTimer();
+      timeoutTimer = setTimeout(() => {
+        if (!isCompleted && !isAborted && hasStartedReceiving) {
+          console.warn('DoAIProxyCall 数据流超时，超过30秒未收到数据');
+          isAborted = true;
+          // 通知调用者超时
+          if (onStreamResponse) {
+            onStreamResponse(AIStreamResponseFlag.STREAM_HANG, "", "数据流超时：超过30秒未收到响应数据");
+          }
+        }
+      }, 60000); // 60秒超时
+    };
+    // 检查是否已经被中止
+    const checkAborted = () => {
+      if (context.signal?.aborted) {
+        isAborted = true;
+        clearTimeoutTimer();
+        return true;
+      }
+      return false;
+    };
+    const onDataCallback = async payload => {
+      if (isAborted || isCompleted || checkAborted()) return;
+      // 更新最后接收数据的时间
+      hasStartedReceiving = true;
+      // 重置超时定时器
+      setTimeoutTimer();
+      try {
+        const decodedPayload = dcnet.pb.DoAIProxyCallReply.decode(payload);
+        if (decodedPayload.flag == AIStreamResponseFlag.CONNECTION_CLOSED) {
+          isCompleted = true; // 如果不是流式响应，标记为完成
+          clearTimeoutTimer();
+          console.log('*********** CONNECTION_CLOSED ***********222');
+        }
+        if (onStreamResponse) {
+          onStreamResponse(decodedPayload.flag, new TextDecoder().decode(decodedPayload.content), new TextDecoder().decode(decodedPayload.err));
+        }
+      } catch (error) {
+        console.error('DoAIProxyCall 解析数据失败:', error);
+        if (onStreamResponse) {
+          onStreamResponse(AIStreamResponseFlag.OTHER_ERROR, "", error instanceof Error ? error.message : String(error));
+        }
+      }
+    };
+    const onEndCallback = async () => {
+      clearTimeoutTimer();
+      if (isAborted || checkAborted() || isCompleted) return;
+      console.log('*********** onEndCallback ***********1111');
+      isCompleted = true;
+      if (onStreamResponse) {
+        onStreamResponse(AIStreamResponseFlag.CONNECTION_CLOSED, "", "");
+      }
+    };
+    const onErrorCallback = async error => {
+      if (isAborted || checkAborted() || isCompleted) return;
+      //不要标记完成,和清理定时器,统一由onEndCallback处理
+      // isCompleted = true; // 
+      // clearTimeoutTimer();
+      if (onStreamResponse) {
+        onStreamResponse(AIStreamResponseFlag.OTHER_ERROR, "", error instanceof Error ? error.message : String(error));
+      }
+    };
+    // 监听外部中止信号 - 这不会拦截信号，只是添加监听器
+    let abortListener = null;
+    if (context.signal) {
+      // 先检查是否已经被中止
+      if (context.signal.aborted) {
+        isAborted = true;
+        clearTimeoutTimer();
+        console.log('DoAIProxyCall 调用前已被中止');
+        return AIStreamResponseFlag.EXTERNAL_EXIT;
+      }
+      abortListener = () => {
+        isAborted = true;
+        clearTimeoutTimer();
+        console.log('DoAIProxyCall 被外部中止');
+        // 通知调用者已被中止
+        if (onStreamResponse) {
+          onStreamResponse(AIStreamResponseFlag.EXTERNAL_EXIT, "", "调用被用户中止");
+        }
+      };
+      context.signal.addEventListener('abort', abortListener);
+    }
+    try {
+      // 开始调用前设置初始超时定时器（用于检测是否开始接收数据）
+      setTimeoutTimer();
+      // 将完整的 context 传递给 grpcClient.Call，让它自己处理中止信号
+      await grpcClient.Call("/dcnet.pb.Service/DoAIProxyCall", messageBytes, 10000000, "server-streaming", onDataCallback, undefined,
+      // dataSourceCallback not needed for server-streaming
+      onEndCallback, onErrorCallback, context // 完整传递 context，包括 signal
+      );
+      return 0;
+    } catch (error) {
+      isCompleted = true;
+      clearTimeoutTimer();
+      console.error("DoAIProxyCall error:", error);
+      // 如果是超时导致的错误，返回特定的错误码
+      if (isAborted) {
+        return AIStreamResponseFlag.STREAM_HANG;
+      }
+      // 检查是否是中止导致的错误
+      if (context.signal?.aborted) {
+        return AIStreamResponseFlag.EXTERNAL_EXIT;
+      }
+      throw error;
+    } finally {
+      // 确保定时器被清理
+      clearTimeoutTimer();
+      // 清理事件监听器
+      if (abortListener && context.signal) {
+        context.signal.removeEventListener('abort', abortListener);
+      }
+      // 无需关闭 gRPC 客户端连接，因为 Libp2pGrpcClient 没有 close 方法
+    }
+  }
+}
+
+export { AIProxyClient };

package/dist/esm/implements/aiproxy/manager.js

@@ -0,0 +1,444 @@
+import { OpenFlag, cidNeedConnect } from '../../common/constants.js';
+import { CommentManager } from '../comment/manager.js';
+import { Ed25519PubKey } from '../../common/dc-key/ed25519.js';
+import { sha256, uint32ToLittleEndianBytes } from '../../util/utils.js';
+import { base32 } from '../../node_modules/multiformats/dist/src/bases/base32.js';
+import { CommentType } from '../../common/define.js';
+import { AIProxyClient } from './client.js';
+import { FileManager } from '../file/manager.js';
+import { toString } from '../../node_modules/uint8arrays/dist/src/to-string.js';
+import { BrowserLineReader, readLine } from '../../util/BrowserLineReader.js';
+import { KeyValueClient } from '../keyvalue/client.js';
+import { SymmetricKey } from '../threaddb/common/key.js';
+
+// 错误定义
+class AIProxyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AIProxyError";
+  }
+}
+const Errors = {
+  ErrNoDcPeerConnected: new AIProxyError("no dc peer connected"),
+  ErrKeyNotValid: new AIProxyError("key not valid"),
+  // nodeAddr is null
+  ErrNodeAddrIsNull: new AIProxyError("nodeAddr is null"),
+  // chainUtil is null
+  ErrChainUtilIsNull: new AIProxyError("chainUtil is null"),
+  // account privatekey sign is null
+  ErrAccountPrivateSignIsNull: new AIProxyError("account privatekey sign is null"),
+  // account publickey is null
+  ErrAccountPublicKeyIsNull: new AIProxyError("account publickey is null")
+};
+class AIProxyManager {
+  constructor(dc, dcNodeClient, chainUtil, context) {
+    Object.defineProperty(this, "dc", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "dcNodeClient", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "chainUtil", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "handleAllConfig", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: async (fileContentString, aesKey) => {
+        const reader = new BrowserLineReader(fileContentString);
+        let allContent = [];
+        let allAuth = [];
+        if (!this.context.getPublicKey()) {
+          return null;
+        }
+        const decryptKey = SymmetricKey.fromString(aesKey);
+        // readLine 循环
+        while (true) {
+          const {
+            line,
+            error
+          } = readLine(reader);
+          if (error && error.message !== "EOF") {
+            console.error("读取错误:", error);
+            break;
+          } else if (line) {
+            // 将Uint8Array转回字符串
+            const decoder = new TextDecoder();
+            const lineString = decoder.decode(line);
+            if (!lineString) {
+              break;
+            }
+            const lineContent = base32.decode(lineString);
+            const plainContent = await decryptKey.decrypt(lineContent);
+            const contentStr = new TextDecoder().decode(plainContent);
+            if (!contentStr) {
+              continue; // 如果内容为空，跳过
+            }
+            if (contentStr.startsWith("$$auth$$:")) {
+              //授权信息
+              try {
+                const authContent = contentStr.split("$$auth$$:")[1];
+                if (!authContent) {
+                  console.error("无效的授权信息格式:", contentStr);
+                  continue; // 如果格式不正确，跳过
+                }
+                const parts = authContent.split(":");
+                if (parts.length < 2) {
+                  console.error("无效的授权信息格式:", authContent);
+                  continue; // 如果格式不正确，跳过
+                }
+                //解析出userpubkey
+                const userPubkey = parts[0] || "";
+                const permission = parts[1] || "";
+                const authContentStr = authContent.substring(userPubkey.length + permission.length + 2 // +2 for the colon and the next colon
+                );
+                //解析到ProxyCallConfig结构
+                const authConfig = JSON.parse(authContentStr);
+                allAuth.push({
+                  UserPubkey: userPubkey,
+                  permission: parseInt(permission),
+                  //转成数字
+                  authConfig: authConfig
+                });
+              } catch (error) {
+                console.error("解析授权信息错误:", error);
+              }
+              continue;
+            }
+            //keyvalue中取出value
+            const parts = contentStr.split(":");
+            if (parts.length < 2) {
+              console.error("无效的内容格式:", contentStr);
+              continue; // 如果格式不正确，跳过
+            }
+            const value = contentStr.substring((parts[0] || "").length + 1);
+            try {
+              const content = JSON.parse(value);
+              allContent.push(content);
+            } catch (error) {
+              console.error("解析内容错误:", error);
+            }
+          }
+        }
+        return [allAuth, allContent];
+      }
+    });
+    this.dc = dc;
+    this.dcNodeClient = dcNodeClient;
+    this.chainUtil = chainUtil;
+    this.context = context;
+  }
+  // 创建AI调用的Proxy配置
+  async createProxyConfig(appId, configTheme) {
+    // Default group to "DCAPP" if empty
+    if (appId === "") {
+      appId = "DCAPP";
+    }
+    const space = 100 << 20;
+    // Theme must start with "keyvalue_"
+    if (!configTheme.startsWith("keyvalue_")) {
+      configTheme = "keyvalue_" + configTheme;
+    }
+    try {
+      // Assuming AddThemeObjDeal is implemented elsewhere
+      const commentManager = new CommentManager(this.context);
+      const res = await commentManager.addThemeObj(appId, configTheme, OpenFlag.AUTH, space);
+      return res;
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  // 删除AI调用的Proxy配置
+  async deleteProxyConfig(appId, configTheme) {
+    // Default group to "DCAPP" if empty
+    if (appId === "") {
+      appId = "DCAPP";
+    }
+    // Theme must start with "keyvalue_"
+    if (!configTheme.startsWith("keyvalue_")) {
+      configTheme = "keyvalue_" + configTheme;
+    }
+    try {
+      const commentManager = new CommentManager(this.context);
+      const res = await commentManager.deleteThemeObj(appId, configTheme);
+      return res;
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  //配置AI代理的访问配置,如果key的值设置为空,则表示删除该key的配置
+  async configAIProxy(appId, configAuthor, configTheme, serviceName, serviceConfig, vaccount) {
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    const blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+    const userPubkey = this.context.getPublicKey();
+    let userPubkeyStr = userPubkey.string();
+    if (!configTheme.startsWith("keyvalue_")) {
+      configTheme = "keyvalue_" + configTheme;
+    }
+    let client = this.context.AccountBackupDc?.client || null;
+    if (!client) {
+      client = await this.dc.connectToUserDcPeer(this.context.publicKey.raw);
+    }
+    if (!client) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    //获取token
+    await client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), this.context.sign);
+    if (client === null) {
+      return [null, Errors.ErrNoDcPeerConnected];
+    }
+    if (client.token == "") {
+      await client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), this.context.sign);
+    }
+    let content = '';
+    const key = serviceName;
+    if (!serviceConfig) {
+      content = `${key}`;
+    } else {
+      serviceConfig.blockheight = blockHeight;
+      const value = JSON.stringify(serviceConfig);
+      content = `${key}:${value}`;
+    }
+    const contentUint8 = new TextEncoder().encode(content);
+    const contenthash = await sha256(contentUint8);
+    const contentCidBase32 = base32.encode(contenthash);
+    const contentSize = contentUint8.length;
+    const hValue = uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+    const themeValue = new TextEncoder().encode(configTheme);
+    const themeAuthorValue = new TextEncoder().encode(configAuthor);
+    const appIdValue = new TextEncoder().encode(appId);
+    const contentCidValue = new TextEncoder().encode(contentCidBase32);
+    const typeValue = uint32ToLittleEndianBytes(CommentType.KeyValue);
+    const preSign = new Uint8Array([...themeValue, ...appIdValue, ...themeAuthorValue, ...hValue, ...contentCidValue, ...typeValue]);
+    const signature = await this.context.sign(preSign);
+    const keyValueClient = new KeyValueClient(client, this.context);
+    try {
+      const res = await keyValueClient.setKeyValue(configTheme, appId, configAuthor, blockHeight, userPubkeyStr, contentCidBase32, content, contentSize, CommentType.KeyValue, signature, vaccount);
+      if (res !== 0) {
+        return [null, new Error(`configAIProxy fail, resFlag:${res}`)];
+      }
+      return [true, null];
+    } catch (error) {
+      return [false, error];
+    }
+  }
+  //配置用户的访问权限
+  async configAuth(appId, configAuthor, configTheme, authPubkey, permission, authConfig, vaccount) {
+    if (!this.context.publicKey) {
+      return [null, Errors.ErrAccountPublicKeyIsNull];
+    }
+    if (!configTheme.startsWith("keyvalue_")) {
+      configTheme = "keyvalue_" + configTheme;
+    }
+    if (!configTheme.endsWith("_authlist")) {
+      configTheme = configTheme + "_authlist";
+    }
+    const userPubkey = this.context.getPublicKey();
+    let userPubkeyStr = userPubkey.string();
+    let client = this.context.AccountBackupDc?.client || null;
+    if (!client) {
+      client = await this.dc.connectToUserDcPeer(this.context.publicKey.raw);
+    }
+    if (client === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client.peerAddr === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client.token == "") {
+      await client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), this.context.sign);
+    }
+    const themeAuthorPubkey = Ed25519PubKey.edPubkeyFromStr(configAuthor);
+    let pubkeyFlag = true;
+    let forPubkey = null;
+    try {
+      forPubkey = Ed25519PubKey.edPubkeyFromStr(authPubkey);
+    } catch (error) {
+      pubkeyFlag = false;
+    }
+    let forPubkeyHex;
+    if (pubkeyFlag && forPubkey) {
+      forPubkeyHex = forPubkey.string();
+    } else {
+      forPubkeyHex = authPubkey;
+    }
+    //将authConfig转换为字符串
+    const remark = JSON.stringify(authConfig);
+    const content = `${forPubkeyHex}:${permission}:${remark}`;
+    // Generate contentCid (sha256 of content)
+    const commentUint8 = new TextEncoder().encode(content);
+    const contentHash = await sha256(commentUint8);
+    const contentCid = base32.encode(contentHash);
+    // Get blockchain height
+    let blockHeight;
+    try {
+      blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+    } catch (error) {
+      return [null, new Error("ErrGetBlockHeightFail")];
+    }
+    const contentSize = commentUint8.length;
+    // Create binary representation of blockHeight (little endian)
+    const hValue = uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+    // Create binary representation of type (little endian)
+    const typeValue = uint32ToLittleEndianBytes(CommentType.Comment);
+    // sign(Theme+appId+objAuthor+blockheight+contentCid)
+    const themeValue = new TextEncoder().encode(configTheme);
+    const appIdValue = new TextEncoder().encode(appId);
+    const themeAuthorValue = new TextEncoder().encode(themeAuthorPubkey.string());
+    const contentCidValue = new TextEncoder().encode(contentCid);
+    let preSign = new Uint8Array([...themeValue, ...appIdValue, ...themeAuthorValue, ...hValue, ...contentCidValue, ...typeValue]);
+    const signature = await this.context.sign(preSign);
+    const keyValueClient = new KeyValueClient(client, this.context);
+    try {
+      const res = await keyValueClient.configThemeObjAuth(configTheme, appId, configAuthor, blockHeight, userPubkeyStr, contentCid, content, contentSize, CommentType.Comment, signature);
+      if (res !== 0) {
+        return [null, new Error(`configThemeObjAuth fail, resFlag: ${res}`)];
+      }
+    } catch (error) {
+      return [null, error];
+    }
+    return [0, null];
+  }
+  //获取的ai代理的所有配置,包括服务与授权列表
+  async GetAIProxyConfig(appId, themeAuthor, configTheme, vaccount) {
+    if (!this.context.publicKey) {
+      return [null, null, Errors.ErrAccountPublicKeyIsNull];
+    }
+    if (!configTheme.startsWith("keyvalue_")) {
+      configTheme = "keyvalue_" + configTheme;
+    }
+    let client = this.context.AccountBackupDc.client || null;
+    if (themeAuthor != this.context.publicKey.string()) {
+      //查询他人主题评论
+      const authorPublicKey = Ed25519PubKey.edPubkeyFromStr(themeAuthor);
+      client = await this.dc.connectToUserDcPeer(authorPublicKey.raw);
+      if (!client) {
+        return [null, null, Errors.ErrNoDcPeerConnected];
+      }
+    }
+    if (client === null) {
+      return [null, null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client.peerAddr === null) {
+      return [null, null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client.token == "") {
+      await client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), this.context.sign);
+    }
+    try {
+      const aiProxyClient = new AIProxyClient(client, this.context);
+      const [proxyConfigCid, aesKey, error] = await aiProxyClient.GetAIProxyConfig(appId, themeAuthor, configTheme);
+      if (error) {
+        return [null, null, error];
+      }
+      const fileManager = new FileManager(this.dc, this.context.AccountBackupDc, this.chainUtil, this.dcNodeClient, this.context);
+      const cid = proxyConfigCid;
+      const fileContent = await fileManager.getFileFromDc(cid, "", cidNeedConnect.NOT_NEED, false);
+      if (!fileContent) {
+        return [[], [], null];
+      }
+      const fileContentString = toString(fileContent);
+      const result = await this.handleAllConfig(fileContentString, aesKey);
+      if (!result) {
+        return [[], [], null];
+      }
+      const [allAuth, allContent] = result;
+      return [allAuth, allContent, null];
+    } catch (error) {
+      return [null, null, error];
+    }
+  }
+  async GetUserOwnAIProxyAuth(appId, themeAuthor, configTheme) {
+    if (!this.context.publicKey) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (!configTheme.startsWith("keyvalue_")) {
+      configTheme = "keyvalue_" + configTheme;
+    }
+    let client = this.context.AccountBackupDc?.client || null;
+    if (themeAuthor != this.context.publicKey.string()) {
+      //查询他人主题评论
+      const authorPublicKey = Ed25519PubKey.edPubkeyFromStr(themeAuthor);
+      client = await this.dc.connectToUserDcPeer(authorPublicKey.raw);
+      if (!client) {
+        return [null, Errors.ErrNoDcPeerConnected];
+      }
+    }
+    if (client === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client.peerAddr === null) {
+      return [null, new Error("ErrConnectToAccountPeersFail")];
+    }
+    if (client.token == "") {
+      await client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), this.context.sign);
+    }
+    const aiProxyClient = new AIProxyClient(client, this.context);
+    const [authInfo, error] = await aiProxyClient.GetUserOwnAIProxyAuth(appId, themeAuthor, configTheme);
+    if (error) {
+      return [null, error];
+    }
+    try {
+      const authConfig = JSON.parse(authInfo);
+      return [authConfig, error];
+    } catch (error) {
+      return [null, error];
+    }
+  }
+  //AI相关代理的调用,包括代理与AI的通信或者与MCPServer的通信
+  async DoAIProxyCall(context, appId, themeAuthor, configTheme, serviceName, reqBody, forceRefresh) {
+    let onStreamResponse = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : null;
+    let headers = arguments.length > 8 ? arguments[8] : undefined;
+    let path = arguments.length > 9 ? arguments[9] : undefined;
+    let model = arguments.length > 10 ? arguments[10] : undefined;
+    if (!configTheme.startsWith("keyvalue_")) {
+      configTheme = "keyvalue_" + configTheme;
+    }
+    const blockHeight = (await this.chainUtil.getBlockHeight()) || 0;
+    const hValue = uint32ToLittleEndianBytes(blockHeight ? blockHeight : 0);
+    const forceRefreshFlag = forceRefresh ? 1 : 0;
+    const forceRefreshValue = uint32ToLittleEndianBytes(forceRefreshFlag);
+    const themeAuthorValue = new TextEncoder().encode(themeAuthor);
+    const themeValue = new TextEncoder().encode(configTheme);
+    const appIdValue = new TextEncoder().encode(appId);
+    const serviceNameValue = new TextEncoder().encode(serviceName);
+    const pathValue = new TextEncoder().encode(path);
+    const headersValue = new TextEncoder().encode(headers);
+    const reqBodyValue = new TextEncoder().encode(reqBody);
+    const modelValue = new TextEncoder().encode(model);
+    const preSign = new Uint8Array([...themeValue, ...appIdValue, ...themeAuthorValue, ...hValue, ...serviceNameValue, ...pathValue, ...reqBodyValue, ...forceRefreshValue, ...modelValue, ...headersValue]);
+    if (!this.context.AccountBackupDc.client) {
+      throw new Error("ErrConnectToAccountPeersFail");
+    }
+    if (!this.context.publicKey) {
+      throw new Error("ErrConnectToAccountPeersFail");
+    }
+    if (this.context.AccountBackupDc.client.token == "") {
+      await this.context.AccountBackupDc.client.GetToken(this.context.appInfo.appId || "", this.context.publicKey.string(), this.context.sign);
+    }
+    const signature = await this.context.sign(preSign);
+    const proxyClient = new AIProxyClient(this.context.AccountBackupDc.client, this.context);
+    let res = await proxyClient.DoAIProxyCall(context, appId, themeAuthor, configTheme, serviceName, path || "", headers || "", reqBody, model || "", forceRefreshFlag, blockHeight, signature, onStreamResponse);
+    return res;
+  }
+}
+
+export { AIProxyError, AIProxyManager, Errors };