klaude-code 1.2.17__py3-none-any.whl → 1.2.19__py3-none-any.whl

klaude_code/core/tool/file/read_tool.md

@@ -1,5 +1,6 @@
 Reads a file from the local filesystem. You can access any file directly by using this tool.
 Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+When you need to read an image, use this tool.
 
 Usage:
 - The file_path parameter must be an absolute path, not a relative path
@@ -11,4 +12,3 @@ Usage:
 - This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
 - You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful. 
 - If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
-- This tool does NOT support reading PDF files. Use a Python script with `pdfplumber` (for text/tables) or `pypdf` (for basic operations) to extract content from PDFs.

klaude_code/core/tool/file/read_tool.py

@@ -16,12 +16,6 @@ from klaude_code.core.tool.tool_context import get_current_file_tracker
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
-SYSTEM_REMINDER_MALICIOUS = (
-    "<system-reminder>\n"
-    "Whenever you read a file, you should consider whether it looks malicious. If it does, you MUST refuse to improve or augment the code. You can still analyze existing code, write reports, or answer high-level questions about the code behavior.\n"
-    "</system-reminder>"
-)
-
 _IMAGE_MIME_TYPES: dict[str, str] = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -51,6 +45,8 @@ class ReadSegmentResult:
     selected_lines: list[tuple[int, str]]
     selected_chars_count: int
     remaining_selected_beyond_cap: int
+    # For large file diagnostics: list of (start_line, end_line, char_count)
+    segment_char_stats: list[tuple[int, int, int]]
 
 
 def _read_segment(options: ReadOptions) -> ReadSegmentResult:
@@ -59,6 +55,13 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
     remaining_selected_beyond_cap = 0
     selected_lines: list[tuple[int, str]] = []
     selected_chars = 0
+
+    # Track char counts per 100-line segment for diagnostics
+    segment_size = 100
+    segment_char_stats: list[tuple[int, int, int]] = []
+    current_segment_start = options.offset
+    current_segment_chars = 0
+
     with open(options.file_path, encoding="utf-8", errors="replace") as f:
         for line_no, raw_line in enumerate(f, start=1):
             total_lines = line_no
@@ -74,16 +77,32 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
                     content[: options.char_limit_per_line]
                     + f" ... (more {truncated_chars} characters in this line are truncated)"
                 )
-            selected_chars += len(content) + 1
+            line_chars = len(content) + 1
+            selected_chars += line_chars
+            current_segment_chars += line_chars
+
+            # Check if we've completed a segment
+            if selected_lines_count % segment_size == 0:
+                segment_char_stats.append((current_segment_start, line_no, current_segment_chars))
+                current_segment_start = line_no + 1
+                current_segment_chars = 0
+
             if options.global_line_cap is None or len(selected_lines) < options.global_line_cap:
                 selected_lines.append((line_no, content))
             else:
                 remaining_selected_beyond_cap += 1
+
+    # Add the last partial segment if any
+    if current_segment_chars > 0 and selected_lines_count > 0:
+        last_line = options.offset + selected_lines_count - 1
+        segment_char_stats.append((current_segment_start, last_line, current_segment_chars))
+
     return ReadSegmentResult(
         total_lines=total_lines,
         selected_lines=selected_lines,
         selected_chars_count=selected_chars,
         remaining_selected_beyond_cap=remaining_selected_beyond_cap,
+        segment_char_stats=segment_char_stats,
     )
 
 
