@elizaos/plugin-wechat 2.0.0-alpha.537

package/dist/index.js

@@ -0,0 +1,833 @@
+import { timingSafeEqual } from "node:crypto";
+import { createServer } from "node:http";
+import { stringToUuid } from "@elizaos/core";
+
+//#region src/bot.ts
+const DEFAULT_DEDUP_WINDOW_MS = 1800 * 1e3;
+const DEDUP_MAX_ENTRIES = 1e3;
+const DEDUP_CLEANUP_INTERVAL_MS = 300 * 1e3;
+var Bot = class {
+	seen = /* @__PURE__ */ new Map();
+	onMessage;
+	featuresGroups;
+	featuresImages;
+	dedupWindowMs;
+	cleanupTimer = null;
+	constructor(options) {
+		this.onMessage = options.onMessage;
+		this.featuresGroups = options.featuresGroups ?? true;
+		this.featuresImages = options.featuresImages ?? true;
+		this.dedupWindowMs = options.dedupWindowMs ?? DEFAULT_DEDUP_WINDOW_MS;
+		this.cleanupTimer = setInterval(() => this.cleanup(), DEDUP_CLEANUP_INTERVAL_MS);
+	}
+	handleIncoming(message) {
+		if (this.isDuplicate(message.id)) return;
+		if (message.group && !this.featuresGroups) return;
+		if (message.type === "image" && !this.featuresImages) return;
+		if (message.type === "unknown") return;
+		Promise.resolve(this.onMessage(message)).catch((error) => {
+			console.error("[wechat] Failed to process inbound message:", error);
+		});
+	}
+	isDuplicate(messageId) {
+		const now = Date.now();
+		if (this.seen.has(messageId)) return true;
+		if (this.seen.size >= DEDUP_MAX_ENTRIES) this.cleanup();
+		this.seen.set(messageId, now);
+		return false;
+	}
+	cleanup() {
+		const cutoff = Date.now() - this.dedupWindowMs;
+		for (const [id, ts] of this.seen) if (ts < cutoff) this.seen.delete(id);
+	}
+	stop() {
+		if (this.cleanupTimer) {
+			clearInterval(this.cleanupTimer);
+			this.cleanupTimer = null;
+		}
+		this.seen.clear();
+	}
+};
+
+//#endregion
+//#region src/callback-server.ts
+const WECHAT_TYPE_MAP = {
+	60001: {
+		type: "text",
+		scope: "private"
+	},
+	60002: {
+		type: "image",
+		scope: "private"
+	},
+	60003: {
+		type: "voice",
+		scope: "private"
+	},
+	60004: {
+		type: "video",
+		scope: "private"
+	},
+	60005: {
+		type: "file",
+		scope: "private"
+	},
+	80001: {
+		type: "text",
+		scope: "group"
+	},
+	80002: {
+		type: "image",
+		scope: "group"
+	},
+	80003: {
+		type: "voice",
+		scope: "group"
+	},
+	80004: {
+		type: "video",
+		scope: "group"
+	},
+	80005: {
+		type: "file",
+		scope: "group"
+	}
+};
+const DEFAULT_MAX_REQUEST_BODY_BYTES = 1024 * 1024;
+async function startCallbackServer(options) {
+	const { port, accounts, onMessage, signal, maxBodyBytes = DEFAULT_MAX_REQUEST_BODY_BYTES } = options;
+	const server = createServer((req, res) => {
+		const account = resolveWebhookAccount(req.url, accounts);
+		if (req.method !== "POST" || !account) {
+			res.writeHead(404);
+			res.end("Not Found");
+			return;
+		}
+		const incomingKey = readHeaderValue(req.headers["x-api-key"]);
+		if (!incomingKey || !safeCompare(incomingKey, account.apiKey)) {
+			res.writeHead(401);
+			res.end("Unauthorized");
+			return;
+		}
+		let body = "";
+		let bodyBytes = 0;
+		req.on("data", (chunk) => {
+			bodyBytes += chunk.length;
+			if (bodyBytes > maxBodyBytes) {
+				res.writeHead(413);
+				res.end("Payload Too Large");
+				req.destroy();
+				return;
+			}
+			body += chunk.toString();
+		});
+		req.on("end", () => {
+			if (res.writableEnded) return;
+			try {
+				const message = normalizePayload(JSON.parse(body));
+				if (message) onMessage(account.accountId, message);
+				res.writeHead(200);
+				res.end("OK");
+			} catch {
+				res.writeHead(400);
+				res.end("Bad Request");
+			}
+		});
+		req.on("error", () => {
+			if (res.writableEnded) return;
+			res.writeHead(400);
+			res.end("Bad Request");
+		});
+	});
+	await new Promise((resolve, reject) => {
+		const handleListening = () => {
+			server.off("error", handleError);
+			resolve();
+		};
+		const handleError = (error) => {
+			server.off("listening", handleListening);
+			reject(error);
+		};
+		server.once("listening", handleListening);
+		server.once("error", handleError);
+		server.listen(port);
+	});
+	const listeningPort = server.address()?.port ?? port;
+	console.log(`[wechat] Webhook server listening on port ${listeningPort}`);
+	server.on("error", (err) => {
+		if (err.code === "EADDRINUSE") console.error(`[wechat] Port ${listeningPort} already in use — webhook server failed to start`);
+		else console.error(`[wechat] Webhook server error:`, err);
+	});
+	if (signal) signal.addEventListener("abort", () => {
+		closeServer(server);
+	}, { once: true });
+	return {
+		close: () => closeServer(server),
+		port: listeningPort
+	};
+}
+function resolveWebhookAccount(rawUrl, accounts) {
+	if (!rawUrl) return null;
+	const pathname = new URL(rawUrl, "http://localhost").pathname;
+	if (pathname === "/webhook/wechat" && accounts.length === 1) return accounts[0];
+	const match = /^\/webhook\/wechat\/([^/]+)$/.exec(pathname);
+	if (!match) return null;
+	const accountId = decodeURIComponent(match[1]);
+	return accounts.find((account) => account.accountId === accountId) ?? null;
+}
+function readHeaderValue(value) {
+	if (Array.isArray(value)) return value[0];
+	return value;
+}
+function safeCompare(a, b) {
+	const bufA = Buffer.from(a);
+	const bufB = Buffer.from(b);
+	if (bufA.length !== bufB.length) {
+		timingSafeEqual(bufA, bufA);
+		return false;
+	}
+	return timingSafeEqual(bufA, bufB);
+}
+function closeServer(server) {
+	if (!server.listening) return Promise.resolve();
+	return new Promise((resolve, reject) => {
+		server.close((error) => {
+			if (error) {
+				reject(error);
+				return;
+			}
+			resolve();
+		});
+	});
+}
+function normalizePayload(payload) {
+	const data = payload.data ?? (payload.content ? payload : null);
+	if (!data) {
+		console.warn("[wechat] Unrecognized webhook payload format");
+		return null;
+	}
+	const typeCode = Number(data.type ?? data.msgType ?? 0);
+	const mapping = WECHAT_TYPE_MAP[typeCode];
+	let msgType = "unknown";
+	let scope = "private";
+	if (mapping) {
+		msgType = mapping.type;
+		scope = mapping.scope;
+	} else if (typeCode >= 60006 && typeCode <= 60010) {
+		msgType = "file";
+		scope = "private";
+	} else if (typeCode >= 80006 && typeCode <= 80010) {
+		msgType = "file";
+		scope = "group";
+	}
+	if (msgType === "unknown") {
+		console.warn(`[wechat] Unknown message type code: ${typeCode}`);
+		return null;
+	}
+	const sender = String(data.sender ?? data.from ?? "");
+	const recipient = String(data.recipient ?? data.to ?? "");
+	const content = String(data.content ?? data.text ?? "");
+	const timestamp = Number(data.timestamp ?? Date.now());
+	const msgId = String(data.msgId ?? data.id ?? `${sender}-${timestamp}`);
+	const isGroup = scope === "group" || sender.includes("@chatroom");
+	const threadId = isGroup ? String(data.roomId ?? data.threadId ?? sender) : void 0;
+	const groupSubject = isGroup ? String(data.roomName ?? data.groupName ?? threadId ?? "") : void 0;
+	const imageUrl = new Set([
+		"image",
+		"voice",
+		"video",
+		"file"
+	]).has(msgType) ? String(data.imageUrl ?? data.mediaUrl ?? data.url ?? data.fileUrl ?? "") : void 0;
+	return {
+		id: msgId,
+		type: msgType,
+		sender,
+		recipient,
+		content,
+		timestamp,
+		threadId,
+		group: groupSubject ? { subject: groupSubject } : void 0,
+		imageUrl: imageUrl || void 0,
+		raw: payload
+	};
+}
+
+//#endregion
+//#region src/proxy-client.ts
+const SUCCESS = 1e3;
+const LOGIN_NEEDED = 1001;
+const REQUEST_TIMEOUT_MS = 3e4;
+var ProxyClient = class {
+	apiKey;
+	baseUrl;
+	accountId;
+	deviceType;
+	constructor(account) {
+		this.apiKey = account.apiKey;
+		this.baseUrl = normalizeProxyUrl(account.proxyUrl);
+		this.accountId = account.id;
+		this.deviceType = account.deviceType ?? "ipad";
+	}
+	async request(path, body) {
+		const url = `${this.baseUrl}${path}`;
+		const headers = {
+			"Content-Type": "application/json",
+			"X-API-Key": this.apiKey,
+			"X-Account-ID": this.accountId,
+			"X-Device-Type": this.deviceType
+		};
+		let lastError;
+		for (let attempt = 0; attempt < 3; attempt++) try {
+			const res = await fetch(url, {
+				method: "POST",
+				headers,
+				body: body ? JSON.stringify(body) : void 0,
+				signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS)
+			});
+			if (res.status === 429) {
+				const retryAfter = res.headers.get("Retry-After");
+				const delay = retryAfter ? Number.parseInt(retryAfter, 10) * 1e3 : Math.min(1e3 * 2 ** attempt, 8e3);
+				await res.text().catch(() => {});
+				await sleep$1(delay);
+				continue;
+			}
+			return await res.json();
+		} catch (err) {
+			lastError = err instanceof Error ? err : new Error(String(err));
+			await sleep$1(Math.min(1e3 * 2 ** attempt, 8e3));
+		}
+		throw lastError ?? /* @__PURE__ */ new Error(`Request failed after 3 attempts: ${path}`);
+	}
+	async getStatus() {
+		const res = await this.request("/api/status");
+		if (res.code === LOGIN_NEEDED) return {
+			valid: true,
+			loginState: "waiting"
+		};
+		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`getStatus failed: ${res.message ?? res.code}`);
+		return requireData(res, "getStatus");
+	}
+	async getQRCode() {
+		const res = await this.request("/api/qrcode");
+		if (res.code !== SUCCESS) throw new Error(`getQRCode failed: ${res.message ?? res.code}`);
+		return requireData(res, "getQRCode").qrCodeUrl;
+	}
+	async checkLogin() {
+		const res = await this.request("/api/check-login");
+		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`checkLogin failed: ${res.message ?? res.code}`);
+		return requireData(res, "checkLogin");
+	}
+	async sendText(to, text) {
+		const res = await this.request("/api/send-text", {
+			to,
+			text
+		});
+		if (res.code === LOGIN_NEEDED) throw new LoginExpiredError();
+		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`sendText failed: ${res.message ?? res.code}`);
+	}
+	async sendImage(to, imagePath, text) {
+		const res = await this.request("/api/send-image", {
+			to,
+			imagePath,
+			text
+		});
+		if (res.code === LOGIN_NEEDED) throw new LoginExpiredError();
+		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`sendImage failed: ${res.message ?? res.code}`);
+	}
+	async getContacts() {
+		const res = await this.request("/api/contacts");
+		if (res.code !== SUCCESS) throw new Error(`getContacts failed: ${res.message ?? res.code}`);
+		return requireData(res, "getContacts");
+	}
+	async registerWebhook(url) {
+		const res = await this.request("/api/webhook/register", { webhookUrl: url });
+		if (res.code !== SUCCESS && res.code !== 1002) throw new Error(`registerWebhook failed: ${res.message ?? res.code}`);
+	}
+	get needsLogin() {
+		return false;
+	}
+};
+var LoginExpiredError = class extends Error {
+	constructor() {
+		super("WeChat login expired — re-login required");
+		this.name = "LoginExpiredError";
+	}
+};
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeProxyUrl(proxyUrl) {
+	const parsed = new URL(proxyUrl);
+	if (parsed.protocol !== "https:") throw new Error("[wechat] proxyUrl must use https://");
+	if (parsed.username || parsed.password) throw new Error("[wechat] proxyUrl must not include credentials");
+	parsed.hash = "";
+	return parsed.toString().replace(/\/$/, "");
+}
+function requireData(response, action) {
+	if (response.data === void 0) throw new Error(`${action} failed: missing response data`);
+	return response.data;
+}
+
+//#endregion
+//#region src/reply-dispatcher.ts
+const DEFAULT_CHUNK_SIZE = 2e3;
+var ReplyDispatcher = class {
+	client;
+	chunkSize;
+	constructor(options) {
+		this.client = options.client;
+		this.chunkSize = options.chunkSize ?? DEFAULT_CHUNK_SIZE;
+	}
+	async sendText(to, text) {
+		const chunks = this.chunk(text);
+		for (const chunk of chunks) try {
+			await this.client.sendText(to, chunk);
+		} catch (err) {
+			console.error(`[wechat] Failed to send text to ${to}:`, err);
+			throw err;
+		}
+	}
+	async sendImage(to, imagePath, caption) {
+		try {
+			await this.client.sendImage(to, imagePath, caption);
+		} catch (err) {
+			console.error(`[wechat] Failed to send image to ${to}:`, err);
+			throw err;
+		}
+	}
+	chunk(text) {
+		if (text.length <= this.chunkSize) return [text];
+		const chunks = [];
+		let remaining = text;
+		while (remaining.length > 0) {
+			if (remaining.length <= this.chunkSize) {
+				chunks.push(remaining);
+				break;
+			}
+			let breakAt = remaining.lastIndexOf("\n", this.chunkSize);
+			if (breakAt <= 0) breakAt = remaining.lastIndexOf(" ", this.chunkSize);
+			if (breakAt <= 0) breakAt = this.chunkSize;
+			chunks.push(remaining.slice(0, breakAt));
+			remaining = remaining.slice(breakAt).trimStart();
+		}
+		return chunks;
+	}
+};
+
+//#endregion
+//#region src/utils/qrcode.ts
+/**
+* Display a QR code URL to the terminal.
+* Prints the URL for the user to open in a browser.
+* A vendored text-based QR renderer could be added here later.
+*/
+function displayQRUrl(url) {
+	console.log("");
+	console.log("╔══════════════════════════════════════════╗");
+	console.log("║  Scan this QR code with WeChat to login  ║");
+	console.log("╠══════════════════════════════════════════╣");
+	console.log(`║  ${url}`);
+	console.log("╚══════════════════════════════════════════╝");
+	console.log("");
+	console.log("Open the URL above in your browser to see the QR code.");
+	console.log("");
+}
+
+//#endregion
+//#region src/channel.ts
+const HEALTH_CHECK_INTERVAL_MS = 6e4;
+const LOGIN_POLL_INTERVAL_MS = 5e3;
+const LOGIN_TIMEOUT_MS = 5 * 6e4;
+var WechatChannel = class {
+	config;
+	onMessage;
+	accounts = /* @__PURE__ */ new Map();
+	callbackServers = [];
+	loginPromises = /* @__PURE__ */ new Map();
+	healthTimer = null;
+	abortController = null;
+	constructor(options) {
+		this.config = options.config;
+		this.onMessage = options.onMessage;
+	}
+	async start() {
+		this.abortController = new AbortController();
+		const resolved = this.resolveAccounts();
+		if (resolved.length === 0) {
+			console.warn("[wechat] No configured accounts found");
+			return;
+		}
+		const webhookAccountsByPort = /* @__PURE__ */ new Map();
+		for (const account of resolved) {
+			const existing = webhookAccountsByPort.get(account.webhookPort) ?? [];
+			existing.push({
+				accountId: account.id,
+				apiKey: account.apiKey
+			});
+			webhookAccountsByPort.set(account.webhookPort, existing);
+		}
+		for (const [webhookPort, accounts] of webhookAccountsByPort) try {
+			this.callbackServers.push(await startCallbackServer({
+				port: webhookPort,
+				accounts,
+				onMessage: (accountId, msg) => this.routeIncoming(accountId, msg),
+				signal: this.abortController.signal
+			}));
+		} catch (err) {
+			const accountIds = accounts.map((a) => a.accountId).join(", ");
+			console.error(`[wechat] Failed to bind webhook server on port ${webhookPort} for accounts [${accountIds}]:`, err);
+		}
+		for (const account of resolved) {
+			const client = new ProxyClient(account);
+			const dispatcher = new ReplyDispatcher({ client });
+			const bot = new Bot({
+				onMessage: (msg) => this.onMessage(account.id, msg),
+				featuresGroups: this.config.features?.groups,
+				featuresImages: this.config.features?.images
+			});
+			this.accounts.set(account.id, {
+				client,
+				dispatcher,
+				bot
+			});
+			await this.ensureLoggedIn(account.id, client);
+			const webhookUrl = `http://localhost:${account.webhookPort}/webhook/wechat/${account.id}`;
+			try {
+				await client.registerWebhook(webhookUrl);
+				console.log(`[wechat] Account "${account.id}" registered webhook at ${webhookUrl}`);
+			} catch (err) {
+				console.error(`[wechat] Failed to register webhook for "${account.id}":`, err);
+				throw new Error(`Webhook registration failed for account "${account.id}": ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+		this.healthTimer = setInterval(() => this.healthCheck(), HEALTH_CHECK_INTERVAL_MS);
+	}
+	async stop() {
+		if (this.healthTimer) {
+			clearInterval(this.healthTimer);
+			this.healthTimer = null;
+		}
+		for (const [, { bot }] of this.accounts) bot.stop();
+		this.accounts.clear();
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = null;
+		}
+		const servers = this.callbackServers.splice(0);
+		await Promise.all(servers.map((server) => server.close().catch(() => void 0)));
+	}
+	async sendText(accountId, to, text) {
+		const entry = this.accounts.get(accountId);
+		if (!entry) throw new Error(`Unknown account: ${accountId}`);
+		try {
+			await entry.dispatcher.sendText(to, text);
+		} catch (err) {
+			if (err instanceof LoginExpiredError) {
+				await this.ensureLoggedIn(accountId, entry.client);
+				await entry.dispatcher.sendText(to, text);
+			} else throw err;
+		}
+	}
+	async sendImage(accountId, to, imagePath, caption) {
+		const entry = this.accounts.get(accountId);
+		if (!entry) throw new Error(`Unknown account: ${accountId}`);
+		try {
+			await entry.dispatcher.sendImage(to, imagePath, caption);
+		} catch (err) {
+			if (err instanceof LoginExpiredError) {
+				await this.ensureLoggedIn(accountId, entry.client);
+				await entry.dispatcher.sendImage(to, imagePath, caption);
+			} else throw err;
+		}
+	}
+	routeIncoming(accountId, msg) {
+		const entry = this.accounts.get(accountId);
+		if (!entry) {
+			console.warn(`[wechat] Received webhook for unknown account "${accountId}"`);
+			return;
+		}
+		entry.bot.handleIncoming(msg);
+	}
+	async ensureLoggedIn(accountId, client) {
+		const existing = this.loginPromises.get(accountId);
+		if (existing) return existing;
+		const promise = this.doLogin(accountId, client).finally(() => {
+			this.loginPromises.delete(accountId);
+		});
+		this.loginPromises.set(accountId, promise);
+		return promise;
+	}
+	async doLogin(accountId, client) {
+		const status = await client.getStatus();
+		if (status.loginState === "logged_in") {
+			console.log(`[wechat] Account "${accountId}" logged in as ${status.nickName ?? status.wcId}`);
+			return;
+		}
+		console.log(`[wechat] Account "${accountId}" needs login — generating QR code...`);
+		displayQRUrl(await client.getQRCode());
+		const timeoutMs = this.config.loginTimeoutMs ?? LOGIN_TIMEOUT_MS;
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			await sleep(LOGIN_POLL_INTERVAL_MS);
+			if (this.abortController?.signal.aborted) throw new Error("Login aborted");
+			const result = await client.checkLogin();
+			if (result.status === "logged_in") {
+				console.log(`[wechat] Account "${accountId}" logged in as ${result.nickName ?? result.wcId}`);
+				return;
+			}
+			if (result.status === "need_verify") console.log(`[wechat] Verification needed: ${result.verifyUrl ?? "check your phone"}`);
+		}
+		throw new Error(`[wechat] Login timed out for account "${accountId}" after ${Math.round(timeoutMs / 1e3)} seconds`);
+	}
+	async healthCheck() {
+		for (const [accountId, { client }] of this.accounts) try {
+			if ((await client.getStatus()).loginState !== "logged_in") {
+				console.warn(`[wechat] Account "${accountId}" login expired — attempting re-login`);
+				await this.ensureLoggedIn(accountId, client);
+			}
+		} catch (err) {
+			console.error(`[wechat] Health check failed for "${accountId}":`, err);
+		}
+	}
+	resolveAccounts() {
+		const accounts = [];
+		const rawPort = Number(process.env.ELIZA_WECHAT_WEBHOOK_PORT);
+		const defaultPort = (Number.isFinite(rawPort) && rawPort > 0 ? rawPort : void 0) ?? this.config.webhookPort ?? 18790;
+		const defaultDevice = this.config.deviceType ?? "ipad";
+		if (this.config.accounts) for (const [id, acc] of Object.entries(this.config.accounts)) {
+			if (acc.enabled === false) continue;
+			accounts.push({
+				id,
+				apiKey: acc.apiKey,
+				proxyUrl: acc.proxyUrl,
+				deviceType: acc.deviceType ?? defaultDevice,
+				webhookPort: acc.webhookPort ?? defaultPort,
+				wcId: acc.wcId,
+				nickName: acc.nickName
+			});
+		}
+		else if (this.config.apiKey && this.config.proxyUrl) accounts.push({
+			id: "default",
+			apiKey: this.config.apiKey,
+			proxyUrl: this.config.proxyUrl,
+			deviceType: defaultDevice,
+			webhookPort: defaultPort
+		});
+		return accounts;
+	}
+};
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+//#endregion
+//#region src/runtime-bridge.ts
+async function deliverIncomingWechatMessage(options) {
+	const runtime = options.runtime;
+	const agentId = typeof runtime.agentId === "string" && runtime.agentId.length > 0 ? runtime.agentId : stringToUuid("wechat-agent");
+	const incomingMemory = buildIncomingMemory(agentId, options.accountId, options.message);
+	const replyTarget = resolveReplyTarget(options.message);
+	let replyIndex = 0;
+	let replyDelivered = false;
+	const onResponse = async (content) => {
+		const replyText = extractReplyText(content);
+		if (!replyText) return [];
+		replyDelivered = true;
+		await options.sendText(options.accountId, replyTarget, replyText);
+		const replyMemory = buildReplyMemory(agentId, options.accountId, options.message, replyText, replyIndex);
+		replyIndex += 1;
+		await runtime.createMemory?.(replyMemory, "messages");
+		return [replyMemory];
+	};
+	await runtime.ensureConnection?.({
+		entityId: incomingMemory.entityId,
+		roomId: incomingMemory.roomId,
+		worldId: stringToUuid(`wechat:world:${options.accountId}`),
+		userName: options.message.sender,
+		userId: options.message.sender,
+		name: options.message.sender,
+		source: "wechat",
+		type: getChannelType(options.message),
+		channelId: resolveChannelId(options.message),
+		worldName: "WeChat"
+	});
+	if (typeof runtime.elizaOS?.sendMessage === "function") {
+		await maybeHandleResponseContent(await runtime.elizaOS.sendMessage(options.runtime, incomingMemory, { onResponse }), replyDelivered, onResponse);
+		return;
+	}
+	if (typeof runtime.messageService?.handleMessage === "function") {
+		await maybeHandleResponseContent(await runtime.messageService.handleMessage(options.runtime, incomingMemory, onResponse), replyDelivered, onResponse);
+		return;
+	}
+	if (typeof runtime.emitEvent === "function") {
+		await runtime.emitEvent(["MESSAGE_RECEIVED"], {
+			runtime: options.runtime,
+			message: incomingMemory,
+			callback: onResponse,
+			source: "wechat"
+		});
+		return;
+	}
+	runtime.logger?.warn?.("[wechat] No inbound runtime message pipeline is available");
+}
+function buildIncomingMemory(agentId, accountId, message) {
+	return {
+		id: stringToUuid(`wechat:incoming:${accountId}:${message.id}`),
+		agentId,
+		entityId: stringToUuid(`wechat:entity:${accountId}:${message.sender}`),
+		roomId: stringToUuid(`wechat:room:${accountId}:${resolveChannelId(message)}`),
+		createdAt: message.timestamp,
+		content: {
+			text: message.content,
+			source: "wechat",
+			channelType: getChannelType(message),
+			metadata: {
+				accountId,
+				sender: message.sender,
+				recipient: message.recipient,
+				messageType: message.type,
+				threadId: message.threadId,
+				groupSubject: message.group?.subject,
+				imageUrl: message.imageUrl
+			}
+		},
+		metadata: {
+			type: "message",
+			source: "wechat",
+			provider: "wechat",
+			timestamp: message.timestamp,
+			entityName: message.sender,
+			entityUserName: message.sender,
+			fromId: message.sender,
+			sourceId: stringToUuid(`wechat:entity:${accountId}:${message.sender}`),
+			chatType: getChannelType(message),
+			messageIdFull: message.id,
+			sender: {
+				id: message.sender,
+				name: message.sender,
+				username: message.sender
+			},
+			wechat: {
+				id: message.sender,
+				userId: message.sender,
+				username: message.sender,
+				userName: message.sender,
+				name: message.sender,
+				messageId: message.id,
+				accountId,
+				recipient: message.recipient,
+				threadId: message.threadId,
+				groupSubject: message.group?.subject
+			}
+		}
+	};
+}
+function buildReplyMemory(agentId, accountId, message, text, replyIndex) {
+	return {
+		id: stringToUuid(`wechat:reply:${accountId}:${message.id}:${replyIndex}`),
+		agentId,
+		entityId: agentId,
+		roomId: stringToUuid(`wechat:room:${accountId}:${resolveChannelId(message)}`),
+		createdAt: Date.now(),
+		content: {
+			text,
+			source: "wechat",
+			channelType: getChannelType(message),
+			inReplyTo: message.id,
+			metadata: {
+				accountId,
+				recipient: resolveReplyTarget(message)
+			}
+		},
+		metadata: {
+			type: "message",
+			source: "wechat",
+			provider: "wechat",
+			timestamp: Date.now(),
+			fromBot: true,
+			fromId: agentId,
+			sourceId: agentId,
+			chatType: getChannelType(message),
+			messageIdFull: `wechat:reply:${message.id}:${replyIndex}`,
+			wechat: {
+				accountId,
+				recipient: resolveReplyTarget(message),
+				threadId: message.threadId
+			}
+		}
+	};
+}
+function getChannelType(message) {
+	return message.group ? "GROUP" : "DM";
+}
+function resolveChannelId(message) {
+	return message.threadId ?? message.sender;
+}
+function resolveReplyTarget(message) {
+	return message.threadId ?? message.sender;
+}
+function extractReplyText(content) {
+	if (typeof content.text !== "string") return null;
+	const trimmed = content.text.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+async function maybeHandleResponseContent(result, replyDelivered, onResponse) {
+	if (replyDelivered || !result?.responseContent) return;
+	await onResponse(result.responseContent);
+}
+
+//#endregion
+//#region src/index.ts
+const WECHAT_PLUGIN_PACKAGE = "@elizaos/plugin-wechat";
+function isWechatConnectorConfigured(config) {
+	if (!config || config.enabled === false) return false;
+	if (config.apiKey) return true;
+	const accounts = config.accounts;
+	if (accounts && typeof accounts === "object") return Object.values(accounts).some((account) => {
+		if (account.enabled === false) return false;
+		return Boolean(account.apiKey);
+	});
+	return false;
+}
+let channel = null;
+const wechatPlugin = {
+	name: "wechat",
+	description: "WeChat messaging via proxy API",
+	async init(config, runtime) {
+		const wechatConfig = config?.connectors?.wechat;
+		if (!wechatConfig) {
+			console.warn("[wechat] No wechat config found in connectors — skipping");
+			return;
+		}
+		if (wechatConfig.enabled === false) {
+			console.log("[wechat] Plugin disabled via config");
+			return;
+		}
+		channel = new WechatChannel({
+			config: wechatConfig,
+			onMessage: async (accountId, msg) => {
+				await deliverIncomingWechatMessage({
+					runtime,
+					accountId,
+					message: msg,
+					sendText: async (replyAccountId, to, text) => {
+						if (!channel) throw new Error("[wechat] Channel is not available for replies");
+						await channel.sendText(replyAccountId, to, text);
+					}
+				});
+			}
+		});
+		await channel.start();
+		console.log("[wechat] Plugin initialized");
+		return async () => {
+			if (channel) {
+				await channel.stop();
+				channel = null;
+				console.log("[wechat] Plugin stopped");
+			}
+		};
+	}
+};
+
+//#endregion
+export { Bot, ProxyClient, ReplyDispatcher, WECHAT_PLUGIN_PACKAGE, WechatChannel, wechatPlugin as default, wechatPlugin, deliverIncomingWechatMessage, isWechatConnectorConfigured };