wechat-ai 0.1.0

package/dist/chunk-PRU3A74K.js

@@ -0,0 +1,774 @@
+// src/config.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var WAI_DIR = join(homedir(), ".wai");
+var CONFIG_PATH = join(WAI_DIR, "config.json");
+var DEFAULT_CONFIG = {
+  defaultProvider: "qwen",
+  providers: {
+    claude: {
+      type: "claude-agent",
+      allowedTools: ["Read", "Glob", "Grep", "Bash", "WebSearch", "WebFetch"]
+    },
+    qwen: {
+      type: "openai-compatible",
+      baseUrl: "https://dashscope.aliyuncs.com/compatible-mode/v1",
+      model: "qwen-plus",
+      apiKeyEnv: "DASHSCOPE_API_KEY"
+    },
+    deepseek: {
+      type: "openai-compatible",
+      baseUrl: "https://api.deepseek.com/v1",
+      model: "deepseek-chat",
+      apiKeyEnv: "DEEPSEEK_API_KEY"
+    },
+    gpt: {
+      type: "openai-compatible",
+      baseUrl: "https://api.openai.com/v1",
+      model: "gpt-4o",
+      apiKeyEnv: "OPENAI_API_KEY"
+    },
+    gemini: {
+      type: "openai-compatible",
+      baseUrl: "https://generativelanguage.googleapis.com/v1beta/openai",
+      model: "gemini-2.0-flash",
+      apiKeyEnv: "GEMINI_API_KEY"
+    },
+    minimax: {
+      type: "openai-compatible",
+      baseUrl: "https://api.minimax.chat/v1",
+      model: "MiniMax-Text-01",
+      apiKeyEnv: "MINIMAX_API_KEY"
+    },
+    zhipu: {
+      type: "openai-compatible",
+      baseUrl: "https://open.bigmodel.cn/api/paas/v4",
+      model: "glm-4-plus",
+      apiKeyEnv: "ZHIPU_API_KEY"
+    }
+  },
+  channels: {
+    weixin: {
+      type: "weixin",
+      enabled: true
+    }
+  },
+  systemPrompt: "You are a helpful AI assistant. Respond concisely.",
+  chunkSize: 4e3
+};
+async function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    await mkdir(dir, { recursive: true });
+  }
+}
+async function loadConfig() {
+  await ensureDir(WAI_DIR);
+  if (!existsSync(CONFIG_PATH)) {
+    await writeFile(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2));
+    return { ...DEFAULT_CONFIG };
+  }
+  const raw = await readFile(CONFIG_PATH, "utf-8");
+  return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+}
+async function saveConfig(config) {
+  await ensureDir(WAI_DIR);
+  await writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function getAccountsDir() {
+  return join(WAI_DIR, "accounts");
+}
+
+// src/logger.ts
+var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
+var currentLevel = "info";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function fmt(level, scope, msg) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+  const tag = level.toUpperCase().padEnd(5);
+  return `\x1B[90m${ts}\x1B[0m ${colorize(level, tag)} \x1B[36m[${scope}]\x1B[0m ${msg}`;
+}
+function colorize(level, text) {
+  switch (level) {
+    case "debug":
+      return `\x1B[90m${text}\x1B[0m`;
+    case "info":
+      return `\x1B[32m${text}\x1B[0m`;
+    case "warn":
+      return `\x1B[33m${text}\x1B[0m`;
+    case "error":
+      return `\x1B[31m${text}\x1B[0m`;
+  }
+}
+function createLogger(scope) {
+  return {
+    debug: (msg) => {
+      if (LEVELS[currentLevel] <= 0) console.log(fmt("debug", scope, msg));
+    },
+    info: (msg) => {
+      if (LEVELS[currentLevel] <= 1) console.log(fmt("info", scope, msg));
+    },
+    warn: (msg) => {
+      if (LEVELS[currentLevel] <= 2) console.warn(fmt("warn", scope, msg));
+    },
+    error: (msg) => {
+      if (LEVELS[currentLevel] <= 3) console.error(fmt("error", scope, msg));
+    }
+  };
+}
+
+// src/channels/weixin.ts
+import { join as join2 } from "path";
+import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { existsSync as existsSync2 } from "fs";
+import { randomBytes, randomUUID } from "crypto";
+var log = createLogger("weixin");
+var DEFAULT_BASE_URL = "https://ilinkai.weixin.qq.com";
+var CHANNEL_VERSION = "1.0.0";
+var API_TIMEOUT_MS = 15e3;
+var MessageType = { USER: 1, BOT: 2 };
+var MessageState = { NEW: 0, GENERATING: 1, FINISH: 2 };
+var MessageItemType = { TEXT: 1, IMAGE: 2, VOICE: 3, FILE: 4, VIDEO: 5 };
+var WeixinChannel = class {
+  name = "weixin";
+  account = null;
+  syncBuf = "";
+  running = false;
+  abortController = null;
+  config;
+  // Cache typing_ticket per user
+  typingTickets = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.config = config;
+  }
+  // ── Auth ──
+  async login() {
+    const baseUrl = this.config.baseUrl || DEFAULT_BASE_URL;
+    log.info("\u83B7\u53D6\u4E8C\u7EF4\u7801\u4E2D...");
+    const qrRes = await this.api(baseUrl, "ilink/bot/get_bot_qrcode?bot_type=3", null, {
+      method: "GET",
+      timeout: 1e4
+    });
+    if (qrRes.ret !== 0) {
+      throw new Error(`\u83B7\u53D6\u4E8C\u7EF4\u7801\u5931\u8D25: ${qrRes.errmsg || qrRes.ret}`);
+    }
+    const qrUrl = qrRes.qrcode_img_content || qrRes.data?.qrcode_img_content;
+    const qrCode = qrRes.qrcode || qrRes.data?.qrcode;
+    if (!qrUrl || !qrCode) {
+      throw new Error(`\u4E8C\u7EF4\u7801\u54CD\u5E94\u7F3A\u5C11\u5B57\u6BB5: ${JSON.stringify(qrRes)}`);
+    }
+    log.info("\u8BF7\u7528\u5FAE\u4FE1\u626B\u63CF\u4E8C\u7EF4\u7801:");
+    console.log();
+    try {
+      const qrTerminal = await import("qrcode-terminal");
+      (qrTerminal.default || qrTerminal).generate(qrUrl, { small: true });
+    } catch {
+      console.log(`  ${qrUrl}`);
+    }
+    console.log();
+    log.info("\u7B49\u5F85\u626B\u7801...");
+    let attempts = 0;
+    while (attempts < 60) {
+      const statusRes = await this.api(
+        baseUrl,
+        `ilink/bot/get_qrcode_status?qrcode=${encodeURIComponent(qrCode)}`,
+        null,
+        { method: "GET", timeout: 4e4 }
+      );
+      const status = statusRes.data?.status || statusRes.status;
+      if (status === "confirmed") {
+        const data = statusRes.data || statusRes;
+        const accountId = data.ilink_bot_id || data.bot_id;
+        const token = data.bot_token || data.token;
+        if (!accountId || !token) {
+          throw new Error("\u767B\u5F55\u6210\u529F\u4F46\u7F3A\u5C11\u51ED\u8BC1");
+        }
+        this.account = {
+          accountId,
+          token,
+          baseUrl: data.baseurl || baseUrl,
+          userId: data.ilink_user_id
+        };
+        await this.saveAccount();
+        log.info(`\u767B\u5F55\u6210\u529F\uFF01\u8D26\u53F7: ${accountId.slice(0, 8)}...`);
+        return;
+      }
+      if (status === "scaned") {
+        log.info("\u5DF2\u626B\u7801\uFF0C\u7B49\u5F85\u786E\u8BA4...");
+      }
+      if (status === "expired") {
+        log.warn("\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F");
+        throw new Error("\u4E8C\u7EF4\u7801\u5DF2\u8FC7\u671F");
+      }
+      attempts++;
+      await sleep(500);
+    }
+    throw new Error("\u767B\u5F55\u8D85\u65F6");
+  }
+  // ── Message loop ──
+  async start(onMessage) {
+    if (!this.account) {
+      await this.loadAccount();
+    }
+    if (!this.account) {
+      log.info("\u672A\u627E\u5230\u8D26\u53F7\uFF0C\u5F00\u59CB\u767B\u5F55...");
+      await this.login();
+    }
+    await this.loadSyncBuf();
+    this.running = true;
+    log.info(`\u6D88\u606F\u76D1\u542C\u5DF2\u542F\u52A8 (${this.account.accountId.slice(0, 8)}...)`);
+    while (this.running) {
+      try {
+        this.abortController = new AbortController();
+        const res = await this.getUpdates();
+        if (res.ret === -14) {
+          log.warn("\u4F1A\u8BDD\u8FC7\u671F\uFF0C\u91CD\u65B0\u767B\u5F55...");
+          this.account = null;
+          await this.login();
+          continue;
+        }
+        if (res.ret && res.ret !== 0) {
+          log.warn(`\u62C9\u53D6\u6D88\u606F\u5931\u8D25: ${res.errmsg || JSON.stringify(res)}`);
+          await sleep(5e3);
+          continue;
+        }
+        if (res.get_updates_buf) {
+          this.syncBuf = res.get_updates_buf;
+          await this.saveSyncBuf();
+        }
+        if (res.msgs && res.msgs.length > 0) {
+          for (const msg of res.msgs) {
+            const text = this.extractText(msg);
+            if (!text || !msg.from_user_id) continue;
+            log.info(`\u6536\u5230\u6D88\u606F [${msg.from_user_id.slice(0, 8)}...]: ${text.slice(0, 50)}`);
+            onMessage({
+              id: String(msg.message_id || msg.seq || Date.now()),
+              channel: "weixin",
+              senderId: msg.from_user_id,
+              text,
+              replyToken: msg.context_token,
+              timestamp: msg.create_time_ms || Date.now()
+            });
+          }
+        }
+      } catch (err) {
+        if (!this.running) break;
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes("aborted") || message.includes("AbortError")) continue;
+        log.error(`\u8F6E\u8BE2\u51FA\u9519: ${message}`);
+        await sleep(3e3);
+      }
+    }
+  }
+  // ── Send typing indicator ──
+  async sendTyping(userId, contextToken) {
+    if (!this.account) return;
+    try {
+      let ticket = this.typingTickets.get(userId);
+      if (!ticket) {
+        const configRes = await this.api(this.account.baseUrl, "ilink/bot/getconfig", {
+          ilink_user_id: userId,
+          context_token: contextToken,
+          base_info: { channel_version: CHANNEL_VERSION }
+        }, { timeout: 1e4 });
+        ticket = configRes.typing_ticket;
+        if (ticket) {
+          this.typingTickets.set(userId, ticket);
+        }
+      }
+      if (!ticket) return;
+      await this.api(this.account.baseUrl, "ilink/bot/sendtyping", {
+        ilink_user_id: userId,
+        typing_ticket: ticket,
+        status: 1,
+        base_info: { channel_version: CHANNEL_VERSION }
+      }, { timeout: 1e4 });
+      log.debug(`\u5DF2\u53D1\u9001\u8F93\u5165\u72B6\u6001\u7ED9 ${userId.slice(0, 8)}...`);
+    } catch {
+    }
+  }
+  // ── Send message ──
+  async send(msg) {
+    if (!this.account) throw new Error("\u672A\u767B\u5F55");
+    const chunks = this.chunkText(msg.text, 4e3);
+    for (const chunk of chunks) {
+      const body = {
+        msg: {
+          from_user_id: "",
+          to_user_id: msg.targetId,
+          client_id: generateClientId(),
+          message_type: MessageType.BOT,
+          message_state: MessageState.FINISH,
+          context_token: msg.replyToken || void 0,
+          item_list: [{ type: MessageItemType.TEXT, text_item: { text: chunk } }]
+        },
+        base_info: { channel_version: CHANNEL_VERSION }
+      };
+      const res = await this.api(
+        this.account.baseUrl,
+        "ilink/bot/sendmessage",
+        body,
+        { timeout: API_TIMEOUT_MS }
+      );
+      if (res.ret && res.ret !== 0) {
+        log.error(`\u53D1\u9001\u5931\u8D25: ${res.errmsg || JSON.stringify(res)}`);
+      }
+    }
+  }
+  async stop() {
+    this.running = false;
+    this.abortController?.abort();
+    log.info("\u5DF2\u505C\u6B62");
+  }
+  // ── Internal ──
+  async getUpdates() {
+    if (!this.account) throw new Error("\u672A\u767B\u5F55");
+    return this.api(this.account.baseUrl, "ilink/bot/getupdates", {
+      get_updates_buf: this.syncBuf,
+      base_info: { channel_version: CHANNEL_VERSION }
+    }, { timeout: 5e4 });
+  }
+  extractText(msg) {
+    if (!msg.item_list?.length) return null;
+    for (const item of msg.item_list) {
+      if (item.type === 1 && item.text_item?.text) {
+        return item.text_item.text;
+      }
+    }
+    return null;
+  }
+  chunkText(text, maxLen) {
+    if (text.length <= maxLen) return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > 0) {
+      let breakAt = remaining.lastIndexOf("\n", maxLen);
+      if (breakAt <= 0) breakAt = maxLen;
+      chunks.push(remaining.slice(0, breakAt));
+      remaining = remaining.slice(breakAt);
+    }
+    return chunks;
+  }
+  async api(baseUrl, path, body, opts = {}) {
+    const url = `${baseUrl.replace(/\/$/, "")}/${path}`;
+    const method = opts.method || "POST";
+    const bodyStr = body ? JSON.stringify(body) : void 0;
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (this.account?.token) {
+      headers["AuthorizationType"] = "ilink_bot_token";
+      headers["Authorization"] = `Bearer ${this.account.token}`;
+      headers["X-WECHAT-UIN"] = randomUin();
+      if (bodyStr) {
+        headers["Content-Length"] = String(Buffer.byteLength(bodyStr, "utf-8"));
+      }
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), opts.timeout || API_TIMEOUT_MS);
+    try {
+      const res = await fetch(url, {
+        method,
+        headers,
+        body: bodyStr,
+        signal: controller.signal
+      });
+      return await res.json();
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  // ── Persistence ──
+  accountFile() {
+    return join2(getAccountsDir(), "weixin.json");
+  }
+  syncFile() {
+    return join2(getAccountsDir(), "weixin-sync.json");
+  }
+  async saveAccount() {
+    await ensureDir(getAccountsDir());
+    await writeFile2(this.accountFile(), JSON.stringify(this.account, null, 2));
+  }
+  async loadAccount() {
+    const path = this.accountFile();
+    if (!existsSync2(path)) return;
+    try {
+      const raw = await readFile2(path, "utf-8");
+      this.account = JSON.parse(raw);
+      log.info(`\u5DF2\u52A0\u8F7D\u8D26\u53F7: ${this.account.accountId.slice(0, 8)}...`);
+    } catch {
+      log.warn("\u52A0\u8F7D\u8D26\u53F7\u5931\u8D25");
+    }
+  }
+  async saveSyncBuf() {
+    await ensureDir(getAccountsDir());
+    await writeFile2(this.syncFile(), JSON.stringify({ get_updates_buf: this.syncBuf }));
+  }
+  async loadSyncBuf() {
+    const path = this.syncFile();
+    if (!existsSync2(path)) return;
+    try {
+      const raw = await readFile2(path, "utf-8");
+      const data = JSON.parse(raw);
+      this.syncBuf = data.get_updates_buf || "";
+    } catch {
+    }
+  }
+};
+function randomUin() {
+  const uint32 = randomBytes(4).readUInt32BE(0);
+  return Buffer.from(String(uint32), "utf-8").toString("base64");
+}
+function generateClientId() {
+  return `wai-${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/providers/claude-agent.ts
+var log2 = createLogger("claude");
+var DEFAULT_TOOLS = ["Read", "Glob", "Grep", "Bash", "WebSearch", "WebFetch"];
+var ClaudeAgentProvider = class {
+  name = "claude-agent";
+  config;
+  sessions = /* @__PURE__ */ new Map();
+  // userId -> sessionId
+  constructor(config) {
+    this.config = config;
+  }
+  async query(prompt, sessionId, options) {
+    const { query } = await import("@anthropic-ai/claude-agent-sdk");
+    const allowedTools = options?.allowedTools || this.config.allowedTools || DEFAULT_TOOLS;
+    const existingSession = this.sessions.get(sessionId);
+    const sdkOptions = {
+      allowedTools,
+      permissionMode: "acceptEdits"
+    };
+    if (options?.maxTokens) {
+      sdkOptions.maxTokens = options.maxTokens;
+    }
+    if (options?.cwd) {
+      sdkOptions.cwd = options.cwd;
+    }
+    if (existingSession) {
+      sdkOptions.resume = existingSession;
+    }
+    if (options?.systemPrompt) {
+      sdkOptions.systemPrompt = options.systemPrompt;
+    }
+    log2.info(`Querying Claude (session: ${sessionId.slice(0, 8)}...)`);
+    let result = "";
+    let newSessionId;
+    try {
+      for await (const message of query({
+        prompt,
+        options: sdkOptions
+      })) {
+        if (isInitMessage(message)) {
+          newSessionId = message.session_id;
+        }
+        if (isResultMessage(message)) {
+          result = message.result;
+        }
+        if (isAssistantMessage(message)) {
+          const textContent = extractText(message);
+          if (textContent) {
+            result = textContent;
+          }
+        }
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log2.error(`Claude query failed: ${errMsg}`);
+      throw err;
+    }
+    if (newSessionId) {
+      this.sessions.set(sessionId, newSessionId);
+    }
+    if (!result) {
+      result = "(No response from Claude)";
+    }
+    log2.info(`Response: ${result.length} chars`);
+    return result;
+  }
+};
+function isInitMessage(msg) {
+  return msg?.type === "system" && msg?.subtype === "init" && typeof msg?.session_id === "string";
+}
+function isResultMessage(msg) {
+  return typeof msg?.result === "string";
+}
+function isAssistantMessage(msg) {
+  return msg?.type === "assistant" && msg?.message?.content;
+}
+function extractText(msg) {
+  if (!msg?.message?.content) return null;
+  const parts = [];
+  for (const block of msg.message.content) {
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts.length > 0 ? parts.join("") : null;
+}
+
+// src/providers/openai-compatible.ts
+var log3 = createLogger("openai-compat");
+var OpenAICompatibleProvider = class {
+  name;
+  config;
+  histories = /* @__PURE__ */ new Map();
+  constructor(name, config) {
+    this.name = name;
+    this.config = config;
+  }
+  async query(prompt, sessionId, options) {
+    const baseUrl = this.config.baseUrl;
+    const apiKey = this.config.apiKey || process.env[this.config.apiKeyEnv || ""];
+    const model = options?.model || this.config.model;
+    if (!baseUrl) throw new Error(`${this.name}: baseUrl is required`);
+    if (!apiKey) throw new Error(`${this.name}: apiKey is required`);
+    if (!model) throw new Error(`${this.name}: model is required`);
+    let history = this.histories.get(sessionId);
+    if (!history) {
+      history = [];
+      this.histories.set(sessionId, history);
+    }
+    const messages = [];
+    const systemPrompt = options?.systemPrompt || this.config.systemPrompt;
+    if (systemPrompt) {
+      messages.push({ role: "system", content: systemPrompt });
+    }
+    const maxHistory = this.config.maxHistory || 20;
+    const recentHistory = history.slice(-maxHistory);
+    messages.push(...recentHistory);
+    messages.push({ role: "user", content: prompt });
+    log3.info(`Querying ${this.name} (model: ${model}, session: ${sessionId.slice(0, 8)}...)`);
+    const url = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        messages,
+        max_tokens: options?.maxTokens || this.config.maxTokens || 4096,
+        temperature: this.config.temperature ?? 0.7
+      })
+    });
+    if (!res.ok) {
+      const errBody = await res.text();
+      log3.error(`${this.name} API error ${res.status}: ${errBody.slice(0, 200)}`);
+      throw new Error(`${this.name} API error: ${res.status}`);
+    }
+    const data = await res.json();
+    const reply = data.choices[0]?.message.content || "(No response)";
+    if (data.usage) {
+      log3.info(`Tokens: ${data.usage.prompt_tokens} in / ${data.usage.completion_tokens} out`);
+    }
+    history.push({ role: "user", content: prompt });
+    history.push({ role: "assistant", content: reply });
+    log3.info(`Response: ${reply.length} chars`);
+    return reply;
+  }
+};
+
+// src/gateway.ts
+var log4 = createLogger("\u7F51\u5173");
+var Gateway = class {
+  channels = /* @__PURE__ */ new Map();
+  providers = /* @__PURE__ */ new Map();
+  config;
+  processing = /* @__PURE__ */ new Set();
+  constructor(config) {
+    this.config = config;
+  }
+  init() {
+    for (const [name, chConfig] of Object.entries(this.config.channels)) {
+      if (chConfig.enabled === false) continue;
+      switch (chConfig.type) {
+        case "weixin":
+          this.channels.set(name, new WeixinChannel(chConfig));
+          break;
+        default:
+          log4.warn(`\u672A\u77E5\u6E20\u9053\u7C7B\u578B: ${chConfig.type}`);
+      }
+    }
+    for (const [name, provConfig] of Object.entries(this.config.providers)) {
+      switch (provConfig.type) {
+        case "claude-agent":
+          this.providers.set(name, new ClaudeAgentProvider(provConfig));
+          break;
+        case "openai-compatible":
+          this.providers.set(name, new OpenAICompatibleProvider(name, provConfig));
+          break;
+        default:
+          log4.warn(`\u672A\u77E5\u6A21\u578B\u7C7B\u578B: ${provConfig.type}`);
+      }
+    }
+    log4.info(`\u5DF2\u521D\u59CB\u5316 ${this.channels.size} \u4E2A\u6E20\u9053, ${this.providers.size} \u4E2A\u6A21\u578B`);
+  }
+  async login(channelName) {
+    const channel = this.channels.get(channelName);
+    if (!channel) {
+      throw new Error(`\u6E20\u9053 "${channelName}" \u4E0D\u5B58\u5728`);
+    }
+    await channel.login();
+  }
+  async start() {
+    if (this.providers.size === 0) {
+      throw new Error("\u672A\u914D\u7F6E\u4EFB\u4F55\u6A21\u578B");
+    }
+    const startPromises = [...this.channels.entries()].map(([name, channel]) => {
+      log4.info(`\u542F\u52A8\u6E20\u9053: ${name}`);
+      return channel.start((msg) => this.handleMessage(msg)).catch((err) => {
+        log4.error(`\u6E20\u9053 ${name} \u5F02\u5E38: ${err instanceof Error ? err.message : err}`);
+      });
+    });
+    await Promise.all(startPromises);
+  }
+  async stop() {
+    log4.info("\u6B63\u5728\u5173\u95ED...");
+    const stops = [...this.channels.values()].map((ch) => ch.stop());
+    await Promise.allSettled(stops);
+    log4.info("\u5DF2\u5173\u95ED");
+  }
+  async handleMessage(msg) {
+    const lockKey = `${msg.channel}:${msg.senderId}`;
+    if (this.processing.has(lockKey)) {
+      log4.warn(`\u8DF3\u8FC7\u6D88\u606F (\u4E0A\u6761\u4ECD\u5728\u5904\u7406)`);
+      return;
+    }
+    this.processing.add(lockKey);
+    try {
+      if (msg.text.startsWith("/")) {
+        await this.handleCommand(msg);
+        return;
+      }
+      const providerName = this.config.userRoutes?.[msg.senderId] || this.config.defaultProvider;
+      const provider = this.providers.get(providerName);
+      if (!provider) {
+        log4.error(`\u6A21\u578B "${providerName}" \u672A\u627E\u5230`);
+        return;
+      }
+      log4.info(`\u8C03\u7528 ${providerName} \u5904\u7406\u4E2D...`);
+      const channel = this.channels.get(msg.channel);
+      if (channel && "sendTyping" in channel) {
+        channel.sendTyping(msg.senderId, msg.replyToken);
+      }
+      const options = {};
+      if (this.config.systemPrompt) {
+        options.systemPrompt = this.config.systemPrompt;
+      }
+      const sessionKey = `${msg.channel}:${msg.senderId}`;
+      const response = await provider.query(msg.text, sessionKey, options);
+      if (!channel) return;
+      await channel.send({
+        targetId: msg.senderId,
+        text: response,
+        replyToken: msg.replyToken
+      });
+      log4.info(`\u5DF2\u56DE\u590D (${response.length} \u5B57\u7B26)`);
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      log4.error(`\u5904\u7406\u6D88\u606F\u5931\u8D25: ${errMsg}`);
+      try {
+        const channel = this.channels.get(msg.channel);
+        if (channel) {
+          await channel.send({
+            targetId: msg.senderId,
+            text: `[\u51FA\u9519\u4E86] \u5904\u7406\u6D88\u606F\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002`,
+            replyToken: msg.replyToken
+          });
+        }
+      } catch {
+      }
+    } finally {
+      this.processing.delete(lockKey);
+    }
+  }
+  async handleCommand(msg) {
+    const channel = this.channels.get(msg.channel);
+    if (!channel) return;
+    const parts = msg.text.trim().split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const arg = parts[1];
+    switch (cmd) {
+      case "/model": {
+        if (!arg) {
+          const current = this.config.userRoutes?.[msg.senderId] || this.config.defaultProvider;
+          const available = [...this.providers.keys()].join(", ");
+          await channel.send({
+            targetId: msg.senderId,
+            text: `\u5F53\u524D\u6A21\u578B: ${current}
+\u53EF\u7528\u6A21\u578B: ${available}
+\u7528\u6CD5: /model <\u540D\u79F0>`,
+            replyToken: msg.replyToken
+          });
+        } else if (this.providers.has(arg)) {
+          if (!this.config.userRoutes) this.config.userRoutes = {};
+          this.config.userRoutes[msg.senderId] = arg;
+          await channel.send({
+            targetId: msg.senderId,
+            text: `\u5DF2\u5207\u6362\u5230: ${arg}`,
+            replyToken: msg.replyToken
+          });
+        } else {
+          await channel.send({
+            targetId: msg.senderId,
+            text: `\u672A\u77E5\u6A21\u578B: ${arg}
+\u53EF\u7528: ${[...this.providers.keys()].join(", ")}`,
+            replyToken: msg.replyToken
+          });
+        }
+        break;
+      }
+      case "/help": {
+        await channel.send({
+          targetId: msg.senderId,
+          text: [
+            "wx-ai \u6307\u4EE4:",
+            "/model [\u540D\u79F0] - \u5207\u6362AI\u6A21\u578B",
+            "/help - \u663E\u793A\u5E2E\u52A9",
+            "/ping - \u68C0\u67E5\u72B6\u6001"
+          ].join("\n"),
+          replyToken: msg.replyToken
+        });
+        break;
+      }
+      case "/ping": {
+        await channel.send({
+          targetId: msg.senderId,
+          text: `pong (${Date.now() - msg.timestamp}ms)`,
+          replyToken: msg.replyToken
+        });
+        break;
+      }
+      default: {
+        await channel.send({
+          targetId: msg.senderId,
+          text: `\u672A\u77E5\u6307\u4EE4: ${cmd}\uFF0C\u8BD5\u8BD5 /help`,
+          replyToken: msg.replyToken
+        });
+      }
+    }
+  }
+};
+
+export {
+  loadConfig,
+  saveConfig,
+  setLogLevel,
+  createLogger,
+  WeixinChannel,
+  ClaudeAgentProvider,
+  OpenAICompatibleProvider,
+  Gateway
+};
+//# sourceMappingURL=chunk-PRU3A74K.js.map