jinzd-ai-cli 0.1.53 → 0.1.55

package/CLAUDE.md

@@ -350,6 +350,68 @@ const stdinLines = Array.isArray(rawStdin) ? rawStdin.map(String)
 - [x] **web_fetch DNS 解析时 SSRF 防护**（v0.1.25）：新增 `resolveAndCheck()` 函数，用 `dns.promises.lookup()` 预解析域名，检查结果 IP 是否为私有地址。初始 URL 和 redirect 目标均校验。
 - [ ] **`persistentCwd` 全局状态**：bash 工具的当前工作目录是模块级全局变量，多 session 并发时可能串扰。现阶段单 session REPL 无影响，GUI 多会话扩展时需重构为 per-session 状态。
 
+## 本轮开发完成记录（2026-03-09，v0.1.53 → v0.1.54）
+
+### 新增功能：Streaming Tool Use — agentic 循环流式工具调用
+
+**背景**：`handleChatWithTools()` agentic 循环中，每轮调用 `provider.chatWithTools()` 使用 `stream: false`，必须等待 API 返回完整响应后才开始处理。AI 生成工具调用参数期间（5-30 秒），用户只看到 spinner，无任何内容反馈。
+
+**设计决策**：
+1. 新增 `chatWithToolsStream()` 方法，不修改现有 `chatWithTools()`
+2. 统一事件模型 `AsyncGenerator<ToolStreamEvent>`（8 种事件类型）
+3. 等待全部工具调用完成后再执行（不做 early execution）
+4. Phase 1 覆盖：OpenAI + Zhipu（继承基类）+ Claude；DeepSeek/Kimi 继续用非流式（虚假声明检测需完整响应）
+
+**变更文件**：
+
+| 文件 | 变更类型 | 说明 |
+|------|---------|------|
+| `src/core/types.ts` | 修改 | 新增 `ToolStreamEvent` 联合类型（8 变体）+ `StreamedToolCallResult` 接口 |
+| `src/providers/base.ts` | 修改 | 新增可选方法 `chatWithToolsStream?()` + 导入 `ToolStreamEvent`/`ToolDefinition` |
+| `src/providers/openai-compatible.ts` | 修改 | 新增 `enableStreamingToolCalls` 标志 + `chatWithToolsStream()` 完整实现（~140 行） |
+| `src/providers/claude.ts` | 修改 | 新增 `chatWithToolsStream()` 实现（~120 行），收集 `rawContentBlocks` 用于 `buildToolResultMessages` |
+| `src/providers/deepseek.ts` | 修改 | `enableStreamingToolCalls = false`（虚假声明检测需完整响应） |
+| `src/providers/kimi.ts` | 修改 | `enableStreamingToolCalls = false`（XML 伪调用 + 虚假声明检测需完整响应） |
+| `src/repl/repl.ts` | 修改 | 新增 `consumeToolStream()` 方法 + `handleChatWithTools()` 流式/非流式双路径 |
+| `src/repl/renderer.ts` | 修改 | `/about` 新增特性条目 |
+| `src/core/constants.ts` | 修改 | VERSION 0.1.53 → 0.1.54 |
+| `package.json` | 修改 | version 0.1.53 → 0.1.54 |
+
+**实现细节**：
+
+*类型层*（`types.ts`）：
+- `ToolStreamEvent`：`text_delta` / `thinking_start` / `thinking_delta` / `thinking_end` / `tool_call_start` / `tool_call_delta` / `tool_call_end` / `done`
+- `StreamedToolCallResult`：`textContent` + `toolCalls` + `usage` + `rawContent`（Claude 专用）
+
+*OpenAI 兼容 Provider*（`openai-compatible.ts`）：
+- `enableStreamingToolCalls = true` 保护标志，子类可 override 为 false 禁用
+- 流式路径：`stream: true` + `stream_options: { include_usage: true }`
+- `delta.tool_calls[i]` 首次出现（含 `id`+`name`）发 `tool_call_start`，后续发 `tool_call_delta`
+- 非流式降级路径：`enableStreamingToolCalls = false` 时调用 `chatWithTools()` 并转换为事件序列
+
+*Claude Provider*（`claude.ts`）：
+- 使用 `this.client.messages.stream()` + AbortSignal 支持
+- 收集 `rawContentBlocks` 数组，通过 `done` 事件的 `rawContent` 传递给 `buildToolResultMessages`
+- 事件映射：`content_block_start`(tool_use) → `tool_call_start`；`input_json_delta` → `tool_call_delta`；`content_block_stop` → `tool_call_end`
+- thinking 块正确处理（`thinking_start`/`thinking_delta`/`thinking_end`）
+
+*REPL 层*（`repl.ts`）：
+- `consumeToolStream()`：消费事件生成器，`text_delta` 实时输出到 stdout（停 spinner），`tool_call_start` 显示 `⚙ Streaming: <name>...`，累积 arguments JSON 碎片，`tool_call_end` 时 JSON.parse
+- `handleChatWithTools()` 循环：检测 `supportsStreamingTools`（`useStreaming && typeof provider.chatWithToolsStream === 'function'`），流式路径用 `setupStreamInterrupt()`/`teardownStreamInterrupt()` 包裹支持 Escape/Ctrl+C 中断
+- `alreadyRendered` 标志防止文本内容双重渲染
+
+**用户体验对比**：
+- Before：Spinner 等待 10-30 秒 → 突然全部出现
+- After：短暂 Spinner → 文本实时流出 → 工具名即时显示 → 参数完整后执行
+
+### 版本与收尾
+- `src/core/constants.ts`：VERSION `0.1.53` → `0.1.54`
+- `package.json`：version 同步
+- 构建验证：`npm run build` 零错误（ESM + CJS 双产物）
+- 发布：`npm publish` → `jinzd-ai-cli@0.1.54`
+
+---
+
 ## 本轮开发完成记录（2026-03-08，v0.1.51 → v0.1.52）
 
 ### Bug 修复：DeepSeek 虚假完成声明（方案 C）+ 虚假声明检测共享重构
