@paean-ai/wechat-mcp 0.1.0 → 0.2.0

package/dist/daemon/server.js

@@ -221,18 +221,22 @@ var DaemonStore = class {
   agents = /* @__PURE__ */ new Map();
   defaultAgentId = null;
   startedAt = Date.now();
-  registerAgent(agentId, name) {
+  registerAgent(agentId, name, mode = "poll", gatewayUrl, gatewayType) {
     const existing = this.agents.get(agentId);
     if (existing) return existing.registration;
     const registration = {
       agentId,
       name: name || agentId,
+      mode,
+      gatewayUrl,
+      gatewayType,
       registeredAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     this.agents.set(agentId, {
       registration,
       messages: [],
-      waiters: []
+      waiters: [],
+      conversationIds: /* @__PURE__ */ new Map()
     });
     if (!this.defaultAgentId) {
       this.defaultAgentId = agentId;
@@ -256,6 +260,9 @@ var DaemonStore = class {
   getAgents() {
     return Array.from(this.agents.values()).map((s) => s.registration);
   }
+  getAgent(agentId) {
+    return this.agents.get(agentId)?.registration ?? null;
+  }
   getDefaultAgentId() {
     return this.defaultAgentId;
   }
@@ -265,6 +272,12 @@ var DaemonStore = class {
   getUptime() {
     return Date.now() - this.startedAt;
   }
+  getConversationId(agentId, senderId) {
+    return this.agents.get(agentId)?.conversationIds.get(senderId);
+  }
+  setConversationId(agentId, senderId, convId) {
+    this.agents.get(agentId)?.conversationIds.set(senderId, convId);
+  }
   /**
    * Push a message to a specific agent's queue.
    * If an agent has a waiting long-poll, resolve it immediately.
@@ -316,6 +329,18 @@ function parseMention(text) {
   }
   return { agent: match[1].toLowerCase(), rest: match[2] || "" };
 }
+function buildMessage(senderId, text, rawText, contextToken, targetAgent) {
+  return {
+    id: crypto2.randomBytes(8).toString("hex"),
+    senderId,
+    senderName: senderId.split("@")[0] || senderId,
+    text,
+    rawText,
+    contextToken,
+    targetAgent,
+    timestamp: Date.now()
+  };
+}
 function routeMessage(store2, senderId, text, contextToken) {
   const { agent, rest } = parseMention(text);
   let targetAgent = null;
@@ -328,20 +353,112 @@ function routeMessage(store2, senderId, text, contextToken) {
     strippedText = text;
   }
   if (!targetAgent) return null;
-  const message = {
-    id: crypto2.randomBytes(8).toString("hex"),
-    senderId,
-    senderName: senderId.split("@")[0] || senderId,
-    text: strippedText,
-    rawText: text,
-    contextToken,
-    targetAgent,
-    timestamp: Date.now()
-  };
+  const message = buildMessage(senderId, strippedText, text, contextToken, targetAgent);
+  const reg = store2.getAgent(targetAgent);
+  if (reg?.mode === "gateway") {
+    return message;
+  }
   store2.pushMessage(targetAgent, message);
   return message;
 }
 
+// src/daemon/adapters.ts
+async function readSSEStream(body, handler) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      handler(line);
+    }
+  }
+}
+var clawAdapter = {
+  name: "claw",
+  async send(gatewayUrl, message, signal, conversationId) {
+    const url = `${gatewayUrl.replace(/\/$/, "")}/api/chat`;
+    const body = { message };
+    if (conversationId) body.conversationId = conversationId;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Gateway error: HTTP ${res.status}`);
+    }
+    let fullContent = "";
+    let returnedConversationId;
+    await readSSEStream(res.body, (line) => {
+      if (!line.startsWith("data: ")) return;
+      try {
+        const event = JSON.parse(line.slice(6));
+        switch (event.type) {
+          case "start":
+            if (event.conversationId) returnedConversationId = event.conversationId;
+            break;
+          case "content":
+            fullContent += event.text || "";
+            break;
+          case "done":
+            if (event.content && !fullContent) fullContent = event.content;
+            break;
+        }
+      } catch {
+      }
+    });
+    return { content: fullContent, conversationId: returnedConversationId };
+  }
+};
+var openaiAdapter = {
+  name: "openai",
+  async send(gatewayUrl, message, signal) {
+    const url = `${gatewayUrl.replace(/\/$/, "")}/v1/chat/completions`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "default",
+        messages: [{ role: "user", content: message }],
+        stream: true
+      }),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Gateway error: HTTP ${res.status}`);
+    }
+    let fullContent = "";
+    await readSSEStream(res.body, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data: ") || trimmed === "data: [DONE]") return;
+      try {
+        const chunk = JSON.parse(trimmed.slice(6));
+        const delta = chunk.choices?.[0]?.delta;
+        if (delta?.content) {
+          fullContent += delta.content;
+        }
+      } catch {
+      }
+    });
+    return { content: fullContent };
+  }
+};
+function getAdapter(type) {
+  switch (type) {
+    case "openai":
+      return openaiAdapter;
+    case "claw":
+    default:
+      return clawAdapter;
+  }
+}
+
 // src/daemon/server.ts
 var store = new DaemonStore();
 var activeAccount = null;
@@ -391,8 +508,19 @@ async function handleRequest(req, res) {
         json(res, 400, { error: "agentId required" });
         return;
       }
-      const reg = store.registerAgent(body.agentId, body.name);
-      log(`Agent registered: ${reg.agentId} (${reg.name})`);
+      const mode = body.mode || "poll";
+      if (mode === "gateway" && !body.gatewayUrl) {
+        json(res, 400, { error: "gatewayUrl required for gateway mode" });
+        return;
+      }
+      const reg = store.registerAgent(
+        body.agentId,
+        body.name,
+        mode,
+        body.gatewayUrl,
+        body.gatewayType
+      );
+      log(`Agent registered: ${reg.agentId} (${reg.name}) mode=${reg.mode}${reg.gatewayUrl ? ` gateway=${reg.gatewayUrl}` : ""}`);
       json(res, 200, reg);
       return;
     }
@@ -461,6 +589,58 @@ async function handleRequest(req, res) {
     json(res, 500, { error: "internal error" });
   }
 }
+async function bridgeToGateway(agentId, senderId, text, contextToken) {
+  const reg = store.getAgent(agentId);
+  if (!reg?.gatewayUrl) {
+    log(`Gateway bridge failed: no gatewayUrl for ${agentId}`);
+    return;
+  }
+  const adapter = getAdapter(reg.gatewayType || "claw");
+  const conversationId = store.getConversationId(agentId, senderId);
+  log(`Gateway bridge: ${agentId} \u2192 ${reg.gatewayUrl} (${adapter.name})`);
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 12e4);
+    const result = await adapter.send(
+      reg.gatewayUrl,
+      text,
+      controller.signal,
+      conversationId
+    );
+    clearTimeout(timeout);
+    if (result.conversationId) {
+      store.setConversationId(agentId, senderId, result.conversationId);
+    }
+    if (result.content && activeAccount && contextToken) {
+      const preview = result.content.length > 80 ? result.content.slice(0, 80) + "..." : result.content;
+      log(`Gateway response: ${agentId} \u2192 ${senderId}: "${preview}"`);
+      for (let i = 0; i < result.content.length; i += MAX_WECHAT_MSG_LENGTH) {
+        await sendTextMessage(
+          activeAccount.baseUrl,
+          activeAccount.token,
+          senderId,
+          result.content.slice(i, i + MAX_WECHAT_MSG_LENGTH),
+          contextToken
+        );
+      }
+    }
+  } catch (err) {
+    const errMsg = err instanceof Error ? err.message : String(err);
+    log(`Gateway bridge error for ${agentId}: ${errMsg}`);
+    if (activeAccount && contextToken) {
+      try {
+        await sendTextMessage(
+          activeAccount.baseUrl,
+          activeAccount.token,
+          senderId,
+          `[${agentId}] Error: ${errMsg}`,
+          contextToken
+        );
+      } catch {
+      }
+    }
+  }
+}
 async function startPolling(account) {
   let buf = loadSyncBuf();
   let failures = 0;
@@ -501,6 +681,12 @@ async function startPolling(account) {
         const routed = routeMessage(store, senderId, text, contextToken);
         if (routed) {
           log(`Message routed: from=${senderId} agent=${routed.targetAgent} text="${text.slice(0, 50)}..."`);
+          const reg = routed.targetAgent ? store.getAgent(routed.targetAgent) : null;
+          if (reg?.mode === "gateway") {
+            bridgeToGateway(routed.targetAgent, senderId, routed.text, contextToken).catch((err) => {
+              log(`Gateway bridge async error: ${err instanceof Error ? err.message : String(err)}`);
+            });
+          }
         } else {
           log(`Message dropped (no agents): from=${senderId} text="${text.slice(0, 50)}..."`);
         }

package/dist/index.d.ts

@@ -50,9 +50,29 @@ interface GetUpdatesResp {
     get_updates_buf?: string;
     longpolling_timeout_ms?: number;
 }
+/**
+ * How messages are delivered to and processed by an agent:
+ *
+ *   channel  — Push via MCP notification (Claude Code's proprietary channel protocol).
+ *              Messages appear in the agent's active conversation.
+ *
+ *   gateway  — Daemon forwards message to the agent's HTTP endpoint (POST /api/chat)
+ *              and relays the SSE response back through WeChat. Like AnyClaw bridge.
+ *
+ *   poll     — Agent actively reads messages via the wechat_read_messages MCP tool.
+ *              Fallback for agents that support neither push nor HTTP gateway.
+ */
+type AgentMode = "channel" | "gateway" | "poll";
+/**
+ * For gateway-mode agents, which HTTP protocol the agent speaks.
+ */
+type GatewayType = "claw" | "openai";
 interface AgentRegistration {
     agentId: string;
     name: string;
+    mode: AgentMode;
+    gatewayUrl?: string;
+    gatewayType?: GatewayType;
     registeredAt: string;
 }
 interface RoutedMessage {
@@ -95,6 +115,14 @@ interface SendMessageResponse {
 interface PollMessagesResponse {
     messages: RoutedMessage[];
 }
+interface GatewaySendResult {
+    content: string;
+    conversationId?: string;
+}
+interface GatewayAdapter {
+    name: string;
+    send(gatewayUrl: string, message: string, signal?: AbortSignal, conversationId?: string): Promise<GatewaySendResult>;
+}
 
 /**
  * Unified WeChat iLink API Client
@@ -157,25 +185,50 @@ declare class DaemonClient {
     private request;
     health(): Promise<boolean>;
     status(): Promise<DaemonStatus>;
-    registerAgent(agentId: string, name?: string): Promise<AgentRegistration>;
+    registerAgent(agentId: string, name?: string, mode?: AgentMode, gatewayUrl?: string, gatewayType?: GatewayType): Promise<AgentRegistration>;
     unregisterAgent(agentId: string): Promise<{
         removed: boolean;
     }>;
     /**
      * Long-poll for messages intended for this agent.
-     * Will block up to ~30s on the daemon side.
+     * Will block up to ~30s on the daemon side by default.
+     * Pass a custom timeoutMs for shorter waits (e.g. 500 for non-blocking read).
      */
-    pollMessages(agentId: string): Promise<RoutedMessage[]>;
+    pollMessages(agentId: string, clientTimeoutMs?: number): Promise<RoutedMessage[]>;
     send(to: string, text: string, agentId: string): Promise<SendMessageResponse>;
     getContacts(): Promise<WechatContact[]>;
 }
 
+/**
+ * Gateway Adapters
+ *
+ * Protocol translators for different agent gateway types.
+ * Ported from AnyClaw bridge — each adapter knows how to POST a message
+ * to a local AI agent's HTTP endpoint and collect the response.
+ */
+
+/**
+ * Claw adapter (OpenClaw / 0claw / PaeanClaw / ZeroClaw / NanoClaw)
+ * All expose POST /api/chat with SSE response.
+ */
+declare const clawAdapter: GatewayAdapter;
+/**
+ * OpenAI-compatible adapter
+ * For any endpoint that speaks POST /v1/chat/completions with SSE.
+ */
+declare const openaiAdapter: GatewayAdapter;
+declare function getAdapter(type: GatewayType): GatewayAdapter;
+
 /**
  * Message Router
  *
  * Parses incoming WeChat messages for @agent_name mentions and routes
  * them to the appropriate agent. Messages without a mention go to the
  * default agent.
+ *
+ * For channel/poll-mode agents, messages are queued in the store.
+ * For gateway-mode agents, the message is returned without queuing —
+ * the daemon server handles the HTTP gateway bridge directly.
  */
 
 /**
@@ -188,8 +241,8 @@ declare function parseMention(text: string): {
     rest: string;
 };
 
-declare const PACKAGE_VERSION = "0.1.0";
+declare const PACKAGE_VERSION = "0.2.0";
 declare const DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
 declare const CONFIG_DIR: string;
 
-export { type AccountData, type AgentRegistration, CONFIG_DIR, DEFAULT_BASE_URL, DaemonClient, type DaemonInfo, type DaemonStatus, type GetUpdatesResp, PACKAGE_VERSION, type PollMessagesResponse, type QRCodeResponse, type QRStatusResponse, type RoutedMessage, type SendMessageRequest, type SendMessageResponse, type WechatContact, type WeixinMessage, checkDaemon, ensureDaemon, extractTextFromMessage, fetchQRCode, getContactToken, getUpdates, loadContacts, loadCredentials, parseMention, pollQRStatus, removeCredentials, saveContact, saveCredentials, sendTextMessage, stopDaemon };
+export { type AccountData, type AgentMode, type AgentRegistration, CONFIG_DIR, DEFAULT_BASE_URL, DaemonClient, type DaemonInfo, type DaemonStatus, type GatewayAdapter, type GatewaySendResult, type GatewayType, type GetUpdatesResp, PACKAGE_VERSION, type PollMessagesResponse, type QRCodeResponse, type QRStatusResponse, type RoutedMessage, type SendMessageRequest, type SendMessageResponse, type WechatContact, type WeixinMessage, checkDaemon, clawAdapter, ensureDaemon, extractTextFromMessage, fetchQRCode, getAdapter, getContactToken, getUpdates, loadContacts, loadCredentials, openaiAdapter, parseMention, pollQRStatus, removeCredentials, saveContact, saveCredentials, sendTextMessage, stopDaemon };

package/dist/index.js

@@ -4,7 +4,7 @@ import crypto from "crypto";
 // src/constants.ts
 import path from "path";
 import os from "os";
-var PACKAGE_VERSION = "0.1.0";
+var PACKAGE_VERSION = "0.2.0";
 var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
 var BOT_TYPE = "3";
 var CHANNEL_VERSION = "0.1.0";
@@ -382,22 +382,30 @@ var DaemonClient = class {
   async status() {
     return this.request("GET", "/status");
   }
-  async registerAgent(agentId, name) {
-    return this.request("POST", "/agents", { agentId, name });
+  async registerAgent(agentId, name, mode, gatewayUrl, gatewayType) {
+    return this.request("POST", "/agents", {
+      agentId,
+      name,
+      mode,
+      gatewayUrl,
+      gatewayType
+    });
   }
   async unregisterAgent(agentId) {
     return this.request("DELETE", `/agents/${encodeURIComponent(agentId)}`);
   }
   /**
    * Long-poll for messages intended for this agent.
-   * Will block up to ~30s on the daemon side.
+   * Will block up to ~30s on the daemon side by default.
+   * Pass a custom timeoutMs for shorter waits (e.g. 500 for non-blocking read).
    */
-  async pollMessages(agentId) {
+  async pollMessages(agentId, clientTimeoutMs) {
+    const path3 = clientTimeoutMs !== void 0 ? `/messages/${encodeURIComponent(agentId)}?timeout=${clientTimeoutMs}` : `/messages/${encodeURIComponent(agentId)}`;
     const resp = await this.request(
       "GET",
-      `/messages/${encodeURIComponent(agentId)}`,
+      path3,
       void 0,
-      35e3
+      Math.max(clientTimeoutMs ?? 35e3, 35e3)
     );
     return resp.messages;
   }
@@ -410,6 +418,103 @@ var DaemonClient = class {
   }
 };
 
+// src/daemon/adapters.ts
+async function readSSEStream(body, handler) {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      handler(line);
+    }
+  }
+}
+var clawAdapter = {
+  name: "claw",
+  async send(gatewayUrl, message, signal, conversationId) {
+    const url = `${gatewayUrl.replace(/\/$/, "")}/api/chat`;
+    const body = { message };
+    if (conversationId) body.conversationId = conversationId;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Gateway error: HTTP ${res.status}`);
+    }
+    let fullContent = "";
+    let returnedConversationId;
+    await readSSEStream(res.body, (line) => {
+      if (!line.startsWith("data: ")) return;
+      try {
+        const event = JSON.parse(line.slice(6));
+        switch (event.type) {
+          case "start":
+            if (event.conversationId) returnedConversationId = event.conversationId;
+            break;
+          case "content":
+            fullContent += event.text || "";
+            break;
+          case "done":
+            if (event.content && !fullContent) fullContent = event.content;
+            break;
+        }
+      } catch {
+      }
+    });
+    return { content: fullContent, conversationId: returnedConversationId };
+  }
+};
+var openaiAdapter = {
+  name: "openai",
+  async send(gatewayUrl, message, signal) {
+    const url = `${gatewayUrl.replace(/\/$/, "")}/v1/chat/completions`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: "default",
+        messages: [{ role: "user", content: message }],
+        stream: true
+      }),
+      signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`Gateway error: HTTP ${res.status}`);
+    }
+    let fullContent = "";
+    await readSSEStream(res.body, (line) => {
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("data: ") || trimmed === "data: [DONE]") return;
+      try {
+        const chunk = JSON.parse(trimmed.slice(6));
+        const delta = chunk.choices?.[0]?.delta;
+        if (delta?.content) {
+          fullContent += delta.content;
+        }
+      } catch {
+      }
+    });
+    return { content: fullContent };
+  }
+};
+function getAdapter(type) {
+  switch (type) {
+    case "openai":
+      return openaiAdapter;
+    case "claw":
+    default:
+      return clawAdapter;
+  }
+}
+
 // src/daemon/router.ts
 import crypto2 from "crypto";
 function parseMention(text) {
@@ -426,13 +531,16 @@ export {
   DaemonClient,
   PACKAGE_VERSION,
   checkDaemon,
+  clawAdapter,
   ensureDaemon,
   extractTextFromMessage,
   fetchQRCode,
+  getAdapter,
   getContactToken,
   getUpdates,
   loadContacts,
   loadCredentials,
+  openaiAdapter,
   parseMention,
   pollQRStatus,
   removeCredentials,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@paean-ai/wechat-mcp",
-  "version": "0.1.0",
-  "description": "WeChat MCP middleware — shared WeChat connection for multiple AI agents with @mention routing",
+  "version": "0.2.0",
+  "description": "WeChat MCP middleware — shared WeChat connection for multiple AI agents with @mention routing and multi-mode message delivery",
   "type": "module",
   "bin": {
     "wechat-mcp": "dist/cli.js"