@hopgoldy/agent-bridge 0.1.1 → 0.2.1

package/dist/cli.js

@@ -783,11 +783,6 @@ var PiRpcClient = class {
     const data = response.data;
     return data ?? {};
   }
-  async getLastAssistantText() {
-    const response = await this.#send({ type: "get_last_assistant_text" });
-    const data = response.data;
-    return data?.text ?? null;
-  }
   async getState() {
     const response = await this.#send({ type: "get_state" });
     return response.data ?? {};
@@ -795,26 +790,6 @@ var PiRpcClient = class {
   async setSessionName(name) {
     await this.#send({ type: "set_session_name", name });
   }
-  waitForSettled(timeoutMs = 10 * 60 * 1e3) {
-    if (!this.#process) {
-      return Promise.reject(new Error("pi RPC client is not running"));
-    }
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => {
-        reject(new Error(`Timed out waiting for pi agent to settle after ${timeoutMs}ms`));
-      }, timeoutMs);
-      this.#settledWaiters.push({
-        resolve: () => {
-          clearTimeout(timeout);
-          resolve();
-        },
-        reject: (error) => {
-          clearTimeout(timeout);
-          reject(error);
-        }
-      });
-    });
-  }
   async #send(command) {
     if (!this.#process?.stdin.writable) {
       throw this.#exitError ?? new Error("pi RPC process is not writable");
@@ -1018,20 +993,12 @@ var PiCodingAgentAdapter = class {
     try {
       if (event.type === "user.message") {
         this.#logger.info(`sending prompt to agent (session=${this.#agentSessionId})`);
-        const startedAt = Date.now();
         await this.#emitProgress({
           type: "assistant.thinking",
           agentSessionId: this.#agentSessionId,
           text: "Processing request"
         });
         await this.#client.prompt(event.text);
-        await this.#client.waitForSettled();
-        const rawText = await this.#client.getLastAssistantText();
-        const { text: text2, attachments } = extractMediaMarkers(rawText ?? "(pi returned no assistant text)");
-        this.#logger.debug(
-          `prompt settled (session=${this.#agentSessionId} durationMs=${Date.now() - startedAt} replyLength=${text2.length} attachments=${attachments.length})`
-        );
-        await this.#emitAssistant(text2, attachments);
         return;
       }
       this.#logger.info(`compacting context (session=${this.#agentSessionId})`);
@@ -1077,6 +1044,28 @@ var PiCodingAgentAdapter = class {
     if (!this.#onOutput) {
       return;
     }
+    if (rpcEvent.type === "message_end") {
+      const message = rpcEvent.message;
+      if (this.#isAssistantMessage(message)) {
+        this.#logger.debug(`assistant message_end content shape (session=${this.#agentSessionId})`, {
+          contentType: Array.isArray(message.content) ? "array" : typeof message.content,
+          contentPreview: this.#summarizeContentShape(message.content)
+        });
+        const rawText = this.#extractMessageText(message.content);
+        const { text: text2, attachments } = extractMediaMarkers(rawText);
+        this.#logger.debug(
+          `assistant message_end received (session=${this.#agentSessionId} textLength=${rawText.length} attachmentCount=${attachments.length})`
+        );
+        if (!text2.trim() && attachments.length === 0) {
+          this.#logger.debug(
+            `ignoring assistant message_end without visible content (session=${this.#agentSessionId})`
+          );
+          return;
+        }
+        await this.#emitAssistant(text2, attachments);
+      }
+      return;
+    }
     if (rpcEvent.type === "tool_execution_start") {
       const toolName = typeof rpcEvent.toolName === "string" ? rpcEvent.toolName : "unknown";
       await this.#emitProgress({
@@ -1098,6 +1087,65 @@ var PiCodingAgentAdapter = class {
       });
     }
   }
+  #isAssistantMessage(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    return value.role === "assistant";
+  }
+  #extractMessageText(content) {
+    if (typeof content === "string") {
+      return content;
+    }
+    if (this.#isTextBlock(content)) {
+      return content.text;
+    }
+    if (!Array.isArray(content)) {
+      return "";
+    }
+    const textParts = [];
+    for (const block of content) {
+      if (this.#isTextBlock(block)) {
+        textParts.push(block.text);
+        continue;
+      }
+      if (!block || typeof block !== "object") {
+        continue;
+      }
+      const candidate = block;
+      if (typeof candidate.content === "string") {
+        textParts.push(candidate.content);
+      }
+    }
+    return textParts.join("");
+  }
+  #isTextBlock(value) {
+    if (!value || typeof value !== "object") {
+      return false;
+    }
+    const candidate = value;
+    return candidate.type === "text" && typeof candidate.text === "string";
+  }
+  #summarizeContentShape(content) {
+    if (typeof content === "string") {
+      return { kind: "string", length: content.length, preview: content.slice(0, 200) };
+    }
+    if (!Array.isArray(content)) {
+      return { kind: typeof content };
+    }
+    return content.slice(0, 10).map((block) => {
+      if (!block || typeof block !== "object") {
+        return { kind: typeof block };
+      }
+      const candidate = block;
+      return {
+        type: candidate.type,
+        textLength: typeof candidate.text === "string" ? candidate.text.length : void 0,
+        contentType: Array.isArray(candidate.content) ? "array" : typeof candidate.content,
+        mimeType: candidate.mimeType
+      };
+    });
+  }
 };
 
 // src/modules/agent/pi-coding-agent/index.ts
@@ -1165,6 +1213,102 @@ function getTypedAgentModule(config) {
   return module;
 }
 
+// src/modules/client/utils/progress-renderer.ts
+var DEFAULT_COLLAPSE_THRESHOLD = 10;
+var NO_PROGRESS_MARKDOWN = "No progress yet.";
+var ProgressRenderer = class {
+  #collapseThreshold;
+  #lines = [];
+  #status = "running";
+  #collapsedCount = 0;
+  constructor(options = {}) {
+    this.#collapseThreshold = options.collapseThreshold ?? DEFAULT_COLLAPSE_THRESHOLD;
+  }
+  /** Whether `event` should be recorded as progress (excludes assistant messages and thinking). */
+  isProgressEvent(event) {
+    return event.type !== "assistant.message" && event.type !== "assistant.thinking";
+  }
+  /** Records a progress event, formatting it into a line and collapsing older lines if needed. */
+  takeProgressEvent(event) {
+    this.#lines.push(this.#formatProgressLine(event));
+    if (this.#lines.length > this.#collapseThreshold) {
+      const overflow = this.#lines.length - this.#collapseThreshold;
+      this.#collapsedCount += overflow;
+      this.#lines.splice(0, overflow);
+    }
+    this.#status = this.#progressStatus(event);
+  }
+  /** Returns the current rendered markdown, status, and collapsed-line count. */
+  getCurrentProgress() {
+    return {
+      markdown: this.#renderMarkdown(),
+      status: this.#status,
+      collapsedCount: this.#collapsedCount
+    };
+  }
+  #renderMarkdown() {
+    const contentLines = [];
+    if (this.#collapsedCount > 0) {
+      contentLines.push(`- Collapsed ${this.#collapsedCount} earlier updates.`);
+    }
+    if (this.#lines.length > 0) {
+      contentLines.push(...this.#lines);
+    }
+    return contentLines.length > 0 ? contentLines.join("\n") : NO_PROGRESS_MARKDOWN;
+  }
+  #formatProgressLine(event) {
+    switch (event.type) {
+      case "session.compacting":
+        return `- Compacting session${event.text ? `: ${event.text}` : ""}`;
+      case "assistant.tool.running":
+        return `- Running ${event.toolName}`;
+      case "assistant.tool.done":
+        return `- Finished ${event.toolName}`;
+      case "assistant.tool.error":
+        return this.#formatToolErrorLine(event.toolName, event.text);
+    }
+  }
+  #formatToolErrorLine(toolName, text2) {
+    const normalizedText = text2?.trim();
+    if (!normalizedText) {
+      return `- ${this.#humanizeToolError(toolName)}`;
+    }
+    const lowerText = normalizedText.toLowerCase();
+    const lowerToolName = toolName.toLowerCase();
+    if (lowerText === lowerToolName || lowerText === `failed ${lowerToolName}`) {
+      return `- ${this.#humanizeToolError(toolName)}`;
+    }
+    return `- ${this.#humanizeToolError(toolName)}: ${normalizedText}`;
+  }
+  #humanizeToolError(toolName) {
+    return `Failed ${toolName}`;
+  }
+  #progressStatus(event) {
+    switch (event.type) {
+      case "assistant.tool.error":
+        return "error";
+      case "assistant.tool.done":
+        return "done";
+      default:
+        return "running";
+    }
+  }
+};
+
+// src/modules/client/utils/slash-commands.ts
+function parseSlashCommand(text2, clientSessionId) {
+  switch (text2) {
+    case "/new":
+      return { type: "command.session.new", clientSessionId };
+    case "/compact":
+      return { type: "command.session.compact", clientSessionId };
+    case "/stop":
+      return { type: "command.session.stop", clientSessionId };
+    default:
+      return null;
+  }
+}
+
 // src/modules/client/feishu/adapter/feishu-client.ts
 import * as Lark from "@larksuiteoapi/node-sdk";
 import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