@@ -606,9 +668,9 @@ const stdinLines = Array.isArray(rawStdin) ? rawStdin.map(String)
 | `package.json` | 修改 | version 0.1.38 → 0.1.40 |
 
 ### 下一步建议
-1. **`/config set` 快捷配置**：REPL 内直接 `/config set ui.theme light` 无需进入向导
-2. **流式工具调用（Streaming Tool Use）**：流式解析 tool_use 事件，更早启动工具执行
-3. **`/diff` 命令**：显示当前 session 内所有文件修改的汇总 diff
+1. ~~**`/config set` 快捷配置**~~：✅ 已实现（v0.1.49）
+2. ~~**流式工具调用（Streaming Tool Use）**~~：✅ 已在 v0.1.54 实现（OpenAI/Claude 流式 + DeepSeek/Kimi 非流式降级）
+3. ~~**`/diff` 命令**~~：✅ 已实现（v0.1.49）
 
 ---
 
@@ -704,10 +766,10 @@ const stdinLines = Array.isArray(rawStdin) ? rawStdin.map(String)
 
 ### 下一步建议
 
-#### Tier 1 — 高价值功能
-1. **`/config set` 快捷配置**：REPL 内直接 `/config set ui.theme light` 无需进入向导，key-path 语法读写 config.json
-2. **流式工具调用（Streaming Tool Use）**：Claude/OpenAI 均支持流式返回 tool_use 事件，当前等待完整 response 才开始执行，改为流式解析可更早启动工具执行
-3. **`/diff` 命令**：显示当前 session 内所有文件修改的汇总 diff，便于 AI 操作后快速审查变更
+#### Tier 1 — 高价值功能（已全部完成）
+1. ~~**`/config set` 快捷配置**~~：✅ 已实现（v0.1.49）
+2. ~~**流式工具调用（Streaming Tool Use）**~~：✅ 已在 v0.1.54 实现（OpenAI/Claude 流式 + DeepSeek/Kimi 非流式降级）
+3. ~~**`/diff` 命令**~~：✅ 已实现（v0.1.49）
 
 #### Tier 2 — 体验增强
 4. ~~**L1 低危**~~：✅ 已在 v0.1.50 修复（safeReadPackageJson + detectNodeTestFramework）

