@gloablehive/celphone-wechat-plugin 1.0.1 → 1.1.1

package/dist/index.js

@@ -3,6 +3,11 @@
  *
  * WorkPhone WeChat Plugin - enables OpenClaw to send/receive WeChat messages
  * through the WorkPhone API platform.
+ *
+ * Multi-account support:
+ * - Each account in accounts[] can bind to a different agent
+ * - Webhook routing uses AccountRegistry to find agentId
+ * - cfg is passed to handleInboundMessage for cache isolation
  */
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
 import { celPhoneWeChatPlugin, handleInboundMessage } from "./src/channel.js";
@@ -35,6 +40,8 @@ export default defineChannelPluginEntry({
             auth: "plugin", // Plugin-managed auth - verify signatures yourself
             handler: async (req, res) => {
                 try {
+                    // Get config from request (provided by OpenClaw framework)
+                    const cfg = req.cfg;
                     // Parse the webhook payload
                     // The exact format depends on WorkPhone's webhook configuration
                     const payload = req.body;
@@ -46,8 +53,8 @@ export default defineChannelPluginEntry({
                         res.end("Missing signature");
                         return true;
                     }
-                    // Handle the inbound message
-                    await handleInboundMessage(api, payload);
+                    // Handle the inbound message with cfg for multi-account routing
+                    await handleInboundMessage(api, payload, cfg);
                     res.statusCode = 200;
                     res.end("ok");
                     return true;

package/dist/src/channel.js

@@ -9,21 +9,50 @@
  * The agent communicates with ALL friends and groups under that WeChat account,
  * not just one DM context. This is "human mode" vs "bot mode".
  *
- * Includes Local Cache:
- * - Per-account, per-user/conversation MD files
- * - YAML frontmatter (aligned with Claude Code)
- * - MEMORY.md indexing
- * - 4-layer compression
- * - AI summary extraction
- * - SAAS connectivity + offline fallback
- * - Cloud sync
+ * Multi-account support:
+ * - Config supports accounts array with per-account credentials
+ * - Each account can be bound to a different agent
+ * - Security policies are per-account isolated
  */
 import { createChatChannelPlugin, createChannelPluginBase, } from "openclaw/plugin-sdk/core";
-import { createWorkPhoneClient } from "./client.js";
 // Import cache modules from shared package
-import { createCacheManager, } from "@gloablehive/wechat-cache";
+import { createCacheManager, createAccountRegistry, } from "@gloablehive/wechat-cache";
+// Import client pool
+import { getWorkPhoneClient, createClientConfig } from "./client-pool.js";
 // Cache manager instance (lazy initialized)
 let cacheManager = null;
+let cacheManagerReady = null;
+// Account registry for routing
+let accountRegistry = null;
+/**
+ * Get or create account registry
+ */
+function getAccountRegistry() {
+    if (!accountRegistry) {
+        accountRegistry = createAccountRegistry();
+    }
+    return accountRegistry;
+}
+/**
+ * Initialize account registry from config
+ */
+function initializeRegistry(cfg) {
+    const registry = getAccountRegistry();
+    registry.clear();
+    const section = cfg.channels?.["celphone-wechat"];
+    const accounts = (section?.accounts || []);
+    // Register each account
+    for (const account of accounts) {
+        if (account.enabled !== false) {
+            const registeredAccount = {
+                ...account,
+                channelType: "celphone-wechat",
+                registeredAt: Date.now(),
+            };
+            registry.register(registeredAccount);
+        }
+    }
+}
 /**
  * Get or create cache manager
  */
@@ -42,11 +71,23 @@ function getCacheManager(cfg) {
             enabled: true,
         });
     }
+    // Initialize registry with accounts
+    initializeRegistry(cfg);
     const basePath = globalThis?.process?.env?.OPENCLAW_CACHE_PATH
         || "~/.openclaw/channels/celphone-wechat";
+    // Build knowledge config if provided in section
+    let knowledgeConfig;
+    if (section?.knowledge) {
+        knowledgeConfig = {
+            ...section.knowledge,
+            nodeId: section.knowledge.nodeId || 'celphone-wechat-node',
+            agentId: section.knowledge.agentId || section.agentId || 'default-agent',
+        };
+    }
     cacheManager = createCacheManager({
         basePath,
         accounts,
+        knowledgeConfig,
         saasConfig: section?.saas ? {
             apiBaseUrl: section.saas.apiBaseUrl,
             apiKey: section.saas.apiKey,
@@ -58,20 +99,62 @@ function getCacheManager(cfg) {
             syncIntervalMs: section.sync.syncIntervalMs || 5 * 60 * 1000,
         } : undefined,
     });
-    // Initialize cache manager
-    cacheManager.init().catch(err => {
+    // Initialize cache manager - await for ready state
+    cacheManagerReady = cacheManager.init().catch(err => {
         console.error("[CelPhoneWeChat] Cache manager init failed:", err);
+        throw err; // Re-throw so caller knows init failed
     });
     return cacheManager;
 }
+/**
+ * Get cache manager ready promise - await before processing messages
+ */
+export function getCacheManagerReady() {
+    return cacheManagerReady;
+}
+/**
+ * List all account IDs from config
+ */
+function listAccountIds(cfg) {
+    const section = cfg.channels?.["celphone-wechat"];
+    const accounts = (section?.accounts || []);
+    if (accounts.length > 0) {
+        return accounts.map(a => a.accountId).filter(Boolean);
+    }
+    // Backward compatibility: single account
+    if (section?.wechatAccountId) {
+        return [section.accountId || "default"];
+    }
+    return [];
+}
 /**
  * Resolve account from OpenClaw config
  *
- * Note: This is a "human account" model - the WeChat account represents
- * a real person with all their friends and groups, not a bot.
+ * Supports both multi-account (accounts array) and legacy (single) formats.
  */
 function resolveAccount(cfg, accountId) {
     const section = cfg.channels?.["celphone-wechat"];
+    const accounts = (section?.accounts || []);
+    // Multi-account mode: look up from accounts array
+    if (accounts.length > 0) {
+        const targetAccountId = accountId || accounts[0]?.accountId;
+        const account = accounts.find(a => a.accountId === targetAccountId);
+        if (!account) {
+            throw new Error(`celphone-wechat: account not found - ${targetAccountId}`);
+        }
+        return {
+            accountId: account.accountId,
+            agentId: account.agentId || null,
+            apiKey: account.apiKey || section?.apiKey || "",
+            baseUrl: account.baseUrl || section?.baseUrl || "https://api.workphone.example.com",
+            wechatAccountId: account.wechatAccountId,
+            wechatId: account.wechatId || account.wechatAccountId,
+            nickName: account.nickName || "WeChat User",
+            allowFrom: account.allowFrom ?? [],
+            dmPolicy: account.dmPolicy,
+        };
+    }
+    // Legacy single-account mode
     const apiKey = section?.apiKey;
     const baseUrl = section?.baseUrl || "https://api.workphone.example.com";
     const wechatAccountId = section?.wechatAccountId;
@@ -83,11 +166,12 @@ function resolveAccount(cfg, accountId) {
     }
     return {
         accountId: accountId ?? null,
+        agentId: null,
         apiKey,
         baseUrl,
         wechatAccountId,
-        wechatId: section?.wechatId || wechatAccountId, // Actual WeChat ID (wxid_xxx)
-        nickName: section?.nickName || "WeChat User", // Display name
+        wechatId: section?.wechatId || wechatAccountId,
+        nickName: section?.nickName || "WeChat User",
         allowFrom: section?.allowFrom ?? [],
         dmPolicy: section?.dmSecurity,
     };
@@ -122,27 +206,25 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
             channel: "celphone-wechat",
             sendText: async (params) => {
                 const cfg = params.cfg;
-                const section = cfg.channels?.["celphone-wechat"];
-                const client = createWorkPhoneClient({
-                    baseUrl: section?.baseUrl || "https://api.workphone.example.com",
-                    apiKey: section?.apiKey,
-                    accountId: section?.accountId || undefined,
-                    wechatAccountId: section?.wechatAccountId,
-                });
+                const accountId = params.accountId;
+                // Resolve account to get credentials
+                const account = resolveAccount(cfg, accountId);
+                // Use client pool for connection reuse
+                const clientConfig = createClientConfig(account.baseUrl, account.apiKey, account.accountId || undefined, account.wechatAccountId);
+                const client = getWorkPhoneClient(account.accountId || "default", clientConfig);
                 const isChatroom = params.to?.includes("@chatroom");
                 let result;
                 if (isChatroom) {
                     result = await client.sendChatroomMessage({
-                        wechatAccountId: section?.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         chatroomId: params.to,
                         content: params.text,
                         type: "text",
                     });
                 }
                 else {
-                    // Send to friend (DM)
                     result = await client.sendFriendMessage({
-                        wechatAccountId: section?.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         friendWechatId: params.to,
                         content: params.text,
                         type: "text",
@@ -150,41 +232,20 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
                 }
                 return { messageId: result.messageId };
             },
-            // Send media - also support both DM and group
             sendMedia: async (params) => {
                 const cfg = params.cfg;
-                const section = cfg.channels?.["celphone-wechat"];
-                const client = createWorkPhoneClient({
-                    baseUrl: section?.baseUrl || "https://api.workphone.example.com",
-                    apiKey: section?.apiKey,
-                    accountId: section?.accountId || undefined,
-                    wechatAccountId: section?.wechatAccountId,
-                });
+                const accountId = params.accountId;
+                // Resolve account to get credentials
+                const account = resolveAccount(cfg, accountId);
+                // Use client pool
+                const clientConfig = createClientConfig(account.baseUrl, account.apiKey, account.accountId || undefined, account.wechatAccountId);
+                const client = getWorkPhoneClient(account.accountId || "default", clientConfig);
                 const isChatroom = params.to?.includes("@chatroom");
-                // Get file path from mediaUrl or mediaReadFile
-                let filePath = "";
-                if (params.mediaUrl) {
-                    filePath = params.mediaUrl;
-                }
-                else if (params.mediaReadFile) {
-                    // Read file from local roots
-                    const roots = params.mediaLocalRoots || ["./"];
-                    for (const root of roots) {
-                        try {
-                            // Need to find the file path from the message
-                            // In practice, we'd need to look at the attachment info
-                            filePath = root;
-                            break;
-                        }
-                        catch {
-                            // Try next root
-                        }
-                    }
-                }
+                let filePath = params.mediaUrl || "";
                 let result;
                 if (isChatroom) {
                     result = await client.sendChatroomMessage({
-                        wechatAccountId: section?.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         chatroomId: params.to,
                         content: filePath,
                         type: "file",
@@ -192,7 +253,7 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
                 }
                 else {
                     result = await client.sendFriendMessage({
-                        wechatAccountId: section?.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         friendWechatId: params.to,
                         content: filePath,
                         type: "file",
@@ -202,8 +263,6 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
             },
         },
     },
-    // Additional capabilities
-    // - Describe the channel's message types and features
     capabilities: {
         supportedMessageTypes: [
             "text",
@@ -214,13 +273,13 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
             "location",
             "contact",
         ],
-        maxAttachmentSize: 25 * 1024 * 1024, // 25MB
-        supportsMarkdown: false, // WeChat uses a limited markup
+        maxAttachmentSize: 25 * 1024 * 1024,
+        supportsMarkdown: false,
         supportsHtml: false,
         supportsEmoji: true,
-        supportsReactions: false, // WeChat doesn't support reactions
-        supportsThreads: true, // Can reply in chat
-        supportsEditing: false, // Cannot edit sent messages
+        supportsReactions: false,
+        supportsThreads: true,
+        supportsEditing: false,
         supportsDeleting: false,
     },
 });
@@ -228,6 +287,10 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
  * Helper function to handle inbound webhook messages
  * This should be called from your HTTP route handler
  *
+ * Supports multi-account routing via AccountRegistry:
+ * - Looks up agentId from wechatAccountId
+ * - Dispatches to correct agent
+ *
  * Integrates with Cache Manager for:
  * - Local MD file caching
  * - User profile storage
@@ -243,6 +306,21 @@ export async function handleInboundMessage(api, payload, cfg) {
         const conversationId = isChatroom
             ? message.chatroomId
             : message.fromUser || message.toUser || "";
+        // Determine the account ID for this message
+        // Priority: payload.accountId > wechatAccountId lookup > "default"
+        const resolvedAccountId = accountId || wechatAccountId || "default";
+        // Look up agentId for routing
+        let agentId = null;
+        if (cfg) {
+            const registry = getAccountRegistry();
+            // Try by wechatAccountId first
+            agentId = registry.getAgentId(wechatAccountId || "");
+            // Fallback to accountId
+            if (!agentId && accountId) {
+                const regAccount = registry.getByAccountId(accountId);
+                agentId = regAccount?.agentId || null;
+            }
+        }
         // Convert to cache format and store locally
         if (cfg) {
             try {
@@ -250,7 +328,7 @@ export async function handleInboundMessage(api, payload, cfg) {
                 const wechatMessage = {
                     messageId: message.messageId,
                     msgSvrId: message.msgSvrId,
-                    accountId: accountId || "default",
+                    accountId: resolvedAccountId,
                     conversationType: isChatroom ? "chatroom" : "friend",
                     conversationId,
                     senderId: message.fromUser || "",
@@ -285,6 +363,8 @@ export async function handleInboundMessage(api, payload, cfg) {
             },
             timestamp: new Date(message.timestamp || Date.now()),
             isSelf: message.isSelf || false,
+            agentId, // Include agentId for routing
+            accountId: resolvedAccountId,
         };
         // Dispatch to OpenClaw
         await api.inbound.dispatchMessage(openclawMessage);
@@ -296,7 +376,7 @@ export async function handleInboundMessage(api, payload, cfg) {
             platformId: friendRequest.fromUser,
             scene: friendRequest.scene,
             ticket: friendRequest.ticket,
-            accountId,
+            accountId: accountId || wechatAccountId,
             wechatAccountId,
         });
     }

package/dist/src/client-pool.js

@@ -0,0 +1,82 @@
+/**
+ * Client Pool - Per-account client management
+ *
+ * Manages WorkPhone API clients per account to avoid creating
+ * new clients for each message and ensure credential isolation.
+ */
+import { WorkPhoneWeChatClient } from "./client.js";
+/**
+ * Client pool for WorkPhone WeChat clients
+ */
+class ClientPool {
+    clients = new Map();
+    /**
+     * Get or create a client for the given account
+     */
+    getClient(accountId, config) {
+        if (this.clients.has(accountId)) {
+            return this.clients.get(accountId);
+        }
+        const client = new WorkPhoneWeChatClient(config);
+        this.clients.set(accountId, client);
+        return client;
+    }
+    /**
+     * Check if client exists
+     */
+    hasClient(accountId) {
+        return this.clients.has(accountId);
+    }
+    /**
+     * Remove a client by accountId
+     */
+    removeClient(accountId) {
+        return this.clients.delete(accountId);
+    }
+    /**
+     * Clear all clients
+     */
+    clear() {
+        this.clients.clear();
+    }
+    /**
+     * Get all account IDs with active clients
+     */
+    getActiveAccountIds() {
+        return Array.from(this.clients.keys());
+    }
+    /**
+     * Get pool size
+     */
+    get size() {
+        return this.clients.size;
+    }
+}
+// Singleton instance
+let clientPool = null;
+/**
+ * Get or create the client pool singleton
+ */
+export function getClientPool() {
+    if (!clientPool) {
+        clientPool = new ClientPool();
+    }
+    return clientPool;
+}
+/**
+ * Get a client for a specific account
+ */
+export function getWorkPhoneClient(accountId, config) {
+    return getClientPool().getClient(accountId, config);
+}
+/**
+ * Create a client config from resolved account
+ */
+export function createClientConfig(baseUrl, apiKey, accountId, wechatAccountId) {
+    return {
+        baseUrl,
+        apiKey,
+        accountId,
+        wechatAccountId,
+    };
+}

package/index.ts

@@ -3,6 +3,11 @@
  *
  * WorkPhone WeChat Plugin - enables OpenClaw to send/receive WeChat messages
  * through the WorkPhone API platform.
+ *
+ * Multi-account support:
+ * - Each account in accounts[] can bind to a different agent
+ * - Webhook routing uses AccountRegistry to find agentId
+ * - cfg is passed to handleInboundMessage for cache isolation
  */
 
 import { defineChannelPluginEntry } from "openclaw/plugin-sdk/core";
@@ -42,6 +47,9 @@ export default defineChannelPluginEntry({
       auth: "plugin", // Plugin-managed auth - verify signatures yourself
       handler: async (req, res) => {
         try {
+          // Get config from request (provided by OpenClaw framework)
+          const cfg = (req as any).cfg;
+
           // Parse the webhook payload
           // The exact format depends on WorkPhone's webhook configuration
           const payload = (req as any).body;
@@ -55,8 +63,8 @@ export default defineChannelPluginEntry({
             return true;
           }
 
-          // Handle the inbound message
-          await handleInboundMessage(api, payload);
+          // Handle the inbound message with cfg for multi-account routing
+          await handleInboundMessage(api, payload, cfg);
 
           res.statusCode = 200;
           res.end("ok");

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@gloablehive/celphone-wechat-plugin",
-  "version": "1.0.1",
+  "version": "1.1.1",
   "type": "module",
-  "description": "OpenClaw channel plugin for workphone-wechat API - enables sending/receiving WeChat messages through workphone",
+  "description": "OpenClaw channel plugin for workphone-wechat API - enables sending/receiving WeChat messages through workphone. Supports multi-account with per-account agent binding.",
   "main": "index.ts",
   "scripts": {
     "test": "npx tsx test-cache.ts",
@@ -24,7 +24,7 @@
     }
   },
   "dependencies": {
-    "@gloablehive/wechat-cache": "^1.0.1",
+    "@gloablehive/wechat-cache": "file:../wechat-cache",
     "openclaw": ">=1.0.0"
   },
   "devDependencies": {

package/src/channel.ts

@@ -9,14 +9,10 @@
  * The agent communicates with ALL friends and groups under that WeChat account,
  * not just one DM context. This is "human mode" vs "bot mode".
  *
- * Includes Local Cache:
- * - Per-account, per-user/conversation MD files
- * - YAML frontmatter (aligned with Claude Code)
- * - MEMORY.md indexing
- * - 4-layer compression
- * - AI summary extraction
- * - SAAS connectivity + offline fallback
- * - Cloud sync
+ * Multi-account support:
+ * - Config supports accounts array with per-account credentials
+ * - Each account can be bound to a different agent
+ * - Security policies are per-account isolated
  */
 
 import {
@@ -24,7 +20,7 @@ import {
   createChannelPluginBase,
 } from "openclaw/plugin-sdk/core";
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { createWorkPhoneClient, type WebhookPayload } from "./client.js";
+import type { WebhookPayload } from "./client.js";
 
 // Import cache modules from shared package
 import {
@@ -32,10 +28,54 @@ import {
   CacheManager,
   WeChatAccount,
   WeChatMessage,
+  AccountRegistry,
+  createAccountRegistry,
+  type RegisteredAccount,
+  type KnowledgeConfig,
 } from "@gloablehive/wechat-cache";
 
+// Import client pool
+import { getWorkPhoneClient, createClientConfig, getClientPool } from "./client-pool.js";
+
 // Cache manager instance (lazy initialized)
 let cacheManager: CacheManager | null = null;
+let cacheManagerReady: Promise<void> | null = null;
+
+// Account registry for routing
+let accountRegistry: AccountRegistry | null = null;
+
+/**
+ * Get or create account registry
+ */
+function getAccountRegistry(): AccountRegistry {
+  if (!accountRegistry) {
+    accountRegistry = createAccountRegistry();
+  }
+  return accountRegistry;
+}
+
+/**
+ * Initialize account registry from config
+ */
+function initializeRegistry(cfg: OpenClawConfig): void {
+  const registry = getAccountRegistry();
+  registry.clear();
+
+  const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+  const accounts = (section?.accounts || []) as WeChatAccount[];
+
+  // Register each account
+  for (const account of accounts) {
+    if (account.enabled !== false) {
+      const registeredAccount: RegisteredAccount = {
+        ...account,
+        channelType: "celphone-wechat",
+        registeredAt: Date.now(),
+      };
+      registry.register(registeredAccount);
+    }
+  }
+}
 
 /**
  * Get or create cache manager
@@ -57,12 +97,26 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
     });
   }
 
+  // Initialize registry with accounts
+  initializeRegistry(cfg);
+
   const basePath = (globalThis as any)?.process?.env?.OPENCLAW_CACHE_PATH
     || "~/.openclaw/channels/celphone-wechat";
 
+  // Build knowledge config if provided in section
+  let knowledgeConfig: (Partial<KnowledgeConfig> & { nodeId: string; agentId: string }) | undefined;
+  if (section?.knowledge) {
+    knowledgeConfig = {
+      ...section.knowledge,
+      nodeId: section.knowledge.nodeId || 'celphone-wechat-node',
+      agentId: section.knowledge.agentId || section.agentId || 'default-agent',
+    };
+  }
+
   cacheManager = createCacheManager({
     basePath,
     accounts,
+    knowledgeConfig,
     saasConfig: section?.saas ? {
       apiBaseUrl: section.saas.apiBaseUrl,
       apiKey: section.saas.apiKey,
@@ -75,36 +129,88 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
     } : undefined,
   });
 
-  // Initialize cache manager
-  cacheManager.init().catch(err => {
+  // Initialize cache manager - await for ready state
+  cacheManagerReady = cacheManager.init().catch(err => {
     console.error("[CelPhoneWeChat] Cache manager init failed:", err);
+    throw err; // Re-throw so caller knows init failed
   });
 
   return cacheManager;
 }
 
+/**
+ * Get cache manager ready promise - await before processing messages
+ */
+export function getCacheManagerReady(): Promise<void> | null {
+  return cacheManagerReady;
+}
+
 export interface CelPhoneWeChatResolvedAccount {
   accountId: string | null;
+  agentId: string | null;
   apiKey: string;
   baseUrl: string;
-  wechatAccountId: string; // Required - which WeChat account this is
-  wechatId: string; // The actual WeChat ID (wxid_xxx)
-  nickName: string; // WeChat nickname for display
+  wechatAccountId: string;
+  wechatId: string;
+  nickName: string;
   allowFrom: string[];
   dmPolicy: string | undefined;
 }
 
+/**
+ * List all account IDs from config
+ */
+function listAccountIds(cfg: OpenClawConfig): string[] {
+  const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+  const accounts = (section?.accounts || []) as WeChatAccount[];
+
+  if (accounts.length > 0) {
+    return accounts.map(a => a.accountId).filter(Boolean);
+  }
+
+  // Backward compatibility: single account
+  if (section?.wechatAccountId) {
+    return [section.accountId || "default"];
+  }
+
+  return [];
+}
+
 /**
  * Resolve account from OpenClaw config
  *
- * Note: This is a "human account" model - the WeChat account represents
- * a real person with all their friends and groups, not a bot.
+ * Supports both multi-account (accounts array) and legacy (single) formats.
  */
 function resolveAccount(
   cfg: OpenClawConfig,
   accountId?: string | null
 ): CelPhoneWeChatResolvedAccount {
   const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+  const accounts = (section?.accounts || []) as WeChatAccount[];
+
+  // Multi-account mode: look up from accounts array
+  if (accounts.length > 0) {
+    const targetAccountId = accountId || accounts[0]?.accountId;
+    const account = accounts.find(a => a.accountId === targetAccountId);
+
+    if (!account) {
+      throw new Error(`celphone-wechat: account not found - ${targetAccountId}`);
+    }
+
+    return {
+      accountId: account.accountId,
+      agentId: account.agentId || null,
+      apiKey: account.apiKey || section?.apiKey || "",
+      baseUrl: account.baseUrl || section?.baseUrl || "https://api.workphone.example.com",
+      wechatAccountId: account.wechatAccountId,
+      wechatId: account.wechatId || account.wechatAccountId,
+      nickName: account.nickName || "WeChat User",
+      allowFrom: account.allowFrom ?? [],
+      dmPolicy: account.dmPolicy,
+    };
+  }
+
+  // Legacy single-account mode
   const apiKey = section?.apiKey;
   const baseUrl = section?.baseUrl || "https://api.workphone.example.com";
   const wechatAccountId = section?.wechatAccountId;
@@ -119,11 +225,12 @@ function resolveAccount(
 
   return {
     accountId: accountId ?? null,
+    agentId: null,
     apiKey,
     baseUrl,
     wechatAccountId,
-    wechatId: section?.wechatId || wechatAccountId, // Actual WeChat ID (wxid_xxx)
-    nickName: section?.nickName || "WeChat User", // Display name
+    wechatId: section?.wechatId || wechatAccountId,
+    nickName: section?.nickName || "WeChat User",
     allowFrom: section?.allowFrom ?? [],
     dmPolicy: section?.dmSecurity,
   };
@@ -162,29 +269,33 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
       channel: "celphone-wechat",
       sendText: async (params: any) => {
         const cfg = params.cfg;
-        const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+        const accountId = params.accountId;
 
-        const client = createWorkPhoneClient({
-          baseUrl: section?.baseUrl || "https://api.workphone.example.com",
-          apiKey: section?.apiKey,
-          accountId: section?.accountId || undefined,
-          wechatAccountId: section?.wechatAccountId,
-        });
+        // Resolve account to get credentials
+        const account = resolveAccount(cfg, accountId);
+
+        // Use client pool for connection reuse
+        const clientConfig = createClientConfig(
+          account.baseUrl,
+          account.apiKey,
+          account.accountId || undefined,
+          account.wechatAccountId
+        );
+        const client = getWorkPhoneClient(account.accountId || "default", clientConfig);
 
         const isChatroom = params.to?.includes("@chatroom");
 
         let result;
         if (isChatroom) {
           result = await client.sendChatroomMessage({
-            wechatAccountId: section?.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             chatroomId: params.to,
             content: params.text,
             type: "text",
           });
         } else {
-          // Send to friend (DM)
           result = await client.sendFriendMessage({
-            wechatAccountId: section?.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             friendWechatId: params.to,
             content: params.text,
             type: "text",
@@ -194,50 +305,37 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
         return { messageId: result.messageId };
       },
 
-      // Send media - also support both DM and group
       sendMedia: async (params: any) => {
         const cfg = params.cfg;
-        const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
+        const accountId = params.accountId;
+
+        // Resolve account to get credentials
+        const account = resolveAccount(cfg, accountId);
 
-        const client = createWorkPhoneClient({
-          baseUrl: section?.baseUrl || "https://api.workphone.example.com",
-          apiKey: section?.apiKey,
-          accountId: section?.accountId || undefined,
-          wechatAccountId: section?.wechatAccountId,
-        });
+        // Use client pool
+        const clientConfig = createClientConfig(
+          account.baseUrl,
+          account.apiKey,
+          account.accountId || undefined,
+          account.wechatAccountId
+        );
+        const client = getWorkPhoneClient(account.accountId || "default", clientConfig);
 
         const isChatroom = params.to?.includes("@chatroom");
 
-        // Get file path from mediaUrl or mediaReadFile
-        let filePath = "";
-        if (params.mediaUrl) {
-          filePath = params.mediaUrl;
-        } else if (params.mediaReadFile) {
-          // Read file from local roots
-          const roots = params.mediaLocalRoots || ["./"];
-          for (const root of roots) {
-            try {
-              // Need to find the file path from the message
-              // In practice, we'd need to look at the attachment info
-              filePath = root;
-              break;
-            } catch {
-              // Try next root
-            }
-          }
-        }
+        let filePath = params.mediaUrl || "";
 
         let result;
         if (isChatroom) {
           result = await client.sendChatroomMessage({
-            wechatAccountId: section?.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             chatroomId: params.to,
             content: filePath,
             type: "file",
           });
         } else {
           result = await client.sendFriendMessage({
-            wechatAccountId: section?.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             friendWechatId: params.to,
             content: filePath,
             type: "file",
@@ -249,8 +347,6 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
     },
   } as any,
 
-  // Additional capabilities
-  // - Describe the channel's message types and features
   capabilities: {
     supportedMessageTypes: [
       "text",
@@ -261,13 +357,13 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
       "location",
       "contact",
     ],
-    maxAttachmentSize: 25 * 1024 * 1024, // 25MB
-    supportsMarkdown: false, // WeChat uses a limited markup
+    maxAttachmentSize: 25 * 1024 * 1024,
+    supportsMarkdown: false,
     supportsHtml: false,
     supportsEmoji: true,
-    supportsReactions: false, // WeChat doesn't support reactions
-    supportsThreads: true, // Can reply in chat
-    supportsEditing: false, // Cannot edit sent messages
+    supportsReactions: false,
+    supportsThreads: true,
+    supportsEditing: false,
     supportsDeleting: false,
   },
 } as any);
@@ -276,6 +372,10 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
  * Helper function to handle inbound webhook messages
  * This should be called from your HTTP route handler
  *
+ * Supports multi-account routing via AccountRegistry:
+ * - Looks up agentId from wechatAccountId
+ * - Dispatches to correct agent
+ *
  * Integrates with Cache Manager for:
  * - Local MD file caching
  * - User profile storage
@@ -297,6 +397,23 @@ export async function handleInboundMessage(
       ? (message as any).chatroomId
       : message.fromUser || message.toUser || "";
 
+    // Determine the account ID for this message
+    // Priority: payload.accountId > wechatAccountId lookup > "default"
+    const resolvedAccountId = accountId || wechatAccountId || "default";
+
+    // Look up agentId for routing
+    let agentId: string | null = null;
+    if (cfg) {
+      const registry = getAccountRegistry();
+      // Try by wechatAccountId first
+      agentId = registry.getAgentId(wechatAccountId || "");
+      // Fallback to accountId
+      if (!agentId && accountId) {
+        const regAccount = registry.getByAccountId(accountId);
+        agentId = regAccount?.agentId || null;
+      }
+    }
+
     // Convert to cache format and store locally
     if (cfg) {
       try {
@@ -304,7 +421,7 @@ export async function handleInboundMessage(
         const wechatMessage: WeChatMessage = {
           messageId: message.messageId,
           msgSvrId: message.msgSvrId,
-          accountId: accountId || "default",
+          accountId: resolvedAccountId,
           conversationType: isChatroom ? "chatroom" : "friend",
           conversationId,
           senderId: message.fromUser || "",
@@ -339,6 +456,8 @@ export async function handleInboundMessage(
       },
       timestamp: new Date(message.timestamp || Date.now()),
       isSelf: message.isSelf || false,
+      agentId, // Include agentId for routing
+      accountId: resolvedAccountId,
     };
 
     // Dispatch to OpenClaw
@@ -350,7 +469,7 @@ export async function handleInboundMessage(
       platformId: friendRequest.fromUser,
       scene: friendRequest.scene,
       ticket: friendRequest.ticket,
-      accountId,
+      accountId: accountId || wechatAccountId,
       wechatAccountId,
     });
   }

package/src/client-pool.ts

@@ -0,0 +1,103 @@
+/**
+ * Client Pool - Per-account client management
+ *
+ * Manages WorkPhone API clients per account to avoid creating
+ * new clients for each message and ensure credential isolation.
+ */
+
+import { WorkPhoneWeChatClient, type WorkPhoneConfig } from "./client.js";
+
+/**
+ * Client pool for WorkPhone WeChat clients
+ */
+class ClientPool {
+  private clients: Map<string, WorkPhoneWeChatClient> = new Map();
+
+  /**
+   * Get or create a client for the given account
+   */
+  getClient(accountId: string, config: WorkPhoneConfig): WorkPhoneWeChatClient {
+    if (this.clients.has(accountId)) {
+      return this.clients.get(accountId)!;
+    }
+
+    const client = new WorkPhoneWeChatClient(config);
+    this.clients.set(accountId, client);
+    return client;
+  }
+
+  /**
+   * Check if client exists
+   */
+  hasClient(accountId: string): boolean {
+    return this.clients.has(accountId);
+  }
+
+  /**
+   * Remove a client by accountId
+   */
+  removeClient(accountId: string): boolean {
+    return this.clients.delete(accountId);
+  }
+
+  /**
+   * Clear all clients
+   */
+  clear(): void {
+    this.clients.clear();
+  }
+
+  /**
+   * Get all account IDs with active clients
+   */
+  getActiveAccountIds(): string[] {
+    return Array.from(this.clients.keys());
+  }
+
+  /**
+   * Get pool size
+   */
+  get size(): number {
+    return this.clients.size;
+  }
+}
+
+// Singleton instance
+let clientPool: ClientPool | null = null;
+
+/**
+ * Get or create the client pool singleton
+ */
+export function getClientPool(): ClientPool {
+  if (!clientPool) {
+    clientPool = new ClientPool();
+  }
+  return clientPool;
+}
+
+/**
+ * Get a client for a specific account
+ */
+export function getWorkPhoneClient(
+  accountId: string,
+  config: WorkPhoneConfig
+): WorkPhoneWeChatClient {
+  return getClientPool().getClient(accountId, config);
+}
+
+/**
+ * Create a client config from resolved account
+ */
+export function createClientConfig(
+  baseUrl: string,
+  apiKey: string,
+  accountId: string | undefined,
+  wechatAccountId: string | undefined
+): WorkPhoneConfig {
+  return {
+    baseUrl,
+    apiKey,
+    accountId,
+    wechatAccountId,
+  };
+}

package/test-integration.ts

@@ -11,7 +11,7 @@ import {
   createCacheManager,
   WeChatAccount,
   WeChatMessage,
-} from './src/cache/index.js';
+} from '@gloablehive/wechat-cache';
 import { handleInboundMessage } from './src/channel.js';
 
 const TEST_CACHE_PATH = '/tmp/wechat-integration-test';