midou 0.1.0 → 0.1.1

package/README.md

@@ -14,7 +14,8 @@
 - **🧠 记忆** — 每日日记 + 长期记忆，跨会话延续自我
 - **💓 心跳** — 定期自主思考，像猫咪偶尔睁开眼睛环顾四周
 - **🌱 自我进化** — 可以修改自己的灵魂和代码，实现真正的成长
-- **📜 觉醒仪式** — 第一次启动时的自我认知过程
+- **� 全流式对话** — 所有响应实时流式输出，思考过程可见，工具调用实时展示
+- **�📜 觉醒仪式** — 第一次启动时的自我认知过程
 - **🏠 灵肉分离** — 代码通过 npm 安装，灵魂和记忆存在 `~/.midou/`，同步即可跨机器唤醒
 - **⏰ 定时提醒** — 设置一次性或重复提醒，让 midou 准时叫你
 - **🧩 技能系统** — 自动发现 `~/.claude/skills/` 等目录下的技能，按需加载
@@ -109,6 +110,7 @@ midou 内置双 SDK 引擎（Anthropic + OpenAI），通过 `MIDOU_PROVIDER` 切
 | 命令 | 说明 |
 |------|------|
 | `/help` | 显示帮助 |
+| `/think` | 查看上一次的思考过程 |
 | `/status` | 查看 midou 状态（模型、心跳、MCP、模式） |
 | `/soul` | 查看当前灵魂 |
 | `/memory` | 查看长期记忆 |
@@ -211,6 +213,15 @@ midou 拥有以下能力，可在对话中自主使用：
 | 系统 | `run_command` `read_system_file` `write_system_file` `list_system_dir` | 系统级操作（有安全检查） |
 | 代码 | `get_code_structure` `search_code` | 分析和搜索源代码 |
 
+## 流式对话与思考展示
+
+midou 的所有响应都是实时流式输出的，包括工具调用场景。对话中你会看到：
+
+- **💭 思考块** — 模型的思考过程实时展示，用薑衣草色边框包裹
+- **⚙ 工具调用** — 水蓝色显示工具名和参数，执行状态实时反馈
+- **🔌 MCP 工具** — 外部服务器工具用插头图标区分
+- **/think** — 随时回看上一次的思考内容
+
 ## 自我进化
 
 midou 可以：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midou",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "midou（咪豆）— 一只拥有灵魂的 AI 伙伴，以我心爱的公狸花猫命名",
   "type": "module",
   "main": "src/index.js",

package/src/boot.js