package/dist/{chunk-E23DQUHQ.js → chunk-OBC56PVG.js}

@@ -8,7 +8,7 @@ import { platform } from "os";
 import chalk from "chalk";
 
 // src/core/constants.ts
-var VERSION = "0.1.53";
+var VERSION = "0.1.55";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";
@@ -73,6 +73,12 @@ var SUBAGENT_ALLOWED_TOOLS = /* @__PURE__ */ new Set([
 ]);
 var CONTEXT_PRESSURE_THRESHOLD = 0.8;
 var TEST_TIMEOUT = 3e5;
+var AGENTIC_BEHAVIOR_GUIDELINE = `# \u91CD\u8981\u884C\u4E3A\u51C6\u5219
+
+**\u533A\u5206"\u7406\u89E3"\u4E0E"\u6267\u884C"**\uFF1A
+- \u5F53\u7528\u6237\u8981\u6C42\u4F60"\u9605\u8BFB"\u3001"\u7406\u89E3"\u3001"\u4E86\u89E3"\u3001"\u5206\u6790"\u3001"\u5BA1\u67E5"\u3001"\u770B\u4E00\u4E0B"\u6587\u4EF6\u6216\u9879\u76EE\u65F6\uFF0C\u4F60\u7684\u4EFB\u52A1\u4EC5\u662F**\u8BFB\u53D6\u5E76\u603B\u7ED3**\uFF0C\u7136\u540E\u7B49\u5F85\u7528\u6237\u7684\u4E0B\u4E00\u6B65\u6307\u793A\u3002\u4E0D\u8981\u81EA\u52A8\u5F00\u59CB\u6267\u884C\u9879\u76EE\u4E2D\u63CF\u8FF0\u7684\u4EFB\u52A1\u3002
+- \u53EA\u6709\u5F53\u7528\u6237**\u660E\u786E\u8981\u6C42**\u4F60\u6267\u884C\u67D0\u4E2A\u64CD\u4F5C\uFF08\u5982"\u751F\u6210"\u3001"\u521B\u5EFA"\u3001"\u4FEE\u6539"\u3001"\u8FD0\u884C"\u3001"\u5F00\u59CB"\u7B49\u52A8\u4F5C\u8BCD\uFF09\u65F6\uFF0C\u624D\u5F00\u59CB\u4F7F\u7528\u5199\u5165/\u6267\u884C\u7C7B\u5DE5\u5177\u3002
+- \u5982\u679C\u4E0D\u786E\u5B9A\u7528\u6237\u610F\u56FE\uFF0C\u4F7F\u7528 ask_user \u5DE5\u5177\u5411\u7528\u6237\u786E\u8BA4\uFF0C\u800C\u4E0D\u662F\u81EA\u884C\u5047\u8BBE\u5E76\u6267\u884C\u3002`;
 var AUTHOR = "\u664B\u6B63\u4E1C";
 var AUTHOR_EMAIL = "zhengdong.jin@gmail.com";
 var DESCRIPTION = "\u8DE8\u5E73\u53F0 REPL \u98CE\u683C AI \u5BF9\u8BDD\u5DE5\u5177\uFF0C\u652F\u6301\u591A Provider \u4E0E Agentic \u5DE5\u5177\u8C03\u7528";
@@ -457,6 +463,7 @@ export {
   SUBAGENT_MAX_ROUNDS_LIMIT,
   SUBAGENT_ALLOWED_TOOLS,
   CONTEXT_PRESSURE_THRESHOLD,
+  AGENTIC_BEHAVIOR_GUIDELINE,
   AUTHOR,
   AUTHOR_EMAIL,
   DESCRIPTION,

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  AGENTIC_BEHAVIOR_GUIDELINE,
   APP_NAME,
   AUTHOR,
   AUTHOR_EMAIL,
@@ -29,7 +30,7 @@ import {
   SUBAGENT_MAX_ROUNDS_LIMIT,
   VERSION,
   runTestsTool
-} from "./chunk-E23DQUHQ.js";
+} from "./chunk-OBC56PVG.js";
 
 // src/index.ts
 import { program } from "commander";
@@ -632,6 +633,111 @@ var ClaudeProvider = class extends BaseProvider {
       throw this.wrapError(err);
     }
   }
