dskcode 0.1.20 → 0.1.22

package/dist/index.js

@@ -1,15 +1,13 @@
 #!/usr/bin/env node
 import {
   DeepSeekProvider,
-  ModelNotSupportedError
-} from "./chunk-BA7UJPKJ.js";
-import {
+  ModelNotSupportedError,
   SUPPORTED_MODELS,
   calculateCost,
   estimateTokens,
   getModelMeta,
   isSupportedModel
-} from "./chunk-7QS2XBBX.js";
+} from "./chunk-I6HEIOSU.js";
 
 // src/cli/index.tsx
 import { Command } from "commander";
@@ -818,7 +816,7 @@ var LOGO_LINES = [
 // src/ui/ChatSession.tsx
 import { Box as Box8, Text as Text9, useInput, Static } from "ink";
 import TextInput from "ink-text-input";
-import { useEffect as useEffect3, useState as useState3, useCallback as useCallback2, useRef as useRef2 } from "react";
+import { useEffect as useEffect3, useState as useState3, useCallback as useCallback2, useMemo, useRef as useRef2 } from "react";
 
 // src/ui/useDoubleCtrlC.ts
 import { useState as useState2, useCallback, useEffect as useEffect2, useRef } from "react";
@@ -848,6 +846,9 @@ function useDoubleCtrlC(onExit) {
   return { doubleCtrlC, handleCtrlC };
 }
 
+// src/ui/ChatSession.tsx
+import InkSpinner2 from "ink-spinner";
+
 // src/ui/AssistantMessage.tsx
 import { Box as Box4, Text as Text5 } from "ink";
 
@@ -1182,38 +1183,58 @@ function estimateMessageTokens(msg) {
   }
   return estimateTokens(text) + 10;
 }
