@gloablehive/celphone-wechat-plugin 1.0.0 → 1.1.0

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;
@@ -61,15 +68,17 @@ export default defineChannelPluginEntry({
             },
         });
         // Register gateway method for outbound media handling
-        api.registerGatewayMethod({
-            method: "POST",
+        api.registerHttpRoute({
             path: "/celphone-wechat/media",
+            auth: "plugin",
             handler: async (req, res) => {
-                const { messageId, mediaUrl, mediaType } = req.body;
+                const payload = req.body;
+                const { messageId, mediaUrl, mediaType } = payload || {};
                 // Handle media upload/send through WorkPhone
                 // This is called when the bot needs to send media files
+                res.setHeader("Content-Type", "application/json");
                 res.statusCode = 200;
-                res.json({ success: true, messageId });
+                res.end(JSON.stringify({ success: true, messageId }));
                 return true;
             },
         });

package/dist/src/channel.js

@@ -9,21 +9,49 @@
  * 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
-import { createCacheManager, } from "./cache/index.js";
+// Import cache modules from shared package
+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;
+// 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
  */
@@ -35,15 +63,17 @@ function getCacheManager(cfg) {
     // If no accounts configured, create default from main config
     if (accounts.length === 0 && section?.wechatAccountId) {
         accounts.push({
-            accountId: section.accountId || 'default',
+            accountId: section.accountId || "default",
             wechatAccountId: section.wechatAccountId,
             wechatId: section.wechatId || section.wechatAccountId,
-            nickName: section.nickName || 'WeChat User',
+            nickName: section.nickName || "WeChat User",
             enabled: true,
         });
     }
+    // Initialize registry with accounts
+    initializeRegistry(cfg);
     const basePath = globalThis?.process?.env?.OPENCLAW_CACHE_PATH
-        || '~/.openclaw/channels/celphone-wechat';
+        || "~/.openclaw/channels/celphone-wechat";
     cacheManager = createCacheManager({
         basePath,
         accounts,
@@ -54,24 +84,59 @@ function getCacheManager(cfg) {
         } : undefined,
         syncConfig: section?.sync ? {
             databaseUrl: section.sync.databaseUrl,
-            syncMode: section.sync.syncMode || 'interval',
+            syncMode: section.sync.syncMode || "interval",
             syncIntervalMs: section.sync.syncIntervalMs || 5 * 60 * 1000,
         } : undefined,
     });
-    // Initialize cache manager
+    // Initialize cache manager - must await for ready state
     cacheManager.init().catch(err => {
-        console.error('[CelPhoneWeChat] Cache manager init failed:', err);
+        console.error("[CelPhoneWeChat] Cache manager init failed:", err);
     });
     return cacheManager;
 }
+/**
+ * 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 +148,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,
     };
@@ -99,115 +165,86 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
     base: createChannelPluginBase({
         id: "celphone-wechat",
         setup: {
-            resolveAccount,
-            inspectAccount(cfg, accountId) {
-                const section = cfg.channels?.["celphone-wechat"];
-                const hasApiKey = Boolean(section?.apiKey);
-                return {
-                    enabled: hasApiKey,
-                    configured: hasApiKey,
-                    tokenStatus: hasApiKey ? "available" : "missing",
-                };
+            resolveAccountId: (params) => {
+                return resolveAccount(params.cfg, params.accountId)?.accountId || "";
             },
+            applyAccountConfig: (params) => params.cfg,
         },
     }),
-    // DM security: who can message the bot
     security: {
         dm: {
             channelKey: "celphone-wechat",
             resolvePolicy: (account) => account.dmPolicy,
             resolveAllowFrom: (account) => account.allowFrom,
-            defaultPolicy: "allowlist", // Default to allowlist for security
+            defaultPolicy: "allowlist",
         },
     },
-    // Pairing: not currently supported for this channel
-    // WorkPhone WeChat doesn't have a standard pairing flow
-    // pairing: { ... },
-    // Threading: how replies are delivered
-    // For WeChat, replies go back to the same chat (friend or chatroom)
     threading: {
-        topLevelReplyToMode: "reply", // Reply to the last message in the thread
+        topLevelReplyToMode: "reply",
     },
-    // Outbound: send messages to WeChat via WorkPhone API
-    //
-    // HUMAN ACCOUNT MODEL IMPORTANT:
-    // This channel connects to a real person's WeChat account.
-    // The agent needs to communicate with ALL their friends and groups,
-    // not just one conversation. We distinguish by conversation type:
-    // - DM (direct): friendWechatId in params.to
-    // - Group chat: chatroomId in params.to (detect by format or metadata)
     outbound: {
+        channel: "celphone-wechat",
         attachedResults: {
-            // Send text - detect if DM or group based on conversation metadata
+            channel: "celphone-wechat",
             sendText: async (params) => {
-                const client = createWorkPhoneClient({
-                    baseUrl: params.account.baseUrl,
-                    apiKey: params.account.apiKey,
-                    accountId: params.account.accountId || undefined,
-                    wechatAccountId: params.account.wechatAccountId,
-                });
-                // Check if this is a group message (chatroom)
-                // Chatroom IDs typically start with certain prefix or have specific format
-                const isChatroom = params.metadata?.conversationType === 'group' ||
-                    (params.to && params.to.includes('@chatroom'));
+                const cfg = params.cfg;
+                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) {
-                    // Send to chatroom (group)
                     result = await client.sendChatroomMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         chatroomId: params.to,
                         content: params.text,
-                        type: 'text',
+                        type: "text",
                     });
                 }
                 else {
-                    // Send to friend (DM)
                     result = await client.sendFriendMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         friendWechatId: params.to,
                         content: params.text,
-                        type: 'text',
+                        type: "text",
                     });
                 }
                 return { messageId: result.messageId };
             },
-            // Send media - also support both DM and group
             sendMedia: async (params) => {
-                const client = createWorkPhoneClient({
-                    baseUrl: params.account.baseUrl,
-                    apiKey: params.account.apiKey,
-                    accountId: params.account.accountId || undefined,
-                    wechatAccountId: params.account.wechatAccountId,
-                });
-                const isChatroom = params.metadata?.conversationType === 'group' ||
-                    (params.to && params.to.includes('@chatroom'));
+                const cfg = params.cfg;
+                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");
+                let filePath = params.mediaUrl || "";
                 let result;
                 if (isChatroom) {
                     result = await client.sendChatroomMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         chatroomId: params.to,
-                        content: params.filePath || '',
-                        type: 'file',
+                        content: filePath,
+                        type: "file",
                     });
                 }
                 else {
                     result = await client.sendFriendMessage({
-                        wechatAccountId: params.account.wechatAccountId,
+                        wechatAccountId: account.wechatAccountId,
                         friendWechatId: params.to,
-                        content: params.filePath || '',
-                        type: 'file',
+                        content: filePath,
+                        type: "file",
                     });
                 }
                 return { messageId: result.messageId };
             },
         },
-        // Additional outbound handlers can be added here for:
-        // - sendLink: Send link cards
-        // - sendLocation: Send location
-        // - sendContact: Send contact card
     },
-    // Additional capabilities
-    // - Describe the channel's message types and features
     capabilities: {
         supportedMessageTypes: [
             "text",
@@ -218,20 +255,24 @@ 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
-        supportsDeleting: false, // Cannot delete sent messages
+        supportsReactions: false,
+        supportsThreads: true,
+        supportsEditing: false,
+        supportsDeleting: false,
     },
 });
 /**
  * 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
@@ -241,31 +282,48 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin({
  */
 export async function handleInboundMessage(api, payload, cfg) {
     const { event, accountId, wechatAccountId, message, friendRequest } = payload;
-    if (event === 'message' && message) {
+    if (event === "message" && message) {
         // Determine conversation type
         const isChatroom = !!message.chatroomId;
         const conversationId = isChatroom
             ? message.chatroomId
-            : message.fromUser || message.toUser || '';
+            : 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 (cacheManager && accountId) {
+        if (cfg) {
             try {
-                await cacheManager.onMessage({
+                const cache = getCacheManager(cfg);
+                const wechatMessage = {
                     messageId: message.messageId,
                     msgSvrId: message.msgSvrId,
-                    accountId: accountId,
-                    conversationType: isChatroom ? 'chatroom' : 'friend',
+                    accountId: resolvedAccountId,
+                    conversationType: isChatroom ? "chatroom" : "friend",
                     conversationId,
-                    senderId: message.fromUser || '',
+                    senderId: message.fromUser || "",
                     content: message.content,
                     messageType: message.type || 1,
                     timestamp: message.timestamp || Date.now(),
                     isSelf: message.isSelf || false,
-                    direction: message.isSelf ? 'outbound' : 'inbound',
-                });
+                    direction: message.isSelf ? "outbound" : "inbound",
+                };
+                await cache.onMessage(wechatMessage);
             }
             catch (err) {
-                console.error('[CelPhoneWeChat] Cache write failed:', err);
+                console.error("[CelPhoneWeChat] Cache write failed:", err);
             }
         }
         // Convert WorkPhone message format to OpenClaw format
@@ -273,32 +331,34 @@ export async function handleInboundMessage(api, payload, cfg) {
             id: message.messageId,
             rawId: message.msgSvrId || message.messageId,
             conversation: {
-                type: isChatroom ? 'group' : 'dm',
+                type: isChatroom ? "group" : "dm",
                 id: conversationId,
                 chatroomId: isChatroom ? conversationId : undefined,
             },
             sender: {
-                id: message.fromUser || '',
+                id: message.fromUser || "",
                 platformId: message.wechatId,
             },
             content: {
-                type: message.type === 1 ? 'text' : 'media',
+                type: message.type === 1 ? "text" : "media",
                 text: message.content,
             },
             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);
     }
-    else if (event === 'friend_request' && friendRequest) {
+    else if (event === "friend_request" && friendRequest) {
         // Handle friend request
         await api.inbound.dispatchFriendRequest({
             id: friendRequest.v1,
             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,9 +47,12 @@ 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.body;
+          const payload = (req as any).body;
 
           // Verify the request is from WorkPhone
           // Add signature verification here if needed
@@ -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");
@@ -71,17 +79,19 @@ export default defineChannelPluginEntry({
     });
 
     // Register gateway method for outbound media handling
-    api.registerGatewayMethod({
-      method: "POST",
+    api.registerHttpRoute({
       path: "/celphone-wechat/media",
+      auth: "plugin",
       handler: async (req, res) => {
-        const { messageId, mediaUrl, mediaType } = req.body;
+        const payload = (req as any).body;
+        const { messageId, mediaUrl, mediaType } = payload || {};
 
         // Handle media upload/send through WorkPhone
         // This is called when the bot needs to send media files
 
+        res.setHeader("Content-Type", "application/json");
         res.statusCode = 200;
-        res.json({ success: true, messageId });
+        res.end(JSON.stringify({ success: true, messageId }));
         return true;
       },
     });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@gloablehive/celphone-wechat-plugin",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "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.0",
+    "@gloablehive/wechat-cache": "^1.0.2",
     "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,18 +20,61 @@ 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 {
   createCacheManager,
   CacheManager,
   WeChatAccount,
+  WeChatMessage,
+  AccountRegistry,
+  createAccountRegistry,
+  type RegisteredAccount,
 } 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;
 
+// 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
  */
@@ -48,16 +87,19 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
   // If no accounts configured, create default from main config
   if (accounts.length === 0 && section?.wechatAccountId) {
     accounts.push({
-      accountId: section.accountId || 'default',
+      accountId: section.accountId || "default",
       wechatAccountId: section.wechatAccountId,
       wechatId: section.wechatId || section.wechatAccountId,
-      nickName: section.nickName || 'WeChat User',
+      nickName: section.nickName || "WeChat User",
       enabled: true,
     });
   }
 
+  // Initialize registry with accounts
+  initializeRegistry(cfg);
+
   const basePath = (globalThis as any)?.process?.env?.OPENCLAW_CACHE_PATH
-    || '~/.openclaw/channels/celphone-wechat';
+    || "~/.openclaw/channels/celphone-wechat";
 
   cacheManager = createCacheManager({
     basePath,
@@ -69,14 +111,14 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
     } : undefined,
     syncConfig: section?.sync ? {
       databaseUrl: section.sync.databaseUrl,
-      syncMode: section.sync.syncMode || 'interval',
+      syncMode: section.sync.syncMode || "interval",
       syncIntervalMs: section.sync.syncIntervalMs || 5 * 60 * 1000,
     } : undefined,
   });
 
-  // Initialize cache manager
+  // Initialize cache manager - must await for ready state
   cacheManager.init().catch(err => {
-    console.error('[CelPhoneWeChat] Cache manager init failed:', err);
+    console.error("[CelPhoneWeChat] Cache manager init failed:", err);
   });
 
   return cacheManager;
@@ -84,26 +126,70 @@ function getCacheManager(cfg: OpenClawConfig): CacheManager {
 
 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;
@@ -118,11 +204,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,
   };
@@ -135,126 +222,110 @@ export const celPhoneWeChatPlugin = createChatChannelPlugin<CelPhoneWeChatResolv
   base: createChannelPluginBase({
     id: "celphone-wechat",
     setup: {
-      resolveAccount,
-      inspectAccount(cfg, accountId) {
-        const section = (cfg.channels as Record<string, any>)?.["celphone-wechat"];
-        const hasApiKey = Boolean(section?.apiKey);
-        return {
-          enabled: hasApiKey,
-          configured: hasApiKey,
-          tokenStatus: hasApiKey ? "available" : "missing",
-        };
+      resolveAccountId: (params: any) => {
+        return resolveAccount(params.cfg, params.accountId)?.accountId || "";
       },
+      applyAccountConfig: (params) => params.cfg,
     },
-  }),
+  }) as any,
 
-  // DM security: who can message the bot
   security: {
     dm: {
       channelKey: "celphone-wechat",
       resolvePolicy: (account) => account.dmPolicy,
       resolveAllowFrom: (account) => account.allowFrom,
-      defaultPolicy: "allowlist", // Default to allowlist for security
+      defaultPolicy: "allowlist",
     },
   },
 
-  // Pairing: not currently supported for this channel
-  // WorkPhone WeChat doesn't have a standard pairing flow
-  // pairing: { ... },
-
-  // Threading: how replies are delivered
-  // For WeChat, replies go back to the same chat (friend or chatroom)
   threading: {
-    topLevelReplyToMode: "reply", // Reply to the last message in the thread
+    topLevelReplyToMode: "reply",
   },
 
-  // Outbound: send messages to WeChat via WorkPhone API
-  //
-  // HUMAN ACCOUNT MODEL IMPORTANT:
-  // This channel connects to a real person's WeChat account.
-  // The agent needs to communicate with ALL their friends and groups,
-  // not just one conversation. We distinguish by conversation type:
-  // - DM (direct): friendWechatId in params.to
-  // - Group chat: chatroomId in params.to (detect by format or metadata)
   outbound: {
+    channel: "celphone-wechat",
     attachedResults: {
-      // Send text - detect if DM or group based on conversation metadata
-      sendText: async (params) => {
-        const client = createWorkPhoneClient({
-          baseUrl: params.account.baseUrl,
-          apiKey: params.account.apiKey,
-          accountId: params.account.accountId || undefined,
-          wechatAccountId: params.account.wechatAccountId,
-        });
-
-        // Check if this is a group message (chatroom)
-        // Chatroom IDs typically start with certain prefix or have specific format
-        const isChatroom = params.metadata?.conversationType === 'group' ||
-                          (params.to && params.to.includes('@chatroom'));
+      channel: "celphone-wechat",
+      sendText: async (params: any) => {
+        const cfg = params.cfg;
+        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) {
-          // Send to chatroom (group)
           result = await client.sendChatroomMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             chatroomId: params.to,
             content: params.text,
-            type: 'text',
+            type: "text",
           });
         } else {
-          // Send to friend (DM)
           result = await client.sendFriendMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             friendWechatId: params.to,
             content: params.text,
-            type: 'text',
+            type: "text",
           });
         }
 
         return { messageId: result.messageId };
       },
 
-      // Send media - also support both DM and group
-      sendMedia: async (params) => {
-        const client = createWorkPhoneClient({
-          baseUrl: params.account.baseUrl,
-          apiKey: params.account.apiKey,
-          accountId: params.account.accountId || undefined,
-          wechatAccountId: params.account.wechatAccountId,
-        });
+      sendMedia: async (params: any) => {
+        const cfg = params.cfg;
+        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");
 
-        const isChatroom = params.metadata?.conversationType === 'group' ||
-                          (params.to && params.to.includes('@chatroom'));
+        let filePath = params.mediaUrl || "";
 
         let result;
         if (isChatroom) {
           result = await client.sendChatroomMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             chatroomId: params.to,
-            content: params.filePath || '',
-            type: 'file',
+            content: filePath,
+            type: "file",
           });
         } else {
           result = await client.sendFriendMessage({
-            wechatAccountId: params.account.wechatAccountId,
+            wechatAccountId: account.wechatAccountId,
             friendWechatId: params.to,
-            content: params.filePath || '',
-            type: 'file',
+            content: filePath,
+            type: "file",
           });
         }
 
         return { messageId: result.messageId };
       },
     },
+  } as any,
 
-    // Additional outbound handlers can be added here for:
-    // - sendLink: Send link cards
-    // - sendLocation: Send location
-    // - sendContact: Send contact card
-  },
-
-  // Additional capabilities
-  // - Describe the channel's message types and features
   capabilities: {
     supportedMessageTypes: [
       "text",
@@ -265,21 +336,25 @@ 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
-    supportsDeleting: false, // Cannot delete sent messages
+    supportsReactions: false,
+    supportsThreads: true,
+    supportsEditing: false,
+    supportsDeleting: false,
   },
-});
+} as any);
 
 /**
  * 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
@@ -294,31 +369,50 @@ export async function handleInboundMessage(
 ): Promise<void> {
   const { event, accountId, wechatAccountId, message, friendRequest } = payload;
 
-  if (event === 'message' && message) {
+  if (event === "message" && message) {
     // Determine conversation type
     const isChatroom = !!(message as any).chatroomId;
     const conversationId = isChatroom
       ? (message as any).chatroomId
-      : message.fromUser || message.toUser || '';
+      : 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 (cacheManager && accountId) {
+    if (cfg) {
       try {
-        await cacheManager.onMessage({
+        const cache = getCacheManager(cfg);
+        const wechatMessage: WeChatMessage = {
           messageId: message.messageId,
           msgSvrId: message.msgSvrId,
-          accountId: accountId,
-          conversationType: isChatroom ? 'chatroom' : 'friend',
+          accountId: resolvedAccountId,
+          conversationType: isChatroom ? "chatroom" : "friend",
           conversationId,
-          senderId: message.fromUser || '',
+          senderId: message.fromUser || "",
           content: message.content,
           messageType: message.type || 1,
           timestamp: message.timestamp || Date.now(),
           isSelf: message.isSelf || false,
-          direction: message.isSelf ? 'outbound' : 'inbound',
-        });
+          direction: message.isSelf ? "outbound" : "inbound",
+        };
+        await cache.onMessage(wechatMessage);
       } catch (err) {
-        console.error('[CelPhoneWeChat] Cache write failed:', err);
+        console.error("[CelPhoneWeChat] Cache write failed:", err);
       }
     }
 
@@ -327,32 +421,34 @@ export async function handleInboundMessage(
       id: message.messageId,
       rawId: message.msgSvrId || message.messageId,
       conversation: {
-        type: isChatroom ? 'group' as const : 'dm' as const,
+        type: isChatroom ? "group" as const : "dm" as const,
         id: conversationId,
         chatroomId: isChatroom ? conversationId : undefined,
       },
       sender: {
-        id: message.fromUser || '',
+        id: message.fromUser || "",
         platformId: message.wechatId,
       },
       content: {
-        type: message.type === 1 ? 'text' : 'media',
+        type: message.type === 1 ? "text" as const : "media" as const,
         text: message.content,
       },
       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);
-  } else if (event === 'friend_request' && friendRequest) {
+  } else if (event === "friend_request" && friendRequest) {
     // Handle friend request
     await api.inbound.dispatchFriendRequest({
       id: friendRequest.v1,
       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/src/client.ts

@@ -107,7 +107,7 @@ export class WorkPhoneWeChatClient {
       throw new Error(`WorkPhone API error: ${response.status} - ${error}`);
     }
 
-    return response.json();
+    return response.json() as Promise<T>;
   }
 
   // ========== WeChat Account Operations ==========

package/test-cache.ts

@@ -10,7 +10,7 @@ import {
   CacheManager,
   WeChatAccount,
   WeChatMessage,
-} from './src/cache/index.js';
+} from "@gloablehive/wechat-cache";
 
 const TEST_CACHE_PATH = '/tmp/wechat-cache-test';
 const ENCODING = 'utf-8';