+  /**
+   * 流式工具调用：文本/thinking 实时输出、工具名称/参数逐块发射。
+   * 同时收集原始 content blocks 供 buildToolResultMessages 使用。
+   */
+  async *chatWithToolsStream(request, tools) {
+    const anthropicTools = tools.map((t) => ({
+      name: t.name,
+      description: t.description,
+      input_schema: {
+        type: "object",
+        properties: Object.fromEntries(
+          Object.entries(t.parameters).map(([key, schema]) => [
+            key,
+            schemaToJsonSchema(schema)
+          ])
+        ),
+        required: Object.entries(t.parameters).filter(([, s]) => s.required).map(([k]) => k)
+      }
+    }));
+    const baseMessages = request.messages.filter((m) => m.role !== "system").map((m) => ({ role: m.role, content: this.contentToClaudeParts(m.content) }));
+    const extraMessages = request._extraMessages ?? [];
+    const allMessages = [...baseMessages, ...extraMessages];
+    const { thinking, temperature } = this.buildThinkingParams(request);
+    try {
+      const stream = this.client.messages.stream({
+        model: request.model,
+        messages: allMessages,
+        tools: anthropicTools,
+        system: request.systemPrompt,
+        max_tokens: request.maxTokens ?? 8192,
+        temperature,
+        thinking
+      }, { signal: request.signal });
+      let currentBlockType = null;
+      let currentToolIndex = 0;
+      const rawContentBlocks = [];
+      let currentBlockData = {};
+      for await (const event of stream) {
+        if (event.type === "content_block_start") {
+          const block = event.content_block;
+          currentBlockType = block.type;
+          currentBlockData = { type: block.type };
+          if (block.type === "thinking") {
+            yield { type: "thinking_start" };
+            currentBlockData = { type: "thinking", thinking: "", signature: "" };
+          } else if (block.type === "text") {
+            currentBlockData = { type: "text", text: "" };
+          } else if (block.type === "tool_use") {
+            const tuBlock = block;
+            yield {
+              type: "tool_call_start",
+              index: currentToolIndex,
+              id: tuBlock.id,
+              name: tuBlock.name
+            };
+            currentBlockData = { type: "tool_use", id: tuBlock.id, name: tuBlock.name, input: {} };
+          } else if (block.type === "redacted_thinking") {
+            currentBlockData = { type: "redacted_thinking", data: block.data };
+          }
+        } else if (event.type === "content_block_delta") {
+          if (event.delta.type === "text_delta") {
+            yield { type: "text_delta", delta: event.delta.text };
+            currentBlockData.text += event.delta.text;
+          } else if (event.delta.type === "thinking_delta") {
+            const thinkingDelta = event.delta.thinking;
+            yield { type: "thinking_delta", delta: thinkingDelta };
+            currentBlockData.thinking += thinkingDelta;
+          } else if (event.delta.type === "input_json_delta") {
+            const jsonDelta = event.delta.partial_json;
+            yield {
+              type: "tool_call_delta",
+              index: currentToolIndex,
+              argumentsDelta: jsonDelta
+            };
+          } else if (event.delta.type === "signature_delta") {
+            currentBlockData.signature += event.delta.signature ?? "";
+          }
+        } else if (event.type === "content_block_stop") {
+          if (currentBlockType === "thinking") {
+            yield { type: "thinking_end" };
+          } else if (currentBlockType === "tool_use") {
+            yield { type: "tool_call_end", index: currentToolIndex };
+            currentToolIndex++;
+          }
+          rawContentBlocks.push(currentBlockData);
+          currentBlockType = null;
+          currentBlockData = {};
+        } else if (event.type === "message_delta") {
+          const usage = event.usage;
+          if (usage) {
+            yield {
+              type: "done",
+              usage: {
+                inputTokens: usage.input_tokens ?? 0,
+                outputTokens: usage.output_tokens ?? 0
+              },
+              rawContent: rawContentBlocks
+            };
+          }
+        }
+      }
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
   buildToolResultMessages(assistantToolCalls, results) {
     const rawContent = assistantToolCalls._rawContent;
     let assistantContent;
@@ -989,6 +1095,8 @@ var OpenAICompatibleProvider = class extends BaseProvider {
   client;
   defaultTimeout = 6e4;
   // ms
+  /** 子类设为 false 可禁用流式工具调用（虚假声明检测需要完整响应） */
+  enableStreamingToolCalls = true;
   async initialize(apiKey, options) {
     if (options?.timeout !== void 0) {
       this.defaultTimeout = options.timeout;
@@ -1159,6 +1267,122 @@ var OpenAICompatibleProvider = class extends BaseProvider {
       throw this.wrapError(err);
     }
   }
+  /**
+   * 流式工具调用：文本内容实时输出、工具名称/参数逐块发射。
+   * 子类（DeepSeek / Kimi）因虚假声明检测需要完整响应，故不继承此方法。
+   */
+  async *chatWithToolsStream(request, tools) {
+    if (!this.enableStreamingToolCalls) {
+      const result = await this.chatWithTools(request, tools);
+      if ("toolCalls" in result) {
+        for (let i = 0; i < result.toolCalls.length; i++) {
+          const tc = result.toolCalls[i];
+          yield { type: "tool_call_start", index: i, id: tc.id, name: tc.name };
+          yield { type: "tool_call_delta", index: i, argumentsDelta: JSON.stringify(tc.arguments) };
+          yield { type: "tool_call_end", index: i };
+        }
+      } else {
+        yield { type: "text_delta", delta: result.content };
+      }
+      yield { type: "done", usage: result.usage };
+      return;
+    }
+    const openaiTools = tools.map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: {
+          type: "object",
+          properties: Object.fromEntries(
+            Object.entries(t.parameters).map(([key, schema]) => [
+              key,
+              schemaToJsonSchema(schema)
+            ])
+          ),
+          required: Object.entries(t.parameters).filter(([, s]) => s.required).map(([k]) => k)
+        }
+      }
+    }));
+    const baseMessages = this.buildMessages(request);
+    const extraMessages = request._extraMessages ?? [];
+    const allMessages = [...baseMessages, ...extraMessages];
+    try {
+      const stream = await this.client.chat.completions.create({
+        model: request.model,
+        messages: allMessages,
+        tools: openaiTools,
+        tool_choice: "auto",
+        temperature: request.temperature,
+        max_tokens: request.maxTokens,
+        stream: true,
+        stream_options: { include_usage: true },
+        ...request.thinking ? { thinking: { type: "enabled" } } : {}
+      }, {
+        timeout: request.timeout ?? this.defaultTimeout,
+        signal: request.signal
+      });
+      const toolCallAccumulators = /* @__PURE__ */ new Map();
+      let toolCallsEnded = false;
+      for await (const chunk of stream) {
+        const choice = chunk.choices[0];
+        if (!choice && chunk.usage) {
+          if (!toolCallsEnded && toolCallAccumulators.size > 0) {
+            for (const [idx] of toolCallAccumulators) {
+              yield { type: "tool_call_end", index: idx };
+            }
+            toolCallsEnded = true;
+          }
+          yield {
+            type: "done",
+            usage: {
+              inputTokens: chunk.usage.prompt_tokens,
+              outputTokens: chunk.usage.completion_tokens
+            }
+          };
+          continue;
+        }
+        if (!choice) continue;
+        const delta = choice.delta;
+        if (delta?.content) {
+          yield { type: "text_delta", delta: delta.content };
+        }
+        if (delta?.tool_calls) {
+          for (const tc of delta.tool_calls) {
+            const idx = tc.index;
+            if (tc.id && tc.function?.name) {
+              toolCallAccumulators.set(idx, {
+                id: tc.id,
+                name: tc.function.name,
+                arguments: tc.function.arguments ?? ""
+              });
+              yield { type: "tool_call_start", index: idx, id: tc.id, name: tc.function.name };
+            } else if (tc.function?.arguments) {
+              const acc = toolCallAccumulators.get(idx);
+              if (acc) {
+                acc.arguments += tc.function.arguments;
+                yield { type: "tool_call_delta", index: idx, argumentsDelta: tc.function.arguments };
+              }
+            }
+          }
+        }
+        if (choice.finish_reason && !toolCallsEnded && toolCallAccumulators.size > 0) {
+          for (const [idx] of toolCallAccumulators) {
+            yield { type: "tool_call_end", index: idx };
+          }
+          toolCallsEnded = true;
+        }
+      }
+      if (!toolCallsEnded && toolCallAccumulators.size > 0) {
+        for (const [idx] of toolCallAccumulators) {
+          yield { type: "tool_call_end", index: idx };
+        }
+      }
+      yield { type: "done" };
+    } catch (err) {
+      throw this.wrapError(err);
+    }
+  }
   /**
    * 将工具结果作为 tool_call 消息追加，供下一轮使用
    */
@@ -1257,6 +1481,8 @@ var DEEPSEEK_TOOL_CALL_REMINDER = `
 \u5982\u679C\u9700\u8981\u751F\u6210\u591A\u4E2A\u6587\u4EF6\uFF0C\u5FC5\u987B\u5BF9\u6BCF\u4E2A\u6587\u4EF6\u5206\u522B\u8C03\u7528 write_file \u5DE5\u5177\uFF0C\u4E0D\u53EF\u7701\u7565\u4EFB\u4F55\u4E00\u4E2A\u3002`;
 var DeepSeekProvider = class extends OpenAICompatibleProvider {
   defaultBaseUrl = "https://api.deepseek.com/v1";
+  // 禁用流式工具调用：DeepSeek 的虚假声明检测（方案 C）需要完整响应
+  enableStreamingToolCalls = false;
   info = {
     id: "deepseek",
     displayName: "DeepSeek",
@@ -1415,6 +1641,8 @@ var KIMI_TOOL_CALL_REMINDER = `
 \u4EC5\u5728\u6587\u672C\u4E2D\u63CF\u8FF0\u6587\u4EF6\u5185\u5BB9\u800C\u4E0D\u8C03\u7528\u5DE5\u5177 = \u6587\u4EF6\u4E0D\u5B58\u5728 = \u4EFB\u52A1\u5931\u8D25\u3002`;
 var KimiProvider = class extends OpenAICompatibleProvider {
   defaultBaseUrl = "https://api.moonshot.ai/v1";
+  // 禁用流式工具调用：Kimi 的 XML 伪调用检测（方案 A）和虚假声明检测（方案 C）需要完整响应
+  enableStreamingToolCalls = false;
   info = {
     id: "kimi",
     displayName: "Kimi (Moonshot AI)",
@@ -2402,6 +2630,7 @@ var Renderer = class {
     console.log(feat("\u5DE5\u5177\u8C03\u7528\u6700\u7EC8\u56DE\u7B54\u6D41\u5F0F\u5316\uFF1A\u6A21\u62DF\u6253\u5B57\u673A\u6548\u679C\u9010\u5757\u8F93\u51FA\uFF0C\u96F6\u989D\u5916 API \u8C03\u7528\uFF0C\u652F\u6301 Escape \u4E2D\u65AD"));
     console.log(feat("/diff \u547D\u4EE4\uFF1A\u663E\u793A\u5F53\u524D session \u5185\u6240\u6709\u6587\u4EF6\u4FEE\u6539\u7684\u6C47\u603B diff\uFF08\u5408\u5E76\u540C\u6587\u4EF6\u591A\u6B21\u4FEE\u6539\uFF09"));
     console.log(feat("/fork \u5BF9\u8BDD\u5206\u652F\uFF1A\u4ECE\u5F53\u524D\u4F4D\u7F6E\u6216\u6307\u5B9A checkpoint \u5206\u53C9\u4E3A\u65B0 session\uFF0C\u63A2\u7D22\u4E0D\u540C\u65B9\u6848"));
+    console.log(feat("Streaming Tool Use\uFF1Aagentic \u5FAA\u73AF\u4E2D\u6587\u672C\u5B9E\u65F6\u6D41\u51FA + \u5DE5\u5177\u540D\u79F0\u5373\u65F6\u663E\u793A\uFF08OpenAI/Claude\uFF09"));
     console.log();
   }
   printPrompt(provider, _model) {
@@ -4363,7 +4592,7 @@ ${hint}` : "")
       description: "Run project tests and show structured report",
       usage: "/test [command|filter]",
       async execute(args, _ctx) {
-        const { executeTests } = await import("./run-tests-VV7FXC5Z.js");
+        const { executeTests } = await import("./run-tests-JS64U54Q.js");
         const argStr = args.join(" ").trim();
         let testArgs = {};
         if (argStr) {
@@ -9169,7 +9398,7 @@ ${projectContext}`);
     const envInfo = `\u64CD\u4F5C\u7CFB\u7EDF\uFF1A${osName}
 ${shellInfo}
 \u5DE5\u4F5C\u76EE\u5F55\uFF1A${process.cwd()}`;
-    const parts = [dateTimeInfo + "\n" + envInfo];
+    const parts = [dateTimeInfo + "\n" + envInfo, AGENTIC_BEHAVIOR_GUIDELINE];
     const memory = this.loadMemoryContent();
     if (memory) {
       parts.push(`# Persistent Memory
@@ -9990,6 +10219,107 @@ Session '${this.resumeSessionId}' not found.
     }
     await this.checkContextPressure();
   }
+  /**
+   * 消费流式工具调用事件生成器，实时渲染文本内容和工具名称，
+   * 累积完整工具调用参数后返回结构化结果。
+   */
+  async consumeToolStream(stream, spinner) {
+    const textParts = [];
+    const toolCallAccumulators = /* @__PURE__ */ new Map();
+    let usage;
+    let rawContent;
+    let spinnerStopped = false;
+    const stopSpinner = () => {
+      if (!spinnerStopped) {
+        spinner.stop();
+        spinnerStopped = true;
+      }
+    };
+    try {
+      for await (const event of stream) {
+        switch (event.type) {
+          case "text_delta":
+            stopSpinner();
+            process.stdout.write(event.delta);
+            textParts.push(event.delta);
+            break;
+          case "thinking_start":
+            stopSpinner();
+            process.stdout.write(theme.dim("<think>"));
+            break;
+          case "thinking_delta":
+            break;
+          case "thinking_end":
+            process.stdout.write(theme.dim("</think>"));
+            break;
+          case "tool_call_start":
+            stopSpinner();
+            process.stdout.write(
+              theme.dim(`
+\u2699 Streaming: `) + theme.toolCall(event.name) + theme.dim("...\n")
+            );
+            toolCallAccumulators.set(event.index, {
+              id: event.id,
+              name: event.name,
+              arguments: ""
+            });
+            break;
+          case "tool_call_delta": {
+            const acc = toolCallAccumulators.get(event.index);
+            if (acc) {
+              acc.arguments += event.argumentsDelta;
+            }
+            break;
+          }
+          case "tool_call_end":
+            break;
+          case "done":
+            if (event.usage) usage = event.usage;
+            if (event.rawContent) rawContent = event.rawContent;
+            break;
+        }
+      }
+    } catch (err) {
+      if (err instanceof Error && (err.name === "AbortError" || err.message.includes("aborted"))) {
+        stopSpinner();
+        process.stdout.write(theme.dim("\n[interrupted]\n"));
+        return {
+          textContent: textParts.join(""),
+          toolCalls: [],
+          usage,
+          rawContent
+        };
+      }
+      throw err;
+    }
+    const toolCalls = [];
+    for (const [, acc] of toolCallAccumulators) {
+      let parsedArgs;
+      try {
+        parsedArgs = JSON.parse(acc.arguments || "{}");
+      } catch {
+        const truncated = acc.arguments.trimEnd();
+        const lastComma = truncated.lastIndexOf(",");
+        const fixed = lastComma > 0 ? truncated.slice(0, lastComma) + "}" : truncated.slice(0, truncated.indexOf("{") + 1) + "}";
+        try {
+          parsedArgs = JSON.parse(fixed);
+        } catch {
+          parsedArgs = {};
+        }
+      }
+      toolCalls.push({
+        id: acc.id,
+        name: acc.name,
+        arguments: parsedArgs
+      });
+    }
+    return {
+      textContent: textParts.join(""),
+      toolCalls,
+      usage,
+      rawContent
+    };
+  }
   async handleChatWithTools(provider, messages) {
     const session = this.sessions.current;
     let toolDefs;
@@ -10016,24 +10346,48 @@ Session '${this.resumeSessionId}' not found.
     const useStreaming = this.config.get("ui").streaming;
     const spinner = this.renderer.showSpinner("Thinking...");
     const roundUsage = { inputTokens: 0, outputTokens: 0 };
+    const supportsStreamingTools = useStreaming && typeof provider.chatWithToolsStream === "function";
     try {
       for (let round = 0; round < MAX_TOOL_ROUNDS; round++) {
         this.toolExecutor.setRoundInfo(round + 1, MAX_TOOL_ROUNDS);
-        const result = await provider.chatWithTools(
-          {
-            messages: apiMessages,
-            model: this.currentModel,
-            systemPrompt,
-            stream: false,
-            temperature: modelParams.temperature,
-            maxTokens: modelParams.maxTokens,
-            timeout: modelParams.timeout,
-            thinking: modelParams.thinking,
-            thinkingBudget: modelParams.thinkingBudget,
-            ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
-          },
-          toolDefs
-        );
+        let result;
+        let alreadyRendered = false;
+        const chatRequest = {
+          messages: apiMessages,
+          model: this.currentModel,
+          systemPrompt,
+          stream: false,
+          temperature: modelParams.temperature,
+          maxTokens: modelParams.maxTokens,
+          timeout: modelParams.timeout,
+          thinking: modelParams.thinking,
+          thinkingBudget: modelParams.thinkingBudget,
+          ...extraMessages.length > 0 ? { _extraMessages: extraMessages } : {}
+        };
+        if (supportsStreamingTools) {
+          const streamAc = this.setupStreamInterrupt();
+          try {
+            const streamGen = provider.chatWithToolsStream(
+              { ...chatRequest, signal: streamAc.signal },
+              toolDefs
+            );
+            const streamResult = await this.consumeToolStream(streamGen, spinner);
+            if (streamResult.toolCalls.length > 0) {
+              const toolCalls = streamResult.toolCalls;
+              if (streamResult.rawContent) {
+                toolCalls._rawContent = streamResult.rawContent;
+              }
+              result = { toolCalls, usage: streamResult.usage };
+            } else {
+              result = { content: streamResult.textContent, usage: streamResult.usage };
+              alreadyRendered = true;
+            }
+          } finally {
+            this.teardownStreamInterrupt();
+          }
+        } else {
+          result = await provider.chatWithTools(chatRequest, toolDefs);
+        }
         if (result.usage) {
           roundUsage.inputTokens += result.usage.inputTokens;
           roundUsage.outputTokens += result.usage.outputTokens;
@@ -10041,15 +10395,21 @@ Session '${this.resumeSessionId}' not found.
         if ("content" in result) {
           spinner.stop();
           const finalContent = result.content;
-          if (useStreaming) {
-            const streamAc = this.setupStreamInterrupt();
-            try {
-              await this.renderer.renderContentAsStream(finalContent, { signal: streamAc.signal });
-            } finally {
-              this.teardownStreamInterrupt();
+          if (!alreadyRendered) {
+            if (useStreaming) {
+              const streamAc = this.setupStreamInterrupt();
+              try {
+                await this.renderer.renderContentAsStream(finalContent, { signal: streamAc.signal });
+              } finally {
+                this.teardownStreamInterrupt();
+              }
+            } else {
+              this.renderer.renderResponse(finalContent);
             }
           } else {
-            this.renderer.renderResponse(finalContent);
+            if (finalContent.trim()) {
+              process.stdout.write("\n\n");
+            }
           }
           lastResponseStore.content = finalContent;
           session.addMessage({

package/dist/{run-tests-VV7FXC5Z.js → run-tests-JS64U54Q.js}

@@ -2,7 +2,7 @@
 import {
   executeTests,
   runTestsTool
-} from "./chunk-E23DQUHQ.js";
+} from "./chunk-OBC56PVG.js";
 export {
   executeTests,
   runTestsTool

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jinzd-ai-cli",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "description": "Cross-platform REPL-style AI CLI with multi-provider support",
   "type": "module",
   "main": "./dist/index.js",