zen-gitsync 2.17.6 → 2.17.8

package/src/cli/ai/termui.test.js

@@ -18,10 +18,12 @@
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
 import chalk from 'chalk'
+import ora from 'ora'
+import stringWidth from 'string-width'
 import {
   stripAnsi, truncateDisplay, summarizeToolArgs,
-  createAssistantWriter, printToolHeader, printToolResult,
-  formatDuration,
+  createAssistantWriter, printToolHeader, printToolResult, startSpinner,
+  formatDuration, wrapTerminalText, renderTurnSummary,
   filterSlashCommands, renderSlashHintBody, parseKeyForSlashHint, SLASH_COMMANDS,
   renderSelectableListBody, parseKeyForSelectableList,
 } from './termui.js'
@@ -87,6 +89,35 @@ test('summarizeToolArgs: 未知工具回退 JSON,缺参数不炸', () => {
 })
 
 // ── createAssistantWriter ──
+test('TTY spinner stops once without moving the cursor over later streamed text', t => {
+  const c = collect()
+  const cursorOperations = []
+  const stream = {
+    isTTY: true, columns: 100,
+    write: c.write,
+    cursorTo: column => cursorOperations.push(['column', column]),
+    moveCursor: (x, y) => cursorOperations.push(['move', x, y]),
+    clearLine: direction => cursorOperations.push(['clear', direction]),
+  }
+  const spinner = startSpinner('waiting', {
+    spinnerFactory: options => ora({ ...options, stream, isEnabled: true, hideCursor: false }),
+  })
+  t.after(() => spinner.stop())
+  spinner.stop()
+  const stoppedOperations = cursorOperations.length
+  assert.ok(stoppedOperations > 0, 'must exercise the real TTY cursor operations')
+  const writer = createAssistantWriter({ write: c.write })
+  for (const chunk of ['先检查 ', 'nginx ', '配置文件。\n', '再确认 ', '项目目录。']) {
+    spinner.stop()
+    writer.writeThinking(chunk)
+  }
+  spinner.stop()
+  writer.finish()
+  assert.equal(cursorOperations.length, stoppedOperations, 'later chunks must not reset the terminal cursor')
+  assert.match(c.text(), /先检查 nginx 配置文件。\n/)
+  assert.match(c.text(), /再确认 项目目录。/)
+})
+
 test('writer: 思考段头部只打印一次,内容直写', () => {
   const c = collect()
   const w = createAssistantWriter({ thinkingHeader: '✻ 思考', write: c.write })
@@ -110,15 +141,16 @@ test('writer: showThinking=false 时丢弃思考段', () => {
   assert.ok(text.includes('正文'))
 })
 
-test('writer: 正文首行 🤖 子弹头,后续行缩进对齐', () => {
+test('writer: 回答标题独立显示,正文各行缩进对齐', () => {
   const c = collect()
   const w = createAssistantWriter({ write: c.write })
   w.writeContent('第一行\n第二行\n第三行')
   w.finish()
   const lines = c.lines()
-  assert.ok(lines.some(l => l.startsWith('🤖  第一行')))
-  assert.ok(lines.some(l => l.startsWith('   第二行')))
-  assert.ok(lines.some(l => l.startsWith('   第三行')))
+  assert.equal(lines.filter(l => l === '◆ 回答').length, 1)
+  assert.ok(lines.includes('  第一行'))
+  assert.ok(lines.includes('  第二行'))
+  assert.ok(lines.includes('  第三行'))
 })
 
 test('writer: 行内 markdown — bold 标记被消费,code 反引号被消费', () => {
@@ -194,19 +226,19 @@ test('writer: 头部空白行被吞掉,连续空白行合并(真实 MiniMax 输
   const lines = c.lines()
   // null→content 自动在 🤖 上方加一空行,跳过空行找正文首行
   const firstContent = lines.find(l => l !== '')
-  assert.equal(firstContent, '🤖  答案', `首行应为 🤖  答案,实际: ${JSON.stringify(lines)}`)
+  assert.equal(firstContent, '◆ 回答')
   // "答案"与"下一段"之间最多一个空行,且空行不带缩进
-  const midBlank = lines.slice(1, lines.indexOf('   下一段')).filter(l => l === '').length
+  const midBlank = lines.slice(lines.indexOf('  答案') + 1, lines.indexOf('  下一段')).filter(l => l === '').length
   assert.ok(midBlank <= 1, `空行应被合并,实际行: ${JSON.stringify(lines)}`)
-  assert.ok(lines.includes('   下一段'))
+  assert.ok(lines.includes('  下一段'))
 })
 
 // ── 工具块 ──
-test('printToolHeader: ▶ + 名称(粗)+ 摘要(粗)', () => {
+test('printToolHeader: 工具标签与参数分行显示', () => {
   const c = collect()
   printToolHeader('run_command', '$ npm test', c.write)
   const text = c.text()
-  assert.ok(text.includes('▶  run_command'))
+  assert.ok(text.includes('▸ 执行命令  run_command'))
   assert.ok(text.includes('$ npm test'))
 })
 
@@ -214,10 +246,39 @@ test('printToolResult: 全部行统一 │ 槽线(无 └─ 拐角)', () => {
   const c = collect()
   printToolResult('$ ls\n(exit 0)\nfile1\nfile2', c.write)
   const lines = c.lines()
-  assert.ok(lines.every(l => l.startsWith('  │  ') || l === ''), `每行都应为 │ 槽线,实际: ${JSON.stringify(lines)}`)
+  assert.ok(lines.every(l => l.startsWith('  │ ') || l === ''), `每行都应为 │ 槽线,实际: ${JSON.stringify(lines)}`)
   assert.ok(!lines.some(l => l.includes('└─')), '不应出现 └─ 拐角字符')
 })
 
+test('Windows command output renders like LF output in compact and full modes', () => {
+  const names = ['.claude', '.git', '.gitattributes', '.github', '.gitignore', '.npmignore',
+    'AGENTS.md', 'docs', 'index.js', 'package.json', 'README.md', '源码笔记.md']
+  for (const full of [false, true]) {
+    const lf = collect(), windows = collect()
+    printToolResult(['$ dir /a /b', '(exit 0)', ...names].join('\n'), lf.write, 38, { full, width: 60 })
+    printToolResult(['$ dir /a /b', '(exit 0)', ...names].join('\r\n'), windows.write, 38, { full, width: 60 })
+    assert.equal(windows.text(), lf.text(), 'line endings must not change layout or the omitted row count')
+    assert.doesNotMatch(windows.text(), /\r/)
+    const rows = windows.lines().filter(Boolean)
+    assert.ok(rows.slice(0, -1).every(row => row.startsWith('  │ ')))
+    assert.match(rows.at(-1), /^  └ 完成 · 38ms · exit 0$/)
+    if (full) assert.deepEqual(rows.slice(0, -1), names.map(name => '  │ ' + name))
+    else assert.match(windows.text(), /回显省略 7 行/)
+  }
+})
+
+test('wrapped Windows paths keep every continuation row to the right of the gutter', () => {
+  const c = collect()
+  const paths = ['C:\\workspace\\项目目录\\src\\components\\DirectorySelector.vue',
+    'C:\\workspace\\项目目录\\docs\\终端显示🙂.md']
+  printToolResult(paths.join('\r\n'), c.write, undefined, { full: true, width: 24 })
+  const rows = c.lines().filter(Boolean)
+  assert.ok(rows.every(row => row.startsWith('  │ ')))
+  assert.ok(rows.every(row => stringWidth(row) <= 28), 'include the gutter when checking physical width')
+  assert.equal(rows.map(row => row.slice(4)).join(''), paths.join(''), 'preserve every path character')
+  assert.doesNotMatch(c.text(), /\r/)
+})
+
 test('printToolResult: 超长结果被截断并含省略标记', () => {
   const c = collect()
   const long = Array.from({ length: 60 }, (_, i) => `line${i} ` + 'y'.repeat(40)).join('\n')
@@ -252,15 +313,15 @@ test('formatDuration: 无效输入返回空串', () => {
 })
 
 // ── printToolResult 带耗时 ──
-test('printToolResult: 传入 durationMs 时末尾追加 ⏱ 计时行', () => {
+test('printToolResult: 结果末尾显示状态与耗时', () => {
   const c = collect()
   printToolResult('hello world', c.write, 1500)
   // 去掉末尾空行(split('\n') 在末尾 \n 后产生空串)
   const lines = c.lines().filter(l => l !== '')
   const lastLine = lines[lines.length - 1]
-  assert.ok(lastLine.includes('⏱'), `应包含 ⏱,实际: ${lastLine}`)
+  assert.ok(lastLine.includes('完成'), `应包含状态,实际: ${lastLine}`)
   assert.ok(lastLine.includes('1.5s'), `应包含 1.5s,实际: ${lastLine}`)
-  assert.ok(lastLine.startsWith('  │  '), `计时行应与结果块同缩进,实际: ${lastLine}`)
+  assert.ok(lastLine.startsWith('  └ '), `计时行应与结果块同缩进,实际: ${lastLine}`)
 })
 
 test('printToolResult: 不传 durationMs 时无计时行(向后兼容)', () => {
@@ -272,6 +333,81 @@ test('printToolResult: 不传 durationMs 时无计时行(向后兼容)', () => {
 
 // ── 斜杠命令即时提示 ──
 
+test('compact tools bound physical rows while full output preserves every line', () => {
+  const output = Array.from({ length: 80 }, (_, i) => `row ${i}`).join('\n')
+  const compact = collect(), full = collect()
+  printToolResult(output, compact.write, 10)
+  printToolResult(output, full.write, 10, { full: true })
+  assert.ok(compact.lines().filter(Boolean).length <= 7)
+  assert.ok(compact.text().includes('row 0'))
+  assert.ok(compact.text().includes('row 79'))
+  assert.ok(full.text().includes('row 40'))
+  assert.doesNotMatch(full.text(), /省略/)
+})
+
+test('thinking previews stop after their row budget and still render the answer', () => {
+  const c = collect()
+  const w = createAssistantWriter({ write: c.write, thinkingLimit: 2, width: 30 })
+  w.writeThinking('first\nsecond\nthird\nfourth')
+  w.writeThinking('hidden more')
+  w.writeContent('answer')
+  w.finish()
+  assert.match(c.text(), /first\n/)
+  assert.doesNotMatch(c.text(), /third|fourth|hidden more/)
+  assert.match(c.text(), /answer/)
+})
+
+test('compact thinking uses its row budget for content even across blank chunks', () => {
+  const c = collect()
+  const writer = createAssistantWriter({ write: c.write, thinkingLimit: 2 })
+  for (const chunk of ['\n\n', 'first', '\n\n', '\nsecond\n', 'third']) writer.writeThinking(chunk)
+  writer.finish()
+  assert.match(c.text(), /first\n/)
+  assert.match(c.text(), /second\n/)
+  assert.doesNotMatch(c.text(), /third/)
+  assert.equal((c.text().match(/\/think full/g) || []).length, 1)
+})
+
+test('full thinking preserves paragraph breaks and text after the preview budget', () => {
+  const c = collect()
+  const writer = createAssistantWriter({ write: c.write })
+  const content = Array.from({ length: 20 }, (_, i) => `line ${i}`).join('\n\n')
+  for (const character of content) writer.writeThinking(character)
+  writer.finish()
+  assert.match(c.text(), /line 0\n\n/)
+  assert.match(c.text(), /line 19/)
+  assert.doesNotMatch(c.text(), /\/think full/)
+})
+
+test('terminal wrapping respects wide glyphs and preserves text', () => {
+  const text = '中文🙂中文abcdef'
+  const rows = wrapTerminalText(chalk.cyan(text), 6)
+  assert.equal(stripAnsi(rows.join('')), text)
+  assert.ok(rows.length >= 3)
+})
+
+test('terminal wrapping recognizes CRLF and bare carriage returns as line breaks', () => {
+  const text = chalk.cyan('first\r\n第二行🙂\nthird\rfourth\r\n')
+  assert.deepEqual(wrapTerminalText(text, 20).map(stripAnsi), ['first', '第二行🙂', 'third', 'fourth', ''])
+})
+
+test('turn summaries distinguish missing and partial usage, and show cancellation', () => {
+  const stats = { status: 'cancelled', totalMs: 2000, llmMs: 1800, toolsMs: 100,
+    firstTokenMs: 200, firstAnswerMs: 500, requests: 2, toolCalls: 1, usageRequests: 0, usage: null }
+  let text = stripAnsi(renderTurnSummary(stats, { width: 200 }))
+  assert.match(text, /已停止/)
+  assert.match(text, /首响应 200ms/)
+  assert.match(text, /正文等待 500ms/)
+  assert.match(text, /服务端未返回/)
+  assert.doesNotMatch(text, /Token 0/)
+  stats.usage = { totalTokens: 120, inputTokens: 100, outputTokens: 20, cachedTokens: 80, reasoningTokens: 5 }
+  stats.usageRequests = 1
+  text = stripAnsi(renderTurnSummary(stats, { width: 200 }))
+  assert.match(text, /Token 120/)
+  assert.match(text, /部分用量（1\/2/)
+  assert.match(text, /输入含缓存 80/)
+})
+
 test('filterSlashCommands: 单个 / 返回全部命令', () => {
   const got = filterSlashCommands('/', 'zh').map(m => m.cmd)
   assert.deepEqual(got, SLASH_COMMANDS.map(c => c.cmd))
@@ -285,11 +421,24 @@ test('filterSlashCommands: 前缀过滤,大小写不敏感', () => {
   assert.deepEqual(filterSlashCommands('/exit', 'zh').map(m => m.cmd), ['/exit'])
 })
 
-test('filterSlashCommands: 已输入空格(进入参数)时不再提示', () => {
+test('filterSlashCommands: 自由输入的参数不再提示', () => {
   assert.deepEqual(filterSlashCommands('/model 2', 'zh'), [])
   assert.deepEqual(filterSlashCommands('/cd ..', 'zh'), [])
 })
 
+test('thinking modes are discoverable from slash menu and complete after a space', () => {
+  const modes = ['/think full', '/think compact', '/think off']
+  const all = filterSlashCommands('/', 'zh').map(m => m.cmd)
+  assert.ok(modes.every(mode => all.includes(mode)))
+  assert.deepEqual(filterSlashCommands('/think ', 'zh').map(m => m.cmd), modes)
+  assert.deepEqual(filterSlashCommands('/think f', 'zh').map(m => m.cmd), ['/think full'])
+  assert.deepEqual(filterSlashCommands('/THINK   C', 'en').map(m => m.cmd), ['/think compact'])
+  assert.deepEqual(filterSlashCommands('/think full ', 'zh'), [], 'completed command must be ready to submit')
+  const lines = stripAnsi(renderSlashHintBody(filterSlashCommands('/think ', 'zh'))).split('\n')
+  assert.match(lines[0], /\/think full\s+完整/)
+  assert.match(lines[1], /\/think compact\s+预览前 12 行/)
+})
+
 test('filterSlashCommands: 非 slash 输入 / 无匹配返回空', () => {
   assert.deepEqual(filterSlashCommands('hello', 'zh'), [])
   assert.deepEqual(filterSlashCommands('', 'zh'), [])

package/src/cli/ai/tools.js

@@ -24,7 +24,7 @@
 //   - 工具内部异常一律 catch 成字符串返回,不抛给 agent 循环 ——
 //     让模型看到错误信息自己修正,而不是中断整轮对话
 
-import { exec } from 'node:child_process'
+import { exec, execFile } from 'node:child_process'
 import { promises as fs } from 'node:fs'
 import path from 'node:path'
 import iconv from 'iconv-lite'
@@ -196,20 +196,39 @@ function decodeOutput(buf) {
 
 // 包装 exec 为 Promise,stdout/stderr 合并返回;出错(非零退出)也正常返回输出
 // encoding:'buffer' 拿原始字节,由 decodeOutput 决定真实编码
+export function terminateCommand(child) {
+  if (!child?.pid || child.exitCode !== null) return Promise.resolve()
+  if (process.platform === 'win32') {
+    return new Promise(resolve => execFile('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true }, () => resolve()))
+  }
+  try { process.kill(-child.pid, 'SIGTERM') } catch { try { child.kill('SIGTERM') } catch {} }
+  return Promise.resolve()
+}
+
 function execCommand(command, options) {
   return new Promise((resolve) => {
-    const child = exec(command, { ...options, encoding: 'buffer' }, (err, stdout, stderr) => {
+    const { signal, timeout, onChild, ...execOptions } = options
+    let timedOut = false
+    const abort = () => { void terminateCommand(child) }
+    const child = exec(command, { ...execOptions, detached: process.platform !== 'win32', encoding: 'buffer' }, (err, stdout, stderr) => {
+      clearTimeout(timer)
+      signal?.removeEventListener('abort', abort)
       resolve({
         code: err ? (typeof err.code === 'number' ? err.code : 1) : 0,
-        killed: !!err?.killed,
+        killed: timedOut,
+        cancelled: !!signal?.aborted,
         stdout: decodeOutput(stdout),
         stderr: decodeOutput(stderr),
         errorMessage: err && !('code' in err) ? err.message : null,
       })
     })
+    const timer = setTimeout(() => { timedOut = true; void terminateCommand(child) }, timeout)
+    timer.unref()
+    signal?.addEventListener('abort', abort, { once: true })
+    if (signal?.aborted) abort()
     trackChild(child)
     // 把 child 暴露给 agent 循环,支持用户 Ctrl+C 时立即中止当前命令
-    if (typeof options.onChild === 'function') options.onChild(child)
+    if (typeof onChild === 'function') onChild(child)
   })
 }
 
@@ -253,9 +272,11 @@ async function toolRunCommand(args, ctx) {
     windowsHide: true,
     env: { ...process.env, FORCE_COLOR: '0' },
     onChild: ctx.onChild,
+    signal: ctx.signal,
   })
 
   const parts = []
+  if (result.cancelled) parts.push('[命令已由用户停止]')
   if (result.killed) parts.push(`[命令超时被终止(>${timeoutSec}s)]`)
   if (result.stdout) parts.push(result.stdout.trimEnd())
   if (result.stderr) parts.push(`[stderr]\n${result.stderr.trimEnd()}`)
@@ -333,7 +354,7 @@ async function toolEditFile(args, ctx) {
     return `错误: old_string 在 ${filePath} 中出现 ${count} 次,不唯一。请提供更多上下文让它唯一,或显式传 replace_all=true 全部替换。`
   }
 
-  const updated = args.replace_all ? raw.split(oldStr).join(newStr) : raw.replace(oldStr, newStr)
+  const updated = args.replace_all ? raw.split(oldStr).join(newStr) : raw.replace(oldStr, () => newStr)
   try {
     await fs.writeFile(filePath, updated, 'utf-8')
     return `已修改 ${filePath} (替换 ${args.replace_all ? count : 1} 处)`
@@ -478,6 +499,7 @@ const TOOL_HANDLERS = {
  * @param {{ cwd: string, onChild?: (child: object) => void }} ctx
  */
 export async function executeTool(name, args, ctx) {
+  if (ctx.signal?.aborted) return 'Cancelled by user; this tool was not executed.'
   const handler = TOOL_HANDLERS[name]
   if (!handler) return `错误: 未知工具 "${name}",可用工具: ${Object.keys(TOOL_HANDLERS).join(', ')}`
   try {

package/src/cli/ai/tools.test.js

@@ -35,6 +35,29 @@ after(async () => {
 
 // ========== schema 基本形态 ==========
 
+test('edit_file preserves literal replacement tokens', async () => {
+  await executeTool('write_file', { path: 'literal.txt', content: 'before' }, ctx)
+  const replacement = '$& $$ $` $\x27'
+  await executeTool('edit_file', { path: 'literal.txt', old_string: 'before', new_string: replacement }, ctx)
+  assert.equal(await fs.readFile(path.join(tmpDir, 'literal.txt'), 'utf8'), replacement)
+})
+
+test('run_command cancellation terminates a running command promptly', async () => {
+  const controller = new AbortController()
+  const started = performance.now()
+  const result = await executeTool('run_command', { command: 'node -e "setInterval(()=>{},1000)"' }, {
+    ...ctx, signal: controller.signal, onChild: () => setTimeout(() => controller.abort(), 80),
+  })
+  assert.match(result, /用户停止/)
+  assert.ok(performance.now() - started < 5000)
+})
+
+test('an already cancelled tool does not write files', async () => {
+  const result = await executeTool('write_file', { path: 'cancelled.txt', content: 'no' }, { ...ctx, signal: AbortSignal.abort() })
+  assert.match(result, /not executed/)
+  await assert.rejects(fs.stat(path.join(tmpDir, 'cancelled.txt')), { code: 'ENOENT' })
+})
+
 test('TOOL_DEFINITIONS 符合 OpenAI function calling 格式', () => {
   assert.ok(Array.isArray(TOOL_DEFINITIONS))
   assert.ok(TOOL_DEFINITIONS.length >= 5)

package/src/cli/ai/transport.js

@@ -0,0 +1,89 @@
+import { TOOL_DEFINITIONS } from './tools.js'
+import { buildAiChatRequest, describeAiHttpError } from '../../utils/aiEndpoint.js'
+import { normalizeUsage } from './telemetry.js'
+
+// Some compatible gateways reject stream_options. Remember that for this process.
+const withoutStreamUsage = new Set()
+
+export async function streamChatOnce({ model, messages, signal, onToken = () => {}, sessionId,
+  fetchFn = fetch, timeoutMs = 300000 }) {
+  const { url, headers } = buildAiChatRequest({ ...model, sessionId })
+  const providerKey = `${url}\n${model.model}`
+  const body = { model: model.model, messages, tools: TOOL_DEFINITIONS, temperature: 0.3, stream: true }
+  if (!withoutStreamUsage.has(providerKey)) body.stream_options = { include_usage: true }
+  const controller = new AbortController()
+  let timedOut = false
+  const timer = setTimeout(() => { timedOut = true; controller.abort() }, timeoutMs)
+  const onAbort = () => controller.abort()
+  if (signal?.aborted) controller.abort()
+  else signal?.addEventListener('abort', onAbort)
+  let content = '', reasoning = '', usage = null, finished = false
+  const toolCalls = []
+
+  const consumeLine = line => {
+    const trimmed = line.trim()
+    if (!trimmed.startsWith('data:')) return
+    const payload = trimmed.slice(5).trim()
+    if (payload === '[DONE]') { finished = true; return }
+    if (!payload) return
+    let evt
+    try { evt = JSON.parse(payload) } catch { throw new Error('Invalid JSON in model stream') }
+    if (evt.error) throw new Error(evt.error.message || 'Model stream failed')
+    // Usage may arrive after finish_reason, in a final event with choices: [].
+    // Events report snapshots, so replace fields instead of summing snapshots.
+    const nextUsage = normalizeUsage(evt.usage)
+    if (nextUsage) usage = Object.fromEntries(Object.entries(nextUsage).map(([key, value]) => [key, value ?? usage?.[key] ?? null]))
+    if (evt.choices?.[0]?.finish_reason) finished = true
+    const delta = evt.choices?.[0]?.delta || {}
+    const thinking = delta.reasoning_content || delta.reasoning || delta.reasoning_text || ''
+    if (thinking) { reasoning += thinking; onToken({ thinking }) }
+    if (delta.content) { content += delta.content; onToken({ content: delta.content }) }
+    for (const tc of delta.tool_calls || []) {
+      const i = tc.index ?? 0
+      if (!Number.isInteger(i) || i < 0 || i > 1024) throw new Error('Invalid tool call index')
+      if (!toolCalls[i]) toolCalls[i] = { id: '', type: 'function', function: { name: '', arguments: '' } }
+      if (tc.id) toolCalls[i].id += tc.id
+      if (tc.function?.name) toolCalls[i].function.name += tc.function.name
+      if (tc.function?.arguments) toolCalls[i].function.arguments += tc.function.arguments
+    }
+    if (delta.tool_calls?.length) onToken({ toolCalls: true })
+  }
+  try {
+    const request = () => fetchFn(url, { method: 'POST', headers, body: JSON.stringify(body), signal: controller.signal })
+    let resp = await request()
+    if (!resp.ok) {
+      const detail = describeAiHttpError(await resp.text().catch(() => ''), resp.status)
+      if ([400, 422].includes(resp.status) && body.stream_options && /stream_options|include_usage/i.test(detail)) {
+        delete body.stream_options
+        withoutStreamUsage.add(providerKey)
+        resp = await request()
+      } else throw new Error(`HTTP ${resp.status}: ${detail || resp.statusText}`)
+    }
+    if (!resp.ok || !resp.body) {
+      throw new Error(`HTTP ${resp.status}: ${describeAiHttpError(await resp.text().catch(() => ''), resp.status) || resp.statusText}`)
+    }
+    const decoder = new TextDecoder()
+    let buf = ''
+    for await (const chunk of resp.body) {
+      buf += decoder.decode(chunk, { stream: true })
+      const lines = buf.split('\n')
+      buf = lines.pop() ?? ''
+      for (const line of lines) consumeLine(line)
+    }
+    buf += decoder.decode()
+    if (buf.trim()) consumeLine(buf)
+    if (controller.signal.aborted) throw new DOMException('Aborted', 'AbortError')
+    if (!finished) throw new Error('模型响应意外中断，请重试；未执行不完整的工具调用。')
+    return { content, reasoning, toolCalls: toolCalls.filter(Boolean), usage, aborted: false }
+  } catch (err) {
+    if (controller.signal.aborted && !timedOut) {
+      return { content, reasoning, toolCalls: [], usage, aborted: true }
+    }
+    const error = timedOut ? new Error('模型响应超时，请重试或切换模型。') : err
+    error.usage = usage
+    throw error
+  } finally {
+    clearTimeout(timer)
+    signal?.removeEventListener('abort', onAbort)
+  }
+}

package/src/cli/ai/turn.js

@@ -0,0 +1,126 @@
+import { executeTool } from './tools.js'
+import { streamChatOnce } from './transport.js'
+import { createThinkFilter } from './streamFilter.js'
+import { imageToDataUrl } from './images.js'
+import { buildRequestMessages } from './context.js'
+import { createTurnStats, addUsage, accumulateSessionStats } from './telemetry.js'
+import * as terminal from './termui.js'
+
+export async function runAgentTurn(state, userText, t, images = [], dependencies = {}) {
+  const chat = dependencies.chat || streamChatOnce
+  const execute = dependencies.execute || executeTool
+  const ui = { ...terminal, ...dependencies.ui }
+  const stats = createTurnStats()
+  const started = performance.now()
+  const cancelled = () => state.cancelRequested || state.abortController?.signal.aborted
+  const checkpoint = () => state.persistSession?.()
+  const recordUsage = usage => {
+    if (!usage) return
+    stats.usageRequests++
+    stats.usage = addUsage(stats.usage, usage)
+  }
+  try {
+    let userContent = userText
+    if (images.length) {
+      userContent = [{ type: 'text', text: userText }]
+      for (const img of images) {
+        try { userContent.push({ type: 'image_url', image_url: { url: await imageToDataUrl(img.path) } }) }
+        catch { ui.printWarn(t.imageBadPath(img.path)) }
+      }
+    }
+    state.messages.push({ role: 'user', content: userContent })
+    await checkpoint()
+    const maxIterations = state.maxToolIterations > 0 ? state.maxToolIterations : 200
+    for (let iter = 0; iter < maxIterations; iter++) {
+      if (cancelled()) { stats.status = 'cancelled'; return stats }
+      const spinner = ui.startSpinner(t.waiting)
+      const writer = ui.createAssistantWriter({
+        showThinking: state.showThinking !== false,
+        thinkingHeader: t.thinkingLabel,
+        answerHeader: t.answerLabel,
+        thinkingLimit: state.thinkingMode === 'compact' ? terminal.THINKING_PREVIEW_LINES : Infinity,
+        thinkingHint: t.thinkingHint,
+      })
+      const filter = createThinkFilter()
+      const render = seg => {
+        if (seg.content) {
+          if (seg.content.trim() && stats.firstAnswerMs === null) stats.firstAnswerMs = performance.now() - started
+          writer.writeContent(seg.content)
+        } else if (seg.thinking) writer.writeThinking(seg.thinking)
+      }
+      let result
+      const llmStart = performance.now()
+      stats.requests++
+      try {
+        const messages = buildRequestMessages(state.messages)
+        state.prepareMessages?.(messages)
+        result = await chat({ model: state.model, messages, signal: state.abortController?.signal,
+          sessionId: state.sessionId, onToken: token => {
+            if (stats.firstTokenMs === null) stats.firstTokenMs = performance.now() - started
+            if (token.content || (token.thinking && state.showThinking !== false)) spinner.stop()
+            if (token.thinking) render({ thinking: token.thinking })
+            if (token.content) filter.feed(token.content).forEach(render)
+          } })
+        recordUsage(result.usage)
+      } catch (err) {
+        recordUsage(err.usage)
+        throw err
+      } finally {
+        stats.llmMs += performance.now() - llmStart
+        spinner.stop()
+        filter.flush().forEach(render)
+        writer.finish()
+      }
+      if (result.aborted || cancelled()) {
+        if (result.content) state.messages.push({ role: 'assistant', content: result.content })
+        stats.status = 'cancelled'; return stats
+      }
+      const { content, toolCalls } = result
+      const assistant = { role: 'assistant', content: content || null }
+      if (result.reasoning) assistant.reasoning_content = result.reasoning
+      if (!toolCalls.length) {
+        if (!content?.trim()) throw new Error(t.emptyResponse)
+        state.messages.push(assistant)
+        stats.status = 'completed'; return stats
+      }
+      // Assign fallback IDs once, so every result references its assistant call.
+      toolCalls.forEach((call, i) => { if (!call.id) call.id = `call_${iter}_${i}` })
+      state.messages.push({ ...assistant, tool_calls: toolCalls })
+      await checkpoint()
+      for (const tc of toolCalls) {
+        const name = tc.function?.name || ''
+        let output
+        if (cancelled()) output = 'Cancelled by user; this tool was not executed.'
+        else {
+          let args
+          try { args = JSON.parse(tc.function?.arguments || '{}') }
+          catch { output = '错误: 工具参数不是合法 JSON，请修正后重试。' }
+          if (output === undefined) {
+            ui.printToolHeader(name, ui.summarizeToolArgs(name, args, { chars: t.chars }), undefined, { locale: state.locale })
+            const toolSpinner = ui.startSpinner(t.toolRunning(name))
+            const toolStart = performance.now()
+            stats.toolCalls++
+            try { output = await execute(name, args, { ...state.ctx, signal: state.abortController?.signal }) }
+            finally { toolSpinner.stop(); stats.toolsMs += performance.now() - toolStart }
+            ui.printToolResult(output, undefined, performance.now() - toolStart, { full: state.fullTools, locale: state.locale })
+          } else ui.printToolResult(output)
+        }
+        state.messages.push({ role: 'tool', tool_call_id: tc.id, name, content: output })
+        await checkpoint()
+      }
+    }
+    stats.status = cancelled() ? 'cancelled' : 'limit'
+    if (!cancelled()) ui.printWarn(t.toolIterLimit(maxIterations))
+  } catch (err) {
+    stats.status = cancelled() ? 'cancelled' : 'failed'
+    if (!cancelled()) ui.printError(t.llmError(err.message))
+  } finally {
+    stats.totalMs = performance.now() - started
+    stats.completedAt = new Date().toISOString()
+    state.lastTurnStats = stats
+    state.sessionStats = accumulateSessionStats(state.sessionStats, stats)
+    await checkpoint()
+    ui.printTurnSummary(stats, { locale: state.locale })
+  }
+  return stats
+}