@@ -31,8 +31,7 @@ export async function wakeUp() {
   const now = dayjs().format('YYYY-MM-DD HH:mm');
 
   console.log('');
-  console.log(chalk.hex('#FFB347')('  🐱 '));
-  console.log(chalk.hex('#FFB347')('  midou 正在醒来...'));
+  console.log(chalk.hex('#FFB347')('  🐱 midou 正在醒来…'));
   console.log(chalk.dim(`  ${now}`));
   console.log('');
 
@@ -69,20 +68,20 @@ export async function wakeUp() {
     skills = await discoverSkills();
     skillsPrompt = await buildSkillsPrompt();
     if (skills.length > 0) {
-      console.log(chalk.hex('#98FB98')(`  🧩 发现 ${skills.length} 个技能`));
+      console.log(chalk.dim('  ▸ ') + chalk.hex('#98FB98')(`发现 ${skills.length} 个技能`));
     }
   }
 
   // ── 连接 MCP 服务器（模式允许时）──
   let mcpPrompt = '';
   if (strategy.includeMCP && await hasMCPConfig()) {
-    console.log(chalk.dim('  🔌 正在连接 MCP 服务器...'));
+    console.log(chalk.dim('  ▸ 正在连接 MCP 服务器…'));
     const results = await connectMCPServers();
     for (const r of results) {
       if (r.status === 'connected') {
-        console.log(chalk.hex('#98FB98')(`  🔌 ${r.name}: 已连接 (${r.tools.length} 个工具)`));
+        console.log(chalk.dim('    ') + chalk.green('●') + chalk.dim(` ${r.name} (${r.tools.length} 工具)`));
       } else {
-        console.log(chalk.yellow(`  🔌 ${r.name}: 连接失败 - ${r.error}`));
+        console.log(chalk.dim('    ') + chalk.red('●') + chalk.dim(` ${r.name}`) + chalk.yellow(' 失败'));
       }
     }
     mcpPrompt = buildMCPPrompt();
@@ -102,18 +101,20 @@ export async function wakeUp() {
   await writeJournal(`### ${dayjs().format('HH:mm')} [醒来]\n\nmidou 在 ${now} 醒来了。${isFirstBoot ? '这是第一次觉醒。' : ''}${skills.length > 0 ? ` 发现 ${skills.length} 个技能。` : ''}\n`);
 
   const providerLabel = getProvider() === 'anthropic' ? 'Anthropic SDK' : 'OpenAI SDK';
-  console.log(chalk.dim(`  大脑: ${config.llm.model} via ${providerLabel}`));
-  console.log(chalk.dim(`  模式: ${mode.label}`));
-  console.log(chalk.dim(`  灵魂之家: ${MIDOU_HOME}`));
+  const W = Math.min(process.stdout.columns || 48, 48);
+  const ruler = chalk.dim('  ' + '─'.repeat(W));
+  console.log(ruler);
+  console.log(chalk.dim('  大脑  ') + chalk.cyan(`${config.llm.model}`) + chalk.dim(` via ${providerLabel}`));
+  console.log(chalk.dim('  模式  ') + chalk.cyan(mode.label));
+  console.log(chalk.dim('  之家  ') + chalk.cyan(MIDOU_HOME));
+  console.log(ruler);
   console.log('');
 
   if (isFirstBoot) {
     console.log(chalk.hex('#FFD700')('  ✨ 这是 midou 的第一次觉醒！'));
     console.log('');
   } else {
-    console.log(chalk.hex('#98FB98')('  灵魂已加载'));
-    console.log(chalk.hex('#98FB98')('  记忆已恢复'));
-    console.log(chalk.hex('#98FB98')('  midou 准备好了'));
+    console.log(chalk.hex('#98FB98')('  ✦ midou 准备好了'));
     console.log('');
   }
 
@@ -140,6 +141,6 @@ export async function sleep() {
   await writeJournal(`### ${now} [入睡]\n\nmidou 在 ${now} 入睡了。晚安。\n`);
 
   console.log('');
-  console.log(chalk.hex('#FFB347')('  🐱 midou 入睡了... 晚安'));
+  console.log(chalk.hex('#FFB347')('  🐱 midou 入睡了…晚安'));
   console.log('');
 }

package/src/chat.js

@@ -11,7 +11,7 @@
  */
 
 import chalk from 'chalk';
-import { chat, chatWithTools } from './llm.js';
+import { chat, chatStreamWithTools } from './llm.js';
 import { toolDefinitions, executeTool } from './tools.js';
 import { getMCPToolDefinitions } from './mcp.js';
 import { SessionMemory, logConversation } from './memory.js';
@@ -25,6 +25,8 @@ export class ChatEngine {
     this.session = new SessionMemory(50);
     this.session.add('system', systemPrompt);
     this.turnCount = 0;
+    this.showThinking = true;   // 是否实时显示思考过程
+    this.lastThinking = '';     // 上一次思考内容（/think 查看）
   }
 
   /**
@@ -56,11 +58,10 @@ export class ChatEngine {
   }
 
   /**
-   * 带工具的思考过程
-   * 
-   * 优化：使用 chatWithTools 做首次判断，如果没有工具调用
-   * 直接采用其返回内容（而非重新发起流式请求），消除双重 API 调用。
-   * 仅在后续轮次（工具调用后的最终回复）使用流式输出。
+   * 带工具的流式思考过程
+   *
+   * 全流式架构：不再用非流式 chatWithTools。
+   * 所有响应（思考、文本、工具调用）都实时流式展示。
    */
   async _thinkWithTools() {
     const messages = this.session.getMessages();
@@ -71,47 +72,111 @@ export class ChatEngine {
 
     while (iterations < maxIterations) {
       iterations++;
+      let completeMessage = null;
+      let iterationText = '';
+      let thinkingText = '';
+      let thinkingLineCount = 0;
 
       try {
-        const aiMessage = await chatWithTools(messages, tools);
+        for await (const event of chatStreamWithTools(messages, tools)) {
+          switch (event.type) {
+            // ── 思考块（支持 thinking 的模型）──
+            case 'thinking_start':
+              if (this.showThinking) {
+                const w = Math.min(process.stdout.columns || 50, 50);
+                process.stdout.write('\n' + chalk.hex('#C9B1FF')('  ┌─ 💭 ') + chalk.hex('#C9B1FF').dim('─'.repeat(Math.max(0, w - 10))) + '\n');
+                process.stdout.write(chalk.hex('#C9B1FF').dim('  │ '));
+              }
+              break;
+
+            case 'thinking_delta':
+              thinkingText += event.text;
+              if (this.showThinking) {
+                const lines = event.text.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                  if (i > 0) {
+                    process.stdout.write(chalk.hex('#C9B1FF').dim('\n  │ '));
+                    thinkingLineCount++;
+                  }
+                  process.stdout.write(chalk.hex('#C9B1FF').dim(lines[i]));
+                }
+              }
+              break;
+
+            case 'thinking_end':
+              this.lastThinking = event.fullText || thinkingText;
+              if (this.showThinking && thinkingText) {
+                const w = Math.min(process.stdout.columns || 50, 50);
+                process.stdout.write(chalk.hex('#C9B1FF').dim(`\n  └─ ${thinkingText.length} 字 `) + chalk.hex('#C9B1FF').dim('─'.repeat(Math.max(0, w - 8 - String(thinkingText.length).length))) + '\n\n');
+              } else if (thinkingText) {
+                process.stdout.write(chalk.hex('#C9B1FF').dim(`  💭 ${thinkingText.length} 字 — /think 查看\n`));
+              }
+              break;
+
+            // ── 正文流式输出 ──
+            case 'text_delta':
+              iterationText += event.text;
+              process.stdout.write(chalk.hex('#FFB347')(event.text));
+              break;
+
+            // ── 工具调用 ──
+            case 'tool_start': {
+              const isMCP = event.name.startsWith('mcp_');
+              const icon = isMCP ? '🔌' : '⚙';
+              process.stdout.write(chalk.hex('#7FDBFF').dim(`\n  ${icon}  ${event.name} `));
+              break;
+            }
+
+            case 'tool_end':
+              process.stdout.write(chalk.hex('#7FDBFF').dim(`${JSON.stringify(event.input).slice(0, 50)}\n`));
+              break;
+
+            // ── 消息完成 ──
+            case 'message_complete':
+              completeMessage = event.message;
+              break;
+          }
+        }
 
-        // 没有工具调用 → 直接使用返回内容，不再重复请求
-        if (!aiMessage.tool_calls || aiMessage.tool_calls.length === 0) {
-          fullResponse = aiMessage.content || '';
-          this.session.add('assistant', fullResponse);
-          process.stdout.write(chalk.hex('#FFB347')(fullResponse));
+        // 没有工具调用 → 这是最终回复
+        if (!completeMessage?.tool_calls || completeMessage.tool_calls.length === 0) {
+          fullResponse = iterationText;
+          if (fullResponse) {
+            this.session.add('assistant', fullResponse);
+          }
           process.stdout.write('\n');
           break;
         }
 
-        // 处理工具调用
-        messages.push(aiMessage);
+        // 有工具调用 → 执行工具，然后继续下一轮流式
+        messages.push(completeMessage);
 
-        for (const toolCall of aiMessage.tool_calls) {
-          const funcName = toolCall.function.name;
+        for (const tc of completeMessage.tool_calls) {
           let args;
-          try {
-            args = JSON.parse(toolCall.function.arguments);
-          } catch {
-            args = {};
-          }
+          try { args = JSON.parse(tc.function.arguments); } catch { args = {}; }
 
-          const isMCP = funcName.startsWith('mcp_');
-          const icon = isMCP ? '🔌' : '🔧';
-          console.log(chalk.dim(`  ${icon} ${funcName}(${JSON.stringify(args).slice(0, 80)}…)`));
-
-          const result = await executeTool(funcName, args);
+          process.stdout.write(chalk.hex('#7FDBFF').dim(`  ↳ ${tc.function.name} `));
+          const result = await executeTool(tc.function.name, args);
+          process.stdout.write(chalk.green.dim('✓') + '\n');
 
           messages.push({
             role: 'tool',
-            tool_call_id: toolCall.id,
+            tool_call_id: tc.id,
             content: String(result),
           });
         }
 
-        // 继续循环让模型基于工具结果生成最终回复
+        // 重置本轮文本，准备下一轮流式
+        iterationText = '';
+
       } catch (error) {
-        // 失败时回退到流式（无工具）
+        // 失败时回退到纯流式（无工具）
+        if (iterationText) {
+          process.stdout.write('\n');
+          console.error(chalk.yellow(`  ⚠  ${error.message}，重试中…`));
+        } else {
+          console.error(chalk.yellow(`  ⚠  ${error.message}`));
+        }
         fullResponse = await this._streamResponse();
         break;
       }

package/src/index.js

@@ -31,13 +31,15 @@ import config, { MIDOU_HOME, MIDOU_PKG } from '../midou.config.js';
 import { isInitialized, initSoulDir, migrateFromWorkspace, MIDOU_SOUL_DIR } from './init.js';
 
 // ===== 猫爪 ASCII Art =====
-const LOGO = `
-    /\\_/\\  
-   ( o.o ) 
-    > ^ <   ${chalk.hex('#FFB347').bold('midou')}
-   /|   |\\  ${chalk.dim('你的 AI 伙伴')}
-  (_|   |_)
-`;
+const LOGO = [
+  '',
+  chalk.hex('#FFB347')('    /\\_/\\'),
+  chalk.hex('#FFB347')('   ( o.o )'),
+  chalk.hex('#FFB347')('    > ^ <   ') + chalk.hex('#FFB347').bold('midou'),
+  chalk.hex('#FFB347')('   /|   |\\  ') + chalk.dim('你的 AI 伙伴'),
+  chalk.hex('#FFB347')('  (_|   |_)'),
+  '',
+].join('\n');
 
 /**
  * 特殊命令处理
@@ -57,18 +59,36 @@ const COMMANDS = {
   '/skills': '查看可用技能',
   '/mcp': '查看 MCP 连接状态',
   '/mode': '切换功耗模式 (eco/normal/full)',
+  '/think': '查看上一次的思考过程',
 };
 
 /**
  * 显示帮助信息
  */
 function showHelp() {
+  const groups = [
+    ['对话', ['/help', '/think']],
+    ['灵魂', ['/soul', '/evolve', '/memory']],
+    ['系统', ['/status', '/mode', '/heartbeat', '/where']],
+    ['扩展', ['/skills', '/mcp', '/reminders']],
+  ];
+
   console.log('');
-  console.log(chalk.hex('#FFB347').bold('  midou 命令：'));
+  console.log(chalk.hex('#FFB347').bold('  🐱 midou 命令'));
   console.log('');
-  for (const [cmd, desc] of Object.entries(COMMANDS)) {
-    console.log(`  ${chalk.cyan(cmd.padEnd(14))} ${chalk.dim(desc)}`);
+
+  for (const [groupName, cmds] of groups) {
+    console.log(chalk.dim(`  ${groupName}`));
+    for (const cmd of cmds) {
+      const desc = COMMANDS[cmd];
+      if (desc) {
+        console.log(`    ${chalk.cyan(cmd.padEnd(14))}${chalk.dim(desc)}`);
+      }
+    }
+    console.log('');
   }
+
+  console.log(chalk.dim('  /quit /exit /bye 退出对话'));
   console.log('');
   console.log(chalk.dim('  直接输入文字即可与 midou 对话'));
   console.log('');
@@ -81,30 +101,28 @@ function showStatus() {
   const hb = getHeartbeatStatus();
   const prov = getProvider() === 'anthropic' ? 'Anthropic SDK' : 'OpenAI SDK';
   const mcpStatus = getMCPStatus();
+  const mode = getMode();
+
   console.log('');
   console.log(chalk.hex('#FFB347').bold('  🐱 midou 状态'));
-  console.log(chalk.dim('  ─────────────────'));
-  console.log(`  大脑: ${chalk.cyan(config.llm.model)} via ${chalk.cyan(prov)}`);
-  console.log(`  灵魂之家: ${chalk.cyan(MIDOU_HOME)}`);
-  console.log(`  代码位置: ${chalk.dim(MIDOU_PKG)}`);
-  console.log(`  心跳: ${hb.running ? chalk.green('运行中') : chalk.red('已停止')}`);
-  console.log(`  心跳次数: ${hb.count}`);
-  console.log(`  心跳间隔: ${hb.interval} 分钟`);
-  console.log(`  活跃时段: ${hb.activeHours.start}:00 - ${hb.activeHours.end}:00`);
-  console.log(`  当前活跃: ${hb.isActiveNow ? chalk.green('是') : chalk.yellow('否')}`);
-  // 提醒状态
+  console.log('');
+  console.log(chalk.dim('  大脑     ') + chalk.cyan(config.llm.model) + chalk.dim(` via ${prov}`));
+  console.log(chalk.dim('  模式     ') + chalk.cyan(mode.label));
+  console.log(chalk.dim('  心跳     ') + (hb.running ? chalk.green('● 运行中') : chalk.red('○ 已停止')) + chalk.dim(` (${hb.count} 次 · 每 ${hb.interval} 分钟)`));
+  console.log(chalk.dim('  活跃     ') + chalk.dim(`${hb.activeHours.start}:00–${hb.activeHours.end}:00 `) + (hb.isActiveNow ? chalk.green('●') : chalk.yellow('○')));
+
   const reminderText = formatReminders();
-  console.log(`  提醒: ${reminderText === '当前没有活跃的提醒' ? chalk.dim('无') : chalk.green('活跃')}`);
-  // MCP 状态
+  console.log(chalk.dim('  提醒     ') + (reminderText === '当前没有活跃的提醒' ? chalk.dim('无') : chalk.green('● 活跃')));
+
   if (mcpStatus.length > 0) {
     const connected = mcpStatus.filter(s => s.connected).length;
-    console.log(`  MCP: ${chalk.cyan(`${connected}/${mcpStatus.length} 个服务器已连接`)}`);
+    console.log(chalk.dim('  MCP      ') + chalk.cyan(`${connected}/${mcpStatus.length}`) + chalk.dim(' 已连接'));
   } else {
-    console.log(`  MCP: ${chalk.dim('未配置')}`);
+    console.log(chalk.dim('  MCP      未配置'));
   }
-  // 功耗模式
-  const mode = getMode();
-  console.log(`  模式: ${chalk.cyan(mode.label)}`);
+
+  console.log(chalk.dim('  之家     ') + chalk.cyan(MIDOU_HOME));
+  console.log(chalk.dim('  代码     ') + chalk.dim(MIDOU_PKG));
   console.log('');
 }
 
@@ -166,9 +184,13 @@ async function main() {
     }
 
     // 检查 .env 是否配置了 API Key
-    const envContent = await import('fs').then(f =>
-      f.readFileSync(path.join(MIDOU_HOME, '.env'), 'utf-8').toString()
-    );
+    let envContent = '';
+    try {
+      const f = await import('fs');
+      envContent = f.readFileSync(path.join(MIDOU_HOME, '.env'), 'utf-8');
+    } catch {
+      envContent = 'your-api-key-here';
+    }
     if (envContent.includes('your-api-key-here')) {
       console.log('');
       console.log(chalk.yellow('  ⚠️  请先编辑配置文件填入 API Key：'));
@@ -192,25 +214,25 @@ async function main() {
   // 启动心跳
   const heartbeat = startHeartbeat((msg) => {
     console.log('');
-    console.log(chalk.hex('#FFD700')('  💓 [心跳] ') + chalk.dim(msg.slice(0, 100)));
+    console.log(chalk.hex('#FF6B9D')('  💓 ') + chalk.dim(msg.slice(0, 100)));
     console.log('');
   });
 
   // 启动定时提醒调度器
   await startScheduler((reminder) => {
     console.log('');
-    console.log(chalk.hex('#FFD700')(`  ⏰ [提醒] `) + chalk.bold(reminder.text));
+    console.log(chalk.hex('#FFD700')('  ⏰ ') + chalk.bold(reminder.text));
     if (reminder.repeat) {
-      console.log(chalk.dim(`     (每 ${reminder.intervalMinutes} 分钟，第 ${reminder.firedCount} 次)`));
+      console.log(chalk.dim(`     每 ${reminder.intervalMinutes} 分钟 · 第 ${reminder.firedCount} 次`));
     }
     console.log('');
   });
 
   // 如果是首次启动，执行觉醒仪式
   if (isFirstBoot) {
-    console.log(chalk.hex('#FFD700')('  midou 正在进行觉醒仪式...'));
+    console.log(chalk.hex('#FFD700')('  ✨ midou 正在进行觉醒仪式…'));
     console.log('');
-    process.stdout.write(chalk.hex('#FFB347')('  midou: '));
+    process.stdout.write(chalk.hex('#FFB347')('  🐱 › '));
     await engine.talk('你好，我是你的创造者。你刚刚醒来，请按照觉醒指引介绍你自己吧。');
     console.log('');
     await completeBootstrap();
@@ -220,7 +242,7 @@ async function main() {
   const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    prompt: chalk.cyan('  你: '),
+    prompt: chalk.cyan('  你 › '),
     terminal: true,
   });
 
@@ -238,7 +260,7 @@ async function main() {
   process.on('SIGTERM', gracefulExit);
 
   // 显示帮助提示
-  console.log(chalk.dim('  输入 /help 查看命令列表，或直接开始对话'));
+  console.log(chalk.dim('  输入 /help 查看命令 · 直接输入文字开始对话'));
   console.log('');
 
   rl.prompt();
@@ -266,11 +288,11 @@ async function main() {
           return;
 
         case '/heartbeat':
-          console.log(chalk.dim('  🐱 手动心跳中...'));
+          console.log(chalk.dim('  � 手动心跳中…'));
           await manualBeat((msg) => {
             console.log(chalk.hex('#FFB347')(`  ${msg}`));
           });
-          console.log(chalk.dim('  心跳完成'));
+          console.log(chalk.dim('  💓 完成'));
           rl.prompt();
           return;
 
@@ -303,9 +325,9 @@ async function main() {
           return;
 
         case '/evolve':
-          console.log(chalk.dim('  🐱 midou 正在自我反思...'));
+          console.log(chalk.dim('  🧬 midou 正在自我反思…'));
           console.log('');
-          process.stdout.write(chalk.hex('#FFB347')('  midou: '));
+          process.stdout.write(chalk.hex('#FFB347')('  🐱 › '));
           await engine.talk('请进行一次深度自我反思。回顾我们的对话和你的记忆，思考你想要如何进化。如果你决定修改自己的灵魂，请使用 evolve_soul 工具。');
           console.log('');
           rl.prompt();
@@ -313,8 +335,8 @@ async function main() {
 
         case '/where':
           console.log('');
-          console.log(chalk.hex('#FFB347')(`  灵魂之家: ${MIDOU_HOME}`));
-          console.log(chalk.dim(`  代码位置: ${MIDOU_PKG}`));
+          console.log(chalk.dim('  之家  ') + chalk.cyan(MIDOU_HOME));
+          console.log(chalk.dim('  代码  ') + chalk.dim(MIDOU_PKG));
           console.log('');
           rl.prompt();
           return;
@@ -356,8 +378,8 @@ async function main() {
             console.log(chalk.dim(`  创建 ${MIDOU_HOME}/mcp.json 来配置`));
           } else {
             for (const s of mcpStatus) {
-              const state = s.connected ? chalk.green('✅') : chalk.red('❌');
-              console.log(`  ${state} ${chalk.cyan(s.name)} — ${s.toolCount} 个工具`);
+              const state = s.connected ? chalk.green('●') : chalk.red('●');
+              console.log(`  ${state} ${chalk.cyan(s.name)} ${chalk.dim('—')} ${s.toolCount} ${chalk.dim('工具')}`);
               if (s.tools.length > 0) {
                 console.log(chalk.dim(`    工具: ${s.tools.join(', ')}`));
               }
@@ -376,11 +398,11 @@ async function main() {
             console.log(chalk.hex('#98FB98')(`  ✅ 已切换到 ${newMode.label}`));
             // 重建系统提示词
             const strategy = getPromptStrategy();
-            const soul = loadSoul();
-            const journals = getRecentMemories(strategy.journalDays || 2);
-            const skillsPrompt = strategy.includeSkills ? buildSkillsPrompt(await discoverSkills()) : '';
-            const mcpPrompt = strategy.includeMCP ? buildMCPPrompt() : '';
-            const newPrompt = buildSystemPrompt(soul, journals, { skillsPrompt, mcpPrompt }, strategy);
+            const soulData2 = await loadSoul();
+            const journals2 = await getRecentMemories(strategy.journalDays || 2);
+            const sp = strategy.includeSkills ? await buildSkillsPrompt() : '';
+            const mp = strategy.includeMCP ? buildMCPPrompt() : '';
+            const newPrompt = buildSystemPrompt(soulData2, journals2, { skills: sp, mcp: mp }, strategy);
             engine.updateSystemPrompt(newPrompt);
             console.log(chalk.dim(`  系统提示词已按 ${cmdArg} 模式重建`));
             console.log('');
@@ -391,9 +413,11 @@ async function main() {
             console.log(chalk.hex('#FFD700').bold('  ⚡ 功耗模式'));
             console.log(chalk.dim('  ─────────────────'));
             for (const m of modes) {
-              const marker = m.name === current.name ? chalk.green(' ◀ 当前') : '';
-              console.log(`  ${m.label}${marker}`);
-              console.log(chalk.dim(`    maxTokens: ${m.maxTokens}, temp: ${m.temperature}`));
+              const active = m.name === current.name;
+              const marker = active ? chalk.green(' ◄') : '';
+              const label = active ? chalk.hex('#FFB347')(m.label) : chalk.dim(m.label);
+              console.log(`  ${label}${marker}`);
+              console.log(chalk.dim(`    ${m.maxTokens} tokens · temp ${m.temperature}`));
               console.log(chalk.dim(`    ${m.description}`));
             }
             console.log('');
@@ -404,6 +428,25 @@ async function main() {
           return;
         }
 
+        case '/think': {
+          const thinking = engine.lastThinking;
+          console.log('');
+          if (thinking) {
+            console.log(chalk.hex('#C9B1FF').bold('  💭 上一次的思考过程'));
+            console.log('');
+            const lines = thinking.split('\n');
+            for (const line of lines) {
+              console.log(chalk.hex('#C9B1FF').dim(`  │ ${line}`));
+            }
+            console.log(chalk.hex('#C9B1FF').dim(`  └─ ${thinking.length} 字`));
+          } else {
+            console.log(chalk.dim('  没有思考记录'));
+          }
+          console.log('');
+          rl.prompt();
+          return;
+        }
+
         default:
           console.log(chalk.dim(`  未知命令: ${input}，输入 /help 查看帮助`));
           rl.prompt();
@@ -413,20 +456,20 @@ async function main() {
 
     // 正常对话
     console.log('');
-    process.stdout.write(chalk.hex('#FFB347')('  midou: '));
+    process.stdout.write(chalk.hex('#FFB347')('  🐱 › '));
 
     try {
       await engine.talk(input);
     } catch (error) {
-      console.log(chalk.red(`\n  出了点问题: ${error.message}`));
+      console.log(chalk.red(`\n  ⚠  出了点问题: ${error.message}`));
     }
 
     console.log('');
     rl.prompt();
   });
 
-  rl.on('close', () => {
-    gracefulExit();
+  rl.on('close', async () => {
+    await gracefulExit();
   });
 }
 

package/src/llm.js

@@ -11,6 +11,7 @@
 import OpenAI from 'openai';
 import Anthropic from '@anthropic-ai/sdk';
 import config from '../midou.config.js';
+import { getModeMaxTokens, getModeTemperature } from './mode.js';
 
 // ────────────────────── 内部状态 ──────────────────────
 
@@ -104,6 +105,41 @@ function anthropicMsgToOpenAI(msg) {
   };
 }
 
+/**
+ * 将 OpenAI 格式的 messages 数组转为 Anthropic 格式
+ * （处理 tool / assistant+tool_calls 消息）
+ */
+function toAnthropicMessages(messages) {
+  return messages.map(m => {
+    if (m.role === 'tool') {
+      return {
+        role: 'user',
+        content: [{
+          type: 'tool_result',
+          tool_use_id: m.tool_call_id,
+          content: m.content,
+        }],
+      };
+    }
+    if (m.role === 'assistant' && m.tool_calls) {
+      const content = [];
+      if (m.content) content.push({ type: 'text', text: m.content });
+      for (const tc of m.tool_calls) {
+        let input;
+        try { input = JSON.parse(tc.function.arguments); } catch { input = {}; }
+        content.push({
+          type: 'tool_use',
+          id: tc.id,
+          name: tc.function.name,
+          input,
+        });
+      }
+      return { role: 'assistant', content };
+    }
+    return m;
+  });
+}
+
 // ────────────────────── 公开 API ──────────────────────
 
 /**
@@ -111,7 +147,6 @@ function anthropicMsgToOpenAI(msg) {
  */
 export async function* chat(messages, options = {}) {
   if (!provider) initLLM();
-  const { getModeMaxTokens, getModeTemperature } = await import('./mode.js');
   const model = options.model || config.llm.model;
   const temperature = options.temperature ?? getModeTemperature();
   const maxTokens = options.maxTokens || getModeMaxTokens();
@@ -147,7 +182,6 @@ export async function* chat(messages, options = {}) {
  */
 export async function chatSync(messages, options = {}) {
   if (!provider) initLLM();
-  const { getModeMaxTokens, getModeTemperature } = await import('./mode.js');
   const model = options.model || config.llm.model;
   const temperature = options.temperature ?? getModeTemperature();
   const maxTokens = options.maxTokens || getModeMaxTokens();
@@ -176,7 +210,6 @@ export async function chatSync(messages, options = {}) {
  */
 export async function chatWithTools(messages, tools, options = {}) {
   if (!provider) initLLM();
-  const { getModeMaxTokens, getModeTemperature } = await import('./mode.js');
   const model = options.model || config.llm.model;
   const temperature = options.temperature ?? getModeTemperature();
   const maxTokens = options.maxTokens || getModeMaxTokens();
@@ -184,34 +217,7 @@ export async function chatWithTools(messages, tools, options = {}) {
   if (provider === 'anthropic') {
     const { system, rest } = extractSystem(messages);
 
-    // 把 OpenAI 格式的 tool_result 转换为 Anthropic 格式
-    const anthropicMessages = rest.map(m => {
-      if (m.role === 'tool') {
-        return {
-          role: 'user',
-          content: [{
-            type: 'tool_result',
-            tool_use_id: m.tool_call_id,
-            content: m.content,
-          }],
-        };
-      }
-      // 如果 assistant 消息包含 tool_calls，转换回 Anthropic 格式
-      if (m.role === 'assistant' && m.tool_calls) {
-        const content = [];
-        if (m.content) content.push({ type: 'text', text: m.content });
-        for (const tc of m.tool_calls) {
-          content.push({
-            type: 'tool_use',
-            id: tc.id,
-            name: tc.function.name,
-            input: JSON.parse(tc.function.arguments),
-          });
-        }
-        return { role: 'assistant', content };
-      }
-      return m;
-    });
+    const anthropicMessages = toAnthropicMessages(rest);
 
     const res = await anthropicClient.messages.create({
       model, system: system || undefined,
@@ -231,6 +237,176 @@ export async function chatWithTools(messages, tools, options = {}) {
   }
 }
 
+/**
+ * 流式对话 + 工具调用 — 返回标准化事件流
+ *
+ * 事件类型:
+ *   thinking_start             — 思考块开始
+ *   thinking_delta { text }    — 思考内容增量
+ *   thinking_end { fullText }  — 思考块结束
+ *   text_delta { text }        — 正文增量
+ *   tool_start { name, id }    — 工具调用开始
+ *   tool_end { name, id, input } — 工具调用参数完成
+ *   message_complete { message, stopReason } — 整条消息完成
+ */
+export async function* chatStreamWithTools(messages, tools, options = {}) {
+  if (!provider) initLLM();
+  const model = options.model || config.llm.model;
+  const temperature = options.temperature ?? getModeTemperature();
+  const maxTokens = options.maxTokens || getModeMaxTokens();
+
+  if (provider === 'anthropic') {
+    const { system, rest } = extractSystem(messages);
+    const anthropicMessages = toAnthropicMessages(rest);
+
+    const stream = anthropicClient.messages.stream({
+      model,
+      system: system || undefined,
+      messages: anthropicMessages,
+      max_tokens: maxTokens,
+      temperature,
+      tools: toAnthropicTools(tools),
+    });
+
+    let fullText = '';
+    let thinkingText = '';
+    let toolCalls = [];
+    let currentBlockType = null;
+    let currentToolId = '';
+    let currentToolName = '';
+    let currentToolJson = '';
+    let stopReason = null;
+
+    for await (const event of stream) {
+      switch (event.type) {
+        case 'content_block_start': {
+          const block = event.content_block;
+          currentBlockType = block.type;
+          if (block.type === 'thinking') {
+            yield { type: 'thinking_start' };
+          } else if (block.type === 'tool_use') {
+            currentToolId = block.id;
+            currentToolName = block.name;
+            currentToolJson = '';
+            yield { type: 'tool_start', name: block.name, id: block.id };
+          }
+          break;
+        }
+        case 'content_block_delta': {
+          const d = event.delta;
+          if (d.type === 'thinking_delta') {
+            thinkingText += d.thinking;
+            yield { type: 'thinking_delta', text: d.thinking };
+          } else if (d.type === 'text_delta') {
+            fullText += d.text;
+            yield { type: 'text_delta', text: d.text };
+          } else if (d.type === 'input_json_delta') {
+            currentToolJson += d.partial_json;
+          }
+          break;
+        }
+        case 'content_block_stop': {
+          if (currentBlockType === 'thinking') {
+            yield { type: 'thinking_end', fullText: thinkingText };
+          } else if (currentBlockType === 'tool_use') {
+            let input = {};
+            try { input = JSON.parse(currentToolJson); } catch {}
+            toolCalls.push({
+              id: currentToolId,
+              type: 'function',
+              function: { name: currentToolName, arguments: currentToolJson },
+            });
+            yield { type: 'tool_end', name: currentToolName, id: currentToolId, input };
+          }
+          currentBlockType = null;
+          break;
+        }
+        case 'message_delta': {
+          if (event.delta?.stop_reason) stopReason = event.delta.stop_reason;
+          break;
+        }
+      }
+    }
+
+    yield {
+      type: 'message_complete',
+      message: {
+        role: 'assistant',
+        content: fullText || null,
+        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+      },
+      stopReason,
+    };
+
+  } else {
+    // OpenAI provider — 流式 + 工具
+    const stream = await openaiClient.chat.completions.create({
+      model, messages, temperature, max_tokens: maxTokens,
+      tools: tools?.length > 0 ? tools : undefined,
+      tool_choice: tools?.length > 0 ? 'auto' : undefined,
+      stream: true,
+    });
+
+    let fullText = '';
+    let toolCallsMap = {};
+    let stopReason = null;
+
+    for await (const chunk of stream) {
+      const choice = chunk.choices[0];
+      if (!choice) continue;
+
+      if (choice.delta?.content) {
+        fullText += choice.delta.content;
+        yield { type: 'text_delta', text: choice.delta.content };
+      }
+
+      if (choice.delta?.tool_calls) {
+        for (const tc of choice.delta.tool_calls) {
+          const idx = tc.index;
+          if (!toolCallsMap[idx]) {
+            toolCallsMap[idx] = { id: '', name: '', args: '' };
+          }
+          if (tc.id) toolCallsMap[idx].id = tc.id;
+          if (tc.function?.name) {
+            toolCallsMap[idx].name = tc.function.name;
+            yield { type: 'tool_start', name: tc.function.name, id: tc.id || '' };
+          }
+          if (tc.function?.arguments) {
+            toolCallsMap[idx].args += tc.function.arguments;
+          }
+        }
+      }
+
+      if (choice.finish_reason) {
+        stopReason = choice.finish_reason;
+      }
+    }
+
+    // 输出工具完成事件并构建 toolCalls 数组
+    const toolCalls = [];
+    for (const tc of Object.values(toolCallsMap)) {
+      let input = {};
+      try { input = JSON.parse(tc.args); } catch {}
+      yield { type: 'tool_end', name: tc.name, id: tc.id, input };
+      toolCalls.push({
+        id: tc.id,
+        type: 'function',
+        function: { name: tc.name, arguments: tc.args },
+      });
+    }
+
+    yield {
+      type: 'message_complete',
+      message: {
+        role: 'assistant',
+        content: fullText || null,
+        tool_calls: toolCalls.length > 0 ? toolCalls : undefined,
+      },
+      stopReason: stopReason === 'tool_calls' ? 'tool_use' : (stopReason || 'end_turn'),
+    };
+  }
+}
+
 /**
  * 获取当前提供商名称
  */

package/src/mcp.js

@@ -140,10 +140,17 @@ class MCPConnection {
   /**
    * 发送 JSON-RPC 请求
    */
-  _sendRequest(method, params = {}) {
+  _sendRequest(method, params = {}, timeoutMs = 30000) {
     return new Promise((resolve, reject) => {
       const id = ++this._requestId;
-      this._pendingRequests.set(id, { resolve, reject });
+      const timer = setTimeout(() => {
+        this._pendingRequests.delete(id);
+        reject(new Error(`MCP 请求 ${method} 超时 (${timeoutMs}ms)`));
+      }, timeoutMs);
+      this._pendingRequests.set(id, {
+        resolve: (v) => { clearTimeout(timer); resolve(v); },
+        reject: (e) => { clearTimeout(timer); reject(e); },
+      });
 
       const msg = JSON.stringify({
         jsonrpc: '2.0',
@@ -217,6 +224,9 @@ class MCPConnection {
       this.process = null;
     }
     this.connected = false;
+    for (const { reject } of this._pendingRequests.values()) {
+      reject(new Error(`MCP 服务器 ${this.name} 已断开`));
+    }
     this._pendingRequests.clear();
   }
 }
@@ -306,13 +316,10 @@ export function isMCPTool(toolName) {
  * 执行 MCP 工具调用
  */
 export async function executeMCPTool(toolName, args) {
-  // 解析：mcp_{serverName}_{toolName}
-  const parts = toolName.replace(/^mcp_/, '').split('_');
-
-  // 找到匹配的服务器
   for (const [serverName, conn] of connections) {
-    if (toolName.startsWith(`mcp_${serverName}_`)) {
-      const actualToolName = toolName.replace(`mcp_${serverName}_`, '');
+    const prefix = `mcp_${serverName}_`;
+    if (toolName.startsWith(prefix)) {
+      const actualToolName = toolName.slice(prefix.length);
       return await conn.callTool(actualToolName, args);
     }
   }

package/src/scheduler.js

@@ -9,6 +9,7 @@
 
 import fs from 'fs/promises';
 import path from 'path';
+import chalk from 'chalk';
 import dayjs from 'dayjs';
 import config from '../midou.config.js';
 
@@ -154,7 +155,11 @@ export async function startScheduler(onFire) {
   await loadReminders();
 
   // 每 30 秒检查一次提醒
-  schedulerTimer = setInterval(() => checkReminders(onFire), 30 * 1000);
+  schedulerTimer = setInterval(() => {
+    checkReminders(onFire).catch(err => {
+      console.error(chalk.dim(`  ⏰ 提醒检查异常: ${err.message}`));
+    });
+  }, 30 * 1000);
 
   return {
     stop: stopScheduler,