@@ -1517,29 +1661,19 @@ var FeishuIMAdapter = class _FeishuIMAdapter {
   #processing = false;
   #lastInboundMessageIdBySession = /* @__PURE__ */ new Map();
   #progressStateBySession = /* @__PURE__ */ new Map();
-  static buildProgressCard(lines, _status, collapsedCount = 0) {
+  static buildProgressCard(markdown) {
     return {
       schema: "2.0",
       body: {
         elements: [
           {
             tag: "markdown",
-            content: _FeishuIMAdapter.progressBody(lines, collapsedCount)
+            content: markdown
           }
         ]
       }
     };
   }
-  static progressBody(lines, collapsedCount) {
-    const contentLines = [];
-    if (collapsedCount > 0) {
-      contentLines.push(`- Collapsed ${collapsedCount} earlier updates.`);
-    }
-    if (lines.length > 0) {
-      contentLines.push(...lines);
-    }
-    return contentLines.length > 0 ? contentLines.join("\n") : "No progress yet.";
-  }
   async #notifySendFailure(chatId, error) {
     if (!this.#client) {
       return;
@@ -1577,28 +1711,10 @@ ${message}`;
       this.#resetProgressState(clientSessionId);
       await this.#client?.startTyping(chatId, messageId);
       const normalizedText = text2.trim();
-      if (normalizedText === "/new") {
-        this.#logger.info(`received command /new (session=${clientSessionId})`);
-        await this.#onOutput({
-          type: "command.session.new",
-          clientSessionId
-        });
-        return;
-      }
-      if (normalizedText === "/compact") {
-        this.#logger.info(`received command /compact (session=${clientSessionId})`);
-        await this.#onOutput({
-          type: "command.session.compact",
-          clientSessionId
-        });
-        return;
-      }
-      if (normalizedText === "/stop") {
-        this.#logger.info(`received command /stop (session=${clientSessionId})`);
-        await this.#onOutput({
-          type: "command.session.stop",
-          clientSessionId
-        });
+      const commandEvent = parseSlashCommand(normalizedText, clientSessionId);
+      if (commandEvent) {
+        this.#logger.info(`received command ${normalizedText} (session=${clientSessionId})`);
+        await this.#onOutput(commandEvent);
         return;
       }
       this.#logger.info(`received user message (session=${clientSessionId}): ${normalizedText}`);
@@ -1686,25 +1802,17 @@ ${message}`;
     if (!this.#client) {
       return;
     }
-    if (!this.#shouldRenderProgressEvent(event)) {
-      return;
-    }
     const state = this.#progressStateBySession.get(event.clientSessionId) ?? {
+      renderer: new ProgressRenderer(),
       messageId: null,
-      creating: false,
-      lines: [],
-      status: "running",
-      turnId: 0,
-      collapsedCount: 0
+      creating: false
     };
-    state.lines.push(this.#formatProgressLine(event));
-    if (state.lines.length > 10) {
-      state.collapsedCount += state.lines.length - 10;
-      state.lines.splice(0, state.lines.length - 10);
-    }
-    state.status = this.#progressStatus(event);
     this.#progressStateBySession.set(event.clientSessionId, state);
-    const card = _FeishuIMAdapter.buildProgressCard(state.lines, state.status, state.collapsedCount);
+    if (!state.renderer.isProgressEvent(event)) {
+      return;
+    }
+    state.renderer.takeProgressEvent(event);
+    const card = _FeishuIMAdapter.buildProgressCard(state.renderer.getCurrentProgress().markdown);
     if (state.messageId) {
       await this.#client.updateCard(state.messageId, card);
       return;
@@ -1723,59 +1831,13 @@ ${message}`;
       state.creating = false;
     }
   }
-  #shouldRenderProgressEvent(event) {
-    return event.type !== "assistant.thinking";
-  }
   #resetProgressState(clientSessionId) {
-    const previous = this.#progressStateBySession.get(clientSessionId);
     this.#progressStateBySession.set(clientSessionId, {
+      renderer: new ProgressRenderer(),
       messageId: null,
-      creating: false,
-      lines: [],
-      status: "running",
-      turnId: (previous?.turnId ?? 0) + 1,
-      collapsedCount: 0
+      creating: false
     });
   }
-  #formatProgressLine(event) {
-    switch (event.type) {
-      case "assistant.thinking":
-        return "";
-      case "session.compacting":
-        return `- Compacting session${event.text ? `: ${event.text}` : ""}`;
-      case "assistant.tool.running":
-        return `- Running ${event.toolName}`;
-      case "assistant.tool.done":
-        return `- Finished ${event.toolName}`;
-      case "assistant.tool.error":
-        return this.#formatToolErrorLine(event.toolName, event.text);
-    }
-  }
-  #formatToolErrorLine(toolName, text2) {
-    const normalizedText = text2?.trim();
-    if (!normalizedText) {
-      return `- ${this.#humanizeToolError(toolName)}`;
-    }
-    const lowerText = normalizedText.toLowerCase();
-    const lowerToolName = toolName.toLowerCase();
-    if (lowerText === lowerToolName || lowerText === `failed ${lowerToolName}`) {
-      return `- ${this.#humanizeToolError(toolName)}`;
-    }
-    return `- ${this.#humanizeToolError(toolName)}: ${normalizedText}`;
-  }
-  #humanizeToolError(toolName) {
-    return `Failed ${toolName}`;
-  }
-  #progressStatus(event) {
-    switch (event.type) {
-      case "assistant.tool.error":
-        return "error";
-      case "assistant.tool.done":
-        return "done";
-      default:
-        return "running";
-    }
-  }
 };
 
 // src/modules/client/feishu/index.ts
@@ -1828,9 +1890,1449 @@ var feishuClientModule = {
   }
 };
 
