oh-my-im 0.1.21 → 0.2.0

package/dist/group-worker.js

@@ -1,18 +1,21 @@
 import { mkdir, open, readdir, readFile, rename, unlink, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { unlinkSync } from "node:fs";
+import { existsSync, mkdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
 import { agentLabel, agentSwitchMessage, runAgent } from "./agents/index.js";
-import { DingTalkCardClient } from "./dingtalk-card.js";
-import { applyMonitorCommand, parseMonitorCommand } from "./monitor-command.js";
+import { DingTalkCardClient } from "./dingtalk/dingtalk-card.js";
+import { DingTalkAiCardClient } from "./dingtalk/dingtalk-ai-card.js";
+import { AiCardSession } from "./dingtalk/ai-card.js";
+import { applyMonitorCommand, parseMonitorCommand } from "./core/monitor-command.js";
 import { normalizeAgentModel, } from "./dws-dashboard.js";
-import { dwsPath, listConversations, getCurrentDwsUser, listGroupBots, addBotToGroup, listGroupMembers, searchBots, startGroupEventStream, } from "./dws-client.js";
-import { createLogger } from "./logger.js";
-import { sendRobotGroupText, sendRobotWebhookText } from "./dingtalk-robot.js";
-import { appendConversationLog } from "./conversation-log.js";
-import { startPersonalHistoryPolling } from "./dws-history.js";
+import { dwsPath, listConversations, getCurrentDwsUser, listGroupBots, listGroupBotMembers, addBotToGroup, listGroupMembers, searchBots, startGroupEventStream, } from "./dws/dws-client.js";
+import { createLogger } from "./core/logger.js";
+import { normalizeDingTalkMarkdown } from "./dingtalk/markdown.js";
+import { sendRobotGroupText, sendRobotWebhookText } from "./dingtalk/dingtalk-robot.js";
+import { appendConversationLog } from "./core/conversation-log.js";
+import { startPersonalHistoryPolling } from "./dws/dws-history.js";
 const log = createLogger("group-worker");
 function notifyGroupFailure(groupId, context, err, config) {
     const reason = err instanceof Error ? err.message : String(err);
@@ -32,15 +35,18 @@ async function sendRobotText(openConversationId, config, content) {
     log.info(`robot API send openConversationId=${openConversationId} robotCode=${config.clientId} robotName=${config.robotName}`);
     return sendRobotGroupText(openConversationId, content, config.clientId, config.clientId, config.clientSecret);
 }
-const DEFAULT_CODEX_WORK_DIR = process.cwd();
 const DEFAULT_DWS_CODEX_TIMEOUT_MS = 300_000;
 const DWS_GROUP_MESSAGE_EVENT = "user_im_message_receive_group_all";
+// Shared AI card client. Credentials are (re)applied whenever the dashboard
+// config is loaded so the console template ID takes effect without a restart.
+const aiCardClient = new DingTalkAiCardClient();
 const DATA_DIR = join(homedir(), ".oh-my-im");
 const LEGACY_DATA_DIR = join(process.cwd(), ".oh-my-im");
 const CONFIG_MIGRATION_FILE = join(DATA_DIR, ".config-location-v1");
 const LISTENER_LOCK_FILE = join(DATA_DIR, "group-worker.lock");
 const CARD_STATE_FILE = join(DATA_DIR, "dws-cards.json");
 const GROUP_SESSIONS_FILE = join(DATA_DIR, "group-sessions.json");
+const GROUP_AGENTS_FILE = join(DATA_DIR, "group-agents.json");
 const DASHBOARD_CONFIG_FILE = join(DATA_DIR, "dws-dashboard.json");
 const DASHBOARD_SERVER_CONFIG_FILE = join(DATA_DIR, "dws-dashboard-server.json");
 const REPLY_HISTORY_DIR = join(DATA_DIR, "replies");
@@ -67,6 +73,23 @@ async function saveGroupSessions(sessions) {
     await writeFile(temporary, `${JSON.stringify(Object.fromEntries(sessions), null, 2)}\n`, "utf8");
     await rename(temporary, GROUP_SESSIONS_FILE);
 }
+// Agent 按群绑定：某群切了 Agent 不影响其他群，重启后每个群各自记住。
+let groupAgentBindings = new Map();
+async function loadGroupAgents() {
+    try {
+        const value = JSON.parse(await readFile(GROUP_AGENTS_FILE, "utf8"));
+        return new Map(Object.entries(value).filter((entry) => entry[1] === "pi" || entry[1] === "codex" || entry[1] === "opencode"));
+    }
+    catch {
+        return new Map();
+    }
+}
+async function saveGroupAgents(agents) {
+    await mkdir(DATA_DIR, { recursive: true });
+    const temporary = `${GROUP_AGENTS_FILE}.${process.pid}.tmp`;
+    await writeFile(temporary, `${JSON.stringify(Object.fromEntries(agents), null, 2)}\n`, "utf8");
+    await rename(temporary, GROUP_AGENTS_FILE);
+}
 function hasMention(event) {
     const hasValue = (value) => {
         if (Array.isArray(value))
@@ -229,10 +252,10 @@ async function acquireListenerLock() {
 async function loadCardState() {
     try {
         const parsed = JSON.parse(await readFile(CARD_STATE_FILE, "utf8"));
-        const cards = Object.fromEntries(Object.entries(parsed.cards ?? {}).map(([groupId, card]) => [
-            groupId,
-            typeof card === "string" ? { cardBizId: card, status: "completed" } : card,
-        ]));
+        const cards = Object.fromEntries(Object.entries(parsed.cards ?? {})
+            .map(([groupId, card]) => [groupId, typeof card === "string" ? { cardBizId: card, status: "completed" } : card])
+            // 旧格式遗留的空条目（key 为 cardBizId/status 等、cardBizId 为空）直接丢弃。
+            .filter((entry) => Boolean(entry[1]?.cardBizId)));
         return { cards };
     }
     catch (err) {
@@ -260,8 +283,6 @@ function defaultBotAllowedUserIds(targets) {
 function normalizeDashboardConfig(parsed) {
     if (!Array.isArray(parsed.targets))
         throw new Error("targets is invalid");
-    if (parsed.replyFormat !== "markdown" && parsed.replyFormat !== "plain")
-        throw new Error("replyFormat is invalid");
     const targets = parsed.targets;
     const legacyModel = parsed.agentModel?.trim() || "";
     const configuredModels = parsed.agentModels ?? { codex: "", pi: "", opencode: "" };
@@ -292,7 +313,7 @@ function normalizeDashboardConfig(parsed) {
             : {},
         robotSenderOpenDingTalkId: parsed.robotSenderOpenDingTalkId?.trim() || "",
         agentModels: {
-            codex: "",
+            codex: configuredModels.codex?.trim() || "",
             pi: normalizeAgentModel("pi", configuredModels.pi?.trim() || (parsed.agent === "pi" ? legacyModel : "")),
             opencode: normalizeAgentModel("opencode", configuredModels.opencode?.trim() || (parsed.agent === "opencode" ? legacyModel : "")),
         },
@@ -301,6 +322,9 @@ function normalizeDashboardConfig(parsed) {
             ? parsed.commandKeywords
             : structuredClone(EMPTY_COMMAND_KEYWORDS),
         groupPromptSuffix: promptSuffix,
+        aiCardTemplateId: typeof parsed.aiCardTemplateId === "string" ? parsed.aiCardTemplateId.trim() : "",
+        aiCardContentKey: (typeof parsed.aiCardContentKey === "string" ? parsed.aiCardContentKey.trim() : "") || "content",
+        aiCardStreamIntervalMs: Number.isFinite(parsed.aiCardStreamIntervalMs) ? Math.max(0, Math.min(60_000, Number(parsed.aiCardStreamIntervalMs))) : 500,
         robotName: parsed.robotName?.trim() || DEFAULT_ROBOT_NAME,
         clientId: parsed.clientId?.trim() || DEFAULT_DINGTALK_CLIENT_ID,
         clientSecret: parsed.clientSecret?.trim() || DEFAULT_DINGTALK_CLIENT_SECRET,
@@ -382,11 +406,13 @@ async function loadDashboardConfig() {
         botSuperAdminUserIds: [],
         botSuperAdminUserNames: {},
         robotSenderOpenDingTalkId: "",
-        replyFormat: "markdown",
         agentModels: { codex: "", pi: "", opencode: "" },
         agent: "codex",
         commandKeywords: structuredClone(EMPTY_COMMAND_KEYWORDS),
         groupPromptSuffix: DEFAULT_GROUP_PROMPT_SUFFIX,
+        aiCardTemplateId: "",
+        aiCardContentKey: "content",
+        aiCardStreamIntervalMs: 500,
         robotName: DEFAULT_ROBOT_NAME,
         clientId: DEFAULT_DINGTALK_CLIENT_ID,
         clientSecret: DEFAULT_DINGTALK_CLIENT_SECRET,
@@ -574,17 +600,24 @@ async function handleMonitorCommand(command, event, groupId, getDashboardConfig,
         senderId,
         senderName,
     };
+    if (typeof command === "object" && command.type === "switch-agent") {
+        // Agent 只绑定到当前群，不再改全局默认。
+        groupAgentBindings.set(groupId, command.agent);
+        await saveGroupAgents(groupAgentBindings);
+        if (sendReply)
+            await sendRobotText(groupId, config, agentSwitchMessage(command.agent));
+        log.info(`monitor command=switch-agent:${command.agent} group=${groupId} replied=${sendReply}`);
+        return;
+    }
     const result = applyMonitorCommand(config, command, target);
     if (result.changed)
         await updateDashboardConfig(result.config);
-    const detail = typeof command === "object"
-        ? agentSwitchMessage(command.agent)
-        : command === "open"
-            ? `已开启 ${senderName} 在本群的AI 能力。`
-            : `已关闭 ${senderName} 在本群的AI 能力。`;
+    const detail = command === "open"
+        ? `已开启 ${senderName} 在本群的AI 能力。`
+        : `已关闭 ${senderName} 在本群的AI 能力。`;
     if (sendReply)
         await sendRobotText(groupId, config, detail);
-    log.info(`monitor command=${typeof command === "object" ? command.type + ":" + command.agent : command} group=${groupId} changed=${result.changed} replied=${sendReply}`);
+    log.info(`monitor command=${command} group=${groupId} changed=${result.changed} replied=${sendReply}`);
 }
 function senderDisplayName(event) {
     const rawSender = event.sender;
@@ -634,19 +667,14 @@ function isCurrentDwsUser(event, currentUser) {
 function configuredGroupIds(config) {
     return Array.from(new Set(config.targets.map((target) => target.groupId)));
 }
-function formatReply(content, format) {
-    if (format === "markdown")
-        return content;
-    return content.replace(/[\\`*_{}\[\]<>()#+\-.!|]/g, "\\$&");
+function formatReply(content) {
+    // DingTalk markdown has no table support; rewrite tables into readable lists
+    // for both the card and the plain-text reply path.
+    return normalizeDingTalkMarkdown(content);
 }
-function completedCardContent(content, modelName, messageCount, toolStats, showDetails) {
+function completionNote(modelName, messageCount, toolStats) {
     const toolCount = Object.values(toolStats).reduce((total, count) => total + count, 0);
-    if (!showDetails)
-        return content.trim() || "(无输出)";
-    return [
-        content.trim() || "(无输出)",
-        `[夯爆了] ${modelName || "默认模型"} ${messageCount}条消息 ${toolCount}次工具`,
-    ].join("\n\n\n");
+    return `${modelName || "默认模型"} ${messageCount}条消息,${toolCount}次工具`;
 }
 function batchQuestion(events) {
     return events.map((event) => event.content?.trim()).filter(Boolean).join("\n");
@@ -685,11 +713,53 @@ function getSenderId(event) {
         (typeof sender.user_id === "string" ? sender.user_id.trim() : "") ||
         "unknown";
 }
+const groupBotCache = new Map();
+const groupBotRefreshing = new Set();
+const GROUP_BOT_CACHE_TTL_MS = 5 * 60 * 1000;
+async function refreshGroupBotCache(groupId, force = false) {
+    const cached = groupBotCache.get(groupId);
+    if (!force && cached && Date.now() - cached.fetchedAt < GROUP_BOT_CACHE_TTL_MS)
+        return;
+    if (groupBotRefreshing.has(groupId))
+        return;
+    groupBotRefreshing.add(groupId);
+    try {
+        const bots = await listGroupBotMembers(groupId);
+        groupBotCache.set(groupId, {
+            ids: new Map(bots.map((bot) => [bot.senderId.toLowerCase(), bot.senderName])),
+            fetchedAt: Date.now(),
+        });
+        log.info(`group bot members refreshed group=${groupId} bots=${bots.map((bot) => bot.senderName).join(",") || "<none>"}`);
+    }
+    catch (err) {
+        log.warn(`unable to refresh group bot members group=${groupId}: ${String(err)}`);
+        // Cache the failure briefly so a broken DWS call does not run on every message.
+        if (!cached)
+            groupBotCache.set(groupId, { ids: new Map(), fetchedAt: Date.now() });
+    }
+    finally {
+        groupBotRefreshing.delete(groupId);
+    }
+}
+// Values of the DingTalk "AI sent" badge/flag that mean the message came from
+// an AI. Anything else (including normal user messages) is not treated as AI so
+// a real person can never be silenced by an unexpected flag value.
+const AI_SEND_FLAG_VALUES = new Set(["DWS", "AI", "AIGC", "AI_TAG", "AITAG", "ROBOT", "BOT", "ASSISTANT", "TRUE", "1", "Y", "YES", "ON"]);
+function isAiSendFlag(event) {
+    const raw = [event.messageAiSendFlag, event.aiSendFlag, event.message_ai_send_flag, event.aiTag, event.ai_tag, event.messageAiTag, event.message_ai_tag]
+        .find((value) => typeof value === "string" && Boolean(value.trim()));
+    if (!raw)
+        return false;
+    return AI_SEND_FLAG_VALUES.has(raw.trim().toUpperCase());
+}
 function isIgnoredRobotEvent(event, config) {
     const sender = event.sender ?? {};
     const senderId = getSenderId(event).toLowerCase();
-    const messageAiSendFlag = typeof event.messageAiSendFlag === "string" ? event.messageAiSendFlag.trim().toUpperCase() : "";
-    if (messageAiSendFlag === "DWS")
+    if (isAiSendFlag(event))
+        return true;
+    // Any bot that is a member of this group is an AI sender.
+    const groupId = eventGroupId(event);
+    if (groupId && groupBotCache.get(groupId)?.ids.has(senderId))
         return true;
     const configuredRobotId = config.robotSenderOpenDingTalkId?.trim().toLowerCase();
     if (configuredRobotId && senderId === configuredRobotId)
@@ -741,8 +811,38 @@ function isIgnoredRobotEvent(event, config) {
         return true;
     return false;
 }
-function codexConfig() {
-    const workDir = process.env.CODEX_WORK_DIR?.trim() || DEFAULT_CODEX_WORK_DIR;
+function safeDirName(value, fallback) {
+    // Keep Chinese characters and normal punctuation, strip anything that could
+    // escape the target directory or break on the filesystem.
+    const cleaned = value
+        .replace(/[\u0000-\u001f\u007f]/g, "")
+        .replace(/[\\/:*?"<>|]/g, "_")
+        .replace(/\s+/g, " ")
+        .replace(/^\.+/, "")
+        .trim()
+        .slice(0, 80)
+        .trim();
+    return cleaned || fallback;
+}
+function groupWorkDir(groupId, dashboardConfig, event) {
+    // Explicit env override wins (exact directory, no group subfolder).
+    const override = process.env.CODEX_WORK_DIR?.trim();
+    if (override)
+        return override;
+    const name = event ? eventGroupName(event, groupId, dashboardConfig) : knownGroupName(groupId);
+    return join(DATA_DIR, "group", safeDirName(name, safeDirName(groupId, "unknown")));
+}
+function codexConfig(workDir) {
+    // Auto-create a configured directory so all three Agents can spawn in it.
+    // Failures are logged (not thrown) and surface later as a spawn error.
+    if (!existsSync(workDir)) {
+        try {
+            mkdirSync(workDir, { recursive: true });
+        }
+        catch (err) {
+            log.warn(`cannot create group work dir ${workDir}: ${String(err)}`);
+        }
+    }
     const timeout = Number.parseInt(process.env.DWS_CODEX_TIMEOUT_MS || String(DEFAULT_DWS_CODEX_TIMEOUT_MS), 10);
     return {
         dingtalkClientId: "",
@@ -765,12 +865,14 @@ function cleanAgentContent(value) {
         .replace(/\s*(?:\[?语音消息\]?)(?:\([^)]*\))?\s*$/u, "")
         .trim();
 }
-function buildPrompt(events) {
+function buildPrompt(events, suffix) {
     const messageContent = events
         .map((event) => cleanAgentContent(event.content?.trim() || event.text?.trim() || ""))
         .filter(Boolean)
         .join("\n");
-    return messageContent;
+    // Restore the prompt suffix that the OpenCode refactor dropped: it is
+    // appended below the user message and applies to every group Agent.
+    return [messageContent, suffix.trim()].filter(Boolean).join("\n\n");
 }
 async function handleBatch(events, groupId, cardState, sessions, cardClient, getDashboardConfig, replies, liveReplies, queue) {
     if (events.length === 0)
@@ -779,18 +881,32 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
     // an already queued history/stream duplicate must not create a new card
     // after the stopped card has been finalized.
     const dashboardConfig = getDashboardConfig();
-    const responseMode = dashboardConfig.responseMode ?? "card";
-    const agent = dashboardConfig.agent;
-    const agentConfig = codexConfig();
+    const requestedMode = dashboardConfig.responseMode ?? "card";
+    const aiTemplateId = dashboardConfig.aiCardTemplateId?.trim() || "";
+    const aiContentKey = dashboardConfig.aiCardContentKey?.trim() || "content";
+    const aiStreamIntervalMs = Number.isFinite(dashboardConfig.aiCardStreamIntervalMs)
+        ? Math.max(0, Number(dashboardConfig.aiCardStreamIntervalMs))
+        : 500;
+    // AI card needs a template ID and app credentials. Without them fall back to
+    // the standard card so a missing configuration never breaks replies.
+    let useAiCard = requestedMode === "aiCard" && Boolean(aiTemplateId) && aiCardClient.configured;
+    if (requestedMode === "aiCard" && !useAiCard) {
+        log.warn(`AI card unavailable (template=${aiTemplateId ? "set" : "empty"}, credentials=${aiCardClient.configured}); using standard card`);
+    }
+    const responseMode = requestedMode === "text" ? "text" : "card";
+    const agent = groupAgentBindings.get(groupId) ?? dashboardConfig.agent;
+    const workDir = groupWorkDir(groupId, dashboardConfig, events[0]);
+    const agentConfig = codexConfig(workDir);
     agentConfig.agent = agent;
-    agentConfig.agentModel = agent === "pi" || agent === "opencode" ? dashboardConfig.agentModels[agent] || undefined : undefined;
+    agentConfig.agentModel = agent === "pi" || agent === "opencode" || agent === "codex" ? dashboardConfig.agentModels[agent] || undefined : undefined;
     const modelName = agentConfig.agentModel?.trim().split("/").pop() || "";
-    const label = `${agentLabel(agent)} Agent`;
-    const processingLabel = agent === "codex" ? `${agentLabel(agent)} Agent` : `${agentLabel(agent)} ${modelName || "默认模型"}`;
+    const label = agentLabel(agent);
+    const processingLabel = `${agentLabel(agent)} ${modelName || "默认模型"}`;
     const processingMessage = `[OMG] ${processingLabel} 正在分析...`;
-    const sessionKey = `${agent}:${groupId}`;
+    const sessionKey = `${agent}:${groupId}:${workDir}`;
     const sessionId = sessions.get(sessionKey);
     log.info(`processing batch size=${events.length} groupSession=${sessionId ? "resume" : "new"}`);
+    const cardIdentity = (value) => value.kind === "aiCard" ? value.session.outTrackId : value.handle.cardBizId;
     let card;
     let stopCardUpdates = () => undefined;
     let latestVisibleContent = `${label} 正在处理...`;
@@ -814,12 +930,42 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
     // The setting only controls the live processing title. Completion always
     // includes the elapsed time as a useful final result summary.
     const finishedTitle = (icon, state) => `${icon} ${title}${state} 总耗时 ${formatElapsed()}`;
+    // Push a card snapshot. AI cards stream full markdown via the streaming API;
+    // standard cards use the cardBizId update API. AI card failures are
+    // best-effort and must never fail the agent task.
+    const pushCard = async (target, title, content) => {
+        if (target.kind === "aiCard") {
+            await target.session.push(formatReply(content));
+            return;
+        }
+        await cardClient.update(target.handle, title, formatReply(content));
+    };
+    const finishCard = async (target, title, content, state, endText) => {
+        if (target.kind === "aiCard") {
+            const stateLabel = state === "completed" ? "完成" : state === "paused" ? "处理暂停" : "处理失败";
+            const statusTitle = `【${label}】${stateLabel} 总耗时 ${formatElapsed()}`;
+            const delivered = await target.session.finish({
+                content: formatReply(content),
+                title: statusTitle,
+                endText: endText ? formatReply(endText) : undefined,
+                error: state !== "completed",
+            });
+            // 流式接口完全失败时发一条文本，保证用户仍能拿到结果。
+            if (!delivered && state === "completed") {
+                await sendRobotText(groupId, getDashboardConfig(), formatReply(`${content}\n\n总耗时 ${formatElapsed()}`))
+                    .catch((sendErr) => log.warn(`AI card text fallback failed: ${String(sendErr)}`));
+            }
+            return;
+        }
+        const cardContent = state === "completed" && endText ? `${content}\n\n\n[夯爆了] ${endText}` : content;
+        await cardClient.update(target.handle, title, formatReply(cardContent));
+    };
     try {
         const storedCard = cardState.cards[groupId];
-        if (responseMode === "card" && storedCard?.status === "processing") {
-            card = { groupId, cardBizId: storedCard.cardBizId };
+        if (responseMode === "card" && storedCard?.status === "processing" && !useAiCard) {
+            card = { kind: "card", handle: { groupId, cardBizId: storedCard.cardBizId } };
             try {
-                await cardClient.update(card, processingTitle(), processingMessage);
+                await cardClient.update(card.handle, processingTitle(), processingMessage);
             }
             catch (err) {
                 if (!isMissingCardError(err))
@@ -829,10 +975,46 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
                 card = undefined;
             }
         }
+        if (responseMode === "card" && useAiCard && storedCard?.status === "processing") {
+            // A previous AI card was left in the "输入中" state by a restart. Close it
+            // as an error so it does not stay in the typing state forever.
+            const staleSession = new AiCardSession({
+                client: aiCardClient,
+                templateId: aiTemplateId,
+                contentKey: aiContentKey,
+                log,
+                outTrackId: storedCard.cardBizId,
+            });
+            await staleSession.closeStale();
+            delete cardState.cards[groupId];
+        }
         if (responseMode === "card" && !card) {
-            const cardBizId = randomUUID();
-            card = await cardClient.create(groupId, cardBizId, processingTitle(), processingMessage);
-            cardState.cards[groupId] = { cardBizId, status: "processing" };
+            const cardId = randomUUID();
+            if (useAiCard) {
+                try {
+                    const session = new AiCardSession({
+                        client: aiCardClient,
+                        templateId: aiTemplateId,
+                        contentKey: aiContentKey,
+                        log,
+                        outTrackId: cardId,
+                    });
+                    await session.openForGroup({
+                        openConversationId: groupId,
+                        title: `【${label}】${modelName || "默认模型"} 进行中...`,
+                    });
+                    card = { kind: "aiCard", session };
+                }
+                catch (err) {
+                    log.warn(`AI card create failed; falling back to standard card: ${String(err)}`);
+                    useAiCard = false;
+                    card = { kind: "card", handle: await cardClient.create(groupId, cardId, processingTitle(), processingMessage) };
+                }
+            }
+            else {
+                card = { kind: "card", handle: await cardClient.create(groupId, cardId, processingTitle(), processingMessage) };
+            }
+            cardState.cards[groupId] = { cardBizId: cardId, status: "processing" };
             await saveCardState(cardState);
         }
         if (responseMode === "text")
@@ -869,9 +1051,10 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
             pendingCardTimer = undefined;
             pendingCardUpdate = undefined;
         };
-        // Pi emits very small deltas quickly. Coalesce them into one complete card
-        // snapshot per second so DingTalk receives fresh content without a backlog.
-        const getCardIntervalMs = () => getDashboardConfig().cardUpdateIntervalMs;
+        // Pi emits very small deltas quickly. Coalesce them into one snapshot so
+        // DingTalk receives fresh content without a backlog. AI cards use their own
+        // (usually faster) typing interval.
+        const getCardIntervalMs = () => useAiCard ? aiStreamIntervalMs : getDashboardConfig().cardUpdateIntervalMs;
         const pumpCardUpdate = () => {
             if (cardUpdatesStopped || cardUpdateInFlight || !pendingCardUpdate)
                 return;
@@ -897,7 +1080,7 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
             if (!activeCard)
                 return;
             lastCardUpdateAt = Date.now();
-            cardUpdateInFlight = cardClient.update(activeCard, latest.title, formatReply(latest.content, getDashboardConfig().replyFormat))
+            cardUpdateInFlight = pushCard(activeCard, latest.title, latest.content)
                 .catch((err) => log.warn(`card update skipped: ${String(err)}`))
                 .finally(() => {
                 cardUpdateInFlight = undefined;
@@ -916,7 +1099,7 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
             if (pendingCardUpdate && !cardUpdatesStopped && activeCard) {
                 const latest = pendingCardUpdate;
                 pendingCardUpdate = undefined;
-                await cardClient.update(activeCard, latest.title, formatReply(latest.content, getDashboardConfig().replyFormat))
+                await pushCard(activeCard, latest.title, latest.content)
                     .catch((err) => log.warn(`card update skipped: ${String(err)}`));
             }
         };
@@ -928,7 +1111,7 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
             pendingCardUpdate = { title, content };
             pumpCardUpdate();
         };
-        if (responseMode === "card") {
+        if (responseMode === "card" && !useAiCard) {
             elapsedTimer = setInterval(() => {
                 updateCard(processingTitle(), liveReply.content.slice(-8_000));
             }, 1_000);
@@ -936,17 +1119,19 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
         }
         let streamedText = "";
         let toolStatus = "";
-        const result = await runAgent(agent, buildPrompt(events), sessionId, agentConfig, {
+        const result = await runAgent(agent, buildPrompt(events, dashboardConfig.groupPromptSuffix), sessionId, agentConfig, {
             onAbortReady: (abort) => { if (queue)
                 queue.abort = abort; },
             onSteerReady: (steer) => { if (queue && agent === "pi")
                 queue.steer = steer; },
             onToolUse: (toolName, stats) => {
-                log.info(`codex tool=${toolName} count=${stats[toolName] ?? 1}`);
-                toolStatus = `[OMG] 调用工具：${toolName} x${stats[toolName] ?? 1}`;
-                liveReply.content = streamedText ? `${streamedText}\n\n\n${toolStatus}` : toolStatus;
-                latestVisibleContent = liveReply.content;
-                updateCard(processingTitle(), liveReply.content);
+                const totalCalls = Object.values(stats).reduce((sum, count) => sum + (count || 0), 0);
+                log.info(`tool=${toolName} total=${totalCalls}`);
+                // AI 卡片在工具调用/等待期显示实时调用次数，出字后清除。
+                if (!useAiCard)
+                    return;
+                toolStatus = `[OMG] 正在调用工具（已 ${totalCalls} 次）…`;
+                updateCard(processingTitle(), streamedText ? `${streamedText}\n\n${toolStatus}` : toolStatus);
             },
             onText: (text) => {
                 streamedText = text;
@@ -973,14 +1158,16 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
             await saveGroupSessions(sessions);
         }
         await flushPendingCardUpdate();
-        const replyText = formatReply(completedCardContent(result.text, modelName, events.length, result.toolStats, getDashboardConfig().showProcessingDetails), getDashboardConfig().replyFormat);
+        const showDetails = getDashboardConfig().showProcessingDetails;
+        const note = showDetails ? completionNote(modelName, events.length, result.toolStats) : undefined;
+        const completedContent = result.text.trim() || "(无输出)";
         if (responseMode === "card" && activeCard)
-            await cardClient.update(activeCard, finishedTitle("✅", "完成"), replyText);
+            await finishCard(activeCard, finishedTitle("✅", "完成"), completedContent, "completed", note);
         else
-            await sendRobotText(groupId, getDashboardConfig(), replyText);
+            await sendRobotText(groupId, getDashboardConfig(), formatReply(note ? `${completedContent}\n\n\n[夯爆了] ${note}` : completedContent));
         liveReplies.delete(groupId);
         if (activeCard)
-            cardState.cards[groupId] = { cardBizId: activeCard.cardBizId, status: "completed" };
+            cardState.cards[groupId] = { cardBizId: cardIdentity(activeCard), status: "completed" };
         await saveCardState(cardState);
         await recordReply(replies, {
             id: randomUUID(),
@@ -1025,9 +1212,9 @@ async function handleBatch(events, groupId, cardState, sessions, cardClient, get
             // paused/failed card update. This prevents a queued update from arriving
             // after stop and changing the title back to "处理中".
             stopCardUpdates();
-            await cardClient.update(card, stopped ? finishedTitle("🔴", "处理暂停") : finishedTitle("❌", "处理失败"), stopped ? stoppedContent : `${label} 处理失败：${message.slice(0, 2_000)}`)
+            await finishCard(card, stopped ? finishedTitle("🔴", "处理暂停") : finishedTitle("❌", "处理失败"), stopped ? stoppedContent : `${label} 处理失败：${message.slice(0, 2_000)}`, stopped ? "paused" : "failed")
                 .catch((updateErr) => log.warn(`card failure update skipped: ${String(updateErr)}`));
-            cardState.cards[groupId] = { cardBizId: card.cardBizId, status: stopped ? "failed" : "failed" };
+            cardState.cards[groupId] = { cardBizId: cardIdentity(card), status: stopped ? "failed" : "failed" };
             await saveCardState(cardState);
             await recordReply(replies, {
                 id: randomUUID(),
@@ -1064,7 +1251,7 @@ async function enqueueGroupEvent(event, groupId, queues, cardState, sessions, ca
         if (queue.activeAgent === "pi" && queue.steer && content) {
             const steered = queue.steer(content);
             if (steered) {
-                void sendRobotText(groupId, getDashboardConfig(), "[灵感]已将这条消息作为引导发送给当前 Pi 任务。")
+                void sendRobotText(groupId, getDashboardConfig(), "[灵感] 已将这条消息作为引导发送给当前 Pi 任务。")
                     .catch((err) => log.warn(`steer acknowledgement failed: ${String(err)}`));
                 log.info(`steered message=${event.message_id || "unknown"} group=${groupId}`);
                 return;
@@ -1145,6 +1332,10 @@ function startGroupListener(seen, queues, cardState, sessions, cardClient, getDa
             log.warn("group event ignored: missing conversation_id");
             return;
         }
+        // Keep the group-bot cache warm for monitored groups. Non-blocking: the
+        // current message uses the cached copy, which is prefetched at startup.
+        if (config.targets.some((target) => target.groupId === groupId))
+            void refreshGroupBotCache(groupId);
         if (isIgnoredRobotEvent(event, config)) {
             log.debug(`ignored robot message event=${event.event_id || "unknown"}`);
             return;
@@ -1153,7 +1344,7 @@ function startGroupListener(seen, queues, cardState, sessions, cardClient, getDa
         // metadata is complete. Never feed our own steer acknowledgement back into
         // the active Pi task, even if robot detection missed that event.
         const eventContent = (event.content || event.text || "").trim();
-        if (queues.get(groupId)?.running && /^\[灵感\]已将这条消息作为引导发送给当前 Pi 任务[。.!！]?$/u.test(eventContent)) {
+        if (queues.get(groupId)?.running && /^\[灵感\] 已将这条消息作为引导发送给当前 Pi 任务[。.!！]?$/u.test(eventContent)) {
             log.debug(`ignored self steer acknowledgement group=${groupId}`);
             return;
         }
@@ -1251,9 +1442,12 @@ function startGroupListener(seen, queues, cardState, sessions, cardClient, getDa
                     await sendRobotText(groupId, getDashboardConfig(), "当前 Agent 任务正在运行，请先暂停后再新建会话。");
                     return;
                 }
-                sessions.delete(`pi:${groupId}`);
-                sessions.delete(`codex:${groupId}`);
-                sessions.delete(`opencode:${groupId}`);
+                for (const agent of ["pi", "codex", "opencode"]) {
+                    const prefix = `${agent}:${groupId}:`;
+                    for (const key of [...sessions.keys()])
+                        if (key.startsWith(prefix))
+                            sessions.delete(key);
+                }
                 await saveGroupSessions(sessions);
                 await sendRobotText(groupId, getDashboardConfig(), "已清空当前群会话的 Agent session，下一条消息将使用新会话处理。");
                 log.info(`group sessions cleared group=${groupId}`);
@@ -1268,9 +1462,7 @@ function startGroupListener(seen, queues, cardState, sessions, cardClient, getDa
         if (options.commandsOnly && !command)
             return;
         if (command) {
-            // Agent switching is scoped to an existing "group + sender" monitor
-            // rule. Group robot membership is checked asynchronously below before
-            // changing the shared agent setting.
+            // Agent 切换只影响当前群（每个群在 group-agents.json 各自保存）。
             if (typeof command === "object" && command.type === "switch-agent" && !acceptsTarget(event, config)) {
                 log.debug(`ignored agent switch outside monitor rule group=${groupId} sender=${getSenderId(event)}`);
                 return;
@@ -1450,6 +1642,7 @@ async function main() {
     const queues = new Map();
     const cardState = await loadCardState();
     const sessions = await loadGroupSessions();
+    groupAgentBindings = await loadGroupAgents();
     const cardClient = new DingTalkCardClient();
     let dashboardConfig = await loadDashboardConfig();
     const applyDashboardConfig = async (config) => {
@@ -1457,11 +1650,21 @@ async function main() {
         dashboardConfig = config;
         cardClient.setCredentials(config.clientId, config.clientSecret);
         cardClient.setRobotCode(config.clientId);
+        aiCardClient.setCredentials(config.clientId, config.clientSecret, config.clientId);
         log.info(`dashboard config applied: ${configuredGroupIds(config).length} group(s), ${config.targets.length} rule(s)`);
     };
     await saveDashboardConfig(dashboardConfig);
     cardClient.setCredentials(dashboardConfig.clientId, dashboardConfig.clientSecret);
     cardClient.setRobotCode(dashboardConfig.clientId);
+    aiCardClient.setCredentials(dashboardConfig.clientId, dashboardConfig.clientSecret, dashboardConfig.clientId);
+    // Warm the group-bot cache for every monitored group so a message from any
+    // AI robot in the group is ignored from the very first event.
+    void Promise.all(configuredGroupIds(dashboardConfig).map((groupId) => refreshGroupBotCache(groupId, true)));
+    // Refresh periodically so bots added after startup are also ignored.
+    const groupBotRefreshTimer = setInterval(() => {
+        void Promise.all(configuredGroupIds(dashboardConfig).map((groupId) => refreshGroupBotCache(groupId, true)));
+    }, GROUP_BOT_CACHE_TTL_MS);
+    groupBotRefreshTimer.unref();
     const replies = await loadReplyHistory();
     const liveReplies = new Map();
     const runtime = {
@@ -1479,6 +1682,7 @@ async function main() {
             dashboardConfig = latest;
             cardClient.setCredentials(latest.clientId, latest.clientSecret);
             cardClient.setRobotCode(latest.clientId);
+            aiCardClient.setCredentials(latest.clientId, latest.clientSecret, latest.clientId);
             log.info(`dashboard config reloaded: ${configuredGroupIds(latest).length} group(s), ${latest.targets.length} rule(s)`);
         }).catch((err) => log.warn(`dashboard config reload failed: ${String(err)}`));
     }, 1_000);

package/dist/omi.js

@@ -5,7 +5,7 @@ import { createInterface } from "node:readline/promises";
 import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
-import { readVersion } from "./version.js";
+import { readVersion } from "./core/version.js";
 const args = process.argv.slice(2);
 const command = args.find((argument) => !argument.startsWith("-")) ?? "start";
 const noListen = args.includes("--no-listen");