+function groupIntoTurns(messages) {
+  const turns = [];
+  let current = null;
+  for (const msg of messages) {
+    if (msg.role === "user") {
+      if (current) turns.push(current);
+      current = [msg];
+    } else {
+      if (!current) current = [];
+      current.push(msg);
+    }
+  }
+  if (current && current.length > 0) turns.push(current);
+  return turns;
+}
+function estimateTurnTokens(turn) {
+  let sum = 0;
+  for (const msg of turn) sum += estimateMessageTokens(msg);
+  return sum;
+}
 function trimMessages(messages, opts) {
   const meta = getModelMeta(opts.model);
   const maxInputTokens = meta.contextWindow - opts.reservedForOutput;
   const systemTokens = estimateTokens(opts.systemPrompt);
   let remaining = maxInputTokens - systemTokens;
-  const preserved = [];
+  const turns = groupIntoTurns(messages);
+  const preservedTurns = [];
   let roundsPreserved = 0;
-  for (let i = messages.length - 1; i >= 0 && roundsPreserved < opts.preserveRecentRounds; i--) {
-    preserved.unshift(messages[i]);
-    if (messages[i].role === "user") {
-      roundsPreserved++;
-    }
+  for (let i = turns.length - 1; i >= 0 && roundsPreserved < opts.preserveRecentRounds; i--) {
+    preservedTurns.unshift(turns[i]);
+    roundsPreserved++;
   }
+  const preserved = preservedTurns.flat();
   for (const msg of preserved) {
     remaining -= estimateMessageTokens(msg);
   }
   if (remaining < 0) {
-    while (preserved.length > 1 && remaining < 0) {
-      const removed = preserved.shift();
-      remaining += estimateMessageTokens(removed);
+    while (preservedTurns.length > 1 && remaining < 0) {
+      const dropped = preservedTurns.shift();
+      remaining += estimateTurnTokens(dropped);
     }
-    return [preserved, true];
+    return [preservedTurns.flat(), true];
   }
-  const olderMessages = messages.slice(0, messages.length - preserved.length);
-  const kept = [];
-  for (let i = olderMessages.length - 1; i >= 0; i--) {
-    const cost = estimateMessageTokens(olderMessages[i]);
+  const olderTurns = turns.slice(0, turns.length - preservedTurns.length);
+  const keptTurns = [];
+  for (let i = olderTurns.length - 1; i >= 0; i--) {
+    const cost = estimateTurnTokens(olderTurns[i]);
     if (remaining - cost < 0) break;
     remaining -= cost;
-    kept.unshift(olderMessages[i]);
+    keptTurns.unshift(olderTurns[i]);
   }
-  const result = [...kept, ...preserved];
+  const result = [...keptTurns, ...preservedTurns].flat();
   const trimmed = result.length < messages.length;
   return [result, trimmed];
 }
@@ -1420,6 +1441,44 @@ function createProvider(config) {
   return defaultRegistry.get(config.name, config);
 }
 
+// src/tool/types.ts
+function eraseTool(tool) {
+  return {
+    get name() {
+      return tool.name;
+    },
+    get description() {
+      return tool.description;
+    },
+    get kind() {
+      return tool.kind;
+    },
+    get parameters() {
+      return tool.parameters;
+    },
+    get supportsInputStreaming() {
+      return tool.supportsInputStreaming ?? false;
+    },
+    get supportedProviders() {
+      return tool.supportedProviders ?? [];
+    },
+    async execute(args, ctx) {
+      return tool.execute(args, ctx);
+    },
+    initialTitle(args) {
+      return tool.initialTitle?.(args) ?? `${tool.name}`;
+    }
+  };
+}
+function isReadOnly(kind) {
+  return kind === "read" /* Read */;
+}
+var AlwaysAllowGate = class {
+  check(_toolName, _args) {
+    return true;
+  }
+};
+
 // src/agent/extra-prompt.ts
 var EXTRA_PROMPT = [
   "\u3010\u7EC8\u7AEF\u8F93\u51FA\u7EA6\u675F\u3011",
@@ -1522,14 +1581,28 @@ ${opts.projectContext}`);
 var ToolRegistry = class {
   #tools = /* @__PURE__ */ new Map();
   #disabledNames;
+  #featureFlagChecker;
+  #provider;
+  /** 所有已注册工具的名称列表（编译期等效） */
+  static ALL_TOOL_NAMES = [];
   constructor(opts) {
     this.#disabledNames = new Set(opts?.disabledTools ?? []);
+    this.#featureFlagChecker = opts?.featureFlagChecker ?? (() => true);
+    this.#provider = opts?.provider;
   }
   /**
-   * 注册一个工具。
+   * 注册一个类型安全的 AgentTool。
+   * 自动擦除类型参数后存储。
    * 如果同名工具已存在则抛出错误。
    */
   register(tool) {
+    return this.registerErased(eraseTool(tool));
+  }
+  /**
+   * 注册一个已经擦除类型 AnyAgentTool。
+   * 如果同名工具已存在则抛出错误。
+   */
+  registerErased(tool) {
     if (this.#tools.has(tool.name)) {
       throw new Error(`\u5DE5\u5177 "${tool.name}" \u5DF2\u6CE8\u518C\uFF0C\u4E0D\u80FD\u91CD\u590D\u6CE8\u518C`);
     }
@@ -1541,7 +1614,7 @@ var ToolRegistry = class {
    */
   registerAll(tools) {
     for (const tool of tools) {
-      this.register(tool);
+      this.registerErased(tool);
     }
     return this;
   }
@@ -1552,25 +1625,44 @@ var ToolRegistry = class {
     return this.#tools.delete(name);
   }
   /**
-   * 按名称获取工具。
-   * 如果工具被禁用或不存在，返回 undefined。
+   * 按名称获取工具（未擦除类型版本，调用方自行断言类型）。
+   * 如果工具被禁用、被 feature flag 拦截、或不支持当前 provider，返回 undefined。
    */
   get(name) {
-    if (this.#disabledNames.has(name)) return void 0;
+    if (!this.#isToolEnabled(name)) return void 0;
     return this.#tools.get(name);
   }
   /**
    * 获取所有启用的工具列表。
+   * 依次应用：禁用列表 → Feature Flag → Provider 过滤。
    */
   list() {
     const result = [];
     for (const [name, tool] of this.#tools) {
-      if (!this.#disabledNames.has(name)) {
+      if (this.#isToolEnabled(name)) {
         result.push(tool);
       }
     }
     return result;
   }
+  /**
+   * 按 ToolKind 分类获取工具列表。
+   */
+  listByKind(kind) {
+    return this.list().filter((t) => t.kind === kind);
+  }
+  /**
+   * 获取读工具列表（可并行执行）。
+   */
+  listReadTools() {
+    return this.listByKind("read" /* Read */);
+  }
+  /**
+   * 获取写工具列表（需串行执行）。
+   */
+  listWriteTools() {
+    return this.list().filter((t) => !isReadOnly(t.kind));
+  }
   /**
    * 获取所有已注册的工具名称（含禁用的）。
    */
@@ -1584,10 +1676,10 @@ var ToolRegistry = class {
     return this.#tools.has(name);
   }
   /**
-   * 检查工具是否已启用。
+   * 检查工具是否已启用（注册 + 未禁用 + 通过 feature flag + 支持 provider）。
    */
   isEnabled(name) {
-    return this.#tools.has(name) && !this.#disabledNames.has(name);
+    return this.#tools.has(name) && this.#isToolEnabled(name);
   }
   /**
    * 禁用一个工具。
@@ -1601,6 +1693,12 @@ var ToolRegistry = class {
   enable(name) {
     this.#disabledNames.delete(name);
   }
+  /**
+   * 获取工具的分类语义。
+   */
+  kindOf(name) {
+    return this.#tools.get(name)?.kind;
+  }
   /**
    * 执行指定工具。
    *
@@ -1626,11 +1724,21 @@ var ToolRegistry = class {
       };
     }
   }
-};
-
-// src/tool/types.ts
-var AlwaysAllowGate = class {
-  check(_toolName, _args) {
+  // ---------------------------------------------------------------------------
+  // 内部方法
+  // ---------------------------------------------------------------------------
+  /**
+   * 判断工具是否应该启用。
+   * 依次检查：是否在禁用列表 → 是否通过 Feature Flag → 是否支持当前 Provider。
+   */
+  #isToolEnabled(name) {
+    const tool = this.#tools.get(name);
+    if (!tool) return false;
+    if (this.#disabledNames.has(name)) return false;
+    if (!this.#featureFlagChecker(name)) return false;
+    if (this.#provider && tool.supportedProviders.length > 0) {
+      if (!tool.supportedProviders.includes(this.#provider)) return false;
+    }
     return true;
   }
 };
@@ -1698,7 +1806,7 @@ var Session = class {
    *    d. 如果没有工具调用 → 退出循环
    * 3. yield done 事件
    */
-  async *chat(userInput) {
+  async *chat(userInput, opts) {
     this.#messages.push({ role: "user", content: userInput });
     const startTime = Date.now();
     let toolRounds = 0;
@@ -1718,7 +1826,11 @@ var Session = class {
         const toolDefs = this.#buildToolDefinitions();
         const stream = this.#provider.chat(apiMessages, {
           signal: this.#abortController.signal,
-          tools: toolDefs.length > 0 ? toolDefs : void 0
+          tools: toolDefs.length > 0 ? toolDefs : void 0,
+          thinkingAllowed: opts?.thinkingAllowed,
+          thinkingEffort: opts?.thinkingEffort,
+          responseFormat: opts?.responseFormat,
+          toolChoice: opts?.toolChoice
         });
         let accumulatedText = "";
         let lastUsage;
@@ -1815,11 +1927,12 @@ ${item.result.diff.patch}`;
   async #executeBatch(calls) {
     const toolCtx = {
       cwd: this.#options.cwd,
-      signal: this.#abortController.signal
+      signal: this.#abortController.signal,
+      writeRoots: this.#options.writeRoots
     };
     const allReadOnly = calls.every((tc) => {
       const tool = this.#toolRegistry.get(tc.name);
-      return tool?.readOnly === true;
+      return tool ? isReadOnly(tool.kind) : true;
     });
     if (allReadOnly && calls.length > 1) {
       const MAX_PARALLEL = 8;
@@ -1873,11 +1986,11 @@ ${item.result.diff.patch}`;
         record: { name: toolName, success: false, error: "GATE_DENIED", timestamp }
       };
     }
-    if (!tool.readOnly) {
-      const maybePreviewer = tool;
-      if (typeof maybePreviewer.preview === "function") {
+    if (!isReadOnly(tool.kind)) {
+      const maybePreview = tool.preview;
+      if (typeof maybePreview === "function") {
         try {
-          await maybePreviewer.preview(toolArgs, ctx);
+          await maybePreview(toolArgs, ctx);
         } catch {
         }
       }
@@ -1977,6 +2090,39 @@ function resolvePath(inputPath, cwd) {
   const resolved = isAbsolute(inputPath) ? inputPath : resolve(cwd, inputPath);
   return resolve(resolved);
 }
+async function realPath(target) {
+  try {
+    return await realpath2(target);
+  } catch {
+    const parent = resolve(target, "..");
+    try {
+      const realParent = await realpath2(parent);
+      return resolve(realParent, relative(parent, target));
+    } catch {
+      return resolve(target);
+    }
+  }
+}
+async function confine(allowedRoots, target) {
+  if (allowedRoots.length === 0) {
+    return { ok: true };
+  }
+  const realTarget = await realPath(target);
+  for (const root of allowedRoots) {
+    const realRoot = await realPath(root);
+    const rel = relative(realRoot, realTarget);
+    if (!rel.startsWith("..") && rel !== "" && !rel.startsWith("/") && !rel.startsWith("\\")) {
+      return { ok: true };
+    }
+    if (realTarget === realRoot) {
+      return { ok: true };
+    }
+  }
+  return {
+    ok: false,
+    error: `\u8DEF\u5F84 "${target}" \u4E0D\u5728\u5141\u8BB8\u7684\u5199\u5165\u8303\u56F4\u5185 ${allowedRoots.join(", ")}`
+  };
+}
 function truncateOutput(content, maxLength = DEFAULT_MAX_OUTPUT_LENGTH) {
   if (content.length <= maxLength) return content;
   const truncated = content.slice(0, maxLength);
@@ -2320,29 +2466,45 @@ function computeFileDiff(oldContent, newContent, filePath) {
   };
 }
 
+// src/tool/eol.ts
+import { writeFile as writeFile3 } from "fs/promises";
+function detectEol(text) {
+  if (text.length === 0) return "\n";
+  const crlfIdx = text.indexOf("\r\n");
+  const lfIdx = text.indexOf("\n");
+  if (crlfIdx !== -1 && (lfIdx === -1 || crlfIdx <= lfIdx)) {
+    return "\r\n";
+  }
+  return "\n";
+}
+function hasTrailingNewline(text) {
+  return text.endsWith("\n") || text.endsWith("\r\n");
+}
+function normalizeEol(originalContent, newContent) {
+  const targetEol = detectEol(originalContent);
+  const lines = newContent.replace(/\r\n/g, "\n").split("\n");
+  const originalHasTrailing = hasTrailingNewline(originalContent);
+  const newHasTrailing = lines.length > 0 && lines[lines.length - 1] === "";
+  let result = lines.join(targetEol);
+  if (originalHasTrailing && !newHasTrailing) {
+    result += targetEol;
+  }
+  if (!originalHasTrailing && newHasTrailing) {
+    if (result.endsWith(targetEol)) {
+      result = result.slice(0, -targetEol.length);
+    }
+  }
+  return result;
+}
+async function writeFileWithEol(filePath, originalContent, newContent) {
+  const content = originalContent.length > 0 ? normalizeEol(originalContent, newContent) : newContent;
+  await writeFile3(filePath, content, "utf-8");
+}
+
 // src/tool/builtins/read-file.ts
 import { readFile as readFile4, stat } from "fs/promises";
 import { open } from "fs/promises";
 import { relative as relative2 } from "path";
-var readFileSchema = {
-  type: "object",
-  properties: {
-    path: {
-      type: "string",
-      description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
-    },
-    startLine: {
-      type: "number",
-      description: "\u8D77\u59CB\u884C\u53F7\uFF08\u4ECE 1 \u5F00\u59CB\uFF09\uFF0C\u9ED8\u8BA4\u4E3A 1"
-    },
-    endLine: {
-      type: "number",
-      description: "\u7ED3\u675F\u884C\u53F7\uFF08\u5305\u542B\uFF09\uFF0C\u9ED8\u8BA4\u5230\u6587\u4EF6\u672B\u5C3E"
-    }
-  },
-  required: ["path"],
-  additionalProperties: false
-};
 async function checkBinary(filePath) {
   const fileHandle = await open(filePath, "r");
   try {
@@ -2355,15 +2517,32 @@ async function checkBinary(filePath) {
 }
 var readFileTool = {
   name: "read_file",
+  kind: "read" /* Read */,
   description: "\u8BFB\u53D6\u6307\u5B9A\u8DEF\u5F84\u7684\u6587\u4EF6\u5185\u5BB9\u3002\u652F\u6301\u884C\u53F7\u8303\u56F4\u9009\u62E9\uFF0C\u8F93\u51FA\u5E26\u884C\u53F7\u3002\u9002\u7528\u4E8E\u67E5\u770B\u6E90\u4EE3\u7801\u3001\u914D\u7F6E\u6587\u4EF6\u7B49\u6587\u672C\u6587\u4EF6\u3002\u81EA\u52A8\u62D2\u7EDD\u4E8C\u8FDB\u5236\u6587\u4EF6\u3002",
-  parameters: readFileSchema,
-  readOnly: true,
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+      },
+      startLine: {
+        type: "number",
+        description: "\u8D77\u59CB\u884C\u53F7\uFF08\u4ECE 1 \u5F00\u59CB\uFF09\uFF0C\u9ED8\u8BA4\u4E3A 1"
+      },
+      endLine: {
+        type: "number",
+        description: "\u7ED3\u675F\u884C\u53F7\uFF08\u5305\u542B\uFF09\uFF0C\u9ED8\u8BA4\u5230\u6587\u4EF6\u672B\u5C3E"
+      }
+    },
+    required: ["path"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.path || typeof params.path !== "string") {
+    if (!args?.path || typeof args.path !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 path", error: "INVALID_ARGS" };
     }
-    const filePath = resolvePath(params.path, ctx.cwd);
+    const filePath = resolvePath(args.path, ctx.cwd);
     try {
       const fileStat = await stat(filePath);
       const maxSize = 10 * 1024 * 1024;
@@ -2396,8 +2575,8 @@ var readFileTool = {
       if (lines.length > 0 && lines[lines.length - 1] === "" && content.endsWith("\n")) {
         lines.pop();
       }
-      const startLine = Math.max(1, params.startLine ?? 1) - 1;
-      const endLine = params.endLine ? Math.min(params.endLine, lines.length) : lines.length;
+      const startLine = Math.max(1, args.startLine ?? 1) - 1;
+      const endLine = args.endLine ? Math.min(args.endLine, lines.length) : lines.length;
       const selectedLines = lines.slice(startLine, endLine);
       const lineNumWidth = String(endLine).length;
       const result = selectedLines.map((line, i) => {
@@ -2427,38 +2606,42 @@ var readFileTool = {
 };
 
 // src/tool/builtins/write-file.ts
-import { writeFile as writeFile3, mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile5 } from "fs/promises";
 import { dirname, relative as relative3, basename } from "path";
-var writeFileSchema = {
-  type: "object",
-  properties: {
-    path: {
-      type: "string",
-      description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
-    },
-    content: {
-      type: "string",
-      description: "\u8981\u5199\u5165\u7684\u6587\u4EF6\u5185\u5BB9"
-    }
-  },
-  required: ["path", "content"],
-  additionalProperties: false
-};
 var writeFileTool = {
   name: "write_file",
+  kind: "edit" /* Edit */,
   description: "\u521B\u5EFA\u6216\u8986\u76D6\u6587\u4EF6\u3002\u5982\u679C\u7236\u76EE\u5F55\u4E0D\u5B58\u5728\u4F1A\u81EA\u52A8\u521B\u5EFA\u3002\u9002\u7528\u4E8E\u521B\u5EFA\u65B0\u6587\u4EF6\u6216\u5B8C\u5168\u66FF\u6362\u6587\u4EF6\u5185\u5BB9\u3002\u8BF7\u52FF\u7528\u6B64\u5DE5\u5177\u521B\u5EFA _temp_\u3001_debug_ \u7B49\u7528\u4E8E\u8BCA\u65AD/\u8C03\u8BD5\u7684\u4E34\u65F6\u6587\u4EF6\u2014\u2014\u5982\u9700\u8BCA\u65AD\u8BF7\u6539\u7528 bash \u5DE5\u5177\u5185\u8054\u811A\u672C\uFF08node -e\uFF09\u3002",
-  parameters: writeFileSchema,
-  readOnly: false,
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+      },
+      content: {
+        type: "string",
+        description: "\u8981\u5199\u5165\u7684\u6587\u4EF6\u5185\u5BB9"
+      }
+    },
+    required: ["path", "content"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.path || typeof params.path !== "string") {
+    if (!args?.path || typeof args.path !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 path", error: "INVALID_ARGS" };
     }
-    if (params.content === void 0 || params.content === null) {
+    if (args.content === void 0 || args.content === null) {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 content", error: "INVALID_ARGS" };
     }
-    const filePath = resolvePath(params.path, ctx.cwd);
+    const filePath = resolvePath(args.path, ctx.cwd);
     try {
+      if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+        const conf = await confine(ctx.writeRoots, filePath);
+        if (!conf.ok) {
+          return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+        }
+      }
       let oldContent = "";
       let existedBefore = false;
       try {
@@ -2467,8 +2650,8 @@ var writeFileTool = {
       } catch {
       }
       await mkdir4(dirname(filePath), { recursive: true });
-      const content = String(params.content);
-      await writeFile3(filePath, content, "utf-8");
+      const content = String(args.content);
+      await writeFileWithEol(filePath, oldContent, content);
       const diff = computeFileDiff(oldContent, content, filePath);
       diff.existedBefore = existedBefore;
       const lineCount = content.split("\n").length;
@@ -2495,47 +2678,51 @@ var writeFileTool = {
 };
 
 // src/tool/builtins/edit-file.ts
-import { readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { basename as basename2 } from "path";
-var editFileSchema = {
-  type: "object",
-  properties: {
-    path: {
-      type: "string",
-      description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
-    },
-    old_text: {
-      type: "string",
-      description: "\u8981\u67E5\u627E\u7684\u539F\u59CB\u6587\u672C\uFF08\u7CBE\u786E\u5339\u914D\uFF09"
-    },
-    new_text: {
-      type: "string",
-      description: "\u66FF\u6362\u540E\u7684\u65B0\u6587\u672C"
-    }
-  },
-  required: ["path", "old_text", "new_text"],
-  additionalProperties: false
-};
 var editFileTool = {
   name: "edit_file",
+  kind: "edit" /* Edit */,
   description: "\u5BF9\u6587\u4EF6\u8FDB\u884C\u7CBE\u786E\u5B57\u7B26\u4E32\u66FF\u6362\u3002\u67E5\u627E\u6587\u4EF6\u4E2D\u7684 old_text \u5E76\u66FF\u6362\u4E3A new_text\u3002\u5982\u679C old_text \u51FA\u73B0\u591A\u6B21\u6216\u672A\u627E\u5230\u5219\u62A5\u9519\u3002\u9002\u7528\u4E8E\u5C0F\u8303\u56F4\u7CBE\u786E\u4FEE\u6539\u3002",
-  parameters: editFileSchema,
-  readOnly: false,
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+      },
+      old_text: {
+        type: "string",
+        description: "\u8981\u67E5\u627E\u7684\u539F\u59CB\u6587\u672C\uFF08\u7CBE\u786E\u5339\u914D\uFF09"
+      },
+      new_text: {
+        type: "string",
+        description: "\u66FF\u6362\u540E\u7684\u65B0\u6587\u672C"
+      }
+    },
+    required: ["path", "old_text", "new_text"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.path || typeof params.path !== "string") {
+    if (!args?.path || typeof args.path !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 path", error: "INVALID_ARGS" };
     }
-    if (typeof params.old_text !== "string") {
+    if (typeof args.old_text !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 old_text", error: "INVALID_ARGS" };
     }
-    if (typeof params.new_text !== "string") {
+    if (typeof args.new_text !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 new_text", error: "INVALID_ARGS" };
     }
-    const filePath = resolvePath(params.path, ctx.cwd);
+    const filePath = resolvePath(args.path, ctx.cwd);
+    if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+      const conf = await confine(ctx.writeRoots, filePath);
+      if (!conf.ok) {
+        return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+      }
+    }
     try {
       const content = await readFile6(filePath, "utf-8");
-      const firstIndex = content.indexOf(params.old_text);
+      const firstIndex = content.indexOf(args.old_text);
       if (firstIndex === -1) {
         return {
           success: false,
@@ -2543,7 +2730,7 @@ var editFileTool = {
           error: "TEXT_NOT_FOUND"
         };
       }
-      const secondIndex = content.indexOf(params.old_text, firstIndex + 1);
+      const secondIndex = content.indexOf(args.old_text, firstIndex + 1);
       if (secondIndex !== -1) {
         return {
           success: false,
@@ -2551,14 +2738,14 @@ var editFileTool = {
           error: "TEXT_MULTIPLE_MATCHES"
         };
       }
-      const newContent = content.replace(params.old_text, params.new_text);
-      await writeFile4(filePath, newContent, "utf-8");
+      const newContent = content.replace(args.old_text, args.new_text);
+      await writeFileWithEol(filePath, content, newContent);
       const diff = computeFileDiff(content, newContent, filePath);
       diff.existedBefore = true;
       const beforeText = content.slice(0, firstIndex);
       const startLine = beforeText.split("\n").length;
-      const oldLines = params.old_text.split("\n").length;
-      const newLines = params.new_text.split("\n").length;
+      const oldLines = args.old_text.split("\n").length;
+      const newLines = args.new_text.split("\n").length;
       const diffSummary = `+${diff.additions} -${diff.deletions}`;
       const summary = `\u{1F4DD} \u4FEE\u6539: ${basename2(filePath)} (+${diff.additions} -${diff.deletions})`;
       return {
@@ -2582,52 +2769,56 @@ ${oldLines} \u884C \u2192 ${newLines} \u884C
 };
 
 // src/tool/builtins/multi-edit.ts
-import { readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { basename as basename3 } from "path";
-var multiEditSchema = {
-  type: "object",
-  properties: {
-    path: {
-      type: "string",
-      description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
-    },
-    edits: {
-      type: "array",
-      description: "\u6709\u5E8F\u7684\u7F16\u8F91\u6B65\u9AA4\u5217\u8868\u3002\u6BCF\u4E2A\u6B65\u9AA4\u5305\u542B oldText\uFF08\u7CBE\u786E\u5339\u914D\uFF09\u3001newText\uFF08\u66FF\u6362\u5185\u5BB9\uFF09\u548C\u53EF\u9009\u7684 replaceAll\uFF08\u662F\u5426\u66FF\u6362\u6240\u6709\u5339\u914D\u9879\uFF09",
-      items: {
-        type: "object",
-        properties: {
-          oldText: { type: "string", description: "\u8981\u67E5\u627E\u7684\u539F\u59CB\u6587\u672C\uFF08\u7CBE\u786E\u5339\u914D\uFF09" },
-          newText: { type: "string", description: "\u66FF\u6362\u540E\u7684\u65B0\u6587\u672C" },
-          replaceAll: { type: "boolean", description: "\u662F\u5426\u66FF\u6362\u6240\u6709\u5339\u914D\u9879\uFF0C\u9ED8\u8BA4 false" }
-        },
-        required: ["oldText", "newText"],
-        additionalProperties: false
-      }
-    }
-  },
-  required: ["path", "edits"],
-  additionalProperties: false
-};
 var multiEditTool = {
   name: "multi_edit",
+  kind: "edit" /* Edit */,
   description: "\u5BF9\u6587\u4EF6\u8FDB\u884C\u539F\u5B50\u6279\u91CF\u66FF\u6362\u7F16\u8F91\u3002\u5728\u4E00\u4E2A\u8BF7\u6C42\u4E2D\u6267\u884C\u591A\u4E2A\u7CBE\u786E\u66FF\u6362\uFF0C\u4EFB\u4E00\u5931\u8D25\u5219\u5168\u90E8\u56DE\u6EDA\u3002\u652F\u6301 replaceAll \u53C2\u6570\u505A\u5168\u5C40\u66FF\u6362\u3002\u9002\u7528\u4E8E\u9700\u8981\u540C\u65F6\u4FEE\u6539\u6587\u4EF6\u591A\u5904\u7684\u573A\u666F\u3002",
-  parameters: multiEditSchema,
-  readOnly: false,
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+      },
+      edits: {
+        type: "array",
+        description: "\u6709\u5E8F\u7684\u7F16\u8F91\u6B65\u9AA4\u5217\u8868\u3002\u6BCF\u4E2A\u6B65\u9AA4\u5305\u542B oldText\uFF08\u7CBE\u786E\u5339\u914D\uFF09\u3001newText\uFF08\u66FF\u6362\u5185\u5BB9\uFF09\u548C\u53EF\u9009\u7684 replaceAll\uFF08\u662F\u5426\u66FF\u6362\u6240\u6709\u5339\u914D\u9879\uFF09",
+        items: {
+          type: "object",
+          properties: {
+            oldText: { type: "string", description: "\u8981\u67E5\u627E\u7684\u539F\u59CB\u6587\u672C\uFF08\u7CBE\u786E\u5339\u914D\uFF09" },
+            newText: { type: "string", description: "\u66FF\u6362\u540E\u7684\u65B0\u6587\u672C" },
+            replaceAll: { type: "boolean", description: "\u662F\u5426\u66FF\u6362\u6240\u6709\u5339\u914D\u9879\uFF0C\u9ED8\u8BA4 false" }
+          },
+          required: ["oldText", "newText"],
+          additionalProperties: false
+        }
+      }
+    },
+    required: ["path", "edits"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.path || typeof params.path !== "string") {
+    if (!args?.path || typeof args.path !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 path", error: "INVALID_ARGS" };
     }
-    if (!Array.isArray(params.edits) || params.edits.length === 0) {
+    if (!Array.isArray(args.edits) || args.edits.length === 0) {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 edits\uFF08\u975E\u7A7A\u6570\u7EC4\uFF09", error: "INVALID_ARGS" };
     }
-    const filePath = resolvePath(params.path, ctx.cwd);
+    const filePath = resolvePath(args.path, ctx.cwd);
+    if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+      const conf = await confine(ctx.writeRoots, filePath);
+      if (!conf.ok) {
+        return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+      }
+    }
     try {
       const originalContent = await readFile7(filePath, "utf-8");
       let currentContent = originalContent;
-      for (let idx = 0; idx < params.edits.length; idx++) {
-        const step = params.edits[idx];
+      for (let idx = 0; idx < args.edits.length; idx++) {
+        const step = args.edits[idx];
         if (typeof step.oldText !== "string") {
           return {
             success: false,
@@ -2669,15 +2860,15 @@ var multiEditTool = {
           currentContent = currentContent.replace(step.oldText, step.newText);
         }
       }
-      await writeFile5(filePath, currentContent, "utf-8");
+      await writeFileWithEol(filePath, originalContent, currentContent);
       const diff = computeFileDiff(originalContent, currentContent, filePath);
       diff.existedBefore = true;
       return {
         success: true,
         data: `\u6587\u4EF6\u5DF2\u7F16\u8F91\uFF1A${filePath}
-\u5171\u6267\u884C ${params.edits.length} \u6B65\u66FF\u6362
+\u5171\u6267\u884C ${args.edits.length} \u6B65\u66FF\u6362
 \u53D8\u66F4\uFF1A+${diff.additions} -${diff.deletions}`,
-        summary: `\u{1F4DD} \u4FEE\u6539: ${basename3(filePath)} (${params.edits.length} \u6B65, +${diff.additions} -${diff.deletions})`,
+        summary: `\u{1F4DD} \u4FEE\u6539: ${basename3(filePath)} (${args.edits.length} \u6B65, +${diff.additions} -${diff.deletions})`,
         diff
       };
     } catch (err) {
@@ -2692,31 +2883,8 @@ var multiEditTool = {
 };
 
 // src/tool/builtins/delete-range.ts
-import { readFile as readFile8, writeFile as writeFile6 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { basename as basename4 } from "path";
-var deleteRangeSchema = {
-  type: "object",
-  properties: {
-    path: {
-      type: "string",
-      description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
-    },
-    startAnchor: {
-      type: "string",
-      description: "\u5220\u9664\u8303\u56F4\u7684\u8D77\u59CB\u6807\u8BB0\u884C\u5185\u5BB9\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u7CBE\u786E\u5339\u914D\u6574\u884C\uFF09"
-    },
-    endAnchor: {
-      type: "string",
-      description: "\u5220\u9664\u8303\u56F4\u7684\u7ED3\u675F\u6807\u8BB0\u884C\u5185\u5BB9\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u7CBE\u786E\u5339\u914D\u6574\u884C\uFF0C\u987B\u5728 start_anchor \u4E4B\u540E\uFF09"
-    },
-    inclusive: {
-      type: "boolean",
-      description: "\u662F\u5426\u5305\u542B\u951A\u70B9\u884C\u672C\u8EAB\uFF0C\u9ED8\u8BA4 false\uFF08\u53EA\u5220\u9664\u4E24\u884C\u4E4B\u95F4\u7684\u5185\u5BB9\uFF09"
-    }
-  },
-  required: ["path", "startAnchor", "endAnchor"],
-  additionalProperties: false
-};
 function findUniqueLine(lines, anchor, label) {
   const matches = [];
   for (let i = 0; i < lines.length; i++) {
@@ -2734,30 +2902,57 @@ function findUniqueLine(lines, anchor, label) {
 }
 var deleteRangeTool = {
   name: "delete_range",
+  kind: "edit" /* Edit */,
   description: "\u5220\u9664\u6587\u4EF6\u4E2D\u4E24\u4E2A\u951A\u70B9\u884C\u4E4B\u95F4\u7684\u5185\u5BB9\u3002\u901A\u8FC7\u4E24\u4E2A\u552F\u4E00\u7684\u884C\u5185\u5BB9\u7CBE\u786E\u5B9A\u4F4D\u8303\u56F4\u3002\u9002\u7528\u4E8E\u5220\u9664\u65B9\u6CD5\u3001\u4EE3\u7801\u5757\u3001\u914D\u7F6E\u6BB5\u7B49\u3002",
-  parameters: deleteRangeSchema,
-  readOnly: false,
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09"
+      },
+      startAnchor: {
+        type: "string",
+        description: "\u5220\u9664\u8303\u56F4\u7684\u8D77\u59CB\u6807\u8BB0\u884C\u5185\u5BB9\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u7CBE\u786E\u5339\u914D\u6574\u884C\uFF09"
+      },
+      endAnchor: {
+        type: "string",
+        description: "\u5220\u9664\u8303\u56F4\u7684\u7ED3\u675F\u6807\u8BB0\u884C\u5185\u5BB9\uFF08\u5FC5\u987B\u5728\u6587\u4EF6\u4E2D\u552F\u4E00\uFF0C\u7CBE\u786E\u5339\u914D\u6574\u884C\uFF0C\u987B\u5728 start_anchor \u4E4B\u540E\uFF09"
+      },
+      inclusive: {
+        type: "boolean",
+        description: "\u662F\u5426\u5305\u542B\u951A\u70B9\u884C\u672C\u8EAB\uFF0C\u9ED8\u8BA4 false\uFF08\u53EA\u5220\u9664\u4E24\u884C\u4E4B\u95F4\u7684\u5185\u5BB9\uFF09"
+      }
+    },
+    required: ["path", "startAnchor", "endAnchor"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.path || typeof params.path !== "string") {
+    if (!args?.path || typeof args.path !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 path", error: "INVALID_ARGS" };
     }
-    if (typeof params.startAnchor !== "string") {
+    if (typeof args.startAnchor !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u6709\u6548\u53C2\u6570 startAnchor", error: "INVALID_ARGS" };
     }
-    if (typeof params.endAnchor !== "string") {
+    if (typeof args.endAnchor !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u6709\u6548\u53C2\u6570 endAnchor", error: "INVALID_ARGS" };
     }
-    const filePath = resolvePath(params.path, ctx.cwd);
-    const inclusive = params.inclusive ?? false;
+    const filePath = resolvePath(args.path, ctx.cwd);
+    const inclusive = args.inclusive ?? false;
+    if (ctx.writeRoots && ctx.writeRoots.length > 0) {
+      const conf = await confine(ctx.writeRoots, filePath);
+      if (!conf.ok) {
+        return { success: false, data: conf.error, error: "OUTSIDE_WRITE_ROOTS" };
+      }
+    }
     try {
       const content = await readFile8(filePath, "utf-8");
       const lines = content.split("\n");
-      const startResult = findUniqueLine(lines, params.startAnchor, "start_anchor");
+      const startResult = findUniqueLine(lines, args.startAnchor, "start_anchor");
       if ("error" in startResult) {
         return { success: false, data: startResult.error, error: "ANCHOR_NOT_FOUND" };
       }
-      const endResult = findUniqueLine(lines, params.endAnchor, "end_anchor");
+      const endResult = findUniqueLine(lines, args.endAnchor, "end_anchor");
       if ("error" in endResult) {
         return { success: false, data: endResult.error, error: "ANCHOR_NOT_FOUND" };
       }
@@ -2781,14 +2976,8 @@ var deleteRangeTool = {
       }
       const newLines = [...lines.slice(0, rangeStart), ...lines.slice(rangeEnd + 1)];
       const newContent = newLines.join("\n");
-      let writeContent = newContent;
-      if (content.endsWith("\n") && !newContent.endsWith("\n")) {
-        writeContent = newContent + "\n";
-      } else if (content.endsWith("\r\n") && !newContent.endsWith("\r\n") && !newContent.endsWith("\n")) {
-        writeContent = newContent + "\r\n";
-      }
-      await writeFile6(filePath, writeContent, "utf-8");
-      const diff = computeFileDiff(content, writeContent, filePath);
+      await writeFileWithEol(filePath, content, newContent);
+      const diff = computeFileDiff(content, newContent, filePath);
       diff.existedBefore = true;
       const deletedLines = rangeEnd - rangeStart + 1;
       const summary = `\u{1F4DD} \u4FEE\u6539: ${basename4(filePath)} (\u5220 ${deletedLines} \u884C, +${diff.additions} -${diff.deletions})`;
@@ -2814,36 +3003,33 @@ var deleteRangeTool = {
 // src/tool/builtins/bash.ts
 import process3 from "process";
 var isWindows2 = process3.platform === "win32";
-var bashSchema = {
-  type: "object",
-  properties: {
-    command: {
-      type: "string",
-      description: "\u8981\u6267\u884C\u7684 shell \u547D\u4EE4"
-    },
-    timeout: {
-      type: "number",
-      description: "\u6267\u884C\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 30000"
-    }
-  },
-  required: ["command"],
-  additionalProperties: false
-};
 var bashTool = {
   name: "bash",
+  kind: "other" /* Other */,
   description: "\u5728 shell \u4E2D\u6267\u884C\u547D\u4EE4\u3002\u8FD4\u56DE\u6807\u51C6\u8F93\u51FA\u3001\u6807\u51C6\u9519\u8BEF\u548C\u9000\u51FA\u7801\u3002\u652F\u6301\u8D85\u65F6\u63A7\u5236\u548C\u4FE1\u53F7\u4E2D\u6B62\u3002\u9002\u7528\u4E8E\u8FD0\u884C\u6784\u5EFA\u3001\u6D4B\u8BD5\u3001Git \u64CD\u4F5C\u7B49\u547D\u4EE4\u3002",
-  parameters: bashSchema,
-  readOnly: false,
-  // bash 有副作用，不能并行执行
+  parameters: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "\u8981\u6267\u884C\u7684 shell \u547D\u4EE4"
+      },
+      timeout: {
+        type: "number",
+        description: "\u6267\u884C\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 30000"
+      }
+    },
+    required: ["command"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.command || typeof params.command !== "string") {
+    if (!args?.command || typeof args.command !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 command", error: "INVALID_ARGS" };
     }
-    const timeout = params.timeout ?? ctx.timeout ?? getDefaultTimeout();
+    const timeout = args.timeout ?? ctx.timeout ?? getDefaultTimeout();
     try {
       const shellCommand = isWindows2 ? "cmd" : "sh";
-      const shellArgs = isWindows2 ? ["/c", params.command] : ["-c", params.command];
+      const shellArgs = isWindows2 ? ["/c", args.command] : ["-c", args.command];
       const result = await execCommand(
         shellCommand,
         shellArgs,
@@ -2851,7 +3037,6 @@ var bashTool = {
         timeout,
         ctx.signal,
         true
-        // isShellCommand — 已指定 shell 程序，不需要二次包装
       );
       const parts = [];
       if (result.stdout) {
@@ -2863,7 +3048,7 @@ ${truncateOutput(result.stderr)}`);
       }
       const success = result.exitCode === 0;
       const output = parts.length > 0 ? parts.join("\n") : "(\u65E0\u8F93\u51FA)";
-      const cmdPreview = params.command.length > 60 ? params.command.slice(0, 57) + "..." : params.command;
+      const cmdPreview = args.command.length > 60 ? args.command.slice(0, 57) + "..." : args.command;
       const summary = `\u{1F527} $ ${cmdPreview}\uFF08exit ${result.exitCode ?? "\u672A\u77E5"}\uFF09`;
       return {
         success,
@@ -2886,21 +3071,6 @@ ${truncateOutput(result.stderr)}`);
 // src/tool/builtins/glob.ts
 import { readdir as readdir2, stat as stat2 } from "fs/promises";
 import { join as join4, relative as relative4, isAbsolute as isAbsolute2 } from "path";
-var globSchema = {
-  type: "object",
-  properties: {
-    pattern: {
-      type: "string",
-      description: "\u641C\u7D22\u6A21\u5F0F\uFF08\u652F\u6301 * \u548C ** \u901A\u914D\u7B26\uFF0C\u5982 **/*.ts\u3001src/**/*.test.ts\uFF09"
-    },
-    directory: {
-      type: "string",
-      description: "\u641C\u7D22\u7684\u8D77\u59CB\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55"
-    }
-  },
-  required: ["pattern"],
-  additionalProperties: false
-};
 function globToRegex(pattern) {
   let regexStr = pattern;
   regexStr = regexStr.replace(/\*\*\//g, "<<GLOBSTAR_SLASH>>");
@@ -2937,16 +3107,29 @@ async function walkDir(dir, baseDir) {
 }
 var globTool = {
   name: "glob",
+  kind: "read" /* Read */,
   description: "\u6309\u6A21\u5F0F\u641C\u7D22\u6587\u4EF6\u8DEF\u5F84\u3002\u652F\u6301 *\uFF08\u5339\u914D\u6587\u4EF6\u540D\u90E8\u5206\uFF09\u548C **\uFF08\u5339\u914D\u591A\u5C42\u76EE\u5F55\uFF09\u901A\u914D\u7B26\u3002\u81EA\u52A8\u8DF3\u8FC7 node_modules \u548C .git \u76EE\u5F55\u3002",
-  parameters: globSchema,
-  readOnly: true,
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "\u641C\u7D22\u6A21\u5F0F\uFF08\u652F\u6301 * \u548C ** \u901A\u914D\u7B26\uFF0C\u5982 **/*.ts\u3001src/**/*.test.ts\uFF09"
+      },
+      directory: {
+        type: "string",
+        description: "\u641C\u7D22\u7684\u8D77\u59CB\u76EE\u5F55\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55"
+      }
+    },
+    required: ["pattern"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.pattern || typeof params.pattern !== "string") {
+    if (!args?.pattern || typeof args.pattern !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 pattern", error: "INVALID_ARGS" };
     }
-    const searchDir = params.directory ? isAbsolute2(params.directory) ? params.directory : join4(ctx.cwd, params.directory) : ctx.cwd;
-    const regex = globToRegex(params.pattern);
+    const searchDir = args.directory ? isAbsolute2(args.directory) ? args.directory : join4(ctx.cwd, args.directory) : ctx.cwd;
+    const regex = globToRegex(args.pattern);
     try {
       const dirStat = await stat2(searchDir);
       if (!dirStat.isDirectory()) {
@@ -2957,8 +3140,8 @@ var globTool = {
       if (matched.length === 0) {
         return {
           success: true,
-          data: `\u672A\u627E\u5230\u5339\u914D "${params.pattern}" \u7684\u6587\u4EF6`,
-          summary: `${params.pattern} \u2192 0 \u4E2A\u6587\u4EF6`
+          data: `\u672A\u627E\u5230\u5339\u914D "${args.pattern}" \u7684\u6587\u4EF6`,
+          summary: `${args.pattern} \u2192 0 \u4E2A\u6587\u4EF6`
         };
       }
       const limit = 200;
@@ -2970,7 +3153,7 @@ var globTool = {
       return {
         success: true,
         data: truncateOutput(output + suffix),
-        summary: `${params.pattern} \u2192 ${matched.length} \u4E2A\u6587\u4EF6`
+        summary: `${args.pattern} \u2192 ${matched.length} \u4E2A\u6587\u4EF6`
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -2986,33 +3169,6 @@ var globTool = {
 // src/tool/builtins/grep.ts
 import { readdir as readdir3, readFile as readFile9, stat as stat3 } from "fs/promises";
 import { join as join5, relative as relative5, isAbsolute as isAbsolute3 } from "path";
-var grepSchema = {
-  type: "object",
-  properties: {
-    pattern: {
-      type: "string",
-      description: "\u6B63\u5219\u8868\u8FBE\u5F0F\u641C\u7D22\u6A21\u5F0F"
-    },
-    directory: {
-      type: "string",
-      description: "\u641C\u7D22\u7684\u76EE\u5F55\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55"
-    },
-    include: {
-      type: "string",
-      description: "\u6587\u4EF6\u6269\u5C55\u540D\u8FC7\u6EE4\uFF08\u5982 ts\u3001json\uFF09\uFF0C\u4E0D\u542B\u70B9\u53F7"
-    },
-    case_sensitive: {
-      type: "boolean",
-      description: "\u662F\u5426\u5927\u5C0F\u5199\u654F\u611F\uFF0C\u9ED8\u8BA4 false"
-    },
-    max_files: {
-      type: "number",
-      description: "\u6700\u5927\u641C\u7D22\u6587\u4EF6\u6570\uFF0C\u9ED8\u8BA4 200"
-    }
-  },
-  required: ["pattern"],
-  additionalProperties: false
-};
 async function collectFiles(dir, baseDir, extension, maxFiles = 200) {
   const results = [];
   let entries;
@@ -3040,24 +3196,49 @@ async function collectFiles(dir, baseDir, extension, maxFiles = 200) {
 }
 var grepTool = {
   name: "grep",
+  kind: "read" /* Read */,
   description: "\u5728\u6587\u4EF6\u5185\u5BB9\u4E2D\u641C\u7D22\u6B63\u5219\u8868\u8FBE\u5F0F\u3002\u8FD4\u56DE\u5339\u914D\u884C\u7684\u6587\u4EF6\u8DEF\u5F84\u3001\u884C\u53F7\u548C\u5185\u5BB9\u3002\u652F\u6301\u5927\u5C0F\u5199\u654F\u611F\u3001\u6587\u4EF6\u6269\u5C55\u540D\u8FC7\u6EE4\u3002",
-  parameters: grepSchema,
-  readOnly: true,
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "\u6B63\u5219\u8868\u8FBE\u5F0F\u641C\u7D22\u6A21\u5F0F"
+      },
+      directory: {
+        type: "string",
+        description: "\u641C\u7D22\u7684\u76EE\u5F55\u8DEF\u5F84\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55"
+      },
+      include: {
+        type: "string",
+        description: "\u6587\u4EF6\u6269\u5C55\u540D\u8FC7\u6EE4\uFF08\u5982 ts\u3001json\uFF09\uFF0C\u4E0D\u542B\u70B9\u53F7"
+      },
+      case_sensitive: {
+        type: "boolean",
+        description: "\u662F\u5426\u5927\u5C0F\u5199\u654F\u611F\uFF0C\u9ED8\u8BA4 false"
+      },
+      max_files: {
+        type: "number",
+        description: "\u6700\u5927\u641C\u7D22\u6587\u4EF6\u6570\uFF0C\u9ED8\u8BA4 200"
+      }
+    },
+    required: ["pattern"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.pattern || typeof params.pattern !== "string") {
+    if (!args?.pattern || typeof args.pattern !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 pattern", error: "INVALID_ARGS" };
     }
-    const searchDir = params.directory ? isAbsolute3(params.directory) ? params.directory : join5(ctx.cwd, params.directory) : ctx.cwd;
-    const maxFiles = params.max_files ?? 200;
+    const searchDir = args.directory ? isAbsolute3(args.directory) ? args.directory : join5(ctx.cwd, args.directory) : ctx.cwd;
+    const maxFiles = args.max_files ?? 200;
     try {
-      const flags = params.case_sensitive ? "g" : "gi";
-      const regex = new RegExp(params.pattern, flags);
+      const flags = args.case_sensitive ? "g" : "gi";
+      const regex = new RegExp(args.pattern, flags);
       const dirStat = await stat3(searchDir);
       if (!dirStat.isDirectory()) {
         return { success: false, data: `\u8DEF\u5F84\u4E0D\u662F\u76EE\u5F55\uFF1A${searchDir}`, error: "NOT_DIRECTORY" };
       }
-      const files = await collectFiles(searchDir, searchDir, params.include, maxFiles);
+      const files = await collectFiles(searchDir, searchDir, args.include, maxFiles);
       const matches = [];
       for (const filePath of files) {
         try {
@@ -3083,13 +3264,13 @@ var grepTool = {
       if (matches.length === 0) {
         return {
           success: true,
-          data: `\u672A\u627E\u5230\u5339\u914D "${params.pattern}" \u7684\u5185\u5BB9`,
-          summary: `\u{1F50D} "${params.pattern}" \u2192 0 \u6761\u547D\u4E2D`
+          data: `\u672A\u627E\u5230\u5339\u914D "${args.pattern}" \u7684\u5185\u5BB9`,
+          summary: `\u{1F50D} "${args.pattern}" \u2192 0 \u6761\u547D\u4E2D`
         };
       }
       const output = matches.map((m) => `${m.file}:${m.line}: ${m.content}`).join("\n");
       const fileSet = new Set(matches.map((m) => m.file));
-      const summary = `\u{1F50D} "${params.pattern}" \u2192 ${matches.length} \u6761\u547D\u4E2D / ${fileSet.size} \u4E2A\u6587\u4EF6`;
+      const summary = `\u{1F50D} "${args.pattern}" \u2192 ${matches.length} \u6761\u547D\u4E2D / ${fileSet.size} \u4E2A\u6587\u4EF6`;
       return {
         success: true,
         data: truncateOutput(output),
@@ -3109,30 +3290,28 @@ var grepTool = {
 // src/tool/builtins/ls.ts
 import { readdir as readdir4, stat as stat4 } from "fs/promises";
 import { join as join6, relative as relative6 } from "path";
-var lsSchema = {
-  type: "object",
-  properties: {
-    path: {
-      type: "string",
-      description: "\u76EE\u5F55\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u76EE\u5F55"
-    },
-    all: {
-      type: "boolean",
-      description: "\u662F\u5426\u663E\u793A\u9690\u85CF\u6587\u4EF6\uFF08\u4EE5 . \u5F00\u5934\u7684\u6587\u4EF6\uFF09\uFF0C\u9ED8\u8BA4 false"
-    }
-  },
-  required: [],
-  additionalProperties: false
-};
 var lsTool = {
   name: "ls",
+  kind: "read" /* Read */,
   description: "\u5217\u51FA\u76EE\u5F55\u5185\u5BB9\u3002\u663E\u793A\u6761\u76EE\u7C7B\u578B\uFF08\u6587\u4EF6/\u76EE\u5F55/\u94FE\u63A5\uFF09\u548C\u5927\u5C0F\u3002\u53EF\u9009\u62E9\u662F\u5426\u663E\u793A\u9690\u85CF\u6587\u4EF6\u3002",
-  parameters: lsSchema,
-  readOnly: true,
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "\u76EE\u5F55\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\u6216\u7EDD\u5BF9\u8DEF\u5F84\uFF09\uFF0C\u9ED8\u8BA4\u4E3A\u5F53\u524D\u76EE\u5F55"
+      },
+      all: {
+        type: "boolean",
+        description: "\u662F\u5426\u663E\u793A\u9690\u85CF\u6587\u4EF6\uFF08\u4EE5 . \u5F00\u5934\u7684\u6587\u4EF6\uFF09\uFF0C\u9ED8\u8BA4 false"
+      }
+    },
+    required: [],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args ?? {};
-    const dirPath = params.path ? resolvePath(params.path, ctx.cwd) : ctx.cwd;
-    const showAll = params.all ?? false;
+    const dirPath = args.path ? resolvePath(args.path, ctx.cwd) : ctx.cwd;
+    const showAll = args.all ?? false;
     try {
       const entries = await readdir4(dirPath, { withFileTypes: true });
       const lines = [];
@@ -3185,58 +3364,56 @@ ${lines.join("\n")}`),
 };
 
 // src/tool/builtins/fetch.ts
-var fetchSchema = {
-  type: "object",
-  properties: {
-    url: {
-      type: "string",
-      description: "\u8BF7\u6C42\u7684 URL"
-    },
-    method: {
-      type: "string",
-      description: "HTTP \u65B9\u6CD5\uFF08GET\u3001POST\u3001PUT\u3001DELETE \u7B49\uFF09\uFF0C\u9ED8\u8BA4 GET"
-    },
-    headers: {
-      type: "object",
-      description: "\u8BF7\u6C42\u5934\u952E\u503C\u5BF9",
-      additionalProperties: { type: "string" }
-    },
-    body: {
-      type: "string",
-      description: "\u8BF7\u6C42\u4F53\u5185\u5BB9\uFF08POST/PUT \u65F6\u4F7F\u7528\uFF09"
-    },
-    max_length: {
-      type: "number",
-      description: "\u54CD\u5E94\u5185\u5BB9\u6700\u5927\u957F\u5EA6\uFF08\u5B57\u7B26\uFF09\uFF0C\u9ED8\u8BA4 50000"
-    }
-  },
-  required: ["url"],
-  additionalProperties: false
-};
 var fetchTool = {
   name: "fetch",
+  kind: "read" /* Read */,
   description: "\u53D1\u8D77 HTTP \u8BF7\u6C42\u5E76\u8FD4\u56DE\u54CD\u5E94\u5185\u5BB9\u3002\u652F\u6301\u81EA\u5B9A\u4E49\u65B9\u6CD5\u548C\u8BF7\u6C42\u5934\u3002\u9002\u7528\u4E8E\u83B7\u53D6\u7F51\u9875\u5185\u5BB9\u3001API \u8C03\u7528\u7B49\u573A\u666F\u3002",
-  parameters: fetchSchema,
-  readOnly: true,
+  parameters: {
+    type: "object",
+    properties: {
+      url: {
+        type: "string",
+        description: "\u8BF7\u6C42\u7684 URL"
+      },
+      method: {
+        type: "string",
+        description: "HTTP \u65B9\u6CD5\uFF08GET\u3001POST\u3001PUT\u3001DELETE \u7B49\uFF09\uFF0C\u9ED8\u8BA4 GET"
+      },
+      headers: {
+        type: "object",
+        description: "\u8BF7\u6C42\u5934\u952E\u503C\u5BF9",
+        additionalProperties: { type: "string" }
+      },
+      body: {
+        type: "string",
+        description: "\u8BF7\u6C42\u4F53\u5185\u5BB9\uFF08POST/PUT \u65F6\u4F7F\u7528\uFF09"
+      },
+      max_length: {
+        type: "number",
+        description: "\u54CD\u5E94\u5185\u5BB9\u6700\u5927\u957F\u5EA6\uFF08\u5B57\u7B26\uFF09\uFF0C\u9ED8\u8BA4 50000"
+      }
+    },
+    required: ["url"],
+    additionalProperties: false
+  },
   async execute(args, ctx) {
-    const params = args;
-    if (!params?.url || typeof params.url !== "string") {
+    if (!args?.url || typeof args.url !== "string") {
       return { success: false, data: "\u7F3A\u5C11\u5FC5\u8981\u53C2\u6570 url", error: "INVALID_ARGS" };
     }
-    const method = (params.method ?? "GET").toUpperCase();
+    const method = (args.method ?? "GET").toUpperCase();
     const timeout = 3e4;
-    const maxLength = params.max_length ?? 5e4;
+    const maxLength = args.max_length ?? 5e4;
     try {
       const fetchOptions = {
         method,
-        headers: params.headers ?? {},
+        headers: args.headers ?? {},
         signal: ctx.signal ?? AbortSignal.timeout(timeout)
       };
-      if (params.body && (method === "POST" || method === "PUT" || method === "PATCH")) {
+      if (args.body && (method === "POST" || method === "PUT" || method === "PATCH")) {
         fetchOptions.headers["Content-Type"] ??= "application/json";
-        fetchOptions.body = params.body;
+        fetchOptions.body = args.body;
       }
-      const response = await fetch(params.url, fetchOptions);
+      const response = await fetch(args.url, fetchOptions);
       const contentType = response.headers.get("content-type") ?? "unknown";
       const statusText = `${response.status} ${response.statusText}`;
       let body;
@@ -3249,7 +3426,7 @@ var fetchTool = {
       const header = `\u72B6\u6001: ${statusText}
 \u5185\u5BB9\u7C7B\u578B: ${contentType}`;
       const separator = body.length > 0 ? "\n---\n" : "";
-      const urlPreview = params.url.length > 60 ? params.url.slice(0, 57) + "..." : params.url;
+      const urlPreview = args.url.length > 60 ? args.url.slice(0, 57) + "..." : args.url;
       const summary = `\u{1F310} ${method} ${urlPreview} \u2192 ${response.status}`;
       return {
         success: response.ok,
@@ -3276,16 +3453,16 @@ var fetchTool = {
 
 // src/tool/builtins/index.ts
 var builtinTools = [
-  readFileTool,
-  writeFileTool,
-  editFileTool,
-  multiEditTool,
-  deleteRangeTool,
-  bashTool,
-  globTool,
-  grepTool,
-  lsTool,
-  fetchTool
+  eraseTool(readFileTool),
+  eraseTool(writeFileTool),
+  eraseTool(editFileTool),
+  eraseTool(multiEditTool),
+  eraseTool(deleteRangeTool),
+  eraseTool(bashTool),
+  eraseTool(globTool),
+  eraseTool(grepTool),
+  eraseTool(lsTool),
+  eraseTool(fetchTool)
 ];
 
 // src/utils/gradient.ts
@@ -3376,6 +3553,8 @@ registerCommand("/help", {
 registerCommand("/clear", { desc: "\u6E05\u7A7A\u5BF9\u8BDD\u5386\u53F2", handler: () => ({ kind: "clear" }) });
 registerCommand("/version", { desc: "\u663E\u793A\u7248\u672C\u4FE1\u606F", handler: () => ({ kind: "text", content: "dskcode v0.1.10" }) });
 registerCommand("/model", { desc: "\u5207\u6362\u6A21\u578B", handler: () => ({ kind: "text", content: "\u8BF7\u76F4\u63A5\u8F93\u5165 /model \u8FDB\u5165\u9009\u62E9\u754C\u9762" }) });
+registerCommand("/thinking", { desc: "\u5207\u6362\u6DF1\u5EA6\u601D\u8003\u6A21\u5F0F", handler: () => ({ kind: "text", content: "\u8BF7\u76F4\u63A5\u8F93\u5165 /thinking \u5207\u6362" }) });
+registerCommand("/effort", { desc: "\u5207\u6362\u63A8\u7406\u7B49\u7EA7 High/Max", handler: () => ({ kind: "text", content: "\u8BF7\u76F4\u63A5\u8F93\u5165 /effort \u5207\u6362" }) });
 registerCommand("/game", { desc: "\u542F\u52A8\u6E38\u620F", handler: () => ({ kind: "navigate", target: "game" }) });
 registerCommand("/stock", { desc: "\u67E5\u770B\u80A1\u7968\u884C\u60C5", handler: () => ({ kind: "navigate", target: "stock" }) });
 var STREAMING_PLACEHOLDERS = [
@@ -3434,6 +3613,19 @@ function ChatSession({
   const [activeModel, setActiveModel] = useState3(model);
   const [streamingModel, setStreamingModel] = useState3(void 0);
   const [streamError, setStreamError] = useState3(void 0);
+  const [thinkingEnabled, setThinkingEnabled] = useState3(true);
+  const [thinkingEffort, setThinkingEffort] = useState3("high");
+  const [responseFormat, setResponseFormat] = useState3("text");
+  const [toolChoice, setToolChoice] = useState3(void 0);
+  const sessionCost = useMemo(() => {
+    return displayMessages.reduce((sum, msg) => {
+      if (msg.assistantDetail?.cost) {
+        return sum + msg.assistantDetail.cost;
+      }
+      return sum;
+    }, 0);
+  }, [displayMessages]);
+  const hasConversationStarted = displayMessages.length > 0;
   const cmdTips = Array.from(getRegisteredCommands()).filter(([name]) => name !== "/exit" && name !== "/quit").map(([name, cmd]) => ({ name, desc: cmd.desc }));
   const [cmdTipIndex, setCmdTipIndex] = useState3(0);
   const [cmdTipGradientColors, setCmdTipGradientColors] = useState3([]);
@@ -3565,6 +3757,11 @@ function ChatSession({
             return;
           }
         }
+        if (selectingModel) {
+          if (key.upArrow || key.downArrow) {
+          }
+          return;
+        }
         if (key.ctrl && _input === "c") {
           if (isStreaming) {
             abortRef.current?.abort();
@@ -3584,7 +3781,7 @@ function ChatSession({
     if (cmdTips.length <= 1) return;
     const timer = setInterval(() => {
       setCmdTipIndex((prev) => (prev + 1) % cmdTips.length);
-    }, 5e3);
+    }, 2e3);
     return () => clearInterval(timer);
   }, [cmdTips.length]);
   useEffect3(() => {
@@ -3631,7 +3828,7 @@ function ChatSession({
     if (!apiKey || !baseUrl) return;
     let cancelled = false;
     setBalanceLoading(true);
-    import("./deepseek-UJXV2D6K.js").then(({ DeepSeekProvider: DeepSeekProvider2 }) => {
+    import("./deepseek-YTT76XDE.js").then(({ DeepSeekProvider: DeepSeekProvider2 }) => {
       const provider = new DeepSeekProvider2({
         apiKey,
         baseUrl,
@@ -3700,14 +3897,48 @@ function ChatSession({
     const trimmed = value.trim();
     if (!trimmed) return;
     if (trimmed.startsWith("/") && trimmed.length > 1) {
-      if (trimmed.toLowerCase() === "/model") {
+      const cmdLower = trimmed.toLowerCase();
+      if (cmdLower === "/model") {
         const curIdx = modelOptions.indexOf(activeModel);
         setModelSelectIndex(curIdx >= 0 ? curIdx : 0);
         setSelectingModel(true);
         setInput("");
         return;
       }
-      const cmd = commandRegistry.get(trimmed.toLowerCase());
+      if (cmdLower === "/thinking") {
+        setThinkingEnabled((prev) => !prev);
+        setDisplayMessages((prev) => [
+          ...prev,
+          { role: "user", content: trimmed },
+          { role: "assistant", content: `\u6DF1\u5EA6\u601D\u8003\u5DF2${thinkingEnabled ? "\u5173\u95ED" : "\u5F00\u542F"}` }
+        ]);
+        setInput("");
+        return;
+      }
+      if (cmdLower === "/effort") {
+        const next = thinkingEffort === "high" ? "max" : "high";
+        setThinkingEffort(next);
+        setDisplayMessages((prev) => [
+          ...prev,
+          { role: "user", content: trimmed },
+          { role: "assistant", content: `\u63A8\u7406\u7B49\u7EA7\u5DF2\u5207\u6362\u4E3A ${next === "high" ? "High" : "Max"}` }
+        ]);
+        setInput("");
+        return;
+      }
+      if (cmdLower === "/tools") {
+        const next = toolChoice === void 0 ? "none" : toolChoice === "none" ? "required" : toolChoice === "required" ? "auto" : void 0;
+        setToolChoice(next);
+        const label = next === void 0 ? "\u81EA\u52A8\uFF08\u9ED8\u8BA4\uFF09" : next === "none" ? "\u7981\u6B62\u8C03\u7528" : next === "required" ? "\u5F3A\u5236\u8C03\u7528" : "\u81EA\u52A8\uFF08\u9ED8\u8BA4\uFF09";
+        setDisplayMessages((prev) => [
+          ...prev,
+          { role: "user", content: trimmed },
+          { role: "assistant", content: `\u5DE5\u5177\u8C03\u7528\u7B56\u7565\u5DF2\u5207\u6362\u4E3A ${label}` }
+        ]);
+        setInput("");
+        return;
+      }
+      const cmd = commandRegistry.get(cmdLower);
       if (cmd) {
         const result = cmd.handler();
         switch (result.kind) {
@@ -3782,7 +4013,12 @@ function ChatSession({
     const abortController = new AbortController();
     abortRef.current = abortController;
     try {
-      for await (const event of session.chat(trimmed)) {
+      for await (const event of session.chat(trimmed, {
+        thinkingAllowed: thinkingEnabled || void 0,
+        thinkingEffort: thinkingEnabled ? thinkingEffort : void 0,
+        responseFormat: responseFormat !== "text" ? responseFormat : void 0,
+        toolChoice
+      })) {
         if (abortController.signal.aborted) break;
         switch (event.type) {
           case "text_delta":
@@ -3820,6 +4056,11 @@ function ChatSession({
             setStreamingModel(event.model);
             currentUsageRef.current = event.usage;
             currentModelRef.current = event.model;
+            {
+              const cost = calculateCost(event.usage, event.model);
+              setCurrentCost(cost.totalCost);
+              currentCostRef.current = cost.totalCost;
+            }
             break;
           case "done":
             setCurrentElapsed(event.elapsed);
@@ -3861,23 +4102,14 @@ function ChatSession({
         ]);
       }
     }
-  }, [onLaunchGame, onLaunchStock, currentContent, currentToolCalls, skills, skillSelectIndex, getFilteredSkills]);
+  }, [onLaunchGame, onLaunchStock, currentContent, currentToolCalls, skills, skillSelectIndex, getFilteredSkills, thinkingEnabled, thinkingEffort, responseFormat, toolChoice, activeModel]);
   useEffect3(() => {
     if (!isStreaming && externalCostTracker) {
       setTodayCost(externalCostTracker.todayTotalCost);
     }
   }, [isStreaming, externalCostTracker]);
-  useEffect3(() => {
-    if (currentUsage && streamingModel && !currentCost) {
-      import("./models-OL7DHYGK.js").then(({ calculateCost: calculateCost2 }) => {
-        const cost = calculateCost2(currentUsage, streamingModel);
-        setCurrentCost(cost.totalCost);
-        currentCostRef.current = cost.totalCost;
-      });
-    }
-  }, [currentUsage, streamingModel, currentCost]);
   return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", paddingLeft: 1, paddingRight: 1, children: [
-    /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", marginBottom: 1, children: [
+    !hasConversationStarted && /* @__PURE__ */ jsxs8(Box8, { flexDirection: "row", marginBottom: 1, children: [
       /* @__PURE__ */ jsx8(Box8, { flexDirection: "column", marginRight: 4, children: LOGO_LINES.map((line, i) => {
         const colorIndex = (i + offset) % CYBER_PALETTE.length;
         return /* @__PURE__ */ jsx8(Box8, { children: /* @__PURE__ */ jsx8(Text9, { bold: true, color: CYBER_PALETTE[colorIndex], children: line }) }, i);
@@ -3899,6 +4131,15 @@ function ChatSession({
           "  \u{1F527} \u6A21\u578B ",
           SUPPORTED_MODELS[activeModel]?.displayName ?? activeModel
         ] }),
+        thinkingEnabled && /* @__PURE__ */ jsxs8(Text9, { color: "#ff9800", children: [
+          "  \u{1F9E0} \u6DF1\u5EA6\u601D\u8003 ",
+          thinkingEffort === "max" ? "Max" : "High"
+        ] }),
+        responseFormat === "json_object" && /* @__PURE__ */ jsx8(Text9, { color: "#4caf50", children: "  \u{1F4C4} JSON" }),
+        toolChoice !== void 0 && /* @__PURE__ */ jsxs8(Text9, { color: "#e91e63", children: [
+          "  \u{1F6E0} ",
+          toolChoice === "none" ? "\u7981\u6B62\u5DE5\u5177" : toolChoice === "required" ? "\u5F3A\u5236\u5DE5\u5177" : ""
+        ] }),
         cmdTips.length > 0 && (() => {
           const tip = cmdTips[cmdTipIndex % cmdTips.length];
           if (!tip) return null;
@@ -4006,7 +4247,21 @@ function ChatSession({
       ] }),
       /* @__PURE__ */ jsx8(Text9, { color: "#00ffff", dimColor: true, children: "\u2500".repeat(dividerWidth) })
     ] }) : /* @__PURE__ */ jsxs8(Fragment, { children: [
-      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: /* @__PURE__ */ jsx8(Text9, { color: "#00ffff", dimColor: true, children: "\u2500".repeat(dividerWidth) }) }),
+      /* @__PURE__ */ jsx8(Box8, { marginTop: 1, children: hasConversationStarted && (balance !== null || sessionCost > 0 || isStreaming) ? /* @__PURE__ */ jsxs8(Text9, { color: "#00ffff", dimColor: true, children: [
+        "\u2500".repeat(Math.max(dividerWidth - 35, 10)),
+        balance !== null && /* @__PURE__ */ jsxs8(Text9, { color: "yellow", children: [
+          " \u{1F4B0} \u4F59\u989D \xA5",
+          balance.toFixed(2)
+        ] }),
+        isStreaming ? /* @__PURE__ */ jsxs8(Text9, { color: "cyan", children: [
+          "  \u{1F4CA} \u672C\u6B21 \xA5",
+          sessionCost > 0 ? sessionCost.toFixed(4) + " " : "",
+          /* @__PURE__ */ jsx8(InkSpinner2, { type: "dots" })
+        ] }) : sessionCost > 0 ? /* @__PURE__ */ jsxs8(Text9, { color: "cyan", children: [
+          "  \u{1F4CA} \u672C\u6B21 \xA5",
+          sessionCost.toFixed(4)
+        ] }) : null
+      ] }) : /* @__PURE__ */ jsx8(Text9, { color: "#00ffff", dimColor: true, children: "\u2500".repeat(dividerWidth) }) }),
       /* @__PURE__ */ jsxs8(Box8, { children: [
         /* @__PURE__ */ jsx8(Box8, { width: 4, flexShrink: 0, children: /* @__PURE__ */ jsx8(Text9, { bold: true, color: "#00ff41", children: "\u26A1" }) }),
         /* @__PURE__ */ jsx8(Box8, { flexGrow: 1, children: !input && !isStreaming && idlePlaceholder && gradientColors.length > 0 ? /* @__PURE__ */ jsx8(Text9, { children: idlePlaceholder.split("").map((ch, i) => /* @__PURE__ */ jsx8(Text9, { color: gradientColors[i] ?? void 0, children: ch }, i)) }) : !input && isStreaming && streamingPlaceholder && streamingGradientColors.length > 0 ? /* @__PURE__ */ jsx8(Text9, { children: streamingPlaceholder.split("").map((ch, i) => /* @__PURE__ */ jsx8(Text9, { color: streamingGradientColors[i] ?? void 0, children: ch }, i)) }) : /* @__PURE__ */ jsx8(
@@ -4224,7 +4479,7 @@ function BrickBreakerGame({ onExit: _onExit }) {
   const [initialLevel, setInitialLevel] = useState5(1);
   const [selectingLevel, setSelectingLevel] = useState5(true);
   const stateRef = useRef3(createInitialState(initialLevel));
-  const [tick, setTick] = useState5(0);
+  const [tick2, setTick] = useState5(0);
   const onExitRef = useRef3(_onExit);
   onExitRef.current = _onExit;
   useEffect4(() => {
@@ -4279,7 +4534,7 @@ function BrickBreakerGame({ onExit: _onExit }) {
   const aliveCount = s.bricks.filter((b) => b.alive).length;
   const board = buildBoard(s);
   const def = getLevel(s.level);
-  void tick;
+  void tick2;
   return /* @__PURE__ */ jsxs10(Box10, { flexDirection: "column", children: [
     /* @__PURE__ */ jsxs10(Box10, { flexDirection: "row", children: [
       /* @__PURE__ */ jsx10(Box10, { width: 20, children: /* @__PURE__ */ jsxs10(Text11, { children: [
@@ -4754,7 +5009,7 @@ function buildGameView(s, scoreLines, scoreColor, message) {
 }
 function CoderCheck({ onExit: _onExit }) {
   const stateRef = useRef4(createInitialState2());
-  const [tick, setTick] = useState6(0);
+  const [tick2, setTick] = useState6(0);
   const [colorOffset, setColorOffset] = useState6(0);
   const onExitRef = useRef4(_onExit);
   onExitRef.current = _onExit;
@@ -4832,7 +5087,7 @@ function CoderCheck({ onExit: _onExit }) {
   const scoreStr = String(s.score).padStart(5, "0");
   const scoreLines = buildScoreLines(scoreStr);
   const view = buildGameView(s, scoreLines, scoreColor, s.message);
-  void tick;
+  void tick2;
   return /* @__PURE__ */ jsxs11(Box11, { flexDirection: "column", paddingX: 1, children: [
     /* @__PURE__ */ jsx11(Box11, { flexDirection: "row", children: /* @__PURE__ */ jsxs11(Text12, { children: [
       "\u751F\u547D ",
@@ -4889,16 +5144,375 @@ var coder_check_default = {
   }
 };
 
+// src/game/snake/engine.ts
+function isOpposite(a, b) {
+  return a === "UP" && b === "DOWN" || a === "DOWN" && b === "UP" || a === "LEFT" && b === "RIGHT" || a === "RIGHT" && b === "LEFT";
+}
+function samePoint(a, b) {
+  return a.x === b.x && a.y === b.y;
+}
+function movePoint(p, dir) {
+  switch (dir) {
+    case "UP":
+      return { x: p.x, y: p.y - 1 };
+    case "DOWN":
+      return { x: p.x, y: p.y + 1 };
+    case "LEFT":
+      return { x: p.x - 1, y: p.y };
+    case "RIGHT":
+      return { x: p.x + 1, y: p.y };
+  }
+}
+function wrapPoint(p, config) {
+  return {
+    x: (p.x % config.width + config.width) % config.width,
+    y: (p.y % config.height + config.height) % config.height
+  };
+}
+function generateFood(snake, config, type, excludePositions = []) {
+  const occupied = new Set(snake.map((p) => `${p.x},${p.y}`));
+  for (const p of excludePositions) {
+    occupied.add(`${p.x},${p.y}`);
+  }
+  const totalCells = config.width * config.height;
+  if (occupied.size >= totalCells) return null;
+  let pos;
+  do {
+    pos = {
+      x: Math.floor(Math.random() * config.width),
+      y: Math.floor(Math.random() * config.height)
+    };
+  } while (occupied.has(`${pos.x},${pos.y}`));
+  return {
+    position: pos,
+    type,
+    ...type === "special" ? { spawnedAt: Date.now() } : {}
+  };
+}
+function createInitialState3(config) {
+  const startX = Math.floor(config.width / 2);
+  const startY = Math.floor(config.height / 2);
+  const snake = [
+    { x: startX, y: startY },
+    { x: startX - 1, y: startY },
+    { x: startX - 2, y: startY }
+  ];
+  const food = generateFood(snake, config, "normal");
+  return {
+    snake,
+    direction: "RIGHT",
+    nextDirection: "RIGHT",
+    food,
+    specialFood: null,
+    score: 0,
+    speedLevel: 1,
+    isGameOver: false,
+    isPaused: false,
+    wallWrap: Math.random() < 0.5,
+    tickInterval: config.initialSpeed
+  };
+}
+function tick(state, config) {
+  state.direction = state.nextDirection;
+  const head = state.snake[0];
+  let newHead = movePoint(head, state.direction);
+  const outOfBounds = newHead.x < 0 || newHead.x >= config.width || newHead.y < 0 || newHead.y >= config.height;
+  if (outOfBounds) {
+    if (state.wallWrap) {
+      newHead = wrapPoint(newHead, config);
+    } else {
+      state.isGameOver = true;
+      return;
+    }
+  }
+  const ateNormal = samePoint(newHead, state.food.position);
+  const ateSpecial = state.specialFood !== null && samePoint(newHead, state.specialFood.position);
+  const willEat = ateNormal || ateSpecial;
+  const bodyToCheck = willEat ? state.snake : state.snake.slice(0, -1);
+  for (const segment of bodyToCheck) {
+    if (samePoint(newHead, segment)) {
+      state.isGameOver = true;
+      return;
+    }
+  }
+  state.snake.unshift(newHead);
+  if (ateNormal) {
+    state.score += 1;
+    updateSpeed(state, config);
+    const exclude = state.specialFood ? [state.specialFood.position] : [];
+    const newFood = generateFood(state.snake, config, "normal", exclude);
+    if (newFood) {
+      state.food = newFood;
+    } else {
+      state.isGameOver = true;
+      return;
+    }
+    if (state.specialFood === null && Math.random() < 0.25) {
+      state.specialFood = generateFood(state.snake, config, "special", [state.food.position]);
+    }
+  } else if (ateSpecial) {
+    state.score += 3;
+    updateSpeed(state, config);
+    state.specialFood = null;
+  } else {
+    state.snake.pop();
+  }
+  if (state.specialFood?.spawnedAt !== void 0) {
+    if (Date.now() - state.specialFood.spawnedAt > 5e3) {
+      state.specialFood = null;
+    }
+  }
+}
+function updateSpeed(state, config) {
+  const newLevel = Math.floor(state.score / config.scorePerLevel) + 1;
+  state.speedLevel = newLevel;
+  state.tickInterval = Math.max(
+    config.minSpeed,
+    config.initialSpeed - (newLevel - 1) * config.speedDecrement
+  );
+}
+function changeDirection(state, newDir) {
+  if (!isOpposite(newDir, state.direction)) {
+    state.nextDirection = newDir;
+  }
+}
+
+// src/game/snake/renderer.ts
+import chalk4 from "chalk";
+var CELL_W = 2;
+var EMPTY = "  ";
+var BODY_CHAR = "\u2593";
+var HEAD_CHAR = "\u2593";
+var NORMAL_FOOD_CHAR = "\u25C6";
+var SPECIAL_FOOD_CHAR = "\u2605";
+var CSI = "\x1B[";
+var CURSOR_HIDE = `${CSI}?25l`;
+var CURSOR_SHOW = `${CSI}?25h`;
+var CURSOR_HOME = `${CSI}H`;
+function hideCursor() {
+  process.stdout.write(CURSOR_HIDE);
+}
+function showCursor() {
+  process.stdout.write(CURSOR_SHOW);
+}
+function clearScreen() {
+  process.stdout.write(`${CSI}2J${CURSOR_HOME}`);
+}
+function cellColor(char, type) {
+  switch (type) {
+    case "snake-head":
+      return chalk4.greenBright(char);
+    case "snake-body":
+      return chalk4.green(char);
+    case "normal-food":
+      return chalk4.red(char);
+    case "special-food":
+      return chalk4.yellow(char);
+    case "empty":
+      return char;
+  }
+}
+function renderToTerminal(state, config) {
+  const lines = buildRenderLines(state, config);
+  process.stdout.write(`${CSI}2J${CURSOR_HOME}` + lines.join("\n"));
+}
+function buildRenderLines(state, config) {
+  const { width: W, height: H } = config;
+  const lines = [];
+  const grid = Array.from({ length: H }, () => Array(W).fill("empty"));
+  for (let i = 1; i < state.snake.length; i++) {
+    const seg = state.snake[i];
+    if (seg.y >= 0 && seg.y < H && seg.x >= 0 && seg.x < W) {
+      grid[seg.y][seg.x] = "snake-body";
+    }
+  }
+  const head = state.snake[0];
+  if (head.y >= 0 && head.y < H && head.x >= 0 && head.x < W) {
+    grid[head.y][head.x] = "snake-head";
+  }
+  const fp = state.food.position;
+  if (grid[fp.y][fp.x] === "empty") {
+    grid[fp.y][fp.x] = "normal-food";
+  }
+  if (state.specialFood) {
+    const sp = state.specialFood.position;
+    if (grid[sp.y][sp.x] === "empty") {
+      grid[sp.y][sp.x] = "special-food";
+    }
+  }
+  lines.push("  " + chalk4.gray("\u2554" + "\u2550\u2550".repeat(W) + "\u2557"));
+  for (let y = 0; y < H; y++) {
+    let row = "  " + chalk4.gray("\u2551");
+    for (let x = 0; x < W; x++) {
+      const cellType = grid[y][x];
+      let char;
+      switch (cellType) {
+        case "snake-head":
+          char = HEAD_CHAR.repeat(CELL_W);
+          break;
+        case "snake-body":
+          char = BODY_CHAR.repeat(CELL_W);
+          break;
+        case "normal-food":
+          char = NORMAL_FOOD_CHAR + " ";
+          break;
+        case "special-food":
+          char = SPECIAL_FOOD_CHAR + " ";
+          break;
+        default:
+          char = EMPTY;
+      }
+      row += cellColor(char, cellType);
+    }
+    row += chalk4.gray("\u2551");
+    lines.push(row);
+  }
+  lines.push("  " + chalk4.gray("\u255A" + "\u2550\u2550".repeat(W) + "\u255D"));
+  lines.push("");
+  lines.push(
+    `  ${chalk4.cyan("\u5206\u6570")}: ${state.score}  ${chalk4.cyan("\u957F\u5EA6")}: ${state.snake.length}  ${chalk4.cyan("\u901F\u5EA6")}: Lv.${state.speedLevel}  ${chalk4.cyan("\u8FB9\u754C")}: ${state.wallWrap ? "\u7A7F\u5899" : "\u649E\u5899"}`
+  );
+  if (state.specialFood?.spawnedAt !== void 0) {
+    const remaining = Math.ceil((5e3 - (Date.now() - state.specialFood.spawnedAt)) / 1e3);
+    if (remaining > 0) {
+      lines.push(`  ${chalk4.yellow(`\u2B50 \u7279\u6B8A\u98DF\u7269 ${remaining} \u79D2\u540E\u6D88\u5931`)}`);
+    }
+  }
+  lines.push(`  ${chalk4.gray("W/A/S/D \u6216 \u65B9\u5411\u952E\u79FB\u52A8 | P \u6682\u505C | M \u5207\u6362\u6A21\u5F0F | Q \u9000\u51FA")}`);
+  if (state.isPaused) {
+    lines.push("");
+    lines.push(`  ${chalk4.yellow("\u23F8  \u5DF2\u6682\u505C \u2014 \u6309 P \u7EE7\u7EED")}`);
+  }
+  if (state.isGameOver) {
+    lines.push("");
+    lines.push(`  ${chalk4.red.bold("\u{1F480}  \u6E38\u620F\u7ED3\u675F!")}  ${chalk4.cyan("\u6700\u7EC8\u5206\u6570: " + state.score)}`);
+    lines.push(`  ${chalk4.gray("\u6309 R \u91CD\u65B0\u5F00\u59CB | \u6309 Q \u9000\u51FA")}`);
+  }
+  return lines;
+}
+
+// src/game/snake/input.ts
+import * as readline from "readline";
+var KEY_TO_DIR = {
+  up: "UP",
+  w: "UP",
+  W: "UP",
+  down: "DOWN",
+  s: "DOWN",
+  S: "DOWN",
+  left: "LEFT",
+  a: "LEFT",
+  A: "LEFT",
+  right: "RIGHT",
+  d: "RIGHT",
+  D: "RIGHT"
+};
+function setupInput(ctx, onQuit, onRestart) {
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+  const handler = (_, key) => {
+    if (!key || !key.name) return;
+    const { name, ctrl } = key;
+    if (ctrl && (name === "c" || name === "d")) {
+      onQuit();
+      return;
+    }
+    if (name === "q") {
+      onQuit();
+      return;
+    }
+    const state = ctx.state;
+    if (state.isGameOver) {
+      if (name === "r") {
+        ctx.state = onRestart();
+      }
+      return;
+    }
+    if (name === "p") {
+      state.isPaused = !state.isPaused;
+      return;
+    }
+    if (name === "m") {
+      state.wallWrap = !state.wallWrap;
+      return;
+    }
+    const dir = KEY_TO_DIR[name];
+    if (dir) {
+      changeDirection(state, dir);
+    }
+  };
+  process.stdin.on("keypress", handler);
+  return () => {
+    process.stdin.removeListener("keypress", handler);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false);
+    }
+  };
+}
+
+// src/game/snake/index.ts
+var CONFIG = {
+  width: 20,
+  height: 16,
+  initialSpeed: 180,
+  minSpeed: 60,
+  speedDecrement: 10,
+  scorePerLevel: 5
+};
+var IDLE_INTERVAL = 200;
+var snakeGame = {
+  id: "snake",
+  name: "Big Snake",
+  description: "\u7ECF\u5178\u8D2A\u5403\u86C7\uFF0C\u53CC\u98DF\u7269\u7CFB\u7EDF\u3001\u96BE\u5EA6\u9012\u589E\u3001\u7A7F\u5899/\u649E\u5899\u6A21\u5F0F",
+  play: async () => {
+    const ctx = { state: createInitialState3(CONFIG) };
+    return new Promise((resolve2) => {
+      const cleanupInput = setupInput(
+        ctx,
+        () => {
+          stop = true;
+          clearTimeout(timerId);
+          showCursor();
+          cleanupInput();
+          resolve2();
+        },
+        () => {
+          return createInitialState3(CONFIG);
+        }
+      );
+      clearScreen();
+      hideCursor();
+      let stop = false;
+      let timerId;
+      function loop() {
+        if (stop) return;
+        const s = ctx.state;
+        if (!s.isGameOver && !s.isPaused) {
+          tick(s, CONFIG);
+        }
+        renderToTerminal(s, CONFIG);
+        const interval = s.isGameOver || s.isPaused ? IDLE_INTERVAL : s.tickInterval;
+        timerId = setTimeout(loop, interval);
+      }
+      timerId = setTimeout(loop, 0);
+    });
+  }
+};
+var snake_default = snakeGame;
+
 // src/game/registry.ts
 function initGames() {
   registerGame(brick_breaker_default);
   registerGame(coder_check_default);
+  registerGame(snake_default);
   return listGames();
 }
 
 // src/cli/index.tsx
 import { render as render4 } from "ink";
-import chalk4 from "chalk";
+import chalk5 from "chalk";
 
 // src/stock/StockList.tsx
 import { Box as Box12, Text as Text13, useInput as useInput5 } from "ink";
@@ -5331,7 +5945,7 @@ function createCli() {
       const key = await promptForApiKey();
       if (!key) process.exit(1);
       const savedPath = await saveApiKey(key);
-      console.log(`  ${chalk4.green("\u2714")} API Key \u5DF2\u4FDD\u5B58\u5230 ${chalk4.dim(savedPath)}
+      console.log(`  ${chalk5.green("\u2714")} API Key \u5DF2\u4FDD\u5B58\u5230 ${chalk5.dim(savedPath)}
 `);
       const result = await loadAndValidate();
       ctx = { ...ctx, config: result.config };
@@ -5478,8 +6092,8 @@ compdef _dskcode_completion dskcode`);
         { code: "sh601899" }
       ];
       const savedPath = await saveStockConfig(defaultSymbols);
-      console.log(`${chalk4.green("\u2714")} \u5DF2\u751F\u6210\u81EA\u9009\u80A1\u914D\u7F6E: ${chalk4.dim(savedPath)}`);
-      console.log(`${chalk4.dim("  \u63D0\u793A: \u53EF\u7F16\u8F91\u4E0A\u8FF0\u6587\u4EF6\u81EA\u5B9A\u4E49\u81EA\u9009\u80A1\u5217\u8868")}
+      console.log(`${chalk5.green("\u2714")} \u5DF2\u751F\u6210\u81EA\u9009\u80A1\u914D\u7F6E: ${chalk5.dim(savedPath)}`);
+      console.log(`${chalk5.dim("  \u63D0\u793A: \u53EF\u7F16\u8F91\u4E0A\u8FF0\u6587\u4EF6\u81EA\u5B9A\u4E49\u81EA\u9009\u80A1\u5217\u8868")}
 `);
     }
     const freshResult = await loadAndValidate();
@@ -5533,7 +6147,7 @@ compdef _dskcode_completion dskcode`);
       });
       if (selectedGame) {
         console.log(`
-  \u542F\u52A8\u6E38\u620F: ${chalk4.green(selectedGame.name)}
+  \u542F\u52A8\u6E38\u620F: ${chalk5.green(selectedGame.name)}
 `);
         await selectedGame.play();
       }