@cloudbase/agent-adapter-wx 1.0.1-alpha.23

package/dist/index.mjs

@@ -0,0 +1,1121 @@
+// src/wechat-message-handler.ts
+var SUPPORTED_MSG_TYPES = ["text", "voice"];
+function validateMessageType(msgType) {
+  if (SUPPORTED_MSG_TYPES.includes(msgType)) {
+    return { isValid: true, skipAI: false };
+  }
+  return {
+    isValid: false,
+    skipAI: true,
+    errorMessage: `\u65E0\u6CD5\u5904\u7406\u7684\u6D88\u606F\u7C7B\u578B:${msgType}`,
+    userErrorMessage: "\u62B1\u6B49\u6682\u65F6\u65E0\u6CD5\u5904\u7406\u8FD9\u4E2A\u7C7B\u578B\u7684\u6D88\u606F"
+  };
+}
+function extractMsgType(originMsg) {
+  return originMsg.msgType || originMsg.MsgType || "text";
+}
+function extractTriggerSrc(originMsg, defaultSrc = "WXCustomerService") {
+  return originMsg.triggerSrc || defaultSrc;
+}
+function extractTextContent(originMsg, triggerSrc) {
+  if (["WXSubscription", "WXService", "WXMiniApp"].includes(triggerSrc)) {
+    return originMsg.Content || originMsg.content || "";
+  } else if (triggerSrc === "WXCustomerService") {
+    return originMsg.text?.content || "";
+  }
+  return "";
+}
+function extractVoiceMediaId(originMsg, triggerSrc) {
+  if (["WXSubscription", "WXService"].includes(triggerSrc)) {
+    return originMsg.MediaId || originMsg.mediaId || "";
+  } else if (triggerSrc === "WXCustomerService") {
+    return originMsg.voice?.mediaId || "";
+  }
+  return "";
+}
+async function getWxChatContent(originMsg, triggerSrc, voiceMessageHandler, botId) {
+  const msgType = extractMsgType(originMsg);
+  if (msgType === "text") {
+    return extractTextContent(originMsg, triggerSrc);
+  }
+  if (msgType === "voice") {
+    const mediaId = extractVoiceMediaId(originMsg, triggerSrc);
+    if (voiceMessageHandler && mediaId && botId) {
+      const result = await voiceMessageHandler(botId, triggerSrc, mediaId);
+      return result?.content || "";
+    }
+  }
+  return "";
+}
+function extractSender(originMsg, triggerSrc) {
+  if (["WXSubscription", "WXService", "WXMiniApp"].includes(triggerSrc)) {
+    return originMsg.FromUserName || originMsg.fromUserName || "";
+  } else if (triggerSrc === "WXCustomerService") {
+    return originMsg.externalUserId || "";
+  }
+  return "";
+}
+function extractConversation(originMsg, triggerSrc) {
+  if (["WXSubscription", "WXService", "WXMiniApp"].includes(triggerSrc)) {
+    return originMsg.FromUserName || originMsg.fromUserName || "";
+  } else if (triggerSrc === "WXCustomerService") {
+    return originMsg.externalUserId || "";
+  }
+  return "";
+}
+function generateRecordId(triggerSrc, msgId, timestamp) {
+  return `${triggerSrc}${msgId}${timestamp}`;
+}
+function extractMsgId(originMsg) {
+  return originMsg.msgId || originMsg.MsgId || Date.now().toString();
+}
+function extractTimestamp(originMsg, triggerSrc) {
+  if (triggerSrc === "WXCustomerService") {
+    return originMsg.sendTime || Math.floor(Date.now() / 1e3);
+  }
+  return originMsg.createTime || originMsg.CreateTime || Math.floor(Date.now() / 1e3);
+}
+function needAsyncReply(triggerSrc, wxVerify) {
+  if (["WXMiniApp", "WXCustomerService"].includes(triggerSrc)) {
+    return true;
+  }
+  return wxVerify;
+}
+function formatWeChatReplyMessage(callbackData, triggerSrc, content) {
+  const createTime = Math.floor(Date.now() / 1e3);
+  const finalContent = content || "\u62B1\u6B49\u6682\u65F6\u65E0\u6CD5\u5904\u7406\u8FD9\u4E2A\u7C7B\u578B\u7684\u6D88\u606F";
+  if (triggerSrc === "WXCustomerService") {
+    return {
+      toUserName: callbackData.externalUserId || callbackData.fromUserName,
+      fromUserName: callbackData.openKfId,
+      openKfId: callbackData.openKfId,
+      createTime,
+      msgType: "text",
+      content: finalContent
+    };
+  }
+  return {
+    toUserName: callbackData.fromUserName || callbackData.FromUserName,
+    fromUserName: callbackData.toUserName || callbackData.ToUserName,
+    createTime,
+    msgType: "text",
+    content: finalContent
+  };
+}
+function dealMsgData(originMsg, triggerSrc, wxVerify, botId) {
+  const baseMsgData = {
+    type: "text",
+    triggerSrc,
+    botId,
+    recommendQuestions: [],
+    content: "",
+    originMsg: "",
+    createdAt: Date.now()
+  };
+  const sender = extractSender(originMsg, triggerSrc);
+  const conversation = extractConversation(originMsg, triggerSrc);
+  const msgId = extractMsgId(originMsg);
+  const timestamp = extractTimestamp(originMsg, triggerSrc);
+  const recordIdBase = generateRecordId(triggerSrc, msgId, timestamp);
+  const asyncReply = needAsyncReply(triggerSrc, wxVerify);
+  const msgType = extractMsgType(originMsg);
+  return {
+    msgData: {
+      ...baseMsgData,
+      recordId: `user-${recordIdBase}`,
+      role: "user",
+      sender,
+      conversation,
+      type: msgType,
+      needAsyncReply: asyncReply,
+      reply: recordIdBase,
+      originMsg: JSON.stringify(originMsg)
+    },
+    replyMsgData: {
+      ...baseMsgData,
+      recordId: recordIdBase,
+      role: "assistant",
+      sender,
+      conversation,
+      type: "text",
+      needAsyncReply: asyncReply,
+      reply: "",
+      originMsg: JSON.stringify({})
+    }
+  };
+}
+async function handleWeChatRetry(previousReply, originMsg, triggerSrc) {
+  if (!previousReply) {
+    return { shouldSkip: false };
+  }
+  const timestamp = extractTimestamp(originMsg, triggerSrc);
+  const deltaTime = Date.now() - timestamp * 1e3;
+  if (previousReply.content) {
+    return {
+      shouldSkip: true,
+      content: previousReply.content
+    };
+  }
+  if (deltaTime > 11 * 1e3) {
+    return {
+      shouldSkip: true,
+      content: '\u601D\u8003\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u56DE\u590D "\u7EE7\u7EED" \u6765\u83B7\u53D6\u56DE\u7B54\u5185\u5BB9'
+    };
+  }
+  await new Promise((resolve) => setTimeout(resolve, 5e3));
+  return { shouldSkip: true };
+}
+function isContinueCommandValid(previousReply) {
+  if (!previousReply) {
+    return false;
+  }
+  const fiveMinutes = 5 * 60 * 1e3;
+  return Date.now() - previousReply.createdAt < fiveMinutes;
+}
+
+// src/server/wx.controller.ts
+import { v4 as uuidv4 } from "uuid";
+import { agui } from "@cloudbase/agent-server";
+import { noopLogger } from "@cloudbase/agent-shared";
+import { EventType } from "@ag-ui/client";
+import {
+  noopLogger as noopLogger2,
+  createConsoleLogger
+} from "@cloudbase/agent-shared";
+function createWxMessageHandler(createAgent, options) {
+  const { logger: parentLogger = noopLogger } = options ?? {};
+  const adapterLogger = parentLogger.child?.({ component: "sendWXMessageAGUI" }) ?? parentLogger;
+  return async (req, res) => {
+    let cleanup = null;
+    try {
+      const {
+        callbackData,
+        triggerSrc,
+        wxVerify = false,
+        botId = "default"
+      } = req.body;
+      const requestId = uuidv4();
+      const logger = adapterLogger.child?.({ requestId }) ?? adapterLogger;
+      if (!callbackData || !triggerSrc) {
+        return res.status(400).json({
+          error: "Bad Request",
+          message: "Missing required fields: callbackData, triggerSrc"
+        });
+      }
+      logger.info?.("[WX] Received message:", { triggerSrc, wxVerify, botId });
+      const { agent: unknownAgent, cleanup: agentCleanup } = await Promise.resolve(createAgent({ request: req }));
+      cleanup = agentCleanup ?? null;
+      const agent = "toAGUIAgent" in unknownAgent ? unknownAgent.toAGUIAgent() : unknownAgent;
+      const { msgData, replyMsgData } = dealMsgData(
+        callbackData,
+        triggerSrc,
+        wxVerify,
+        botId
+      );
+      let skipAI = false;
+      let isEnd = false;
+      const msgType = extractMsgType(callbackData);
+      const validation = validateMessageType(msgType);
+      if (!validation.isValid) {
+        skipAI = true;
+        replyMsgData.content = validation.userErrorMessage || "\u6682\u4E0D\u652F\u6301\u8BE5\u6D88\u606F\u7C7B\u578B";
+      }
+      const previousReply = await agent.getPreviousReply(
+        replyMsgData.conversation,
+        replyMsgData.recordId
+      );
+      const voiceHandler = async (vBotId, vTriggerSrc, mediaId) => {
+        try {
+          const content2 = await agent?.aitools?.getWxMediaContent(
+            vBotId,
+            vTriggerSrc,
+            mediaId
+          );
+          if (content2) {
+            return {
+              content: content2
+            };
+          }
+          return null;
+        } catch {
+          return null;
+        }
+      };
+      const content = await getWxChatContent(
+        callbackData,
+        triggerSrc,
+        voiceHandler,
+        botId
+      );
+      if (["WXSubscription", "WXService"].includes(triggerSrc) && !wxVerify && !skipAI) {
+        const result = await agent.handleUnverifiedChat({
+          content,
+          conversation: replyMsgData.conversation,
+          previousReply,
+          callbackData,
+          triggerSrc
+        });
+        skipAI = result.needSkipAI;
+        isEnd = result.isEnd;
+        if (result.replyContent) replyMsgData.content = result.replyContent;
+      }
+      if (isEnd) {
+        return res.json({});
+      }
+      if (!content && !skipAI) {
+        logger.warn?.("[WX] Empty content");
+        return res.json(
+          formatWeChatReplyMessage(callbackData, triggerSrc, "\u65E0\u6CD5\u8BC6\u522B\u6D88\u606F\u5185\u5BB9")
+        );
+      }
+      if (skipAI) {
+        logger.info?.("[WX] Skipping AI");
+        return res.json(
+          formatWeChatReplyMessage(
+            callbackData,
+            triggerSrc,
+            replyMsgData.content
+          )
+        );
+      }
+      logger.info?.("[WX] Processing:", content.substring(0, 100));
+      const input = {
+        messages: [
+          {
+            id: msgData.recordId,
+            role: "user",
+            content
+          }
+        ],
+        state: void 0,
+        threadId: msgData.conversation,
+        runId: uuidv4(),
+        tools: [],
+        context: [],
+        forwardedProps: {
+          wxSendmessageInput: req.body,
+          // Pass full msgData for history storage
+          msgData,
+          // Pass replay info with replyMsgData for assistant history
+          replay: {
+            id: replyMsgData.recordId,
+            ...replyMsgData
+          }
+        }
+      };
+      const events = agui.sendMessageAGUI.handler(input, agent);
+      for await (const event of events) {
+        if (event.type === EventType.RUN_ERROR) {
+          logger.error?.(
+            "[WX] Agent error:",
+            event.error || event.message
+          );
+        }
+      }
+      logger.info?.("[WX] Processing complete");
+      if (replyMsgData.needAsyncReply) {
+        return res.json({});
+      }
+      const finalContent = agent.lastReply || "\u62B1\u6B49\uFF0C\u65E0\u6CD5\u751F\u6210\u56DE\u590D";
+      return res.json(
+        formatWeChatReplyMessage(callbackData, triggerSrc, finalContent)
+      );
+    } catch (error) {
+      console.error("[WX] Error processing message:", error);
+      return res.status(500).json({
+        error: "Internal Server Error",
+        message: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      if (cleanup) cleanup();
+    }
+  };
+}
+
+// src/types.ts
+var WeChatPlatform = /* @__PURE__ */ ((WeChatPlatform2) => {
+  WeChatPlatform2["CUSTOM_SERVICE"] = "WXCustomerService";
+  WeChatPlatform2["MINI_APP"] = "WXMiniApp";
+  WeChatPlatform2["SERVICE"] = "WXService";
+  WeChatPlatform2["SUBSCRIPTION"] = "WXSubscription";
+  return WeChatPlatform2;
+})(WeChatPlatform || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["TEXT"] = "text";
+  MessageType2["IMAGE"] = "image";
+  MessageType2["EVENT"] = "event";
+  MessageType2["VOICE"] = "voice";
+  return MessageType2;
+})(MessageType || {});
+var WeChatSendMode = /* @__PURE__ */ ((WeChatSendMode2) => {
+  WeChatSendMode2["LOCAL"] = "local";
+  WeChatSendMode2["AITOOLS"] = "aitools";
+  return WeChatSendMode2;
+})(WeChatSendMode || {});
+
+// src/token-manager.ts
+var TokenManager = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get access token (with caching)
+   */
+  async getAccessToken(config) {
+    const cacheKey = this.getCacheKey(config);
+    const cached = this.cache.get(cacheKey);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.accessToken;
+    }
+    const token = await this.fetchAccessToken(config);
+    return token;
+  }
+  /**
+   * Fetch access token from WeChat API
+   */
+  async fetchAccessToken(config) {
+    const url = this.getTokenUrl(config);
+    const response = await fetch(url);
+    const data = await response.json();
+    if (data.errcode && data.errcode !== 0) {
+      throw new Error(`Failed to get access token: ${data.errmsg}`);
+    }
+    const cacheKey = this.getCacheKey(config);
+    const expiresAt = Date.now() + (data.expires_in - 300) * 1e3;
+    this.cache.set(cacheKey, {
+      accessToken: data.access_token,
+      expiresAt
+    });
+    return data.access_token;
+  }
+  /**
+   * Get token URL based on platform
+   */
+  getTokenUrl(config) {
+    if (config.platform === "WXCustomerService" /* CUSTOM_SERVICE */) {
+      return `https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=${config.appId}&corpsecret=${config.appSecret}`;
+    }
+    return `https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid=${config.appId}&secret=${config.appSecret}`;
+  }
+  /**
+   * Generate cache key
+   */
+  getCacheKey(config) {
+    return `${config.platform}_${config.appId}`;
+  }
+  /**
+   * Clear token cache
+   */
+  clearCache(config) {
+    if (config) {
+      this.cache.delete(this.getCacheKey(config));
+    } else {
+      this.cache.clear();
+    }
+  }
+};
+
+// src/message-formatter.ts
+var MessageFormatter = class {
+  /**
+   * Format message for WeChat API
+   */
+  formatMessage(options, platform, originMsg) {
+    const { toUser, message, recommendQuestions, msgId } = options;
+    let content = message.content;
+    if (recommendQuestions && recommendQuestions.length > 0) {
+      content = this.withRecommendQuestions(content, recommendQuestions);
+    }
+    const baseMessage = {
+      touser: toUser,
+      msgtype: message.type
+    };
+    if (message.type === "text" /* TEXT */) {
+      baseMessage.text = { content };
+    } else if (message.type === "image" /* IMAGE */ && message.imageUrl) {
+      baseMessage.image = { pic_url: message.imageUrl };
+    }
+    if (platform === "WXCustomerService" /* CUSTOM_SERVICE */) {
+      baseMessage.open_kfid = originMsg?.open_kfid;
+      baseMessage.msgid = msgId || originMsg?.msgid;
+    }
+    return baseMessage;
+  }
+  /**
+   * Append recommended questions to content
+   */
+  withRecommendQuestions(content, questions) {
+    if (!questions || questions.length === 0) {
+      return content;
+    }
+    return `${content}
+
+\u63A8\u8350\u95EE\u9898:
+${questions.join("\n")}`;
+  }
+  /**
+   * Split long message into chunks
+   */
+  splitLongMessage(content, maxLength = 2e3) {
+    if (content.length <= maxLength) {
+      return [content];
+    }
+    const chunks = [];
+    let currentChunk = "";
+    const lines = content.split("\n");
+    for (const line of lines) {
+      if ((currentChunk + line).length > maxLength) {
+        if (currentChunk) {
+          chunks.push(currentChunk.trim());
+          currentChunk = "";
+        }
+        if (line.length > maxLength) {
+          for (let i = 0; i < line.length; i += maxLength) {
+            chunks.push(line.substring(i, i + maxLength));
+          }
+        } else {
+          currentChunk = line + "\n";
+        }
+      } else {
+        currentChunk += line + "\n";
+      }
+    }
+    if (currentChunk) {
+      chunks.push(currentChunk.trim());
+    }
+    return chunks;
+  }
+};
+
+// src/platform-router.ts
+var PlatformRouter = class {
+  constructor(tokenManager) {
+    this.tokenManager = tokenManager;
+  }
+  /**
+   * Send message to WeChat platform
+   */
+  async send(message, config) {
+    const accessToken = await this.tokenManager.getAccessToken(config);
+    switch (config.platform) {
+      case "WXCustomerService" /* CUSTOM_SERVICE */:
+        return this.sendToCustomService(message, accessToken, config);
+      case "WXMiniApp" /* MINI_APP */:
+        return this.sendToMiniApp(message, accessToken);
+      case "WXService" /* SERVICE */:
+      case "WXSubscription" /* SUBSCRIPTION */:
+        return this.sendToOfficialAccount(message, accessToken);
+      default:
+        throw new Error(`Unsupported platform: ${config.platform}`);
+    }
+  }
+  /**
+   * Send to Enterprise WeChat Customer Service
+   */
+  async sendToCustomService(message, accessToken, config) {
+    const url = `https://qyapi.weixin.qq.com/cgi-bin/kf/send_msg?access_token=${accessToken}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    return response.json();
+  }
+  /**
+   * Send to WeChat Mini Program
+   */
+  async sendToMiniApp(message, accessToken) {
+    const url = `https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=${accessToken}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    return response.json();
+  }
+  /**
+   * Send to WeChat Official Account (Service/Subscription)
+   */
+  async sendToOfficialAccount(message, accessToken) {
+    const url = `https://api.weixin.qq.com/cgi-bin/message/custom/send?access_token=${accessToken}`;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(message)
+    });
+    return response.json();
+  }
+};
+
+// src/wechat-sender.ts
+var WeChatSender = class {
+  constructor(config) {
+    this.config = config;
+    this.tokenManager = new TokenManager();
+    this.messageFormatter = new MessageFormatter();
+    this.platformRouter = new PlatformRouter(this.tokenManager);
+  }
+  /**
+   * Send a message to WeChat
+   */
+  async send(options, originMsg) {
+    const validatedOptions = options;
+    const message = this.messageFormatter.formatMessage(
+      validatedOptions,
+      this.config.platform,
+      originMsg
+    );
+    const result = await this.platformRouter.send(message, this.config);
+    if (result.errcode !== 0) {
+      throw new Error(`Failed to send message: ${result.errmsg}`);
+    }
+    return result;
+  }
+  /**
+   * Send multiple messages in batch
+   */
+  async sendBatch(messages) {
+    const results = [];
+    for (const message of messages) {
+      try {
+        const result = await this.send(message);
+        results.push(result);
+      } catch (error) {
+        results.push({
+          errcode: -1,
+          errmsg: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    return results;
+  }
+  /**
+   * Send message asynchronously (fire and forget)
+   */
+  async sendAsync(options, originMsg) {
+    this.send(options, originMsg).catch((error) => {
+      console.error("Failed to send message:", error);
+    });
+  }
+  /**
+   * Clear token cache
+   */
+  clearCache() {
+    this.tokenManager.clearCache(this.config);
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+};
+
+// src/agent.ts
+import {
+  EventType as EventType2,
+  AbstractAgent
+} from "@ag-ui/client";
+import { Observable } from "rxjs";
+
+// src/wechat-history-manager.ts
+import tcb from "@cloudbase/node-sdk";
+var WX_CHAT_HISTORY_COLLECTION = "wx_chat_history";
+function entryToData(entry) {
+  return {
+    bot_id: entry.botId || "",
+    record_id: entry.messageId,
+    role: entry.role,
+    status: entry.status,
+    content: entry.content,
+    conversation: entry.threadId,
+    type: entry.type,
+    trace_id: entry.runId,
+    async_reply: entry.needAsyncReply,
+    metadata: entry.metadata,
+    createdAt: entry.createdAt || Date.now(),
+    updatedAt: Date.now()
+  };
+}
+function dataToEntry(data) {
+  return {
+    id: data._id,
+    messageId: data.record_id,
+    role: data.role,
+    content: data.content,
+    threadId: data.conversation,
+    createdAt: data.createdAt,
+    botId: data.bot_id,
+    runId: data.trace_id,
+    needAsyncReply: data.async_reply,
+    status: data.status,
+    type: data.type,
+    metadata: data.metadata
+  };
+}
+var WeChatHistoryManager = class _WeChatHistoryManager {
+  constructor(config) {
+    this.collectionReady = false;
+    this.collectionName = config?.collectionName || WX_CHAT_HISTORY_COLLECTION;
+    this.botId = config?.botId || "default";
+    const envId = config?.envId || process.env.TCB_ENV || process.env.CLOUDBASE_ENV;
+    if (!envId) {
+      throw new Error(
+        "[WeChatHistoryManager] envId is required. Set TCB_ENV or CLOUDBASE_ENV environment variable, or pass envId in config."
+      );
+    }
+    this.tcbClient = tcb.init({
+      env: envId,
+      secretId: config?.secretId,
+      secretKey: config?.secretKey,
+      sessionToken: config?.token
+    });
+  }
+  static getInstance(config) {
+    if (!_WeChatHistoryManager.instance) {
+      _WeChatHistoryManager.instance = new _WeChatHistoryManager(config);
+    }
+    return _WeChatHistoryManager.instance;
+  }
+  /**
+   * Ensure collection exists, create if not
+   */
+  async ensureCollection() {
+    if (this.collectionReady) return;
+    try {
+      const db = this.tcbClient.database();
+      await db.createCollection(this.collectionName);
+      this.collectionReady = true;
+    } catch (error) {
+      if (error?.code === -502005 || error?.message?.includes("already exists")) {
+        this.collectionReady = true;
+      } else {
+        console.error(
+          "[WeChatHistoryManager] Failed to create collection:",
+          error
+        );
+        throw error;
+      }
+    }
+  }
+  /**
+   * Get previous reply from history
+   */
+  async getPreviousReply(threadId, messageId) {
+    await this.ensureCollection();
+    const db = this.tcbClient.database();
+    const _ = db.command;
+    const collection = db.collection(this.collectionName);
+    const whereCondition = {
+      conversation: _.eq(threadId)
+    };
+    if (messageId) {
+      whereCondition.record_id = _.eq(messageId);
+    }
+    const result = await collection.where(whereCondition).orderBy("createdAt", "desc").limit(1).get();
+    if (result.data && result.data.length > 0) {
+      return dataToEntry(result.data[0]);
+    }
+    return null;
+  }
+  /**
+   * Save record to history
+   */
+  async saveToHistory(record) {
+    await this.ensureCollection();
+    const db = this.tcbClient.database();
+    const _ = db.command;
+    const collection = db.collection(this.collectionName);
+    const existing = await collection.where({ record_id: _.eq(record.messageId) }).limit(1).get();
+    const data = entryToData({ ...record, botId: record.botId || this.botId });
+    if (existing.data && existing.data.length > 0) {
+      await collection.where({ record_id: _.eq(record.messageId) }).update(data);
+    } else {
+      await collection.add(data);
+    }
+  }
+  /**
+   * Update record content by messageId
+   */
+  async updateContent(_threadId, messageId, content) {
+    await this.ensureCollection();
+    const db = this.tcbClient.database();
+    const _ = db.command;
+    const collection = db.collection(this.collectionName);
+    await collection.where({ record_id: _.eq(messageId) }).update({
+      content,
+      updatedAt: Date.now()
+    });
+  }
+};
+var getHistoryManager = WeChatHistoryManager.getInstance;
+
+// src/agent.ts
+import { aitools } from "@cloudbase/aiagent-framework";
+import { randomUUID } from "crypto";
+var AITOOLS = aitools.AITools;
+var WeChatAgent = class extends AbstractAgent {
+  constructor(config) {
+    super({
+      agentId: config.agentId || config.agent.agentId,
+      description: config.description || config.agent.description,
+      threadId: config.threadId || config.agent.threadId,
+      ...config
+    });
+    this.messageBuffer = "";
+    /**
+     * Last assembled reply content after run() completes
+     * Controller can read this instead of re-assembling from events
+     */
+    this.lastReply = "";
+    /**
+     * Whether last run had an error
+     */
+    this.lastRunHadError = false;
+    this.wrappedAgent = config.agent;
+    this.wechatConfig = config.wechatConfig;
+    this.recommendQuestions = config.recommendQuestions;
+    this._historyManager = config.historyManager || WeChatHistoryManager.getInstance();
+    const sendMode = config.wechatConfig.sendMode || "local" /* LOCAL */;
+    if (sendMode === "aitools" /* AITOOLS */) {
+      if (!config.wechatConfig.context) {
+        throw new Error("context is required when sendMode is AITOOLS");
+      }
+      this.aitools = new AITOOLS(config.wechatConfig.context);
+    } else {
+      this.wechatSender = new WeChatSender(config.wechatConfig);
+    }
+    this.messageFormatter = config.messageFormatter || ((content) => ({
+      toUser: "",
+      // Will be set from originMsg
+      message: {
+        content,
+        type: "text" /* TEXT */
+      },
+      recommendQuestions: this.recommendQuestions
+    }));
+    this.eventFilter = config.eventFilter || ((event) => event.type === EventType2.TEXT_MESSAGE_CONTENT);
+  }
+  /**
+   * Get previous reply from history
+   * Used for: retry detection, "继续" command
+   */
+  async getPreviousReply(conversation, recordId) {
+    return this._historyManager.getPreviousReply(conversation, recordId);
+  }
+  /**
+   * Update message content in history
+   */
+  async updateHistoryContent(messageId, content, threadId) {
+    await this._historyManager.updateContent(threadId, messageId, content);
+  }
+  /**
+   * Handle unverified account logic (WXSubscription/WXService)
+   * Handles "继续" command and 11-second retry
+   * Uses existing functions from wechat-message-handler.ts
+   * @returns { needSkipAI, replyContent, isEnd }
+   */
+  async handleUnverifiedChat(params) {
+    const { content, conversation, previousReply, callbackData, triggerSrc } = params;
+    if (previousReply && previousReply.needAsyncReply) {
+      return { needSkipAI: true, replyContent: "", isEnd: true };
+    }
+    if (content === "continue" || content === "\u7EE7\u7EED") {
+      const latest = await this._historyManager.getPreviousReply(conversation);
+      let replyContent = "";
+      if (!latest) {
+        replyContent = "\u672A\u627E\u5230\u76F8\u5173\u56DE\u7B54\uFF0C\u8BF7\u5148\u53D1\u9001\u6D88\u606F";
+      } else if (isContinueCommandValid(latest)) {
+        replyContent = latest.content || '\u6B63\u5728\u601D\u8003\u4E2D\uFF0C\u8BF7\u7A0D\u540E\u518D\u56DE\u590D"\u7EE7\u7EED"';
+      } else {
+        replyContent = "\u56DE\u7B54\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u53D1\u9001\u6D88\u606F";
+      }
+      return { needSkipAI: true, replyContent, isEnd: false };
+    }
+    if (previousReply) {
+      const result = await handleWeChatRetry(
+        previousReply,
+        callbackData,
+        triggerSrc
+      );
+      return {
+        needSkipAI: result.shouldSkip,
+        replyContent: result.content || "",
+        isEnd: false
+      };
+    }
+    return { needSkipAI: false, replyContent: "", isEnd: false };
+  }
+  /**
+   * Run method with WeChat integration
+   * Wraps the underlying agent's run() and sends messages to WeChat
+   */
+  run(input) {
+    return new Observable((subscriber) => {
+      this.messageBuffer = "";
+      this.lastReply = "";
+      this.lastRunHadError = false;
+      let errorMessage = "";
+      let subscription;
+      const replyId = input?.forwardedProps?.replay.id || randomUUID();
+      Promise.all([
+        this.saveInputToHistory(input),
+        this.saveReplyToHistory(
+          {
+            id: replyId,
+            content: this.lastReply
+          },
+          input
+        )
+      ]).then(
+        () => {
+          subscription = this.wrappedAgent.run(input).subscribe({
+            next: (event) => {
+              subscriber.next(event);
+              if (event.type === EventType2.RUN_ERROR) {
+                this.lastRunHadError = true;
+                const errorEvent = event;
+                errorMessage = errorEvent.message || errorEvent.error?.message || "\u5904\u7406\u6D88\u606F\u65F6\u53D1\u751F\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+              }
+              this.handleWeChatSending(event, input);
+            },
+            error: (error) => {
+              subscriber.error(error);
+            },
+            complete: () => {
+              this.lastReply = this.lastRunHadError ? errorMessage : this.messageBuffer.trim() || "";
+              if (this.messageBuffer.trim() && !this.lastRunHadError) {
+                this.sendToWeChat(this.messageBuffer, input).catch(
+                  console.error
+                );
+              }
+              this.saveReplyToHistory(
+                {
+                  id: input?.forwardedProps?.replay.id || randomUUID(),
+                  content: this.lastReply
+                },
+                input
+              ).catch(console.error);
+              subscriber.complete();
+            }
+          });
+        },
+        (e) => {
+          subscriber.error(e);
+        }
+      );
+      return () => {
+        subscription?.unsubscribe();
+      };
+    });
+  }
+  /**
+   * Save input message to history at the start of run()
+   * Only saves if the last message is from user role
+   * Uses msgData from forwardedProps for complete data (similar to dealMsgData)
+   */
+  async saveInputToHistory(input) {
+    const messages = input.messages;
+    if (!messages || messages.length === 0) return;
+    const lastMessage = messages[messages.length - 1];
+    if (lastMessage.role !== "user") return;
+    const { threadId, runId } = input;
+    const msgData = input.forwardedProps?.msgData;
+    const messageId = msgData?.recordId || lastMessage.id || lastMessage.messageId || randomUUID();
+    const rawContent = lastMessage.content;
+    const content = typeof rawContent === "string" ? rawContent : Array.isArray(rawContent) ? rawContent.filter((c) => c.type === "text").map((c) => c.text).join("") : "";
+    if (threadId && content) {
+      await this._historyManager.saveToHistory({
+        messageId,
+        role: "user",
+        content,
+        threadId,
+        runId,
+        createdAt: msgData?.createdAt || Date.now(),
+        // Additional fields from msgData (similar to dealMsgData)
+        botId: msgData?.botId,
+        needAsyncReply: msgData?.needAsyncReply,
+        type: msgData?.type,
+        metadata: {
+          sender: msgData?.sender,
+          triggerSrc: msgData?.triggerSrc,
+          originMsg: msgData?.originMsg,
+          reply: msgData?.reply,
+          recommendQuestions: msgData?.recommendQuestions
+        }
+      });
+    }
+  }
+  /**
+   * Handle WeChat message sending based on events
+   */
+  handleWeChatSending(event, input) {
+    if (event.type === EventType2.RUN_ERROR) {
+      const errorEvent = event;
+      const errorMessage = errorEvent.message || errorEvent.error?.message || "\u5904\u7406\u6D88\u606F\u65F6\u53D1\u751F\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+      this.messageBuffer = "";
+      this.sendToWeChat(errorMessage, input).catch(console.error);
+      return;
+    }
+    if (!this.eventFilter(event)) {
+      return;
+    }
+    switch (event.type) {
+      case EventType2.TEXT_MESSAGE_CONTENT:
+        const content = event.delta || event.content || "";
+        this.messageBuffer += content;
+        break;
+      case EventType2.TEXT_MESSAGE_END:
+        if (this.messageBuffer.trim()) {
+          this.sendToWeChat(this.messageBuffer, input).catch(console.error);
+          this.messageBuffer = "";
+        }
+        break;
+    }
+  }
+  /**
+   * Send message to WeChat and save to history
+   * Only sends in async mode (needAsyncReply=true)
+   * For sync mode, message is returned via HTTP response by controller
+   */
+  async sendToWeChat(content, input) {
+    try {
+      const needAsyncReply2 = input.forwardedProps?.replay.needAsyncReply ?? true;
+      if (needAsyncReply2) {
+        const sendMode = this.wechatConfig.sendMode || "local" /* LOCAL */;
+        if (sendMode === "aitools" /* AITOOLS */) {
+          await this.sendViaAITools(content, input);
+        } else {
+          await this.sendViaLocalSender(content, input);
+        }
+      }
+    } catch (error) {
+      console.error("Failed to send message to WeChat:", error);
+    }
+  }
+  /**
+   * Save reply content to history
+   * Uses replay metadata from forwardedProps for complete data (similar to dealMsgData)
+   */
+  async saveReplyToHistory(reply, input) {
+    const { threadId, runId } = input;
+    const replay = input.forwardedProps?.replay;
+    const msgData = input.forwardedProps?.msgData;
+    const messageId = reply.id;
+    if (threadId && messageId) {
+      await this._historyManager.saveToHistory({
+        id: messageId,
+        messageId,
+        role: "assistant",
+        content: reply.content,
+        threadId,
+        runId,
+        createdAt: Date.now(),
+        // Additional fields from replay/msgData (similar to dealMsgData replyMsgData)
+        botId: replay?.botId || msgData?.botId,
+        needAsyncReply: replay?.needAsyncReply,
+        type: replay?.type || "text",
+        metadata: {
+          sender: replay?.sender || msgData?.sender,
+          triggerSrc: replay?.triggerSrc || msgData?.triggerSrc,
+          // For assistant, reply field is empty, replyTo points to user message
+          replyTo: replay?.replyTo || msgData?.recordId,
+          originMsg: replay?.originMsg,
+          reply: replay?.reply,
+          recommendQuestions: replay?.recommendQuestions
+        }
+      });
+    }
+  }
+  /**
+   * Send message via aitools SDK (for cloud function environment)
+   */
+  async sendViaAITools(content, input) {
+    if (!this.aitools) {
+      throw new Error("aitools is not initialized");
+    }
+    const wxSendmessageInput = input.forwardedProps?.wxSendmessageInput;
+    if (!wxSendmessageInput) {
+      console.warn(
+        "wxSendmessageInput not found in forwardedProps, skipping aitools send"
+      );
+      return;
+    }
+    const toWxMsgData = this.processReplyMsg(wxSendmessageInput, content);
+    if (!toWxMsgData) {
+      console.warn("Failed to process reply message, skipping send");
+      return;
+    }
+    const triggerSrc = wxSendmessageInput.triggerSrc || this.wechatConfig.platform;
+    await this.aitools.sendMessageToClient(triggerSrc, {
+      msgType: toWxMsgData.msgType,
+      touser: toWxMsgData.toUserName,
+      text: {
+        content: toWxMsgData.content
+      },
+      openKfId: toWxMsgData.openKfId,
+      msgId: toWxMsgData.msgId
+    });
+  }
+  /**
+   * Format reply message for WeChat HTTP response (sync mode)
+   * Public method for controller to use
+   */
+  formatReplyMessage(callbackData, triggerSrc, content) {
+    return formatWeChatReplyMessage(callbackData, triggerSrc, content);
+  }
+  /**
+   * Process reply message to get correct format for different WeChat platforms
+   * Based on chat_wx.service.ts processReplyMsg implementation
+   */
+  processReplyMsg(wxSendMessageInput, content) {
+    const triggerSrc = wxSendMessageInput.triggerSrc || this.wechatConfig.platform;
+    const callbackData = wxSendMessageInput.callbackData;
+    return formatWeChatReplyMessage(callbackData, triggerSrc, content);
+  }
+  /**
+   * Send message via local WeChatSender (for local development)
+   */
+  async sendViaLocalSender(content, input) {
+    if (!this.wechatSender) {
+      throw new Error("wechatSender is not initialized");
+    }
+    const messageOptions = this.messageFormatter(content, {
+      type: EventType2.TEXT_MESSAGE_CONTENT,
+      content
+    });
+    const originMsg = input.forwardedProps?.originMsg;
+    await this.wechatSender.send(messageOptions, originMsg);
+  }
+};
+export {
+  MessageFormatter,
+  MessageType,
+  PlatformRouter,
+  SUPPORTED_MSG_TYPES,
+  TokenManager,
+  WeChatAgent,
+  WeChatHistoryManager,
+  WeChatPlatform,
+  WeChatSendMode,
+  WeChatSender,
+  createWxMessageHandler,
+  dealMsgData,
+  extractConversation,
+  extractMsgId,
+  extractMsgType,
+  extractSender,
+  extractTextContent,
+  extractTimestamp,
+  extractTriggerSrc,
+  extractVoiceMediaId,
+  formatWeChatReplyMessage,
+  generateRecordId,
+  getHistoryManager,
+  getWxChatContent,
+  handleWeChatRetry,
+  isContinueCommandValid,
+  needAsyncReply,
+  validateMessageType
+};
+//# sourceMappingURL=index.mjs.map