@@ -190,8 +209,9 @@ class ReadTool(ToolABC):
             return model.ToolResultItem(
                 status="error",
                 output=(
-                    "<tool_use_error>PDF files are not supported by this tool. "
-                    "Please use a Python script with `pdfplumber` to extract text/tables:\n\n"
+                    "<tool_use_error>PDF files are not supported by this tool.\n"
+                    "If there's an available skill for PDF, use it.\n"
+                    "Or use a Python script with `pdfplumber` to extract text/tables:\n\n"
                     "```python\n"
                     "# /// script\n"
                     '# dependencies = ["pdfplumber"]\n'
@@ -292,10 +312,21 @@ class ReadTool(ToolABC):
 
         # After limit/offset, if total selected chars exceed limit, error (only check if limits are enabled)
         if max_chars is not None and read_result.selected_chars_count > max_chars:
+            # Build segment statistics for better guidance
+            stats_lines: list[str] = []
+            for start, end, chars in read_result.segment_char_stats:
+                stats_lines.append(f"  Lines {start}-{end}: {chars} chars")
+            segment_stats_str = "\n".join(stats_lines) if stats_lines else "  (no segment data)"
+
             return model.ToolResultItem(
                 status="error",
                 output=(
-                    f"File content ({read_result.selected_chars_count} chars) exceeds maximum allowed tokens ({max_chars}). Please use offset and limit parameters to read specific portions of the file, or use the `rg` command to search for specific content."
+                    f"Selected file content {read_result.selected_chars_count} chars exceeds maximum allowed chars ({max_chars}).\n"
+                    f"File has {read_result.total_lines} total lines.\n\n"
+                    f"Character distribution by segment:\n{segment_stats_str}\n\n"
+                    f"Use offset and limit parameters to read specific portions. "
+                    f"For example: offset=1, limit=100 to read the first 100 lines. "
+                    f"Or use `rg` command to search for specific content."
                 ),
             )
 
@@ -304,8 +335,6 @@ class ReadTool(ToolABC):
         if read_result.remaining_selected_beyond_cap > 0:
             lines_out.append(f"... (more {read_result.remaining_selected_beyond_cap} lines are truncated)")
         read_result_str = "\n".join(lines_out)
-        # if read_result_str:
-        # read_result_str += "\n\n" + SYSTEM_REMINDER_MALICIOUS
 
         # Update FileTracker with last modified time
         _track_file_access(file_path)

klaude_code/core/tool/memory/skill_loader.py

@@ -132,20 +132,22 @@ class SkillLoader:
         for user_dir in self.USER_SKILLS_DIRS:
             expanded_dir = user_dir.expanduser()
             if expanded_dir.exists():
-                for skill_file in expanded_dir.rglob("SKILL.md"):
-                    skill = self.load_skill(skill_file, location="user")
-                    if skill:
-                        skills.append(skill)
-                        self.loaded_skills[skill.name] = skill
+                for pattern in ("SKILL.md", "skill.md"):
+                    for skill_file in expanded_dir.rglob(pattern):
+                        skill = self.load_skill(skill_file, location="user")
+                        if skill:
+                            skills.append(skill)
+                            self.loaded_skills[skill.name] = skill
 
         # Load project-level skills (override user skills if same name)
         project_dir = self.PROJECT_SKILLS_DIR.resolve()
         if project_dir.exists():
-            for skill_file in project_dir.rglob("SKILL.md"):
-                skill = self.load_skill(skill_file, location="project")
-                if skill:
-                    skills.append(skill)
-                    self.loaded_skills[skill.name] = skill
+            for pattern in ("SKILL.md", "skill.md"):
+                for skill_file in project_dir.rglob(pattern):
+                    skill = self.load_skill(skill_file, location="project")
+                    if skill:
+                        skills.append(skill)
+                        self.loaded_skills[skill.name] = skill
 
         # Log discovery summary
         if skills:

klaude_code/core/tool/shell/bash_tool.py

@@ -11,8 +11,28 @@ from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
-# Regex to strip ANSI escape sequences from command output
-_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-9;]*m")
+# Regex to strip ANSI and terminal control sequences from command output
+#
+# This is intentionally broader than just SGR color codes (e.g. "\x1b[31m").
+# Many interactive or TUI-style programs emit additional escape sequences
+# that move the cursor, clear the screen, or switch screen buffers
+# (CSI/OSC/DCS/APC/PM, etc). If these reach the Rich console, they can
+# corrupt the REPL layout. We therefore remove all of them before
+# rendering the output.
+_ANSI_ESCAPE_RE = re.compile(
+    r"""
+    \x1B
+    (?:
+        \[[0-?]*[ -/]*[@-~]         |  # CSI sequences
+        \][0-?]*.*?(?:\x07|\x1B\\) |  # OSC sequences
+        P.*?(?:\x07|\x1B\\)       |  # DCS sequences
+        _.*?(?:\x07|\x1B\\)       |  # APC sequences
+        \^.*?(?:\x07|\x1B\\)      |  # PM sequences
+        [@-Z\\-_]                      # 2-char sequences
+    )
+    """,
+    re.VERBOSE | re.DOTALL,
+)
 
 
 @register(tools.BASH)

klaude_code/core/tool/tool_registry.py

@@ -66,7 +66,7 @@ def load_agent_tools(
 
     # Main agent tools
     if "gpt-5" in model_name:
-        tool_names = [tools.BASH, tools.APPLY_PATCH, tools.UPDATE_PLAN]
+        tool_names = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
     elif "gemini-3" in model_name:
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE]
     else:

klaude_code/core/tool/tool_runner.py

@@ -9,6 +9,9 @@ from klaude_code.core.tool.truncation import truncate_tool_output
 from klaude_code.protocol import model, tools
 from klaude_code.protocol.sub_agent import is_sub_agent_tool
 
+# Tools that can run concurrently (IO-bound, no local state mutations)
+_CONCURRENT_TOOLS: frozenset[str] = frozenset({tools.WEB_SEARCH, tools.WEB_FETCH})
+
 
 async def run_tool(tool_call: model.ToolCallItem, registry: dict[str, type[ToolABC]]) -> model.ToolResultItem:
     """Execute a tool call and return the result.
@@ -89,8 +92,8 @@ class ToolExecutor:
     """Execute and coordinate a batch of tool calls for a single turn.
 
     The executor is responsible for:
-    - Partitioning tool calls into regular tools and sub-agent tools
-    - Running regular tools sequentially and sub-agent tools concurrently
+    - Partitioning tool calls into sequential and concurrent tools
+    - Running sequential tools one by one and concurrent tools in parallel
     - Emitting ToolCall/ToolResult events and tool side-effect events
     - Tracking unfinished calls so `cancel()` can synthesize cancellation results
     """
@@ -106,7 +109,7 @@ class ToolExecutor:
 
         self._unfinished_calls: dict[str, model.ToolCallItem] = {}
         self._call_event_emitted: set[str] = set()
-        self._sub_agent_tasks: set[asyncio.Task[list[ToolExecutorEvent]]] = set()
+        self._concurrent_tasks: set[asyncio.Task[list[ToolExecutorEvent]]] = set()
 
     async def run_tools(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[ToolExecutorEvent]:
         """Run the given tool calls and yield execution events.
@@ -119,10 +122,10 @@ class ToolExecutor:
         for tool_call in tool_calls:
             self._unfinished_calls[tool_call.call_id] = tool_call
 
-        regular_tool_calls, sub_agent_tool_calls = self._partition_tool_calls(tool_calls)
+        sequential_tool_calls, concurrent_tool_calls = self._partition_tool_calls(tool_calls)
 
-        # Run regular tools sequentially.
-        for tool_call in regular_tool_calls:
+        # Run sequential tools one by one.
+        for tool_call in sequential_tool_calls:
             tool_call_event = self._build_tool_call_started(tool_call)
             self._call_event_emitted.add(tool_call.call_id)
             yield tool_call_event
@@ -136,16 +139,16 @@ class ToolExecutor:
             for exec_event in result_events:
                 yield exec_event
 
-        # Run sub-agent tools concurrently.
-        if sub_agent_tool_calls:
+        # Run concurrent tools (sub-agents, web tools) in parallel.
+        if concurrent_tool_calls:
             execution_tasks: list[asyncio.Task[list[ToolExecutorEvent]]] = []
-            for tool_call in sub_agent_tool_calls:
+            for tool_call in concurrent_tool_calls:
                 tool_call_event = self._build_tool_call_started(tool_call)
                 self._call_event_emitted.add(tool_call.call_id)
                 yield tool_call_event
 
                 task = asyncio.create_task(self._run_single_tool_call(tool_call))
-                self._register_sub_agent_task(task)
+                self._register_concurrent_task(task)
                 execution_tasks.append(task)
 
             for task in asyncio.as_completed(execution_tasks):
@@ -165,7 +168,7 @@ class ToolExecutor:
     def cancel(self) -> Iterable[ToolExecutorEvent]:
         """Cancel unfinished tool calls and synthesize error results.
 
-        - Cancels any running sub-agent tool tasks so they stop emitting events.
+        - Cancels any running concurrent tool tasks so they stop emitting events.
         - For each unfinished tool call, yields a ToolExecutionCallStarted (if not
           already emitted for this turn) followed by a ToolExecutionResult with
           error status and a standard cancellation output. The corresponding
@@ -174,11 +177,11 @@ class ToolExecutor:
 
         events_to_yield: list[ToolExecutorEvent] = []
 
-        # Cancel running sub-agent tool tasks.
-        for task in list(self._sub_agent_tasks):
+        # Cancel running concurrent tool tasks.
+        for task in list(self._concurrent_tasks):
             if not task.done():
                 task.cancel()
-        self._sub_agent_tasks.clear()
+        self._concurrent_tasks.clear()
 
         if not self._unfinished_calls:
             return events_to_yield
@@ -203,11 +206,11 @@ class ToolExecutor:
 
         return events_to_yield
 
-    def _register_sub_agent_task(self, task: asyncio.Task[list[ToolExecutorEvent]]) -> None:
-        self._sub_agent_tasks.add(task)
+    def _register_concurrent_task(self, task: asyncio.Task[list[ToolExecutorEvent]]) -> None:
+        self._concurrent_tasks.add(task)
 
         def _cleanup(completed: asyncio.Task[list[ToolExecutorEvent]]) -> None:
-            self._sub_agent_tasks.discard(completed)
+            self._concurrent_tasks.discard(completed)
 
         task.add_done_callback(_cleanup)
 
@@ -215,14 +218,14 @@ class ToolExecutor:
     def _partition_tool_calls(
         tool_calls: list[model.ToolCallItem],
     ) -> tuple[list[model.ToolCallItem], list[model.ToolCallItem]]:
-        regular_tool_calls: list[model.ToolCallItem] = []
-        sub_agent_tool_calls: list[model.ToolCallItem] = []
+        sequential_tool_calls: list[model.ToolCallItem] = []
+        concurrent_tool_calls: list[model.ToolCallItem] = []
         for tool_call in tool_calls:
-            if is_sub_agent_tool(tool_call.name):
-                sub_agent_tool_calls.append(tool_call)
+            if is_sub_agent_tool(tool_call.name) or tool_call.name in _CONCURRENT_TOOLS:
+                concurrent_tool_calls.append(tool_call)
             else:
-                regular_tool_calls.append(tool_call)
-        return regular_tool_calls, sub_agent_tool_calls
+                sequential_tool_calls.append(tool_call)
+        return sequential_tool_calls, concurrent_tool_calls
 
     def _build_tool_call_started(self, tool_call: model.ToolCallItem) -> ToolExecutionCallStarted:
         return ToolExecutionCallStarted(tool_call=tool_call)

klaude_code/core/tool/truncation.py

@@ -21,6 +21,15 @@ class TruncationResult:
     truncated_length: int = 0
 
 
+FILE_SAVED_PATTERN = re.compile(r"<file_saved>([^<]+)</file_saved>")
+
+
+def _extract_saved_file_path(output: str) -> str | None:
+    """Extract file path from <file_saved> tag if present."""
+    match = FILE_SAVED_PATTERN.search(output)
+    return match.group(1) if match else None
+
+
 def _extract_url_filename(url: str) -> str:
     """Extract a safe filename from a URL."""
     parsed = urlparse(url)
@@ -116,24 +125,29 @@ class SmartTruncationStrategy(TruncationStrategy):
         if original_length <= self.max_length:
             return TruncationResult(output=output, was_truncated=False, original_length=original_length)
 
-        # Save full output to file
-        saved_file_path = self._save_to_file(output, tool_call)
+        # Check if file was already saved (e.g., by WebFetch)
+        existing_file_path = _extract_saved_file_path(output)
+        saved_file_path = existing_file_path or self._save_to_file(output, tool_call)
+
+        # Strip existing <file_saved> tag to avoid duplication in head/tail
+        content_to_truncate = FILE_SAVED_PATTERN.sub("", output).lstrip("\n") if existing_file_path else output
+        content_length = len(content_to_truncate)
 
-        truncated_length = original_length - self.head_chars - self.tail_chars
-        head_content = output[: self.head_chars]
-        tail_content = output[-self.tail_chars :]
+        truncated_length = content_length - self.head_chars - self.tail_chars
+        head_content = content_to_truncate[: self.head_chars]
+        tail_content = content_to_truncate[-self.tail_chars :]
 
         # Build truncated output with file info
         if saved_file_path:
             header = (
-                f"<system-reminder>Output truncated: {truncated_length} chars hidden. "
-                f"Full tool output saved to {saved_file_path}. "
-                f"Use Read with limit+offset or rg/grep to inspect.\n"
+                f"<system-reminder>Output truncated ({truncated_length} chars hidden) to reduce context usage. "
+                f"Full content saved to <file_saved>{saved_file_path}</file_saved>. "
+                f"Use Read(offset, limit) or rg to inspect if needed. "
                 f"Showing first {self.head_chars} and last {self.tail_chars} chars:</system-reminder>\n\n"
             )
         else:
             header = (
-                f"<system-reminder>Output truncated: {truncated_length} chars hidden. "
+                f"<system-reminder>Output truncated ({truncated_length} chars hidden) to reduce context usage. "
                 f"Showing first {self.head_chars} and last {self.tail_chars} chars:</system-reminder>\n\n"
             )
 

klaude_code/core/tool/web/web_fetch_tool.md

@@ -5,4 +5,4 @@ The tool automatically processes the response based on Content-Type:
 - JSON responses are formatted with indentation
 - Markdown and other text content is returned as-is
 
-Use this tool to retrieve web page content for analysis.
+Content is always saved to a local file. The file path is included at the start of the output in a `<file_saved>` tag. For large content that gets truncated, you can read the saved file directly.

klaude_code/core/tool/web/web_fetch_tool.py

@@ -1,18 +1,23 @@
 import asyncio
 import json
+import re
+import time
 import urllib.error
 import urllib.request
 from http.client import HTTPResponse
 from pathlib import Path
+from urllib.parse import urlparse
 
 from pydantic import BaseModel
 
+from klaude_code import const
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
 DEFAULT_TIMEOUT_SEC = 30
 DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; KlaudeCode/1.0)"
+WEB_FETCH_SAVE_DIR = Path(const.TOOL_OUTPUT_TRUNCATION_DIR) / "web"
 
 
 def _extract_content_type(response: HTTPResponse) -> str:
@@ -43,6 +48,30 @@ def _format_json(text: str) -> str:
         return text
 
 
+def _extract_url_filename(url: str) -> str:
+    """Extract a safe filename from a URL."""
+    parsed = urlparse(url)
+    host = parsed.netloc.replace(".", "_").replace(":", "_")
+    path = parsed.path.strip("/").replace("/", "_")
+    name = f"{host}_{path}" if path else host
+    name = re.sub(r"[^a-zA-Z0-9_\-]", "_", name)
+    return name[:80] if len(name) > 80 else name
+
+
+def _save_web_content(url: str, content: str) -> str | None:
+    """Save web content to file. Returns file path or None on failure."""
+    try:
+        WEB_FETCH_SAVE_DIR.mkdir(parents=True, exist_ok=True)
+        timestamp = int(time.time())
+        identifier = _extract_url_filename(url)
+        filename = f"{identifier}-{timestamp}.md"
+        file_path = WEB_FETCH_SAVE_DIR / filename
+        file_path.write_text(content, encoding="utf-8")
+        return str(file_path)
+    except OSError:
+        return None
+
+
 def _process_content(content_type: str, text: str) -> str:
     """Process content based on Content-Type header."""
     if content_type == "text/html":
@@ -127,9 +156,15 @@ class WebFetchTool(ToolABC):
             content_type, text = await asyncio.to_thread(_fetch_url, url)
             processed = _process_content(content_type, text)
 
+            # Always save content to file
+            saved_path = _save_web_content(url, processed)
+
+            # Build output with file path info
+            output = f"<file_saved>{saved_path}</file_saved>\n\n{processed}" if saved_path else processed
+
             return model.ToolResultItem(
                 status="success",
-                output=processed,
+                output=output,
             )
 
         except urllib.error.HTTPError as e:

klaude_code/core/turn.py

@@ -100,6 +100,8 @@ class TurnExecutor:
         self._context = context
         self._tool_executor: ToolExecutor | None = None
         self._turn_result: TurnResult | None = None
+        self._assistant_delta_buffer: list[str] = []
+        self._assistant_response_id: str | None = None
 
     @property
     def report_back_result(self) -> str | None:
@@ -138,6 +140,7 @@ class TurnExecutor:
     def cancel(self) -> list[events.Event]:
         """Cancel running tools and return any resulting events."""
         ui_events: list[events.Event] = []
+        self._persist_partial_assistant_on_cancel()
         if self._tool_executor is not None:
             for exec_event in self._tool_executor.cancel():
                 for ui_event in build_events_from_tool_executor_event(self._context.session_ctx.session_id, exec_event):
@@ -227,6 +230,9 @@ class TurnExecutor:
                         session_id=session_ctx.session_id,
                     )
                 case model.AssistantMessageDelta() as item:
+                    if item.response_id:
+                        self._assistant_response_id = item.response_id
+                    self._assistant_delta_buffer.append(item.content)
                     yield events.AssistantMessageDeltaEvent(
                         content=item.content,
                         response_id=item.response_id,
@@ -274,6 +280,8 @@ class TurnExecutor:
             session_ctx.append_history([turn_result.assistant_message])
         if turn_result.tool_calls:
             session_ctx.append_history(turn_result.tool_calls)
+        self._assistant_delta_buffer.clear()
+        self._assistant_response_id = None
 
     async def _run_tool_executor(self, tool_calls: list[model.ToolCallItem]) -> AsyncGenerator[events.Event]:
         """Run tools for the turn and translate executor events to UI events."""
@@ -292,3 +300,23 @@ class TurnExecutor:
                         yield ui_event
             finally:
                 self._tool_executor = None
+
+    def _persist_partial_assistant_on_cancel(self) -> None:
+        """Persist streamed assistant text when a turn is interrupted.
+
+        Reasoning and tool calls are intentionally discarded on interrupt; only
+        the assistant message text collected so far is saved so it appears in
+        subsequent history/context.
+        """
+
+        if not self._assistant_delta_buffer:
+            return
+        partial_text = "".join(self._assistant_delta_buffer) + "<system interrupted by user>"
+        if not partial_text:
+            return
+        message_item = model.AssistantMessageItem(
+            content=partial_text,
+            response_id=self._assistant_response_id,
+        )
+        self._context.session_ctx.append_history([message_item])
+        self._assistant_delta_buffer.clear()

klaude_code/llm/anthropic/client.py

@@ -1,4 +1,5 @@
 import json
+import os
 from collections.abc import AsyncGenerator
 from typing import override
 
@@ -61,11 +62,20 @@ def build_payload(param: llm_param.LLMCallParameter) -> MessageCreateParamsStrea
 class AnthropicClient(LLMClientABC):
     def __init__(self, config: llm_param.LLMConfigParameter):
         super().__init__(config)
-        client = anthropic.AsyncAnthropic(
-            api_key=config.api_key,
-            base_url=config.base_url,
-            timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
-        )
+        # Remove ANTHROPIC_AUTH_TOKEN env var to prevent anthropic SDK from adding
+        # Authorization: Bearer header that may conflict with third-party APIs
+        # (e.g., deepseek, moonshot) that use Authorization header for authentication.
+        # The API key will be sent via X-Api-Key header instead.
+        saved_auth_token = os.environ.pop("ANTHROPIC_AUTH_TOKEN", None)
+        try:
+            client = anthropic.AsyncAnthropic(
+                api_key=config.api_key,
+                base_url=config.base_url,
+                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+            )
+        finally:
+            if saved_auth_token is not None:
+                os.environ["ANTHROPIC_AUTH_TOKEN"] = saved_auth_token
         self.client: anthropic.AsyncAnthropic = client
 
     @classmethod
@@ -120,35 +130,38 @@ class AnthropicClient(LLMClientABC):
                     case BetaRawContentBlockDeltaEvent() as event:
                         match event.delta:
                             case BetaThinkingDelta() as delta:
-                                metadata_tracker.record_token()
+                                if delta.thinking:
+                                    metadata_tracker.record_token()
                                 accumulated_thinking.append(delta.thinking)
                                 yield model.ReasoningTextDelta(
                                     content=delta.thinking,
                                     response_id=response_id,
                                 )
                             case BetaSignatureDelta() as delta:
-                                metadata_tracker.record_token()
                                 yield model.ReasoningEncryptedItem(
                                     encrypted_content=delta.signature,
                                     response_id=response_id,
                                     model=str(param.model),
                                 )
                             case BetaTextDelta() as delta:
-                                metadata_tracker.record_token()
+                                if delta.text:
+                                    metadata_tracker.record_token()
                                 accumulated_content.append(delta.text)
                                 yield model.AssistantMessageDelta(
                                     content=delta.text,
                                     response_id=response_id,
                                 )
                             case BetaInputJSONDelta() as delta:
-                                metadata_tracker.record_token()
                                 if current_tool_inputs is not None:
+                                    if delta.partial_json:
+                                        metadata_tracker.record_token()
                                     current_tool_inputs.append(delta.partial_json)
                             case _:
                                 pass
                     case BetaRawContentBlockStartEvent() as event:
                         match event.content_block:
                             case BetaToolUseBlock() as block:
+                                metadata_tracker.record_token()
                                 yield model.ToolCallStartItem(
                                     response_id=response_id,
                                     call_id=block.id,
@@ -161,6 +174,7 @@ class AnthropicClient(LLMClientABC):
                                 pass
                     case BetaRawContentBlockStopEvent() as event:
                         if len(accumulated_thinking) > 0:
+                            metadata_tracker.record_token()
                             full_thinking = "".join(accumulated_thinking)
                             yield model.ReasoningTextItem(
                                 content=full_thinking,
@@ -169,12 +183,14 @@ class AnthropicClient(LLMClientABC):
                             )
                             accumulated_thinking.clear()
                         if len(accumulated_content) > 0:
+                            metadata_tracker.record_token()
                             yield model.AssistantMessageItem(
                                 content="".join(accumulated_content),
                                 response_id=response_id,
                             )
                             accumulated_content.clear()
                         if current_tool_name and current_tool_call_id:
+                            metadata_tracker.record_token()
                             yield model.ToolCallItem(
                                 name=current_tool_name,
                                 call_id=current_tool_call_id,

klaude_code/llm/openai_compatible/client.py

@@ -23,7 +23,7 @@ def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreatePa
 
     extra_body: dict[str, object] = {}
 
-    if param.thinking:
+    if param.thinking and param.thinking.type == "enabled":
         extra_body["thinking"] = {
             "type": param.thinking.type,
             "budget": param.thinking.budget_tokens,
@@ -182,7 +182,10 @@ class OpenAICompatibleClient(LLMClientABC):
             yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
 
         # Finalize
-        for item in state.flush_all():
+        flushed_items = state.flush_all()
+        if flushed_items:
+            metadata_tracker.record_token()
+        for item in flushed_items:
             yield item
 
         metadata_tracker.set_response_id(state.response_id)