@ww_nero/mini-cli 1.0.56

package/src/chat.js

@@ -0,0 +1,1008 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const readline = require('readline');
+const chalk = require('chalk');
+const { encode } = require('gpt-tokenizer');
+
+const { ConfigError, loadEndpointConfig, getDefaultConfigPath, ensureConfigFiles, loadSettings, DEFAULT_COMPACT_TOKEN_THRESHOLD } = require('./config');
+const { chatCompletion } = require('./llm');
+const { performCompactSummary } = require('./request');
+const { toolSystemPrompt } = require('./prompt/tool');
+const { createToolRuntime } = require('./tools');
+const { renderToolCall } = require('./utils/renderer');
+const { safeJsonParse } = require('./utils/helpers');
+const { describeModel, createModelManager } = require('./utils/model');
+const { SLASH_COMMANDS, createCommandHandler } = require('./utils/commands');
+const { CLI_OPTIONS } = require('./utils/cliOptions');
+const { ensureGitRepository } = require('./utils/git');
+const {
+  createThinkParserState,
+  processThinkChunk,
+  flushThinkState
+} = require('./utils/think');
+const {
+  mergeReasoningContent,
+  renderAssistantOutput,
+  sanitizeContentWithThink,
+  printUsageTokens
+} = require('./utils/output');
+const {
+  createHistoryFilePath,
+  saveHistoryMessages,
+  listHistoryFiles,
+  trimHistoryFiles,
+  readHistoryMessages,
+  extractFirstUserQuestion,
+  formatPreviewText,
+  refreshHistoryFilePath
+} = require('./utils/history');
+
+const CURSOR_STYLE_CODES = {
+  default: '\u001B[0 q',
+  loading: '\u001B[5 q'
+};
+
+const MINI_FILE_NAME = 'MINI.md';
+const MINI_DIR_NAME = '.mini';
+
+const readMiniFileContent = (filePath) => {
+  try {
+    if (fs.existsSync(filePath)) {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return content.trim();
+    }
+  } catch (error) {
+    console.log(chalk.yellow(`读取 ${filePath} 失败：${error.message}`));
+  }
+  return '';
+};
+
+const appendMiniInstructions = (baseContent, workspaceRoot) => {
+  const sections = [];
+  const globalMiniPath = path.join(os.homedir(), MINI_DIR_NAME, MINI_FILE_NAME);
+  const workspaceMiniPath = path.join(workspaceRoot, MINI_FILE_NAME);
+
+  const globalContent = readMiniFileContent(globalMiniPath);
+  if (globalContent) {
+    sections.push(`<system_instruction>\n${globalContent}\n</system_instruction>`);
+  }
+
+  const workspaceContent = readMiniFileContent(workspaceMiniPath);
+  if (workspaceContent) {
+    sections.push(`<project_instruction>\n${workspaceContent}\n</project_instruction>`);
+  }
+
+  if (sections.length === 0) {
+    return baseContent;
+  }
+
+  return `${baseContent}\n\n${sections.join('\n\n')}`;
+};
+
+const stringifyToolResult = (value) => {
+  if (typeof value === 'string') {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch (_) {
+    return String(value);
+  }
+};
+
+const enforceToolOutputLimit = (text, tokenLimit) => {
+  const content = typeof text === 'string' ? text : stringifyToolResult(text);
+  const safeContent = typeof content === 'string' ? content : '';
+  try {
+    const tokens = encode(safeContent);
+    const tokenCount = tokens.length;
+    if (tokenCount > tokenLimit) {
+      return {
+        content: '输出内容太长,请优化工具调用方式。',
+        truncated: true,
+        originalTokenCount: tokenCount,
+        limit: tokenLimit
+      };
+    }
+    return {
+      content: safeContent,
+      truncated: false,
+      tokenCount
+    };
+  } catch (_) {
+    // 忽略分词异常，保持原始输出
+    return {
+      content: safeContent,
+      truncated: false,
+      tokenCount: null
+    };
+  }
+};
+
+const truncateForDisplay = (text, maxLength = 100) => {
+  if (!text || typeof text !== 'string') {
+    return '';
+  }
+  const normalized = text.replace(/\s+/g, ' ').trim();
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return normalized.substring(0, maxLength) + '...';
+};
+
+const supportsCursorControl = () => Boolean(process.stdout && process.stdout.isTTY);
+
+let loadingCursorActive = false;
+let cursorCleanupRegistered = false;
+
+const applyCursorStyleCode = (code) => {
+  if (!supportsCursorControl()) {
+    return;
+  }
+  process.stdout.write(code);
+};
+
+const restoreCursorStyle = () => {
+  if (!supportsCursorControl()) {
+    return;
+  }
+  applyCursorStyleCode(CURSOR_STYLE_CODES.default);
+  loadingCursorActive = false;
+};
+
+const setLoadingCursorState = (isLoading) => {
+  if (!supportsCursorControl()) {
+    return;
+  }
+  if (isLoading) {
+    if (loadingCursorActive) {
+      return;
+    }
+    loadingCursorActive = true;
+    applyCursorStyleCode(CURSOR_STYLE_CODES.loading);
+    if (!cursorCleanupRegistered) {
+      cursorCleanupRegistered = true;
+      process.once('exit', restoreCursorStyle);
+    }
+  } else if (loadingCursorActive) {
+    restoreCursorStyle();
+  }
+};
+
+const startChatSession = async ({
+  initialQuestion = '',
+  initialModelName,
+  cliOptions = []
+} = {}) => {
+  const initResult = ensureConfigFiles();
+  if (initResult.createdFiles && initResult.createdFiles.length > 0) {
+    console.log(chalk.yellow(`已在 ${initResult.configDir} 创建配置文件：${initResult.createdFiles.join(', ')}，请完善模型 key 等信息后重试。`));
+  }
+
+  let endpoints = [];
+  let resolvedPath;
+  try {
+    const loaded = loadEndpointConfig();
+    endpoints = loaded.endpoints;
+    resolvedPath = loaded.configPath;
+  } catch (error) {
+    if (error instanceof ConfigError) {
+      console.error(chalk.red(error.message));
+      return;
+    }
+    throw error;
+  }
+
+  const modelManager = createModelManager(endpoints, { configPath: resolvedPath || getDefaultConfigPath() });
+  modelManager.setActiveModel(0, { updateDefault: true, announce: false, persistConfig: false });
+
+  if (initialModelName) {
+    modelManager.applyModelByName(initialModelName, { source: 'cli', announceSuccess: true, showError: true });
+  }
+
+  const workspaceRoot = process.cwd();
+  const { gitInitialized, gitignoreCreated, initialCommitCreated } = ensureGitRepository(workspaceRoot);
+  if (gitInitialized) {
+    console.log(chalk.gray('已自动初始化 Git 仓库。'));
+  }
+  if (gitignoreCreated) {
+    console.log(chalk.gray('已创建默认 .gitignore。'));
+  }
+  if (initialCommitCreated) {
+    console.log(chalk.gray('已创建初始提交：init project。'));
+  }
+  const systemPromptContent = appendMiniInstructions(toolSystemPrompt, workspaceRoot);
+
+  // Load settings to get toolOutputTokenLimit and compactTokenThreshold
+  const { settings } = loadSettings();
+  const toolOutputTokenLimit = settings.toolOutputTokenLimit;
+  const compactTokenThreshold = settings.compactTokenThreshold || DEFAULT_COMPACT_TOKEN_THRESHOLD;
+
+  let toolRuntime;
+  try {
+    toolRuntime = await createToolRuntime(workspaceRoot);
+  } catch (error) {
+    console.log(chalk.yellow(`加载工具失败，将仅使用基础对话：${error.message}`));
+    toolRuntime = {
+      tools: [],
+      handlers: {},
+      dispose: null,
+      mcpConfigPath: null,
+      mcpToolNames: new Set(),
+      enabledToolNames: [],
+      enabledMcpNames: []
+    };
+  }
+  const {
+    tools: toolSchemas,
+    handlers: toolHandlers,
+    dispose: disposeTools,
+    mcpConfigPath,
+    mcpToolNames,
+    enabledToolNames,
+    enabledMcpNames
+  } = toolRuntime || {
+    tools: [],
+    handlers: {},
+    dispose: null,
+    mcpConfigPath: null,
+    mcpToolNames: new Set(),
+    enabledToolNames: [],
+    enabledMcpNames: []
+  };
+
+  const createSystemMessage = () => ({ role: 'system', content: systemPromptContent });
+  const messages = [createSystemMessage()];
+  let activeHistoryFilePath = null;
+
+  const resetHistorySession = () => {
+    activeHistoryFilePath = null;
+  };
+
+  const resetMessages = () => {
+    messages.length = 0;
+    messages.push(createSystemMessage());
+    resetHistorySession();
+  };
+
+  const ensureHistoryFileReady = () => {
+    if (activeHistoryFilePath) {
+      return true;
+    }
+    const firstQuestion = extractFirstUserQuestion(messages);
+    const hasAssistantMessage = messages.some((entry) => entry && entry.role === 'assistant');
+    if (!firstQuestion || !hasAssistantMessage) {
+      return false;
+    }
+    try {
+      activeHistoryFilePath = createHistoryFilePath(workspaceRoot);
+      return true;
+    } catch (error) {
+      activeHistoryFilePath = null;
+      console.log(chalk.yellow(`创建历史记录失败：${error.message}`));
+      return false;
+    }
+  };
+
+  const persistHistorySafely = () => {
+    if (!ensureHistoryFileReady()) {
+      return;
+    }
+    try {
+      const saved = saveHistoryMessages(activeHistoryFilePath, messages);
+      if (saved) {
+        const removed = trimHistoryFiles(undefined, workspaceRoot);
+        if (Array.isArray(removed) && removed.includes(activeHistoryFilePath)) {
+          activeHistoryFilePath = null;
+        }
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`保存历史记录失败：${error.message}`));
+    }
+  };
+
+  const loadHistoryFromFile = (filePath, historyMessages) => {
+    messages.length = 0;
+    if (Array.isArray(historyMessages) && historyMessages.length > 0) {
+      historyMessages.forEach((entry) => {
+        if (entry && typeof entry === 'object') {
+          messages.push(entry);
+        }
+      });
+    }
+    if (messages.length === 0) {
+      messages.push(createSystemMessage());
+    }
+    activeHistoryFilePath = filePath || null;
+  };
+
+  const replayHistoryConversation = (historyMessages) => {
+    if (!Array.isArray(historyMessages) || historyMessages.length === 0) {
+      console.log(chalk.yellow('历史记录为空，暂无内容可展示。'));
+      return;
+    }
+
+    console.log(chalk.gray('-------- 历史会话开始 --------'));
+
+    const toolMessageQueues = new Map();
+    const consumedToolMessages = new Set();
+
+    historyMessages.forEach((message) => {
+      if (message && message.role === 'tool' && message.tool_call_id) {
+        const queue = toolMessageQueues.get(message.tool_call_id) || [];
+        queue.push(message);
+        toolMessageQueues.set(message.tool_call_id, queue);
+      }
+    });
+
+    const toDisplayString = (value) => {
+      if (typeof value === 'string') {
+        return value;
+      }
+      if (value == null) {
+        return '';
+      }
+      try {
+        return JSON.stringify(value, null, 2);
+      } catch (error) {
+        return '';
+      }
+    };
+
+    historyMessages.forEach((message) => {
+      if (!message || typeof message !== 'object') {
+        return;
+      }
+
+      if (message.role === 'system') {
+        return;
+      }
+
+      if (message.role === 'user') {
+        const content = typeof message.content === 'string' ? message.content : '';
+        console.log(`${chalk.cyan('用户>')} ${content}`);
+        return;
+      }
+
+      if (message.role === 'assistant') {
+        const ensureHistoryNewline = (() => {
+          let used = false;
+          return () => {
+            if (!used) {
+              process.stdout.write('\n');
+              used = true;
+            }
+          };
+        })();
+
+        const reasoningText = mergeReasoningContent(message.reasoning_content || '');
+        const primaryContent = typeof message.content === 'string' ? message.content : '';
+        const sanitizedContent = sanitizeContentWithThink(primaryContent, primaryContent);
+
+        renderAssistantOutput(reasoningText, sanitizedContent, ensureHistoryNewline);
+
+        const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
+        toolCalls.forEach((toolCall) => {
+          const functionName = toolCall?.function?.name || 'unknown_tool';
+          const rawArgs = toolCall?.function?.arguments || '';
+          const parsedArgs = typeof rawArgs === 'string' ? safeJsonParse(rawArgs) : rawArgs;
+          const args = parsedArgs && typeof parsedArgs === 'object'
+            ? parsedArgs
+            : { raw: typeof rawArgs === 'string' ? rawArgs : '' };
+
+          const queue = toolMessageQueues.get(toolCall.id) || [];
+          const toolMessage = queue.shift();
+          if (queue.length === 0) {
+            toolMessageQueues.delete(toolCall.id);
+          } else {
+            toolMessageQueues.set(toolCall.id, queue);
+          }
+
+          if (toolMessage) {
+            consumedToolMessages.add(toolMessage);
+          }
+
+          renderToolCall({
+            functionName,
+            args
+          }, mcpToolNames);
+        });
+        return;
+      }
+
+      if (message.role === 'tool') {
+        if (consumedToolMessages.has(message)) {
+          return;
+        }
+        const fallback = toDisplayString(message.content) || '(无输出)';
+        console.log(chalk.magenta(`工具输出: ${fallback}`));
+      }
+    });
+
+    console.log(chalk.gray('-------- 历史会话结束，可继续提问 --------'));
+  };
+
+  const handleResumeCommand = (rawArgs = '') => {
+    const entries = listHistoryFiles(workspaceRoot);
+    if (entries.length === 0) {
+      console.log(chalk.yellow('暂无历史记录。'));
+      return;
+    }
+
+    if (!rawArgs) {
+      entries.forEach((entry, index) => {
+        const historyMessages = readHistoryMessages(entry.filePath);
+        if (!historyMessages) {
+          console.log(`${index + 1}. ${chalk.red('(记录损坏)')}`);
+          return;
+        }
+        const previewSource = extractFirstUserQuestion(historyMessages);
+        const preview = formatPreviewText(previewSource);
+        console.log(`${index + 1}. ${preview}`);
+      });
+      console.log(chalk.gray('使用 /resume <序号> 恢复指定对话。'));
+      return;
+    }
+
+    const numeric = Number.parseInt(rawArgs, 10);
+    if (Number.isNaN(numeric)) {
+      console.log(chalk.yellow('请输入合法的序号，例如 /resume 2。'));
+      return;
+    }
+
+    const target = entries[numeric - 1];
+    if (!target) {
+      console.log(chalk.yellow(`序号 ${numeric} 超出范围，当前共有 ${entries.length} 条历史记录。`));
+      return;
+    }
+
+    const historyMessages = readHistoryMessages(target.filePath);
+    if (!Array.isArray(historyMessages) || historyMessages.length === 0) {
+      console.log(chalk.yellow('该历史记录为空或已损坏，无法恢复。'));
+      return;
+    }
+
+    const refreshedPath = refreshHistoryFilePath(target.filePath, workspaceRoot) || target.filePath;
+    loadHistoryFromFile(refreshedPath, historyMessages);
+    console.log(chalk.green(`已切换到历史记录 #${numeric}，可继续对话。`));
+    replayHistoryConversation(historyMessages);
+  };
+
+  console.log(chalk.blueBright('Mini CLI 已启动，随时输入问题开始提问。'));
+  console.log(chalk.gray(`聊天模型: ${describeModel(modelManager.getActiveEndpoint())}`));
+
+  // 打印启用的工具列表
+  if (enabledToolNames.length > 0) {
+    console.log(chalk.gray(`启用的工具 (${enabledToolNames.length}): ${enabledToolNames.join(', ')}`));
+  } else {
+    console.log(chalk.gray('未启用任何工具'));
+  }
+
+  // 打印启用的 MCP 列表
+  if (enabledMcpNames.length > 0) {
+    console.log(chalk.gray(`启用的 MCP (${enabledMcpNames.length}): ${enabledMcpNames.join(', ')}`));
+  } else {
+    console.log(chalk.gray('未启用任何 MCP 服务器'));
+  }
+
+  const startupOptions = (Array.isArray(cliOptions) && cliOptions.length > 0) ? cliOptions : CLI_OPTIONS;
+  if (startupOptions.length > 0) {
+    console.log(chalk.gray('启动参数：'));
+    startupOptions.forEach((option) => {
+      console.log(chalk.gray(`  ${option.flags}  ${option.description}`));
+    });
+  }
+
+  console.log(chalk.gray('快捷命令：'));
+  SLASH_COMMANDS.forEach((cmd) => {
+    console.log(chalk.gray(`  ${cmd.value} - ${cmd.description}`));
+  });
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+
+  const DEFAULT_PROMPT = `${chalk.cyan('用户>')} `;
+  rl.setPrompt(DEFAULT_PROMPT);
+
+  const LOADING_PROMPT_BASE_TEXT = '⌛ 回答中...（按 Esc 取消）';
+  const FLOW_GRADIENT_COLORS = ['#FFF7CC', '#FFE58F', '#FFD666', '#FFC53D', '#FFA940', '#FF7A45'];
+  const FLOW_DIM_COLOR = '#5F5F6A';
+  const loadingPromptCharacters = Array.from(LOADING_PROMPT_BASE_TEXT);
+  const loadingPromptCharCount = loadingPromptCharacters.length || 1;
+  const supportsHexColor = typeof chalk.hex === 'function';
+  const flowGradientFns = supportsHexColor
+    ? FLOW_GRADIENT_COLORS.map((hex) => chalk.hex(hex))
+    : [];
+  const dimTextFn = supportsHexColor ? chalk.hex(FLOW_DIM_COLOR) : chalk.yellow;
+
+  const formatLoadingPrompt = (frame) => {
+    if (!supportsHexColor) {
+      return chalk.yellow(LOADING_PROMPT_BASE_TEXT);
+    }
+    const gradientLength = Math.min(flowGradientFns.length, loadingPromptCharCount);
+    const startIndex = frame % loadingPromptCharCount;
+    return loadingPromptCharacters.map((char, index) => {
+      const distance = (index - startIndex + loadingPromptCharCount) % loadingPromptCharCount;
+      if (distance < gradientLength) {
+        return flowGradientFns[distance](char);
+      }
+      return dimTextFn(char);
+    }).join('');
+  };
+
+  const LOADING_PROMPT_INTERVAL = 140;
+  let loadingPromptFrame = 0;
+  let loadingPromptTimer = null;
+  let loadingPromptVisible = false;
+
+  const getCurrentLoadingPromptText = () => formatLoadingPrompt(loadingPromptFrame);
+
+  const tickLoadingPromptAnimation = () => {
+    if (!loadingPromptVisible || !supportsHexColor) {
+      return;
+    }
+    loadingPromptFrame = (loadingPromptFrame + 1) % loadingPromptCharCount;
+    refreshLoadingPrompt();
+  };
+
+  const startLoadingPromptAnimation = () => {
+    if (loadingPromptTimer || !process.stdout.isTTY || !supportsHexColor) {
+      return;
+    }
+    loadingPromptTimer = setInterval(tickLoadingPromptAnimation, LOADING_PROMPT_INTERVAL);
+    if (typeof loadingPromptTimer.unref === 'function') {
+      loadingPromptTimer.unref();
+    }
+  };
+
+  const stopLoadingPromptAnimation = () => {
+    if (loadingPromptTimer) {
+      clearInterval(loadingPromptTimer);
+      loadingPromptTimer = null;
+    }
+  };
+
+  const writeLoadingPrompt = () => {
+    if (!process.stdout.isTTY) {
+      return;
+    }
+    readline.cursorTo(process.stdout, 0);
+    readline.clearLine(process.stdout, 0);
+    process.stdout.write(getCurrentLoadingPromptText());
+  };
+
+  const showLoadingPrompt = () => {
+    if (loadingPromptVisible || !process.stdout.isTTY) {
+      return;
+    }
+    loadingPromptVisible = true;
+    writeLoadingPrompt();
+    startLoadingPromptAnimation();
+  };
+
+  const refreshLoadingPrompt = () => {
+    if (!loadingPromptVisible) {
+      return;
+    }
+    writeLoadingPrompt();
+  };
+
+  const clearLoadingPrompt = () => {
+    if (!loadingPromptVisible) {
+      return;
+    }
+    if (process.stdout.isTTY) {
+      readline.cursorTo(process.stdout, 0);
+      readline.clearLine(process.stdout, 0);
+    }
+    stopLoadingPromptAnimation();
+    loadingPromptFrame = 0;
+    loadingPromptVisible = false;
+  };
+
+  let inFlightController = null;
+  let closing = false;
+  let cancelNoticeShown = false;
+  let skipNextLoopPrompt = false;
+  let toolsDisposed = false;
+
+  const cleanupTools = () => {
+    if (toolsDisposed || typeof disposeTools !== 'function') {
+      return;
+    }
+    toolsDisposed = true;
+    Promise.resolve(disposeTools()).catch((error) => {
+      console.log(chalk.yellow(`清理工具失败：${error.message}`));
+    });
+  };
+
+  const closeSession = () => {
+    if (closing) return;
+    closing = true;
+    clearLoadingPrompt();
+    setLoadingCursorState(false);
+    cleanupTools();
+    rl.close();
+    console.log(chalk.gray('已退出 mini 对话。'));
+  };
+
+  const commandHandler = createCommandHandler({
+    modelManager,
+    resetMessages,
+    closeSession,
+    handleResume: handleResumeCommand
+  });
+
+  const resizeHandler = () => {
+    refreshLoadingPrompt();
+  };
+
+  if (process.stdout && typeof process.stdout.on === 'function') {
+    process.stdout.on('resize', resizeHandler);
+  }
+
+  const cancelActiveRequest = (message) => {
+    if (!inFlightController) {
+      return false;
+    }
+    inFlightController.abort();
+    inFlightController = null;
+    clearLoadingPrompt();
+    setLoadingCursorState(false);
+    cancelNoticeShown = true;
+    console.log(`\n${chalk.yellow(message)}`);
+    if (!closing) {
+      rl.prompt();
+      skipNextLoopPrompt = true;
+    }
+    return true;
+  };
+
+  const inputStream = rl.input;
+  if (inputStream && typeof inputStream.on === 'function') {
+    readline.emitKeypressEvents(inputStream, rl);
+    const handleKeypress = (str, key = {}) => {
+      if (key && key.name === 'escape') {
+        cancelActiveRequest('已中断当前请求。');
+      }
+    };
+    inputStream.on('keypress', handleKeypress);
+    rl.on('close', () => {
+      inputStream.removeListener('keypress', handleKeypress);
+    });
+  }
+
+  rl.on('SIGINT', () => {
+    if (cancelActiveRequest('已取消当前请求。')) {
+      return;
+    }
+    closeSession();
+  });
+
+  rl.on('close', () => {
+    if (process.stdout && typeof process.stdout.off === 'function') {
+      process.stdout.off('resize', resizeHandler);
+    } else if (process.stdout && typeof process.stdout.removeListener === 'function') {
+      process.stdout.removeListener('resize', resizeHandler);
+    }
+    cleanupTools();
+  });
+
+  const sendQuestion = async (rawInput) => {
+    const text = (rawInput || '').trim();
+    if (!text) {
+      return true;
+    }
+
+    const slashCommandResult = commandHandler.handleSlashCommand(text);
+    if (slashCommandResult.handled) {
+      return !slashCommandResult.shouldExit;
+    }
+
+    const targetEndpoint = modelManager.getActiveEndpoint();
+
+    const userMessage = { role: 'user', content: text };
+    messages.push(userMessage);
+    persistHistorySafely();
+
+    setLoadingCursorState(true);
+
+    const controller = new AbortController();
+    inFlightController = controller;
+    cancelNoticeShown = false;
+    let conversationAdvanced = false;
+
+    const ensureNotAborted = () => {
+      if (controller.signal.aborted) {
+        const abortError = new Error('Aborted');
+        abortError.name = 'AbortError';
+        throw abortError;
+      }
+    };
+
+    const runAgentLoop = async (endpointForRequest) => {
+      const buildHistoryAssistantMessage = (sourceMessage, fallbackContent, reasoningText) => {
+        const baseMessage = (sourceMessage && typeof sourceMessage === 'object')
+          ? sourceMessage
+          : { role: 'assistant' };
+        const historyMessage = { ...baseMessage };
+        if (typeof baseMessage.content === 'string') {
+          historyMessage.content = baseMessage.content;
+        } else if (typeof fallbackContent === 'string') {
+          historyMessage.content = fallbackContent;
+        } else {
+          historyMessage.content = '';
+        }
+
+        if (reasoningText) {
+          historyMessage.reasoning_content = reasoningText;
+        } else if ('reasoning_content' in historyMessage) {
+          delete historyMessage.reasoning_content;
+        }
+
+        return historyMessage;
+      };
+
+      while (true) {
+        process.stdout.write('\n');
+        showLoadingPrompt();
+        const streamState = {
+          thinkState: createThinkParserState(),
+          content: '',
+          reasoningFromThink: ''
+        };
+        let reasoningFromModel = '';
+        let printedNewline = false;
+
+        const ensureNewline = () => {
+          if (!printedNewline) {
+            clearLoadingPrompt();
+            process.stdout.write('\n');
+            printedNewline = true;
+          }
+        };
+
+        const handleStreamChunk = (chunk) => {
+          const { contentChunk, reasonChunk } = processThinkChunk(streamState.thinkState, chunk);
+
+          if (contentChunk) {
+            streamState.content += contentChunk;
+          }
+
+          if (reasonChunk) {
+            streamState.reasoningFromThink += reasonChunk;
+          }
+        };
+
+        const handleReasoningChunk = (_, aggregate) => {
+          reasoningFromModel = aggregate || reasoningFromModel;
+        };
+
+        const finalizeStreamState = () => {
+          const { contentChunk, reasonChunk } = flushThinkState(streamState.thinkState);
+          if (contentChunk) {
+            streamState.content += contentChunk;
+          }
+          if (reasonChunk) {
+            streamState.reasoningFromThink += reasonChunk;
+          }
+        };
+
+        const result = await chatCompletion({
+          endpoint: endpointForRequest,
+          messages,
+          abortController: controller,
+          tools: toolSchemas,
+          onToken: handleStreamChunk,
+          onReasoningToken: handleReasoningChunk,
+          onRetry: (retryCount, error) => {
+            const detail = error ? `（${error.message}）` : '';
+            process.stdout.write(`\n${chalk.yellow(`请求失败，${retryCount} 次重试中${detail}...`)}\n`);
+          }
+        });
+
+        finalizeStreamState();
+
+        const rawReasoning = (reasoningFromModel || result.reasoningContent || '').trim();
+        const mergedReasoning = mergeReasoningContent(
+          rawReasoning,
+          streamState.reasoningFromThink
+        );
+
+        const toolCalls = Array.isArray(result.toolCalls) ? result.toolCalls : [];
+
+        if (toolCalls.length > 0) {
+          conversationAdvanced = true;
+          const baseMessage = result.message || { role: 'assistant', content: result.content || '' };
+          const sanitizedContent = sanitizeContentWithThink(
+            streamState.content,
+            typeof baseMessage.content === 'string' ? baseMessage.content : result.content
+          );
+          renderAssistantOutput(mergedReasoning, sanitizedContent, ensureNewline);
+          const assistantMessage = buildHistoryAssistantMessage(
+            baseMessage,
+            result.content,
+            rawReasoning
+          );
+          messages.push(assistantMessage);
+
+          for (const toolCall of toolCalls) {
+            ensureNotAborted();
+            const functionName = toolCall?.function?.name || 'unknown_tool';
+            const rawArgs = toolCall?.function?.arguments || '';
+            const parsedArgs = safeJsonParse(rawArgs);
+            const handler = toolHandlers[functionName];
+            const displayArgs = parsedArgs && typeof parsedArgs === 'object'
+              ? parsedArgs
+              : { raw: typeof rawArgs === 'string' ? rawArgs : '' };
+
+            renderToolCall({ functionName, args: displayArgs }, mcpToolNames);
+
+            let toolResult;
+
+            if (!parsedArgs || typeof parsedArgs !== 'object') {
+              toolResult = '工具调用失败：参数解析错误';
+            } else if (!handler) {
+              toolResult = `工具 ${functionName} 未实现`;
+            } else {
+              showLoadingPrompt();
+              try {
+                toolResult = await handler(parsedArgs);
+              } catch (toolError) {
+                toolResult = `工具执行异常: ${toolError.message}`;
+              } finally {
+                clearLoadingPrompt();
+              }
+            }
+
+            const resultInfo = enforceToolOutputLimit(stringifyToolResult(toolResult), toolOutputTokenLimit);
+            const toolContent = resultInfo.content;
+
+            // Display tool output
+            if (functionName === 'write_todos') {
+              // For todos, display full formatted output without truncation
+              if (toolContent) {
+                console.log(chalk.gray(`  ${toolContent}`));
+              }
+            } else {
+              // For other tools, show preview in gray
+              const preview = truncateForDisplay(toolContent, 100);
+              if (preview) {
+                console.log(chalk.gray(`  ${preview}`));
+              }
+
+              // If truncated, show warning with token count
+              if (resultInfo.truncated) {
+                console.log(chalk.yellow(`  ⚠ 输出已截断 (${resultInfo.originalTokenCount} tokens > ${resultInfo.limit} limit)`));
+              } else if (resultInfo.tokenCount != null) {
+                console.log(chalk.gray(`  (${resultInfo.tokenCount} tokens)`));
+              }
+            }
+
+            messages.push({
+              role: 'tool',
+              tool_call_id: toolCall.id,
+              content: toolContent
+            });
+          }
+          printUsageTokens(result.usage);
+          persistHistorySafely();
+
+          // 检测是否需要触发 compact
+          const totalTokens = result.usage?.total_tokens;
+          if (typeof totalTokens === 'number' && totalTokens >= compactTokenThreshold) {
+            console.log(chalk.yellow(`\n⏳ 上下文过长 (${totalTokens} tokens)，正在压缩...`));
+            showLoadingPrompt();
+
+            try {
+              const summaryContent = await performCompactSummary(endpointForRequest, messages, controller);
+
+              // 提取 system prompt
+              const systemMessage = messages.find(msg => msg.role === 'system');
+
+              // 重置消息列表
+              messages.length = 0;
+              if (systemMessage) {
+                messages.push(systemMessage);
+              }
+
+              // 添加总结内容作为新的用户消息
+              messages.push({
+                role: 'user',
+                content: `<context_summary>\n${summaryContent}\n</context_summary>\n\n请根据以上总结的上下文，继续完成待完成的任务。`
+              });
+
+              clearLoadingPrompt();
+              console.log(chalk.green('✓ 上下文已压缩，可继续对话。'));
+              persistHistorySafely();
+            } catch (compactError) {
+              clearLoadingPrompt();
+              if (compactError.name === 'AbortError') {
+                throw compactError;
+              }
+              console.log(chalk.yellow('⚠ 上下文压缩失败，将继续使用当前上下文'));
+            }
+          }
+
+          continue;
+        }
+
+        conversationAdvanced = true;
+        const finalText = sanitizeContentWithThink(streamState.content, result.content);
+        renderAssistantOutput(mergedReasoning, finalText, ensureNewline);
+        const assistantMessage = buildHistoryAssistantMessage(
+          result.message,
+          result.content,
+          rawReasoning
+        );
+        messages.push(assistantMessage);
+        persistHistorySafely();
+        printUsageTokens(result.usage);
+        break;
+      }
+    };
+
+    try {
+      await runAgentLoop(targetEndpoint);
+    } catch (error) {
+      const isAbortError = error.name === 'AbortError';
+      if (!isAbortError) {
+        process.stdout.write('\n');
+      }
+      if (!conversationAdvanced) {
+        const lastMessage = messages[messages.length - 1];
+        if (lastMessage && lastMessage.role === 'user') {
+          messages.pop();
+        }
+      }
+      if (isAbortError) {
+        if (!cancelNoticeShown) {
+          console.log(chalk.yellow('对话已取消。'));
+        }
+      } else {
+        console.error(chalk.red(`请求失败: ${error.message}`));
+      }
+    } finally {
+      clearLoadingPrompt();
+      setLoadingCursorState(false);
+      inFlightController = null;
+      cancelNoticeShown = false;
+    }
+
+    return true;
+  };
+
+  if (typeof initialQuestion === 'string' && initialQuestion.trim()) {
+    console.log(`${chalk.cyan('用户>')}${initialQuestion.trim()}`);
+    const shouldContinue = await sendQuestion(initialQuestion);
+    if (!shouldContinue) {
+      return;
+    }
+  }
+
+  rl.prompt();
+  for await (const input of rl) {
+    const shouldContinue = await sendQuestion(input);
+    if (!shouldContinue) {
+      break;
+    }
+    if (closing) {
+      return;
+    }
+    if (skipNextLoopPrompt) {
+      skipNextLoopPrompt = false;
+      continue;
+    }
+    rl.prompt();
+  }
+
+  closeSession();
+};
+
+module.exports = {
+  startChatSession
+};