evolclaw 2.2.0 → 2.4.0

package/dist/index.js

@@ -1,23 +1,26 @@
-import { ClaudeSessionFileAdapter } from './core/adapters/claude-session-file-adapter.js';
-import { CodexSessionFileAdapter } from './core/adapters/codex-session-file-adapter.js';
-import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, validateConfigIntegrity } from './config.js';
-import { SessionManager } from './core/session-manager.js';
+import { ClaudeSessionFileAdapter } from './core/session/adapters/claude-session-file-adapter.js';
+import { CodexSessionFileAdapter } from './core/session/adapters/codex-session-file-adapter.js';
+import { GeminiSessionFileAdapter } from './core/session/adapters/gemini-session-file-adapter.js';
+import { loadConfig, ensureDataDirs, resolvePaths, resolveAnthropicConfig, isOwner, validateConfigIntegrity, validateChannelInstanceNames, getOwner } from './config.js';
+import { SessionManager } from './core/session/session-manager.js';
 import { ClaudeAgentPlugin } from './agents/claude-runner.js';
 import { CodexAgentPlugin } from './agents/codex-runner.js';
+import { GeminiAgentPlugin } from './agents/gemini-runner.js';
 import { FeishuChannelPlugin } from './channels/feishu.js';
 import { WechatChannelPlugin } from './channels/wechat.js';
 import { AUNChannelPlugin } from './channels/aun.js';
-import { MessageProcessor } from './core/message-processor.js';
-import { MessageQueue } from './core/message-queue.js';
-import { MessageBridge } from './core/message-bridge.js';
-import { MessageCache } from './utils/message-cache.js';
+import { MessageProcessor } from './core/message/message-processor.js';
+import { MessageQueue } from './core/message/message-queue.js';
+import { MessageBridge } from './core/message/message-bridge.js';
+import { MessageCache } from './core/message/message-cache.js';
 import { CommandHandler } from './core/command-handler.js';
 import { EventBus } from './core/event-bus.js';
-import { StatsCollector } from './core/stats-collector.js';
+import { StatsCollector } from './utils/stats-collector.js';
 import { PermissionGateway } from './core/permission.js';
+import { InteractionRouter } from './core/interaction-router.js';
 import { ChannelLoader } from './core/channel-loader.js';
 import { AgentLoader } from './core/agent-loader.js';
-import { IpcServer } from './core/ipc-server.js';
+import { IpcServer } from './ipc.js';
 import { logger } from './utils/logger.js';
 import path from 'path';
 import fs from 'fs';
@@ -54,6 +57,8 @@ async function main() {
     }
     const anthropic = resolveAnthropicConfig(config);
     logger.info('✓ Config loaded (API keys hidden)');
+    // Channel instance name uniqueness check
+    validateChannelInstanceNames(config);
     if (anthropic.baseUrl) {
         logger.info(`✓ Using custom API base URL: ${anthropic.baseUrl}`);
     }
