jinzd-ai-cli 0.1.52 → 0.1.54

package/dist/{chunk-KRYABIB4.js → chunk-AF33GPHX.js}

@@ -8,7 +8,7 @@ import { platform } from "os";
 import chalk from "chalk";
 
 // src/core/constants.ts
-var VERSION = "0.1.52";
+var VERSION = "0.1.54";
 var APP_NAME = "ai-cli";
 var CONFIG_DIR_NAME = ".aicli";
 var CONFIG_FILE_NAME = "config.json";

package/dist/index.js

@@ -29,7 +29,7 @@ import {
   SUBAGENT_MAX_ROUNDS_LIMIT,
   VERSION,
   runTestsTool
-} from "./chunk-KRYABIB4.js";
+} from "./chunk-AF33GPHX.js";
 
 // src/index.ts
 import { program } from "commander";
@@ -632,6 +632,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 +1094,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 +1266,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 消息追加，供下一轮使用
    */
@@ -1206,6 +1429,23 @@ var OpenAICompatibleProvider = class extends BaseProvider {
   detectsHallucinatedFileOp(content) {
     return HALLUCINATION_PATTERNS.some((pattern) => pattern.test(content));
   }
+  /**
+   * 检查 _extraMessages 中是否已存在 write_file / edit_file 的成功调用记录。
+   * 若前面的 agentic 轮次已实际调用了写文件工具，则最终文本总结中提到「已保存」
+   * 是合理的事实陈述，不应被判定为虚假声明。
+   * 用于避免误报（false positive）。
+   */
+  hadPreviousWriteToolCalls(request) {
+    const extraMessages = request._extraMessages ?? [];
+    return extraMessages.some((msg) => {
+      if (msg.role !== "assistant" || !Array.isArray(msg.tool_calls)) return false;
+      return msg.tool_calls.some((tc) => {
+        const fn = tc.function;
+        const name = fn?.name ?? "";
+        return name === "write_file" || name === "edit_file";
+      });
+    });
+  }
   /**
    * 合并两次 API 调用的 token 用量（虚假声明重试时使用）
    */
@@ -1240,6 +1480,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",
@@ -1279,7 +1521,8 @@ var DeepSeekProvider = class extends OpenAICompatibleProvider {
     const result = await super.chatWithTools(enhancedRequest, tools);
     if ("content" in result && result.content) {
       const hasWriteTools = tools.some((t) => t.name === "write_file" || t.name === "edit_file");
-      if (hasWriteTools && this.detectsHallucinatedFileOp(result.content)) {
+      const alreadyWrote = this.hadPreviousWriteToolCalls(enhancedRequest);
+      if (hasWriteTools && !alreadyWrote && this.detectsHallucinatedFileOp(result.content)) {
         process.stderr.write(
           `[deepseek] \u26A0 \u68C0\u6D4B\u5230\u865A\u5047\u5B8C\u6210\u58F0\u660E\uFF08AI \u58F0\u79F0\u5DF2\u5199\u5165\u6587\u4EF6\u4F46\u672A\u8C03\u7528\u5DE5\u5177\uFF09\uFF0C\u6B63\u5728\u5F3A\u5236\u91CD\u65B0\u8BF7\u6C42...
 `
@@ -1397,6 +1640,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)",
@@ -1487,7 +1732,8 @@ var KimiProvider = class extends OpenAICompatibleProvider {
         return { toolCalls: xmlToolCalls, usage: result.usage };
       }
       const hasWriteTools = tools.some((t) => t.name === "write_file" || t.name === "edit_file");
-      if (hasWriteTools && this.detectsHallucinatedFileOp(result.content)) {
+      const alreadyWrote = this.hadPreviousWriteToolCalls(enhancedRequest);
+      if (hasWriteTools && !alreadyWrote && this.detectsHallucinatedFileOp(result.content)) {
         process.stderr.write(
           `[kimi] \u26A0 \u68C0\u6D4B\u5230\u865A\u5047\u5B8C\u6210\u58F0\u660E\uFF08AI \u58F0\u79F0\u5DF2\u5199\u5165\u6587\u4EF6\u4F46\u672A\u8C03\u7528\u5DE5\u5177\uFF09\uFF0C\u6B63\u5728\u5F3A\u5236\u91CD\u65B0\u8BF7\u6C42...
 `
@@ -2383,6 +2629,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) {
@@ -4344,7 +4591,7 @@ ${hint}` : "")
       description: "Run project tests and show structured report",
       usage: "/test [command|filter]",
       async execute(args, _ctx) {
-        const { executeTests } = await import("./run-tests-MTYDLLII.js");
+        const { executeTests } = await import("./run-tests-BTBQNJ44.js");
         const argStr = args.join(" ").trim();
         let testArgs = {};
         if (argStr) {
@@ -9971,6 +10218,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;
@@ -9997,24 +10345,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;
@@ -10022,15 +10394,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-MTYDLLII.js → run-tests-BTBQNJ44.js}

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

package/package.json

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