+// src/modules/client/wecom/adapter/wecom-client.ts
+import { existsSync as existsSync4 } from "fs";
+import { mkdir as mkdir4, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
+import { randomUUID as randomUUID2 } from "crypto";
+import { tmpdir as tmpdir2 } from "os";
+import { basename as basename2, extname, join as join2 } from "path";
+import { WSClient } from "@wecom/aibot-node-sdk";
+var DEFAULT_WEBSOCKET_URL = "wss://openws.work.weixin.qq.com";
+var MEDIA_TEMP_DIR = join2(tmpdir2(), "agent-bridge-wecom-media");
+var IMAGE_SIGNATURE_PNG = Buffer.from("89504e470d0a1a0a", "hex");
+var IMAGE_SIGNATURE_JPG = Buffer.from("ffd8ff", "hex");
+var PROCESSED_MESSAGE_ID_LIMIT = 500;
+var KICKED_ERROR_MESSAGE = "WeCom connection was closed by the server because a newer connection was established for the same bot; this instance will not reconnect";
+function sanitizeFileName(fileName) {
+  return fileName.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function detectImageExtension(data) {
+  if (data.subarray(0, IMAGE_SIGNATURE_PNG.length).equals(IMAGE_SIGNATURE_PNG)) return ".png";
+  if (data.subarray(0, IMAGE_SIGNATURE_JPG.length).equals(IMAGE_SIGNATURE_JPG)) return ".jpg";
+  return ".jpg";
+}
+function decodeBase64(data) {
+  const payload = data.split(",", 1).length > 1 ? data.split(",", 2)[1] : data;
+  return Buffer.from(payload.trim(), "base64");
+}
+function buildMarkdownBody(text2) {
+  return {
+    msgtype: "markdown",
+    markdown: {
+      content: text2
+    }
+  };
+}
+async function ensureMediaDir() {
+  if (!existsSync4(MEDIA_TEMP_DIR)) {
+    await mkdir4(MEDIA_TEMP_DIR, { recursive: true });
+  }
+}
+var WecomClient = class {
+  #config;
+  #logger;
+  #onMessage = null;
+  #onKicked = null;
+  #client = null;
+  #kicked = false;
+  #processedMessageIds = /* @__PURE__ */ new Set();
+  #replyReqIdByMessageId = /* @__PURE__ */ new Map();
+  #lastChatReqId = /* @__PURE__ */ new Map();
+  #replyContextByMessageId = /* @__PURE__ */ new Map();
+  #lastReplyContextByChatId = /* @__PURE__ */ new Map();
+  #streamContextByMessageId = /* @__PURE__ */ new Map();
+  #lastStreamContextByChatId = /* @__PURE__ */ new Map();
+  constructor(config, logger3 = createLogger("wecom")) {
+    this.#config = config;
+    this.#logger = logger3;
+  }
+  setOnMessage(onMessage) {
+    this.#onMessage = onMessage;
+  }
+  setOnKicked(onKicked) {
+    this.#onKicked = onKicked;
+  }
+  isKicked() {
+    return this.#kicked;
+  }
+  async connect() {
+    const websocketUrl = this.#config.websocketUrl ?? DEFAULT_WEBSOCKET_URL;
+    this.#kicked = false;
+    const client = new WSClient({
+      botId: this.#config.botId,
+      secret: this.#config.secret,
+      wsUrl: websocketUrl,
+      logger: this.#logger
+    });
+    this.#client = client;
+    this.#registerInboundHandlers(client);
+    await new Promise((resolve, reject) => {
+      let settled = false;
+      const resolveOnce = () => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        resolve();
+      };
+      const rejectOnce = (error, phase) => {
+        if (settled) {
+          return;
+        }
+        settled = true;
+        reject(this.#toConnectionError(error, websocketUrl, phase));
+      };
+      client.on("authenticated", resolveOnce);
+      client.on("ready", resolveOnce);
+      client.on("error", (error) => rejectOnce(error, "connect"));
+      client.on("auth_error", (error) => rejectOnce(error, "subscribe"));
+      client.on("close", () => {
+        if (!settled) {
+          rejectOnce(new Error("WeCom websocket closed before subscription completed"), "connect");
+        }
+      });
+      try {
+        client.connect();
+      } catch (error) {
+        rejectOnce(error, "connect");
+      }
+    });
+  }
+  #toConnectionError(error, websocketUrl, phase) {
+    if (error instanceof Error) {
+      return new Error(`WeCom websocket ${phase} failed (${websocketUrl}): ${error.message}`);
+    }
+    const event = error;
+    const details = [event?.message, event?.error].filter((value) => typeof value === "string" && value.trim().length > 0).join("; ");
+    const suffix = details ? `: ${details}` : "";
+    return new Error(`WeCom websocket ${phase} failed (${websocketUrl})${suffix}`);
+  }
+  async disconnect() {
+    this.#client?.disconnect();
+    this.#client = null;
+  }
+  #requireClient() {
+    if (!this.#client) {
+      throw new Error("WeCom websocket is not connected");
+    }
+    if (this.#kicked) {
+      throw new Error(KICKED_ERROR_MESSAGE);
+    }
+    return this.#client;
+  }
+  async sendText(chatId, text2, replyToMessageId) {
+    const client = this.#requireClient();
+    const replyContext = this.#replyContextForMessage(replyToMessageId) ?? this.#lastReplyContextByChatId.get(chatId);
+    if (replyContext) {
+      this.#logger.debug(`reply context available for ${chatId}: ${replyContext.reqId}`);
+      await client.reply(replyContext.frame, buildMarkdownBody(text2));
+      return;
+    }
+    await client.sendMessage(chatId, buildMarkdownBody(text2));
+  }
+  async sendStreamText(chatId, text2, options) {
+    const client = this.#requireClient();
+    const replyToMessageId = options?.replyToMessageId;
+    const replyContext = this.#replyContextForMessage(replyToMessageId) ?? this.#lastReplyContextByChatId.get(chatId);
+    if (!replyContext) {
+      await client.sendMessage(chatId, buildMarkdownBody(text2));
+      return;
+    }
+    const streamContext = this.#streamContextFor(chatId, replyToMessageId);
+    const feedback = !streamContext.started && options?.feedbackId ? { id: options.feedbackId } : void 0;
+    await client.replyStream(
+      replyContext.frame,
+      streamContext.streamId,
+      text2,
+      options?.finish ?? false,
+      void 0,
+      feedback
+    );
+    streamContext.started = true;
+  }
+  async sendAttachment(chatId, attachment, replyToMessageId) {
+    const client = this.#requireClient();
+    const upload = await this.#uploadMedia(attachment);
+    const replyContext = this.#replyContextForMessage(replyToMessageId) ?? this.#lastReplyContextByChatId.get(chatId);
+    if (replyContext) {
+      this.#logger.debug(`reply media context available for ${chatId}: ${replyContext.reqId}`);
+      await client.replyMedia(replyContext.frame, upload.type, upload.mediaId);
+      return;
+    }
+    await client.sendMessage(chatId, {
+      msgtype: upload.type,
+      [upload.type]: { media_id: upload.mediaId }
+    });
+  }
+  async #uploadMedia(attachment) {
+    if (!this.#client) {
+      throw new Error("WeCom websocket is not connected");
+    }
+    const data = await readFile3(attachment.filePath);
+    const type = attachment.kind === "image" ? "image" : "file";
+    const filename = sanitizeFileName(attachment.fileName ?? basename2(attachment.filePath));
+    const response = await this.#client.uploadMedia(data, { type, filename });
+    const mediaId = String(response.media_id ?? "").trim();
+    if (!mediaId) {
+      throw new Error("media upload failed: missing media_id");
+    }
+    return { type, mediaId };
+  }
+  #replyReqIdForMessage(messageId) {
+    if (!messageId) return void 0;
+    return this.#replyReqIdByMessageId.get(messageId);
+  }
+  #replyContextForMessage(messageId) {
+    if (!messageId) return void 0;
+    return this.#replyContextByMessageId.get(messageId);
+  }
+  #streamContextFor(chatId, messageId) {
+    if (messageId) {
+      const existing = this.#streamContextByMessageId.get(messageId);
+      if (existing) {
+        this.#lastStreamContextByChatId.set(chatId, existing);
+        return existing;
+      }
+    }
+    const fallback = this.#lastStreamContextByChatId.get(chatId);
+    if (fallback) {
+      return fallback;
+    }
+    const created = { streamId: randomUUID2(), started: false };
+    if (messageId) {
+      this.#streamContextByMessageId.set(messageId, created);
+    }
+    this.#lastStreamContextByChatId.set(chatId, created);
+    return created;
+  }
+  #registerInboundHandlers(client) {
+    client.on("event", (payload) => {
+      this.#logger.info(
+        `received SDK event event (reqId=${String(payload?.headers?.req_id ?? "") || "n/a"} eventType=${String(payload?.body?.event?.eventtype ?? "") || "n/a"})`
+      );
+    });
+    client.on("event.enter_chat", (payload) => {
+      this.#logger.info(
+        `received enter_chat event (reqId=${String(payload?.headers?.req_id ?? "") || "n/a"} userId=${String(payload?.body?.from?.userid ?? "") || "n/a"})`
+      );
+      void this.#handleEnterChat(payload);
+    });
+    client.on("event.disconnected_event", (payload) => {
+      this.#kicked = true;
+      this.#logger.error(
+        `connection replaced by a newer connection for the same bot (reqId=${String(payload?.headers?.req_id ?? "") || "n/a"}); this instance will no longer receive or send messages`
+      );
+      this.#onKicked?.();
+    });
+    const specificMsgTypes = /* @__PURE__ */ new Set(["text", "image", "file", "voice", "video", "mixed"]);
+    client.on("message", (payload) => {
+      const msgtype = String(payload?.body?.msgtype ?? "").toLowerCase();
+      if (specificMsgTypes.has(msgtype)) {
+        return;
+      }
+      this.#logger.info(
+        `received SDK event message (reqId=${String(payload?.headers?.req_id ?? "") || "n/a"} msgtype=${msgtype || "n/a"})`
+      );
+      void this.#handleInboundCallback(
+        payload,
+        String(payload?.headers?.req_id ?? "")
+      );
+    });
+    for (const eventName of [
+      "message.text",
+      "message.image",
+      "message.file",
+      "message.voice",
+      "message.video",
+      "message.mixed"
+    ]) {
+      client.on(eventName, (payload) => {
+        this.#logger.info(
+          `received SDK event ${eventName} (reqId=${String(payload?.headers?.req_id ?? "") || "n/a"} msgtype=${String(payload?.body?.msgtype ?? "") || "n/a"})`
+        );
+        void this.#handleInboundCallback(
+          payload,
+          String(payload?.headers?.req_id ?? "")
+        );
+      });
+    }
+  }
+  /**
+   * Records a message id as processed. Returns false when the id was already
+   * seen, so callers can drop duplicate callbacks. Bounded to the most recent
+   * PROCESSED_MESSAGE_ID_LIMIT ids (insertion-ordered Set acts as the LRU).
+   */
+  #markMessageProcessed(messageId) {
+    if (this.#processedMessageIds.has(messageId)) {
+      return false;
+    }
+    this.#processedMessageIds.add(messageId);
+    if (this.#processedMessageIds.size > PROCESSED_MESSAGE_ID_LIMIT) {
+      const oldest = this.#processedMessageIds.values().next().value;
+      if (oldest !== void 0) {
+        this.#processedMessageIds.delete(oldest);
+      }
+    }
+    return true;
+  }
+  async #handleInboundCallback(payload, reqId) {
+    const body = payload.body ?? {};
+    const senderId = String(body.from?.userid ?? "").trim();
+    const chatId = String(body.chatid ?? senderId).trim();
+    if (!chatId) {
+      this.#logger.warn(`dropping inbound callback without chatId (reqId=${reqId || "n/a"})`);
+      return;
+    }
+    const messageId = String(body.msgid ?? reqId ?? randomUUID2()).trim();
+    if (!this.#markMessageProcessed(messageId)) {
+      this.#logger.info(
+        `dropping duplicate inbound callback (messageId=${messageId} reqId=${reqId || "n/a"})`
+      );
+      return;
+    }
+    this.#replyReqIdByMessageId.set(messageId, reqId);
+    this.#lastChatReqId.set(chatId, reqId);
+    const replyContext = { reqId, frame: { headers: { req_id: reqId } } };
+    this.#replyContextByMessageId.set(messageId, replyContext);
+    this.#lastReplyContextByChatId.set(chatId, replyContext);
+    const streamContext = { streamId: randomUUID2(), started: false };
+    this.#streamContextByMessageId.set(messageId, streamContext);
+    this.#lastStreamContextByChatId.set(chatId, streamContext);
+    const textParts = [];
+    const plainText = String(body.text?.content ?? "").trim();
+    if (plainText) {
+      textParts.push(plainText);
+    }
+    if (String(body.msgtype ?? "").toLowerCase() === "appmsg") {
+      const title = String(body.appmsg?.title ?? "").trim();
+      if (title) {
+        textParts.push(title);
+      }
+    }
+    if (String(body.msgtype ?? "").toLowerCase() === "mixed") {
+      const items = Array.isArray(body.mixed?.msg_item) ? body.mixed.msg_item : [];
+      for (const item of items) {
+        if (String(item?.msgtype ?? "").toLowerCase() === "text") {
+          const content = String(item?.text?.content ?? "").trim();
+          if (content) textParts.push(content);
+        }
+      }
+    }
+    const refs = this.#extractMediaRefs(body);
+    for (const ref of refs) {
+      const localPath = await this.#downloadMediaRef(ref);
+      if (localPath) {
+        textParts.push(`[Received ${ref.kind}: ${localPath}]`);
+      }
+    }
+    const chatType = String(body.chattype ?? "").toLowerCase() === "group" ? "group" : "dm";
+    const rawText = textParts.join("\n").trim();
+    const { text: text2, mentionedBot } = this.#normalizeMention(rawText, chatType);
+    this.#logger.info(
+      `normalized inbound message (chatType=${chatType} chatId=${chatId} messageId=${messageId} textLength=${text2.length})`
+    );
+    await this.#onMessage?.({
+      chatId,
+      chatType,
+      messageId,
+      text: text2,
+      mentionedBot,
+      raw: payload
+    });
+  }
+  async #handleEnterChat(payload) {
+    if (!this.#client) {
+      return;
+    }
+    const reqId = String(payload?.headers?.req_id ?? "").trim();
+    if (!reqId) {
+      return;
+    }
+    try {
+      await this.#client.replyWelcome(
+        { headers: { req_id: reqId } },
+        {
+          msgtype: "text",
+          text: {
+            content: "\u60A8\u597D\uFF0C\u6211\u5DF2\u8FDE\u63A5\u6210\u529F\uFF0C\u53EF\u4EE5\u76F4\u63A5\u7ED9\u6211\u53D1\u6D88\u606F\u3002"
+          }
+        }
+      );
+      this.#logger.info(`sent enter_chat welcome reply (reqId=${reqId})`);
+    } catch (error) {
+      this.#logger.warn(`failed to send enter_chat welcome reply (reqId=${reqId}):`, error);
+    }
+  }
+  #normalizeMention(text2, chatType) {
+    if (chatType !== "group") {
+      return { text: text2, mentionedBot: false };
+    }
+    const match = text2.match(/^@(\S+)\s*(.*)$/s);
+    if (!match) {
+      return { text: text2, mentionedBot: false };
+    }
+    return { text: match[2] ?? "", mentionedBot: true };
+  }
+  #extractMediaRefs(body) {
+    const refs = [];
+    const msgType = String(body.msgtype ?? "").toLowerCase();
+    if (msgType === "image" && body.image) {
+      refs.push({
+        kind: "image",
+        url: typeof body.image.url === "string" ? body.image.url : void 0,
+        aeskey: typeof body.image.aeskey === "string" ? body.image.aeskey : void 0,
+        base64: typeof body.image.base64 === "string" ? body.image.base64 : void 0,
+        fileName: typeof body.image.filename === "string" ? body.image.filename : void 0
+      });
+    }
+    if (msgType === "file" && body.file) {
+      refs.push({
+        kind: "file",
+        url: typeof body.file.url === "string" ? body.file.url : void 0,
+        aeskey: typeof body.file.aeskey === "string" ? body.file.aeskey : void 0,
+        base64: typeof body.file.base64 === "string" ? body.file.base64 : void 0,
+        fileName: typeof body.file.filename === "string" ? body.file.filename : typeof body.file.name === "string" ? body.file.name : void 0
+      });
+    }
+    if (msgType === "appmsg" && body.appmsg?.file) {
+      refs.push({
+        kind: "file",
+        url: typeof body.appmsg.file.url === "string" ? body.appmsg.file.url : void 0,
+        aeskey: typeof body.appmsg.file.aeskey === "string" ? body.appmsg.file.aeskey : void 0,
+        base64: typeof body.appmsg.file.base64 === "string" ? body.appmsg.file.base64 : void 0,
+        fileName: typeof body.appmsg.file.filename === "string" ? body.appmsg.file.filename : typeof body.appmsg.title === "string" ? body.appmsg.title : void 0
+      });
+    }
+    return refs;
+  }
+  async #downloadMediaRef(ref) {
+    try {
+      await ensureMediaDir();
+      let bytes;
+      let fileName = ref.fileName;
+      if (ref.base64) {
+        bytes = decodeBase64(ref.base64);
+      } else if (ref.url) {
+        if (!this.#client) {
+          throw new Error("WeCom websocket is not connected");
+        }
+        const downloaded = await this.#client.downloadFile(ref.url, ref.aeskey);
+        bytes = downloaded.buffer;
+        fileName = fileName ?? downloaded.filename;
+      } else {
+        return null;
+      }
+      const safeName = fileName ? sanitizeFileName(fileName) : ref.kind === "image" ? `${randomUUID2()}${detectImageExtension(bytes)}` : `${randomUUID2()}.bin`;
+      const resolvedName = extname(safeName) ? safeName : ref.kind === "image" ? `${safeName}${detectImageExtension(bytes)}` : `${safeName}.bin`;
+      const outputPath = join2(MEDIA_TEMP_DIR, `${Date.now()}-${resolvedName}`);
+      await writeFile3(outputPath, bytes);
+      return outputPath;
+    } catch (error) {
+      this.#logger.warn(`failed to download ${ref.kind} resource:`, error);
+      return null;
+    }
+  }
+};
+
+// src/modules/client/wecom/adapter/wecom-session.ts
+function buildWecomSessionId(chatType, chatId) {
+  if (chatType === "dm") {
+    return `wecom:dm:${chatId}`;
+  }
+  if (chatType === "group") {
+    return `wecom:group:${chatId}`;
+  }
+  throw new Error(`Unsupported WeCom chat type: ${chatType}`);
+}
+function parseWecomSessionId(clientSessionId) {
+  if (clientSessionId.startsWith("wecom:dm:")) {
+    return { platform: "wecom", chatType: "dm", chatId: clientSessionId.slice("wecom:dm:".length) };
+  }
+  if (clientSessionId.startsWith("wecom:group:")) {
+    return { platform: "wecom", chatType: "group", chatId: clientSessionId.slice("wecom:group:".length) };
+  }
+  throw new Error(`Unsupported clientSessionId: ${clientSessionId}`);
+}
+
+// src/modules/client/wecom/adapter/wecom-im-adapter.ts
+var MAX_TEXT_CHUNK2 = 4e3;
+var STARTING_MESSAGE = "Processing...";
+function chunkText2(text2, maxLen) {
+  if (text2.length <= maxLen) return [text2];
+  const chunks = [];
+  let remaining = text2;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitPos = remaining.lastIndexOf("\n", maxLen);
+    if (splitPos <= 0) {
+      splitPos = remaining.lastIndexOf(" ", maxLen);
+    }
+    if (splitPos <= 0) {
+      chunks.push(remaining.slice(0, maxLen));
+      remaining = remaining.slice(maxLen);
+      continue;
+    }
+    chunks.push(remaining.slice(0, splitPos + 1));
+    remaining = remaining.slice(splitPos + 1);
+  }
+  return chunks.filter((chunk) => chunk.length > 0);
+}
+var WecomIMAdapter = class {
+  #config;
+  #logger;
+  #onOutput = null;
+  #client = null;
+  #egressQueue = [];
+  #processing = false;
+  #lastInboundMessageIdBySession = /* @__PURE__ */ new Map();
+  #progressStateBySession = /* @__PURE__ */ new Map();
+  async #notifySendFailure(chatId, error) {
+    if (!this.#client) {
+      return;
+    }
+    if (this.#client.isKicked()) {
+      this.#logger.debug("skipping send-failure notification, connection was replaced");
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const text2 = `[agent-bridge error] Message delivery failed
+
+${message}`;
+    try {
+      await this.#client.sendText(chatId, text2);
+    } catch (notifyError) {
+      this.#logger.error("failed to notify send failure:", notifyError);
+    }
+  }
+  constructor(config, logger3 = createLogger("wecom")) {
+    this.#config = config;
+    this.#logger = logger3;
+  }
+  async start(onOutput) {
+    this.#onOutput = onOutput;
+    this.#client = new WecomClient(this.#config, this.#logger);
+    this.#client.setOnKicked(() => {
+      this.#logger.error(
+        "this bot connection was replaced by a newer connection (another instance is running with the same bot credentials); this instance will keep running but can no longer receive or send messages \u2014 stop the other instance and restart this process to recover"
+      );
+    });
+    this.#client.setOnMessage(async ({ chatId, chatType, text: text2, messageId, mentionedBot }) => {
+      if (!this.#onOutput) {
+        this.#logger.warn(`dropping inbound message, adapter not ready (chatId=${chatId})`);
+        return;
+      }
+      this.#logger.info(
+        `adapter received inbound message (chatType=${chatType} chatId=${chatId} messageId=${messageId} mentionedBot=${mentionedBot} textLength=${text2.trim().length})`
+      );
+      const clientSessionId = buildWecomSessionId(chatType, chatId);
+      if (chatType === "group" && (this.#config.requireMentionInGroup ?? true) && !mentionedBot) {
+        this.#logger.debug(
+          `ignoring group message without bot mention (session=${clientSessionId} messageId=${messageId})`
+        );
+        return;
+      }
+      const normalizedText = text2.trim();
+      const commandEvent = parseSlashCommand(normalizedText, clientSessionId);
+      if (commandEvent) {
+        await this.#onOutput(commandEvent);
+        return;
+      }
+      this.#lastInboundMessageIdBySession.set(clientSessionId, messageId);
+      this.#resetProgressState(clientSessionId);
+      await this.#announceStart(chatId, messageId, clientSessionId);
+      await this.#onOutput({
+        type: "user.message",
+        clientSessionId,
+        text: text2
+      });
+    });
+    await this.#client.connect();
+    this.#logger.info(
+      `adapter started (websocketUrl=${this.#config.websocketUrl ?? "wss://openws.work.weixin.qq.com"})`
+    );
+  }
+  async stop() {
+    this.#egressQueue.length = 0;
+    this.#progressStateBySession.clear();
+    if (this.#client) {
+      await this.#client.disconnect();
+      this.#client = null;
+    }
+    this.#processing = false;
+    this.#onOutput = null;
+    this.#logger.info("adapter stopped");
+  }
+  async input(event) {
+    if (!this.#client) {
+      throw new Error("WecomIMAdapter is not started");
+    }
+    this.#egressQueue.push(event);
+    void this.#drainEgressQueue();
+  }
+  async isBusy() {
+    return this.#processing || this.#egressQueue.length > 0;
+  }
+  async #drainEgressQueue() {
+    if (this.#processing) {
+      return;
+    }
+    this.#processing = true;
+    try {
+      while (this.#client && this.#egressQueue.length > 0) {
+        const event = this.#egressQueue.shift();
+        if (!event) continue;
+        try {
+          const target = parseWecomSessionId(event.clientSessionId);
+          if (event.type !== "assistant.message") {
+            await this.#handleProgressEvent(target.chatId, event);
+            continue;
+          }
+          const replyToMessageId = this.#lastInboundMessageIdBySession.get(event.clientSessionId);
+          await this.#finishProgressMessage(target.chatId, event.clientSessionId, replyToMessageId);
+          if (event.text.trim().length > 0) {
+            const chunks = chunkText2(event.text, MAX_TEXT_CHUNK2);
+            for (const [index, chunk] of chunks.entries()) {
+              await this.#client.sendText(target.chatId, chunk, index === 0 ? replyToMessageId : void 0);
+            }
+          }
+          for (const attachment of event.attachments ?? []) {
+            try {
+              await this.#client.sendAttachment(target.chatId, attachment, replyToMessageId);
+            } catch (attachmentError) {
+              this.#logger.error("failed to send attachment:", attachmentError);
+              await this.#notifySendFailure(target.chatId, attachmentError);
+            }
+          }
+        } catch (error) {
+          this.#logger.error("failed to send egress event:", error);
+          try {
+            const target = parseWecomSessionId(event.clientSessionId);
+            await this.#notifySendFailure(target.chatId, error);
+          } catch (notifyError) {
+            this.#logger.error("failed to handle egress send failure:", notifyError);
+          }
+        }
+      }
+    } finally {
+      this.#processing = false;
+    }
+  }
+  async #announceStart(chatId, messageId, clientSessionId) {
+    const state = this.#progressStateBySession.get(clientSessionId);
+    if (!state || state.announced || !this.#client) {
+      return;
+    }
+    await this.#client.sendStreamText(chatId, STARTING_MESSAGE, {
+      replyToMessageId: messageId,
+      finish: false
+    });
+    state.announced = true;
+  }
+  async #handleProgressEvent(chatId, event) {
+    if (!this.#client) {
+      return;
+    }
+    const state = this.#progressStateBySession.get(event.clientSessionId) ?? {
+      renderer: new ProgressRenderer(),
+      announced: false
+    };
+    this.#progressStateBySession.set(event.clientSessionId, state);
+    if (!state.renderer.isProgressEvent(event)) {
+      return;
+    }
+    state.renderer.takeProgressEvent(event);
+    const body = state.renderer.getCurrentProgress().markdown;
+    const replyToMessageId = this.#lastInboundMessageIdBySession.get(event.clientSessionId);
+    await this.#client.sendStreamText(chatId, body, {
+      replyToMessageId,
+      finish: false
+    });
+    state.announced = true;
+  }
+  async #finishProgressMessage(chatId, clientSessionId, replyToMessageId) {
+    const state = this.#progressStateBySession.get(clientSessionId);
+    if (!state || !state.announced || !this.#client) {
+      return;
+    }
+    this.#progressStateBySession.delete(clientSessionId);
+    const progress = state.renderer.getCurrentProgress();
+    const body = progress.markdown === NO_PROGRESS_MARKDOWN ? STARTING_MESSAGE : progress.markdown;
+    try {
+      await this.#client.sendStreamText(chatId, body, { replyToMessageId, finish: true });
+    } catch (error) {
+      this.#logger.warn("failed to finish progress message:", error);
+    }
+  }
+  #resetProgressState(clientSessionId) {
+    this.#progressStateBySession.set(clientSessionId, {
+      renderer: new ProgressRenderer(),
+      announced: false
+    });
+  }
+};
+
+// src/modules/client/wecom/index.ts
+var DEFAULT_WEBSOCKET_URL2 = "wss://openws.work.weixin.qq.com";
+function createWecomConfigCollector() {
+  return {
+    async collect(ctx) {
+      const botId = await ctx.input("WeCom Bot ID", {
+        required: true,
+        validate: (value) => value ? null : "Bot ID is required"
+      });
+      const secret = await ctx.input("WeCom Secret", {
+        required: true,
+        secret: true,
+        validate: (value) => value ? null : "Secret is required"
+      });
+      const websocketUrl = await ctx.input("WeCom WebSocket URL", {
+        defaultValue: DEFAULT_WEBSOCKET_URL2,
+        validate: (value) => !value || /^wss?:\/\//.test(value) ? null : "WebSocket URL must start with ws:// or wss://"
+      });
+      const requireMentionInGroup = await ctx.confirm("Require @mention in group chats", true);
+      return { botId, secret, websocketUrl, requireMentionInGroup };
+    },
+    validate(config) {
+      if (!config.botId.trim()) {
+        throw new Error("WeCom botId is required");
+      }
+      if (!config.secret.trim()) {
+        throw new Error("WeCom secret is required");
+      }
+      if (config.websocketUrl && !/^wss?:\/\//.test(config.websocketUrl)) {
+        throw new Error("WeCom websocketUrl must start with ws:// or wss://");
+      }
+    },
+    summarize(config) {
+      const masked = config.botId.length > 8 ? `${config.botId.slice(0, 4)}****${config.botId.slice(-4)}` : "****";
+      return `type=wecom botId=${masked} websocketUrl=${config.websocketUrl ?? DEFAULT_WEBSOCKET_URL2} requireMentionInGroup=${config.requireMentionInGroup ?? true}`;
+    }
+  };
+}
+var wecomClientModule = {
+  type: "wecom",
+  createConfigCollector: createWecomConfigCollector,
+  createClientAdapter(config) {
+    return new WecomIMAdapter(config);
+  }
+};
+
+// src/modules/client/weixin/adapter/weixin-client.ts
+import * as fs from "fs/promises";
+import { randomUUID as randomUUID3 } from "crypto";
+import { basename as basename3, extname as extname2, join as join3 } from "path";
+import { tmpdir as tmpdir3 } from "os";
+import { Client as OpenILinkClient, extractText, TYPING, CANCEL_TYPING } from "@openilink/openilink-sdk-node";
+var MEDIA_TEMP_DIR2 = join3(tmpdir3(), "agent-bridge-weixin-media");
+var STALE_SESSION_ERRCODE = -2;
+var STALE_SESSION_ERRMSG = "unknown error";
+var WeixinStaleSessionError = class extends Error {
+  constructor(message = "Weixin conversation context became stale; wait for the user to send a fresh message.") {
+    super(message);
+    this.name = "WeixinStaleSessionError";
+  }
+};
+var WeixinClient = class {
+  #config;
+  #logger;
+  #onMessage = null;
+  #client = null;
+  #monitorTask = null;
+  #running = false;
+  #syncBuf = "";
+  constructor(config, logger3 = createLogger("weixin")) {
+    this.#config = config;
+    this.#logger = logger3;
+  }
+  setOnMessage(onMessage) {
+    this.#onMessage = onMessage;
+  }
+  async connect() {
+    if (this.#client) {
+      return;
+    }
+    this.#client = new OpenILinkClient(this.#config.token, {
+      base_url: this.#config.baseUrl,
+      cdn_base_url: this.#config.cdnBaseUrl
+    });
+    this.#running = true;
+    this.#monitorTask = this.#client.monitor(
+      async (message) => {
+        await this.#handleMessage(message);
+      },
+      {
+        initial_buf: this.#syncBuf,
+        on_buf_update: (buf) => {
+          this.#syncBuf = buf;
+        },
+        on_error: (error) => {
+          this.#logger.error("weixin monitor error:", error);
+        },
+        should_continue: () => this.#running
+      }
+    ).catch((error) => {
+      if (this.#running) {
+        this.#logger.error("weixin monitor stopped unexpectedly:", error);
+      }
+    });
+  }
+  async disconnect() {
+    this.#running = false;
+    try {
+      await this.#monitorTask;
+    } catch {
+    }
+    this.#monitorTask = null;
+    this.#client = null;
+  }
+  async sendText(chatId, text2) {
+    if (!this.#client) {
+      throw new Error("Weixin client is not connected");
+    }
+    try {
+      await this.#client.push(chatId, text2);
+    } catch (error) {
+      if (isStaleSessionError(error)) {
+        throw new WeixinStaleSessionError();
+      }
+      throw error;
+    }
+  }
+  async sendAttachment(chatId, attachment) {
+    if (!this.#client) {
+      throw new Error("Weixin client is not connected");
+    }
+    const contextToken = this.#client.getContextToken(chatId);
+    if (!contextToken) {
+      throw new Error(`No context token for Weixin chat ${chatId}`);
+    }
+    const data = await fs.readFile(attachment.filePath);
+    await this.#client.sendMediaFile(
+      chatId,
+      contextToken,
+      data,
+      attachment.fileName ?? basename3(attachment.filePath),
+      attachment.caption ?? ""
+    );
+  }
+  async sendTyping(chatId) {
+    if (!this.#client) {
+      return;
+    }
+    const contextToken = this.#client.getContextToken(chatId);
+    if (!contextToken) {
+      return;
+    }
+    const config = await this.#client.getConfig(chatId, contextToken);
+    if (!config.typing_ticket) {
+      return;
+    }
+    await this.#client.sendTyping(chatId, config.typing_ticket, TYPING);
+  }
+  async stopTyping(chatId) {
+    if (!this.#client) {
+      return;
+    }
+    const contextToken = this.#client.getContextToken(chatId);
+    if (!contextToken) {
+      return;
+    }
+    const config = await this.#client.getConfig(chatId, contextToken);
+    if (!config.typing_ticket) {
+      return;
+    }
+    await this.#client.sendTyping(chatId, config.typing_ticket, CANCEL_TYPING);
+  }
+  async #handleMessage(message) {
+    const chatType = this.#inferChatType(message);
+    const chatId = this.#resolveChatId(message, chatType);
+    const extractedText = extractText(message);
+    const { text: text2, mentionedBot } = this.#normalizeMention(extractedText, chatType);
+    const attachmentHints = await this.#downloadAttachmentHints(message);
+    const combinedText = [text2, ...attachmentHints].filter((part) => part.trim().length > 0).join("\n").trim();
+    if (!combinedText) {
+      return;
+    }
+    await this.#onMessage?.({
+      chatId,
+      chatType,
+      messageId: String(message.message_id ?? randomUUID3()),
+      text: combinedText,
+      mentionedBot,
+      raw: message
+    });
+  }
+  #inferChatType(message) {
+    const roomId = String(message.room_id ?? message.chat_room_id ?? "").trim();
+    if (roomId) {
+      return "group";
+    }
+    const fromUserId = String(message.from_user_id ?? "").trim();
+    return fromUserId.endsWith("@chatroom") ? "group" : "dm";
+  }
+  #resolveChatId(message, chatType) {
+    if (chatType === "group") {
+      return String(message.room_id ?? message.chat_room_id ?? message.from_user_id ?? "").trim();
+    }
+    return String(message.from_user_id ?? "").trim();
+  }
+  #normalizeMention(text2, chatType) {
+    if (chatType !== "group") {
+      return { text: text2, mentionedBot: false };
+    }
+    const match = text2.match(/^@(\S+)\s*(.*)$/s);
+    if (!match) {
+      return { text: text2, mentionedBot: false };
+    }
+    return { text: match[2] ?? "", mentionedBot: true };
+  }
+  async #downloadAttachmentHints(message) {
+    if (!this.#client) {
+      return [];
+    }
+    const hints = [];
+    for (const item of Array.isArray(message.item_list) ? message.item_list : []) {
+      const downloaded = await this.#downloadItem(item);
+      if (downloaded) {
+        hints.push(downloaded);
+      }
+    }
+    return hints;
+  }
+  async #downloadItem(item) {
+    if (!this.#client || typeof item?.type !== "number") {
+      return null;
+    }
+    try {
+      switch (item.type) {
+        case 2:
+          return await this.#downloadMediaHint(item.image_item?.media, "image", ".jpg");
+        case 3:
+          return await this.#downloadMediaHint(item.voice_item?.media, "voice", ".silk");
+        case 4:
+          return await this.#downloadMediaHint(
+            item.file_item?.media,
+            "file",
+            extname2(String(item.file_item?.file_name ?? "")) || ".bin",
+            String(item.file_item?.file_name ?? "").trim() || void 0
+          );
+        case 5:
+          return await this.#downloadMediaHint(item.video_item?.media, "video", ".mp4");
+        default:
+          return null;
+      }
+    } catch (error) {
+      this.#logger.warn("failed to download Weixin attachment:", error);
+      return null;
+    }
+  }
+  async #downloadMediaHint(media, label, fallbackExt, preferredName) {
+    if (!this.#client || !media) {
+      throw new Error("missing media payload");
+    }
+    const bytes = await this.#client.downloadMedia(media);
+    await fs.mkdir(MEDIA_TEMP_DIR2, { recursive: true });
+    const safeName = (preferredName || `${Date.now()}-${randomUUID3()}${fallbackExt}`).replace(/[^a-zA-Z0-9._@-]/g, "_");
+    const resolvedName = extname2(safeName) ? safeName : `${safeName}${fallbackExt}`;
+    const outputPath = join3(MEDIA_TEMP_DIR2, resolvedName);
+    await fs.writeFile(outputPath, Buffer.from(bytes));
+    return `[Received ${label}: ${outputPath}]`;
+  }
+};
+function isStaleSessionError(error) {
+  const details = extractErrorDetails(error);
+  if (details.errMsg.toLowerCase() === STALE_SESSION_ERRMSG) {
+    return details.ret === STALE_SESSION_ERRCODE || details.errCode === STALE_SESSION_ERRCODE;
+  }
+  return false;
+}
+function extractErrorDetails(error) {
+  const candidate = error;
+  const message = String(candidate?.message ?? "");
+  const ret = typeof candidate?.ret === "number" ? candidate.ret : parseCodeFromText(message, /ret=(-?\d+)/i);
+  const errCode = typeof candidate?.errCode === "number" ? candidate.errCode : parseCodeFromText(message, /errcode=(-?\d+)/i);
+  const errMsg = typeof candidate?.errMsg === "string" ? candidate.errMsg : parseErrMsgFromText(message);
+  return { ret, errCode, errMsg };
+}
+function parseCodeFromText(text2, pattern) {
+  const match = text2.match(pattern);
+  if (!match) {
+    return void 0;
+  }
+  const parsed = Number(match[1]);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function parseErrMsgFromText(text2) {
+  const match = text2.match(/errmsg=([^\n]+)$/i);
+  return (match?.[1] ?? text2).trim();
+}
+
+// src/modules/client/weixin/adapter/weixin-session.ts
+function buildWeixinSessionId(chatType, chatId) {
+  if (chatType === "dm") {
+    return `weixin:dm:${chatId}`;
+  }
+  if (chatType === "group") {
+    return `weixin:group:${chatId}`;
+  }
+  throw new Error(`Unsupported Weixin chat type: ${chatType}`);
+}
+function parseWeixinSessionId(clientSessionId) {
+  if (clientSessionId.startsWith("weixin:dm:")) {
+    return { platform: "weixin", chatType: "dm", chatId: clientSessionId.slice("weixin:dm:".length) };
+  }
+  if (clientSessionId.startsWith("weixin:group:")) {
+    return { platform: "weixin", chatType: "group", chatId: clientSessionId.slice("weixin:group:".length) };
+  }
+  throw new Error(`Unsupported clientSessionId: ${clientSessionId}`);
+}
+
+// src/modules/client/weixin/adapter/weixin-im-adapter.ts
+var MAX_TEXT_CHUNK3 = 2e3;
+var PROGRESS_INTERVAL_MS = 6e4;
+var MESSAGE_DEDUP_TTL_MS = 5 * 6e4;
+var TYPING_REFRESH_INTERVAL_MS = 1e4;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var RATE_LIMIT_THRESHOLD = 2;
+var RATE_LIMIT_COOLDOWN_MS = 6e4;
+function chunkText3(text2, maxLen) {
+  if (text2.length <= maxLen) return [text2];
+  const chunks = [];
+  let remaining = text2;
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLen) {
+      chunks.push(remaining);
+      break;
+    }
+    let splitPos = remaining.lastIndexOf("\n", maxLen);
+    if (splitPos <= 0) {
+      splitPos = remaining.lastIndexOf(" ", maxLen);
+    }
+    if (splitPos <= 0) {
+      chunks.push(remaining.slice(0, maxLen));
+      remaining = remaining.slice(maxLen);
+      continue;
+    }
+    chunks.push(remaining.slice(0, splitPos + 1));
+    remaining = remaining.slice(splitPos + 1);
+  }
+  return chunks.filter((chunk) => chunk.length > 0);
+}
+var WeixinIMAdapter = class {
+  #config;
+  #logger;
+  #onOutput = null;
+  #client = null;
+  #egressQueue = [];
+  #processing = false;
+  #progressStateBySession = /* @__PURE__ */ new Map();
+  #typingHeartbeatBySession = /* @__PURE__ */ new Map();
+  #recentInboundMessageIds = /* @__PURE__ */ new Map();
+  #recentInboundContentKeys = /* @__PURE__ */ new Map();
+  #rateLimitEvents = [];
+  #rateLimitCircuitUntil = 0;
+  constructor(config, logger3 = createLogger("weixin")) {
+    this.#config = config;
+    this.#logger = logger3;
+  }
+  async start(onOutput) {
+    this.#onOutput = onOutput;
+    this.#client = new WeixinClient(this.#config, this.#logger);
+    this.#client.setOnMessage(async ({ chatId, chatType, text: text2, messageId }) => {
+      if (!this.#onOutput) {
+        this.#logger.warn(`dropping inbound message, adapter not ready (chatId=${chatId})`);
+        return;
+      }
+      const clientSessionId = buildWeixinSessionId(chatType, chatId);
+      if (this.#isDuplicateInbound(chatId, messageId, text2)) {
+        this.#logger.debug(
+          `dropping duplicate inbound message (session=${clientSessionId} messageId=${messageId})`
+        );
+        return;
+      }
+      if (chatType === "group") {
+        this.#logger.debug(`ignoring unsupported Weixin group message (session=${clientSessionId})`);
+        return;
+      }
+      this.#resetProgressState(clientSessionId);
+      const normalizedText = text2.trim();
+      const commandEvent = parseSlashCommand(normalizedText, clientSessionId);
+      if (commandEvent) {
+        await this.#onOutput(commandEvent);
+        return;
+      }
+      await this.#client?.sendTyping(chatId);
+      this.#startTypingHeartbeat(clientSessionId, chatId);
+      await this.#onOutput({
+        type: "user.message",
+        clientSessionId,
+        text: text2
+      });
+    });
+    await this.#client.connect();
+    this.#logger.info(`adapter started (baseUrl=${this.#config.baseUrl ?? "https://ilinkai.weixin.qq.com"})`);
+  }
+  async stop() {
+    this.#egressQueue.length = 0;
+    for (const state of this.#progressStateBySession.values()) {
+      if (state.interval) {
+        clearInterval(state.interval);
+      }
+    }
+    this.#progressStateBySession.clear();
+    for (const timer of this.#typingHeartbeatBySession.values()) {
+      clearInterval(timer);
+    }
+    this.#typingHeartbeatBySession.clear();
+    if (this.#client) {
+      await this.#client.disconnect();
+      this.#client = null;
+    }
+    this.#processing = false;
+    this.#onOutput = null;
+    this.#logger.info("adapter stopped");
+  }
+  async input(event) {
+    if (!this.#client) {
+      throw new Error("WeixinIMAdapter is not started");
+    }
+    this.#egressQueue.push(event);
+    await this.#drainEgressQueue();
+  }
+  async isBusy() {
+    return this.#processing || this.#egressQueue.length > 0;
+  }
+  async #drainEgressQueue() {
+    if (this.#processing) {
+      return;
+    }
+    this.#processing = true;
+    try {
+      while (this.#client && this.#egressQueue.length > 0) {
+        const event = this.#egressQueue.shift();
+        if (!event) continue;
+        try {
+          const target = parseWeixinSessionId(event.clientSessionId);
+          if (event.type === "$progress.flush") {
+            await this.#flushProgressSummary(target.chatId, event.clientSessionId);
+            continue;
+          }
+          if (event.type !== "assistant.message") {
+            this.#recordProgressEvent(event);
+            continue;
+          }
+          this.#stopProgressTimer(event.clientSessionId);
+          if (event.text.trim().length > 0) {
+            const chunks = chunkText3(event.text, MAX_TEXT_CHUNK3);
+            for (const chunk of chunks) {
+              await this.#sendTextWithProtection(target.chatId, chunk);
+            }
+          }
+          for (const attachment of event.attachments ?? []) {
+            try {
+              await this.#client.sendAttachment(target.chatId, attachment);
+            } catch (attachmentError) {
+              this.#logger.error("failed to send attachment:", attachmentError);
+              await this.#notifySendFailure(target.chatId, attachmentError);
+            }
+          }
+          this.#stopTypingHeartbeat(event.clientSessionId);
+          await this.#client.stopTyping(target.chatId);
+        } catch (error) {
+          this.#logger.error("failed to send egress event:", error);
+          try {
+            const target = parseWeixinSessionId(event.clientSessionId);
+            this.#stopTypingHeartbeat(event.clientSessionId);
+            await this.#client.stopTyping(target.chatId);
+            await this.#notifySendFailure(target.chatId, error);
+          } catch (notifyError) {
+            this.#logger.error("failed to handle egress send failure:", notifyError);
+          }
+        }
+      }
+    } finally {
+      this.#processing = false;
+    }
+  }
+  #startTypingHeartbeat(clientSessionId, chatId) {
+    this.#stopTypingHeartbeat(clientSessionId);
+    const timer = setInterval(() => {
+      void this.#client?.sendTyping(chatId);
+    }, TYPING_REFRESH_INTERVAL_MS);
+    timer.unref?.();
+    this.#typingHeartbeatBySession.set(clientSessionId, timer);
+  }
+  #stopTypingHeartbeat(clientSessionId) {
+    const timer = this.#typingHeartbeatBySession.get(clientSessionId);
+    if (!timer) {
+      return;
+    }
+    clearInterval(timer);
+    this.#typingHeartbeatBySession.delete(clientSessionId);
+  }
+  async #notifySendFailure(chatId, error) {
+    if (!this.#client) {
+      return;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const text2 = `[agent-bridge error] Message delivery failed
+
+${message}`;
+    try {
+      await this.#client.sendText(chatId, text2);
+    } catch (notifyError) {
+      this.#logger.error("failed to notify send failure:", notifyError);
+    }
+  }
+  async #sendTextWithProtection(chatId, text2) {
+    if (!this.#client) {
+      throw new Error("WeixinIMAdapter is not started");
+    }
+    const now = Date.now();
+    if (this.#rateLimitCircuitUntil > now) {
+      throw new Error("Weixin send is cooling down after rate limiting. Please try again shortly.");
+    }
+    if (this.#rateLimitCircuitUntil !== 0 && this.#rateLimitCircuitUntil <= now) {
+      this.#rateLimitCircuitUntil = 0;
+      this.#rateLimitEvents = [];
+    }
+    try {
+      await this.#client.sendText(chatId, text2);
+      this.#resetRateLimitState();
+    } catch (error) {
+      if (this.#isStaleSessionError(error)) {
+        throw error;
+      }
+      if (this.#isRateLimitError(error)) {
+        this.#recordRateLimitEvent(now);
+        if (this.#rateLimitCircuitUntil > now) {
+          throw new Error("Weixin send is cooling down after rate limiting. Please try again shortly.");
+        }
+      }
+      throw error;
+    }
+  }
+  #recordProgressEvent(event) {
+    const state = this.#progressStateBySession.get(event.clientSessionId) ?? this.#createProgressState();
+    this.#progressStateBySession.set(event.clientSessionId, state);
+    if (!state.renderer.isProgressEvent(event)) {
+      return;
+    }
+    state.renderer.takeProgressEvent(event);
+    state.dirty = true;
+  }
+  async #flushProgressSummary(chatId, clientSessionId) {
+    const state = this.#progressStateBySession.get(clientSessionId);
+    if (!state || !state.dirty || !this.#client) {
+      return;
+    }
+    await this.#sendTextWithProtection(chatId, state.renderer.getCurrentProgress().markdown);
+    state.dirty = false;
+  }
+  #queueProgressFlush(clientSessionId) {
+    this.#egressQueue.push({ type: "$progress.flush", clientSessionId });
+    void this.#drainEgressQueue();
+  }
+  #createProgressState() {
+    return {
+      renderer: new ProgressRenderer(),
+      dirty: false,
+      interval: null
+    };
+  }
+  #resetProgressState(clientSessionId) {
+    const previous = this.#progressStateBySession.get(clientSessionId);
+    if (previous?.interval) {
+      clearInterval(previous.interval);
+    }
+    const state = this.#createProgressState();
+    state.interval = setInterval(() => {
+      this.#queueProgressFlush(clientSessionId);
+    }, PROGRESS_INTERVAL_MS);
+    state.interval.unref?.();
+    this.#progressStateBySession.set(clientSessionId, state);
+  }
+  #stopProgressTimer(clientSessionId) {
+    const state = this.#progressStateBySession.get(clientSessionId);
+    if (!state) {
+      return;
+    }
+    if (state.interval) {
+      clearInterval(state.interval);
+    }
+    this.#progressStateBySession.delete(clientSessionId);
+  }
+  #isDuplicateInbound(chatId, messageId, text2) {
+    const now = Date.now();
+    this.#pruneDedupState(now);
+    if (messageId) {
+      const existing = this.#recentInboundMessageIds.get(messageId);
+      if (existing && now - existing < MESSAGE_DEDUP_TTL_MS) {
+        return true;
+      }
+      this.#recentInboundMessageIds.set(messageId, now);
+    }
+    const normalizedText = text2.trim();
+    if (!normalizedText) {
+      return false;
+    }
+    const contentKey = `${chatId}:${normalizedText}`;
+    const existingContent = this.#recentInboundContentKeys.get(contentKey);
+    if (existingContent && now - existingContent < MESSAGE_DEDUP_TTL_MS) {
+      return true;
+    }
+    this.#recentInboundContentKeys.set(contentKey, now);
+    return false;
+  }
+  #pruneDedupState(now) {
+    for (const [messageId, seenAt] of this.#recentInboundMessageIds) {
+      if (now - seenAt >= MESSAGE_DEDUP_TTL_MS) {
+        this.#recentInboundMessageIds.delete(messageId);
+      }
+    }
+    for (const [contentKey, seenAt] of this.#recentInboundContentKeys) {
+      if (now - seenAt >= MESSAGE_DEDUP_TTL_MS) {
+        this.#recentInboundContentKeys.delete(contentKey);
+      }
+    }
+  }
+  #recordRateLimitEvent(now) {
+    this.#rateLimitEvents = this.#rateLimitEvents.filter(
+      (timestamp2) => now - timestamp2 < RATE_LIMIT_WINDOW_MS
+    );
+    this.#rateLimitEvents.push(now);
+    if (this.#rateLimitEvents.length >= RATE_LIMIT_THRESHOLD) {
+      this.#rateLimitCircuitUntil = now + RATE_LIMIT_COOLDOWN_MS;
+    }
+  }
+  #resetRateLimitState() {
+    this.#rateLimitEvents = [];
+    this.#rateLimitCircuitUntil = 0;
+  }
+  #isRateLimitError(error) {
+    if (!(error instanceof Error)) {
+      return false;
+    }
+    const message = error.message.toLowerCase();
+    if (this.#isStaleSessionError(error)) {
+      return false;
+    }
+    return message.includes("frequency limit") || message.includes("rate limit") || message.includes("freq limit");
+  }
+  #isStaleSessionError(error) {
+    return error instanceof Error && error.name === "WeixinStaleSessionError";
+  }
+};
+
+// src/modules/client/weixin/adapter/weixin-qr-login.ts
+import { Client as OpenILinkClient2 } from "@openilink/openilink-sdk-node";
+async function loginWithWeixinQr(options = {}) {
+  const { baseUrl = "https://ilinkai.weixin.qq.com", timeoutMs } = options;
+  const renderQr = await loadQrRenderer();
+  const client = new OpenILinkClient2("", {
+    base_url: baseUrl
+  });
+  let lastQrUrl = "";
+  const result = await client.loginWithQr(
+    {
+      on_qrcode(url) {
+        lastQrUrl = url;
+        console.log("\n\u8BF7\u4F7F\u7528\u5FAE\u4FE1\u626B\u63CF\u4EE5\u4E0B\u4E8C\u7EF4\u7801\uFF1A");
+        try {
+          renderQr(url);
+        } catch (error) {
+          console.log(`\uFF08\u7EC8\u7AEF\u4E8C\u7EF4\u7801\u6E32\u67D3\u5931\u8D25: ${String(error)}\uFF09`);
+          console.log(url);
+        }
+      },
+      on_scanned() {
+        console.log("\n\u5DF2\u626B\u7801\uFF0C\u8BF7\u5728\u5FAE\u4FE1\u91CC\u786E\u8BA4...");
+      },
+      on_expired(attempt, maxAttempts) {
+        console.log(`
+\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F\uFF0C\u6B63\u5728\u5237\u65B0... (${attempt}/${maxAttempts})`);
+      }
+    },
+    timeoutMs
+  );
+  if (!result.connected || !result.bot_id || !result.bot_token) {
+    throw new Error(`Weixin QR login failed: ${result.message || "unknown error"}`);
+  }
+  const resolvedBaseUrl = result.base_url || baseUrl;
+  console.log(`
+\u5FAE\u4FE1\u8FDE\u63A5\u6210\u529F\uFF0CaccountId=${result.bot_id}`);
+  if (!lastQrUrl) {
+    console.log("\u63D0\u793A\uFF1A\u5982\u9700\u91CD\u65B0\u767B\u5F55\uFF0C\u53EF\u518D\u6B21\u89E6\u53D1\u4E8C\u7EF4\u7801\u767B\u5F55\u6D41\u7A0B\u3002");
+  }
+  return {
+    accountId: result.bot_id,
+    token: result.bot_token,
+    baseUrl: resolvedBaseUrl
+  };
+}
+async function loadQrRenderer() {
+  const mod = await import("qrcode-terminal");
+  const api = mod.default ?? mod;
+  if (typeof api.generate !== "function") {
+    throw new Error("qrcode-terminal generate() is unavailable");
+  }
+  return (data) => {
+    api.generate?.(data, { small: true });
+    console.log("\n\u4E8C\u7EF4\u7801\u94FE\u63A5\uFF1A");
+    console.log(data);
+  };
+}
+
+// src/modules/client/weixin/index.ts
+var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+var DEFAULT_CDN_BASE_URL = "https://novac2c.cdn.weixin.qq.com/c2c";
+function createWeixinConfigCollector() {
+  return {
+    async collect(_ctx) {
+      const qrCreds = await loginWithWeixinQr({ baseUrl: DEFAULT_BASE_URL });
+      return {
+        accountId: qrCreds.accountId,
+        token: qrCreds.token,
+        baseUrl: qrCreds.baseUrl,
+        cdnBaseUrl: DEFAULT_CDN_BASE_URL
+      };
+    },
+    validate(config) {
+      if (!config.accountId.trim()) {
+        throw new Error("Weixin accountId is required");
+      }
+      if (!config.token.trim()) {
+        throw new Error("Weixin token is required");
+      }
+      if (config.baseUrl && !/^https?:\/\//.test(config.baseUrl)) {
+        throw new Error("Weixin baseUrl must start with http:// or https://");
+      }
+      if (config.cdnBaseUrl && !/^https?:\/\//.test(config.cdnBaseUrl)) {
+        throw new Error("Weixin cdnBaseUrl must start with http:// or https://");
+      }
+    },
+    summarize(config) {
+      const masked = config.accountId.length > 8 ? `${config.accountId.slice(0, 4)}****${config.accountId.slice(-4)}` : "****";
+      return `type=weixin accountId=${masked} baseUrl=${config.baseUrl ?? DEFAULT_BASE_URL}`;
+    }
+  };
+}
+var weixinClientModule = {
+  type: "weixin",
+  createConfigCollector: createWeixinConfigCollector,
+  createClientAdapter(config) {
+    return new WeixinIMAdapter(config);
+  }
+};
+
 // src/modules/client/index.ts
 var registry2 = /* @__PURE__ */ new Map([
-  [feishuClientModule.type, feishuClientModule]
+  [feishuClientModule.type, feishuClientModule],
+  [wecomClientModule.type, wecomClientModule],
+  [weixinClientModule.type, weixinClientModule]
 ]);
 function listClientModules() {
   return [...registry2.values()];
@@ -1995,7 +3497,7 @@ async function startChannel(channelName) {
 }
 async function runCli(argv = process2.argv) {
   const program = new Command();
-  program.name("agent-bridge").description("IM to Pi bridge CLI").version("0.1.0");
+  program.name("agent-bridge").description("IM to Agent bridge CLI").version("0.1.0");
   program.command("add").description("Interactively add a channel").action(async () => {
     const config = await loadConfig();
     await addChannel(config);