@@ -70,10 +75,12 @@ async function main() {
     // 注册会话文件适配器（Claude / Codex 各自的会话文件操作）
     sessionManager.registerFileAdapter(new ClaudeSessionFileAdapter());
     sessionManager.registerFileAdapter(new CodexSessionFileAdapter());
+    sessionManager.registerFileAdapter(new GeminiSessionFileAdapter());
     // Agent 插件系统
     const agentLoader = new AgentLoader();
     agentLoader.register(new ClaudeAgentPlugin());
     agentLoader.register(new CodexAgentPlugin());
+    agentLoader.register(new GeminiAgentPlugin());
     const agentInstances = agentLoader.createAll(config, {
         onSessionIdUpdate: async (sessionId, agentSessionId) => {
             await sessionManager.updateAgentSessionIdBySessionId(sessionId, agentSessionId);
@@ -93,6 +100,8 @@ async function main() {
     // 权限审批网关
     const permissionGateway = new PermissionGateway();
     permissionGateway.setEventBus(eventBus);
+    // 交互路由器
+    const interactionRouter = new InteractionRouter();
     // 为所有支持权限的 agent 设置 gateway
     for (const inst of agentInstances) {
         inst.agent.setPermissionGateway?.(permissionGateway);
@@ -111,9 +120,12 @@ async function main() {
     channelLoader.register(new AUNChannelPlugin());
     const channelInstances = await channelLoader.createAll(config);
     logger.info(`✓ Created ${channelInstances.length} channel instance(s)`);
+    // 启动迁移：将 sessions.channel 从 channelType 回填为实例名
+    sessionManager.migrateChannelToInstanceName();
     // 创建命令处理器
     const cmdHandler = new CommandHandler(sessionManager, agentMap, config, messageCache, eventBus, defaultAgent);
     cmdHandler.setPermissionGateway(permissionGateway);
+    cmdHandler.setInteractionRouter(interactionRouter);
     cmdHandler.setStatsCollector(statsCollector);
     // 创建消息处理器
     const processor = new MessageProcessor(agentMap, sessionManager, config, messageCache, eventBus, (content, channel, channelId, userId, threadId) => {
@@ -129,6 +141,8 @@ async function main() {
     }, defaultAgent);
     // 回填 processor 和 messageQueue 的引用
     cmdHandler.setProcessor(processor);
+    // 设置交互路由器
+    processor.setInteractionRouter(interactionRouter);
     // 设置 compact 开始回调（对所有支持的 agent）
     for (const inst of agentInstances) {
         inst.agent.setCompactStartCallback?.((sessionId) => {
@@ -166,18 +180,27 @@ async function main() {
         // 设置项目路径提供器（如果需要）
         if (inst.onProjectPathRequest && inst.channel.onProjectPathRequest) {
             inst.channel.onProjectPathRequest(async (channelId) => {
-                const session = await sessionManager.getOrCreateSession(inst.adapter.name, channelId, config.projects?.defaultPath || process.cwd(), undefined, undefined, undefined, undefined);
+                const session = await sessionManager.getOrCreateSession(inst.adapter.channelName, channelId, config.projects?.defaultPath || process.cwd(), undefined, undefined, undefined, undefined);
                 return path.isAbsolute(session.projectPath)
                     ? session.projectPath
                     : path.resolve(process.cwd(), session.projectPath);
             });
         }
-        // 注册 adapter、policy 和 options
-        processor.registerChannel(inst.adapter, inst.policy || defaultPolicy, inst.options);
+        // 注册 adapter、policy 和 options（注入 channelType）
+        const opts = inst.channelType
+            ? { ...inst.options, channelType: inst.channelType }
+            : inst.options;
+        processor.registerChannel(inst.adapter, inst.policy || defaultPolicy, opts);
         cmdHandler.registerAdapter(inst.adapter);
-        cmdHandler.registerChannel(inst.adapter.name, inst.channel);
+        cmdHandler.registerChannel(inst.adapter.channelName, inst.channel, inst.channelType);
         if (inst.policy) {
-            cmdHandler.registerPolicy(inst.adapter.name, inst.policy);
+            cmdHandler.registerPolicy(inst.adapter.channelName, inst.policy);
+        }
+        // 注册交互回调：渠道收到用户操作后路由到 InteractionRouter
+        if (inst.adapter.onInteraction) {
+            inst.adapter.onInteraction((response) => {
+                interactionRouter.handle(response);
+            });
         }
     }
     // ── MessageBridge：Channel ↔ Core 消息桥梁 ──
@@ -185,86 +208,133 @@ async function main() {
     // ── 渠道消息注册 ──
     // 连接插件系统的渠道
     for (const inst of channelInstances) {
-        if (inst.adapter.name === 'feishu') {
-            msgBridge.register('feishu', (handler) => inst.channel.onMessage(async ({ channelId: chatId, content, images, peerId, peerName, messageId, mentions, threadId, rootId, chatType }) => {
-                handler({
-                    channel: 'feishu', channelId: chatId, content, images, chatType,
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'feishu') {
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async ({ channelId: chatId, content, images, peerId, peerName, messageId, mentions, threadId, rootId, chatType }) => {
+                await handler({
+                    channel: channelType, channelId: chatId, content, images, chatType,
                     peerId: peerId || '', peerName, messageId, mentions, threadId,
-                    replyContext: rootId ? { replyToMessageId: rootId, replyInThread: true } : undefined,
+                    replyContext: rootId ? { replyToMessageId: rootId, replyInThread: !!threadId } : undefined,
                 });
             }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, {
                 replyToMessageId: replyContext?.replyToMessageId,
-                replyInThread: true,
-            }), inst.adapter);
+                replyInThread: replyContext?.replyInThread,
+            }), inst.adapter, channelType);
             inst.channel.onRecall?.((messageId) => {
                 msgBridge.cancel(messageId);
             });
         }
-        if (inst.adapter.name === 'wechat') {
-            msgBridge.register('wechat', (handler) => inst.channel.onMessage(async (channelId, content, peerId, images, chatType) => {
+        if (channelType === 'wechat') {
+            // 注入 EventBus（用于 channel:health 事件）
+            if (inst.channel.setEventBus) {
+                inst.channel.setEventBus(eventBus);
+            }
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (channelId, content, peerId, images, chatType) => {
                 handler({
-                    channel: 'wechat',
+                    channel: channelType,
                     channelId,
                     content,
                     images,
                     chatType: chatType || 'private',
                     peerId: peerId || '',
                 });
-            }), (channelId, text) => inst.channel.sendMessage(channelId, text), inst.adapter);
+            }), (channelId, text) => inst.channel.sendMessage(channelId, text), inst.adapter, channelType);
         }
-        if (inst.adapter.name === 'aun') {
-            msgBridge.register('aun', (handler) => inst.channel.onMessage(async (opts) => {
+        if (channelType === 'aun') {
+            msgBridge.register(inst.adapter.channelName, (handler) => inst.channel.onMessage(async (opts) => {
                 handler({
-                    channel: 'aun',
+                    channel: channelType,
                     channelId: opts.channelId,
                     content: opts.content,
                     chatType: opts.chatType || 'private',
                     peerId: opts.peerId || '',
+                    peerName: opts.peerName,
                     messageId: opts.messageId,
                     mentions: opts.mentions,
                     threadId: opts.threadId,
                     replyContext: opts.replyContext,
                 });
-            }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, replyContext), inst.adapter);
+            }), (channelId, text, replyContext) => inst.channel.sendMessage(channelId, text, replyContext), inst.adapter, channelType);
         }
     }
     // ── 连接所有渠道 ──
     const connected = await channelLoader.connectAll(channelInstances);
     // 预填充 Feishu 已知 thread_id（重启后避免误判话题创建）
     for (const inst of channelInstances) {
-        if (inst.adapter.name === 'feishu' && 'preloadThreads' in inst.channel) {
-            const threadIds = sessionManager.getKnownThreadIds('feishu');
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'feishu' && 'preloadThreads' in inst.channel) {
+            const threadIds = sessionManager.getKnownThreadIds(inst.adapter.channelName);
             inst.channel.preloadThreads(threadIds);
         }
     }
     for (const name of connected) {
+        // 查找对应实例以获取 channelType
+        const inst = channelInstances.find(i => i.adapter.channelName === name);
+        const type = inst?.channelType || name;
         eventBus.publish({
             type: 'channel:connected',
-            channel: name.toLowerCase(),
+            channel: type.toLowerCase(),
+            channelName: name,
             timestamp: Date.now()
         });
     }
-    // AUN 重连失败通知：通过其他渠道给 owner 发消息
+    // AUN 重连失败通知：通过 channel:health 事件
     for (const inst of channelInstances) {
-        if (inst.adapter.name === 'aun' && inst.channel.setOnChannelDown) {
+        const channelType = inst.channelType || inst.adapter.channelName;
+        if (channelType === 'aun' && inst.channel.setOnChannelDown) {
             inst.channel.setOnChannelDown(() => {
-                logger.error('[AUN] All reconnect attempts exhausted, notifying owners');
-                const msg = '⚠️ AUN 渠道断连，自动重试已用尽。\n使用 /check reconnect 手动重连';
-                for (const other of channelInstances) {
-                    if (other.adapter.name === inst.adapter.name)
-                        continue;
-                    const ownerCfg = config.channels?.[other.adapter.name];
-                    const ownerId = ownerCfg?.owner;
-                    if (ownerId) {
-                        other.adapter.sendText(ownerId, msg).catch(err => {
-                            logger.error(`[AUN] Failed to notify ${other.adapter.name} owner:`, err);
-                        });
-                    }
-                }
+                eventBus.publish({
+                    type: 'channel:health',
+                    channel: channelType,
+                    channelName: inst.adapter.channelName,
+                    status: 'auth_error',
+                    message: `⚠️ AUN 渠道 ${inst.adapter.channelName} 断连，自动重试已用尽。\n使用 /check rty aun 手动重连`,
+                    timestamp: Date.now(),
+                });
+            });
+        }
+    }
+    // 统一 channel:health 跨通道通知（仅 auth_error）
+    // 按 (channelType, ownerId) 去重，避免同类型多实例重复通知
+    eventBus.subscribe('channel:health', (event) => {
+        if (event.type !== 'channel:health' || event.status !== 'auth_error')
+            return;
+        const sourceChannelType = event.channel;
+        const sourceChannelName = event.channelName || sourceChannelType;
+        const msg = event.message;
+        logger.error(`[ChannelHealth] ${sourceChannelName} auth_error: ${msg}`);
+        const notified = new Set(); // channelType 去重（同类型只通知一次）
+        for (const other of channelInstances) {
+            const otherType = other.channelType || other.adapter.channelName;
+            if (otherType === sourceChannelType)
+                continue; // 跳过同类型通道
+            if (notified.has(otherType))
+                continue; // 同类型已通知过
+            const ownerId = getOwner(config, other.adapter.channelName);
+            if (!ownerId)
+                continue;
+            notified.add(otherType);
+            other.adapter.sendText(ownerId, msg).catch(err => {
+                logger.error(`[ChannelHealth] Failed to notify ${other.adapter.channelName} owner:`, err);
             });
         }
+    });
+    // 按 channelType 归组显示连接摘要
+    const connectedGroups = new Map();
+    for (const inst of channelInstances) {
+        const name = inst.adapter.channelName;
+        if (!connected.includes(name))
+            continue;
+        const type = inst.channelType || name;
+        if (!connectedGroups.has(type))
+            connectedGroups.set(type, []);
+        connectedGroups.get(type).push(name);
     }
-    logger.info(`\n🚀 EvolClaw is running with ${connected.length} channel(s): ${connected.join(', ')}\n`);
+    const channelSummary = Array.from(connectedGroups.entries())
+        .map(([type, names]) => names.length === 1 ? names[0] : `${type}[${names.join(', ')}]`)
+        .join(', ');
+    const totalCount = connected.length;
+    logger.info(`\n🚀 EvolClaw is running with ${totalCount} channel(s): ${channelSummary}\n`);
     eventBus.publish({
         type: 'system:started',
         channels: connected.map(c => c.toLowerCase()),
@@ -309,7 +379,7 @@ async function main() {
             const adapter = cmdHandler.getAdapter(pending.channel);
             if (adapter) {
                 const replyContext = pending.rootId
-                    ? { replyToMessageId: pending.rootId, replyInThread: true }
+                    ? { replyToMessageId: pending.rootId, replyInThread: !!pending.threadId }
                     : undefined;
                 await adapter.sendText(pending.channelId, '✅ 服务重启成功！', replyContext);
                 logger.info(`[Restart] Notification sent via ${pending.channel}`);
@@ -327,15 +397,22 @@ async function main() {
     // IPC server — 供 CLI 查询实时状态
     const ipcServer = new IpcServer(resolvePaths().socket, () => {
         const channels = {};
+        const channelsByType = {};
         for (const inst of channelInstances) {
-            const name = inst.adapter.name;
-            channels[name] = inst.channel.getStatus?.() ?? { connected: true };
+            const name = inst.adapter.channelName;
+            const status = inst.channel.getStatus?.() ?? { connected: true };
+            const channelType = inst.channelType || name;
+            channels[name] = { ...status, channelType };
+            if (!channelsByType[channelType])
+                channelsByType[channelType] = [];
+            channelsByType[channelType].push(name);
         }
         const snap = statsCollector.getSnapshot();
         return {
             pid: process.pid,
             uptime: snap.uptimeMs,
             channels,
+            channelsByType,
             queue: {
                 pending: messageQueue.getGlobalQueueLength(),
                 processing: messageQueue.getGlobalProcessingCount(),
@@ -378,8 +455,13 @@ async function main() {
         }
     });
     // 优雅关闭
-    const shutdown = async () => {
-        logger.info('\n\nShutting down gracefully...');
+    let shutdownSignal = 'unknown';
+    const shutdown = async (signal) => {
+        if (signal)
+            shutdownSignal = signal;
+        const pid = process.pid;
+        const ppid = process.ppid;
+        logger.info(`\n\nShutting down gracefully... (signal=${shutdownSignal}, pid=${pid}, ppid=${ppid})`);
         fs.unwatchFile(configPath);
         ipcServer.stop();
         eventBus.publish({
@@ -389,14 +471,15 @@ async function main() {
         // 断开插件系统的渠道
         await channelLoader.disconnectAll(channelInstances);
         for (const inst of channelInstances) {
-            eventBus.publish({ type: 'channel:disconnected', channel: inst.adapter.name, reason: 'shutdown' });
+            const type = inst.channelType || inst.adapter.channelName;
+            eventBus.publish({ type: 'channel:disconnected', channel: type, channelName: inst.adapter.channelName, reason: 'shutdown' });
         }
         sessionManager.close();
         logger.info('✓ Shutdown complete');
         process.exit(0);
     };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
+    process.on('SIGINT', () => shutdown('SIGINT'));
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
 }
 main().catch((error) => {
     const msg = `Fatal error: ${error?.stack || error}`;

package/dist/{core/ipc-server.js → ipc.js}

@@ -1,6 +1,6 @@
 import net from 'net';
 import fs from 'fs';
-import { logger } from '../utils/logger.js';
+import { logger } from './utils/logger.js';
 export class IpcServer {
     socketPath;
     getStatus;
@@ -69,3 +69,38 @@ export class IpcServer {
         }
     }
 }
+/**
+ * Query the running EvolClaw daemon via Unix socket.
+ * Returns null if the service is not running or the socket is unreachable.
+ */
+export function ipcQuery(socketPath, cmd, timeoutMs = 3000) {
+    return new Promise((resolve) => {
+        const conn = net.connect(socketPath);
+        let buf = '';
+        const timer = setTimeout(() => {
+            conn.destroy();
+            resolve(null);
+        }, timeoutMs);
+        conn.on('connect', () => {
+            conn.write(JSON.stringify(cmd) + '\n');
+        });
+        conn.on('data', (data) => {
+            buf += data.toString();
+            const idx = buf.indexOf('\n');
+            if (idx !== -1) {
+                clearTimeout(timer);
+                try {
+                    resolve(JSON.parse(buf.slice(0, idx)));
+                }
+                catch {
+                    resolve(null);
+                }
+                conn.destroy();
+            }
+        });
+        conn.on('error', () => {
+            clearTimeout(timer);
+            resolve(null);
+        });
+    });
+}

package/dist/types.js

@@ -1 +1,4 @@
+// ── Channel config types ──
+// Single-object form: `name` is optional (defaults to channel type name).
+// Array form: `name` is required to distinguish instances.
 export {};

package/dist/utils/cross-platform.js

@@ -78,15 +78,52 @@ export function getProcessInfo(pid) {
             }
         }
         else {
-            const uptime = execFileSync('ps', ['-p', String(pid), '-o', 'etime='], { encoding: 'utf-8' }).trim();
+            const etimes = execFileSync('ps', ['-p', String(pid), '-o', 'etimes='], { encoding: 'utf-8' }).trim();
             const cpu = execFileSync('ps', ['-p', String(pid), '-o', '%cpu='], { encoding: 'utf-8' }).trim();
             const mem = execFileSync('ps', ['-p', String(pid), '-o', 'rss='], { encoding: 'utf-8' }).trim();
+            const uptime = formatUptime(parseInt(etimes, 10));
             return { uptime, cpu, memory: mem };
         }
     }
     catch { }
     return {};
 }
+function formatUptime(totalSeconds) {
+    if (isNaN(totalSeconds) || totalSeconds < 0)
+        return 'unknown';
+    const days = Math.floor(totalSeconds / 86400);
+    const hours = Math.floor((totalSeconds % 86400) / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    const parts = [];
+    if (days > 0)
+        parts.push(`${days}d`);
+    if (hours > 0)
+        parts.push(`${hours}h`);
+    if (minutes > 0)
+        parts.push(`${minutes}m`);
+    if (parts.length === 0)
+        parts.push(`${seconds}s`);
+    return parts.join(' ');
+}
+/**
+ * Read a specific environment variable from a running process.
+ * Returns undefined if the process doesn't exist or the variable is not set.
+ * Linux: reads /proc/<pid>/environ; Windows: not supported (returns undefined).
+ */
+export function getProcessEnv(pid, varName) {
+    if (isWindows)
+        return undefined;
+    try {
+        const environ = fs.readFileSync(`/proc/${pid}/environ`, 'utf-8');
+        const prefix = `${varName}=`;
+        const entry = environ.split('\0').find(e => e.startsWith(prefix));
+        return entry ? entry.slice(prefix.length) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Cross-platform command existence check.
  */

package/dist/utils/error-utils.js

@@ -2,11 +2,66 @@ export var ErrorType;
 (function (ErrorType) {
     ErrorType["SDK_TIMEOUT"] = "sdk_timeout";
     ErrorType["API_ERROR"] = "api_error";
+    ErrorType["AUTH_ERROR"] = "auth_error";
     ErrorType["FILE_CORRUPT"] = "file_corrupt";
     ErrorType["STREAM_ERROR"] = "stream_error";
     ErrorType["CONTEXT_TOO_LONG"] = "context_too_long";
     ErrorType["UNKNOWN"] = "unknown";
 })(ErrorType || (ErrorType = {}));
+/**
+ * 错误来源前缀 — 区分基础设施异常 vs Agent 任务失败
+ *
+ * infra:  基础设施级（SDK 崩溃、API 不可用、文件损坏）— 应累计安全模式
+ * agent:  Agent 任务级（权限拒绝、max turns、工具失败）— 仅统计，不累计安全模式
+ */
+export const ERROR_PREFIX = {
+    INFRA: 'infra',
+    AGENT: 'agent',
+};
+/**
+ * 判断 Agent complete.subtype 是否属于系统级故障（应累计安全模式）
+ *
+ * 非系统级（用户操作或任务边界）：
+ * - end_turn / max_turns: Agent 正常结束或达到轮次上限
+ * - permission_denied: 用户主动拒绝权限
+ * - stop: 用户主动停止
+ *
+ * 系统级（SDK/模型/平台故障）：
+ * - error_model / error_tool_use / error_api 等：基础设施异常
+ * - 未知 subtype：保守地视为系统级
+ *
+ * terminalReason 提供更精确的判断（SDK 0.2.100+）：
+ * - rapid_refill_breaker: API 限流，不是代码问题
+ * - tool_deferred: 工具延迟，不是错误
+ * - stop_hook_prevented: Stop hook 阻止，不是错误
+ * - aborted_streaming / aborted_tools: 中断，已有中断处理逻辑
+ */
+const NON_INFRA_SUBTYPES = new Set([
+    'end_turn',
+    'max_turns',
+    'permission_denied',
+    'stop',
+]);
+const NON_INFRA_TERMINAL_REASONS = new Set([
+    'rapid_refill_breaker',
+    'tool_deferred',
+    'stop_hook_prevented',
+    'aborted_streaming',
+    'aborted_tools',
+]);
+export function isInfraError(subtype, terminalReason) {
+    // terminalReason 优先级更高（更精确）
+    if (terminalReason && NON_INFRA_TERMINAL_REASONS.has(terminalReason)) {
+        return false;
+    }
+    if (!subtype)
+        return true; // 未知 subtype，保守视为系统级
+    return !NON_INFRA_SUBTYPES.has(subtype);
+}
+/** 为 errorType 添加来源前缀 */
+export function prefixErrorType(prefix, errorType) {
+    return `${prefix}:${errorType}`;
+}
 export function classifyError(error) {
     const msg = (error?.message || '').toLowerCase();
     if (msg.includes('上下文过长') || msg.includes('context too long')
@@ -14,12 +69,21 @@ export function classifyError(error) {
         || msg.includes('prompt is too long') || msg.includes('context limit')) {
         return ErrorType.CONTEXT_TOO_LONG;
     }
+    // 认证错误（401 / Invalid API Key / key_not_found）— 不可恢复，不应触发安全模式
+    if (msg.includes('401') || msg.includes('invalid api key') || msg.includes('key_not_found')
+        || msg.includes('authentication_error') || msg.includes('failed to authenticate')) {
+        return ErrorType.AUTH_ERROR;
+    }
     if (msg.includes('timeout') || msg.includes('etimedout')) {
         return ErrorType.SDK_TIMEOUT;
     }
     if (msg.includes('5') && (msg.includes('00') || msg.includes('02') || msg.includes('03') || msg.includes('04'))) {
         return ErrorType.API_ERROR;
     }
+    // "X is not valid JSON" — API 返回了非 JSON 响应（如算力池切换提示），属于 API 错误
+    if (msg.includes('is not valid json')) {
+        return ErrorType.API_ERROR;
+    }
     if (msg.includes('enoent') || msg.includes('corrupt') || msg.includes('invalid json')) {
         return ErrorType.FILE_CORRUPT;
     }
@@ -28,7 +92,61 @@ export function classifyError(error) {
     }
     return ErrorType.UNKNOWN;
 }
-export function getErrorMessage(error) {
+/**
+ * 判断错误是否可重试（暂时性 API 错误）
+ * 403 算力池切换、429 限流、5xx 服务端错误
+ * 注意：401 认证错误不可重试（API Key 无效不会因重试恢复）
+ */
+export function isRetryableError(error) {
+    const msg = error?.message || String(error);
+    const lower = msg.toLowerCase();
+    // 认证错误不可重试：重试不会恢复无效/缺失凭据
+    if (lower.includes('401')
+        || lower.includes('invalid api key')
+        || lower.includes('key_not_found')
+        || lower.includes('authentication_error')
+        || lower.includes('failed to authenticate')
+        || (lower.includes('api error: 403') && (lower.includes('auth') || lower.includes('key') || lower.includes('token')))) {
+        return false;
+    }
+    if (msg.includes('API Error: 403'))
+        return true;
+    if (msg.includes('API Error: 429'))
+        return true;
+    if (msg.includes('API Error: 500'))
+        return true;
+    if (msg.includes('API Error: 502'))
+        return true;
+    if (msg.includes('API Error: 503'))
+        return true;
+    if (msg.includes('API Error: 504'))
+        return true;
+    return false;
+}
+export function getErrorMessage(error, terminalReason) {
+    // terminalReason 提供更精确的错误提示（SDK 0.2.100+）
+    if (terminalReason) {
+        switch (terminalReason) {
+            case 'max_turns':
+                return '❌ 任务达到最大轮次限制，请简化需求或分步执行';
+            case 'prompt_too_long':
+                return '⚠️ 输入过长，请精简提问或使用 /compact 压缩上下文';
+            case 'rapid_refill_breaker':
+                return '⚠️ API 限流中，请稍后重试';
+            case 'context_compact_failed':
+                return '⚠️ 上下文过长，自动压缩失败，请手动输入 /compact 重试';
+            case 'model_error':
+                return '❌ 模型服务异常，请稍后重试';
+            case 'tool_error':
+                return '❌ 工具执行失败，请检查操作或重试';
+            case 'permission_denied':
+                return '❌ 权限被拒绝，操作已取消';
+            case 'aborted_streaming':
+            case 'aborted_tools':
+                return '❌ 任务已中断';
+        }
+    }
+    // 回退到原有的错误消息匹配逻辑
     const msg = error?.message || String(error);
     if (msg.includes('CONTEXT_COMPACT_FAILED')) {
         return '⚠️ 上下文过长，自动压缩失败，请手动输入 /compact 重试';
@@ -38,10 +156,17 @@ export function getErrorMessage(error) {
         return '⚠️ 上下文过长，自动压缩重试失败，请手动输入 /compact 重试';
     }
     if (msg.includes('API Error: 400')) {
-        return '⚠️ 请求格式错误，请检查输入内容';
+        return '❌ 请求格式错误，请检查输入内容';
+    }
+    if (msg.includes('401') || msg.includes('Invalid API key') || msg.includes('key_not_found')
+        || msg.includes('authentication_error')) {
+        return '❌ API Key 无效，请检查密钥配置。使用 /status 查看当前配置';
     }
     if (msg.includes('API Error: 500')) {
-        return '⚠️ API 服务暂时不可用，请稍后重试';
+        return '❌ API 服务暂时不可用，请稍后重试';
+    }
+    if (msg.includes('API Error: 403')) {
+        return '❌ API 认证失败，请检查密钥配置或稍后重试';
     }
     if (msg.includes('API Error: 429')) {
         return '⚠️ 请求过于频繁，请稍后再试';
@@ -50,7 +175,7 @@ export function getErrorMessage(error) {
         return '⚠️ 请求超时，请重试';
     }
     if (msg.includes('permission') || msg.includes('im:resource')) {
-        return '⚠️ 权限不足，请联系管理员配置应用权限';
+        return '❌ 权限不足，请联系管理员配置应用权限';
     }
-    return '⚠️ 处理消息时出错，请稍后重试';
+    return '❌ 处理消息时出错，请稍后重试';
 }