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

klaude_code/core/task.py

@@ -2,13 +2,13 @@ from __future__ import annotations
 
 import asyncio
 import time
-from collections.abc import AsyncGenerator, Callable, MutableMapping, Sequence
+from collections.abc import AsyncGenerator, Callable, Sequence
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 
 from klaude_code import const
 from klaude_code.core.reminders import Reminder
-from klaude_code.core.tool import TodoContext, ToolABC
+from klaude_code.core.tool import FileTracker, TodoContext, ToolABC
 from klaude_code.core.turn import TurnError, TurnExecutionContext, TurnExecutor
 from klaude_code.protocol import events, model
 from klaude_code.trace import DebugType, log_debug
@@ -100,7 +100,7 @@ class SessionContext:
     session_id: str
     get_conversation_history: Callable[[], list[model.ConversationItem]]
     append_history: Callable[[Sequence[model.ConversationItem]], None]
-    file_tracker: MutableMapping[str, float]
+    file_tracker: FileTracker
     todo_context: TodoContext
 
 
@@ -149,8 +149,7 @@ class TaskExecutor:
             session_id=session_ctx.session_id,
             sub_agent_state=ctx.sub_agent_state,
         )
-
-        session_ctx.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
+        del user_input  # Persisted by the operation handler before launching the task.
 
         profile = ctx.profile
         metadata_accumulator = MetadataAccumulator(model_name=profile.llm_client.model_name)

klaude_code/core/tool/__init__.py

@@ -15,6 +15,7 @@ from .todo.todo_write_tool import TodoWriteTool
 from .todo.update_plan_tool import UpdatePlanTool
 from .tool_abc import ToolABC
 from .tool_context import (
+    FileTracker,
     TodoContext,
     ToolContextToken,
     build_todo_context,
@@ -36,6 +37,7 @@ __all__ = [
     "BashTool",
     "DiffError",
     "EditTool",
+    "FileTracker",
     "MemoryTool",
     "MermaidTool",
     "MultiEditTool",

klaude_code/core/tool/file/apply_patch_tool.py

@@ -80,7 +80,9 @@ class ApplyPatchHandler:
 
             if file_tracker is not None:
                 with contextlib.suppress(Exception):  # pragma: no cover - file tracker best-effort
-                    file_tracker[resolved] = Path(resolved).stat().st_mtime
+                    existing = file_tracker.get(resolved)
+                    is_mem = existing.is_memory if existing else False
+                    file_tracker[resolved] = model.FileStatus(mtime=Path(resolved).stat().st_mtime, is_memory=is_mem)
 
         def remove_fn(path: str) -> None:
             resolved = resolve_path(path)

klaude_code/core/tool/file/edit_tool.py

@@ -119,8 +119,8 @@ class EditTool(ToolABC):
                 output=("File has not been read yet. Read it first before writing to it."),
             )
         if file_tracker is not None:
-            tracked = file_tracker.get(file_path)
-            if tracked is None:
+            tracked_status = file_tracker.get(file_path)
+            if tracked_status is None:
                 return model.ToolResultItem(
                     status="error",
                     output=("File has not been read yet. Read it first before writing to it."),
@@ -128,8 +128,8 @@ class EditTool(ToolABC):
             try:
                 current_mtime = Path(file_path).stat().st_mtime
             except Exception:
-                current_mtime = tracked
-            if current_mtime != tracked:
+                current_mtime = tracked_status.mtime
+            if current_mtime != tracked_status.mtime:
                 return model.ToolResultItem(
                     status="error",
                     output=(
@@ -193,7 +193,9 @@ class EditTool(ToolABC):
         # Update tracker with new mtime
         if file_tracker is not None:
             with contextlib.suppress(Exception):
-                file_tracker[file_path] = Path(file_path).stat().st_mtime
+                existing = file_tracker.get(file_path)
+                is_mem = existing.is_memory if existing else False
+                file_tracker[file_path] = model.FileStatus(mtime=Path(file_path).stat().st_mtime, is_memory=is_mem)
 
         # Build output message
         if args.replace_all:

klaude_code/core/tool/file/multi_edit_tool.py

@@ -92,8 +92,8 @@ class MultiEditTool(ToolABC):
         # FileTracker check:
         if file_exists(file_path):
             if file_tracker is not None:
-                tracked = file_tracker.get(file_path)
-                if tracked is None:
+                tracked_status = file_tracker.get(file_path)
+                if tracked_status is None:
                     return model.ToolResultItem(
                         status="error",
                         output=("File has not been read yet. Read it first before writing to it."),
@@ -101,8 +101,8 @@ class MultiEditTool(ToolABC):
                 try:
                     current_mtime = Path(file_path).stat().st_mtime
                 except Exception:
-                    current_mtime = tracked
-                if current_mtime != tracked:
+                    current_mtime = tracked_status.mtime
+                if current_mtime != tracked_status.mtime:
                     return model.ToolResultItem(
                         status="error",
                         output=(
@@ -164,7 +164,9 @@ class MultiEditTool(ToolABC):
         # Update tracker
         if file_tracker is not None:
             with contextlib.suppress(Exception):
-                file_tracker[file_path] = Path(file_path).stat().st_mtime
+                existing = file_tracker.get(file_path)
+                is_mem = existing.is_memory if existing else False
+                file_tracker[file_path] = model.FileStatus(mtime=Path(file_path).stat().st_mtime, is_memory=is_mem)
 
         # Build output message
         lines = [f"Applied {len(args.edits)} edits to {file_path}:"]

klaude_code/core/tool/file/read_tool.py

@@ -106,12 +106,15 @@ def _read_segment(options: ReadOptions) -> ReadSegmentResult:
     )
 
 
-def _track_file_access(file_path: str) -> None:
+def _track_file_access(file_path: str, *, is_memory: bool = False) -> None:
     file_tracker = get_current_file_tracker()
     if file_tracker is None or not file_exists(file_path) or is_directory(file_path):
         return
     with contextlib.suppress(Exception):
-        file_tracker[file_path] = Path(file_path).stat().st_mtime
+        existing = file_tracker.get(file_path)
+        # Preserve is_memory flag if already set
+        is_mem = is_memory or (existing.is_memory if existing else False)
+        file_tracker[file_path] = model.FileStatus(mtime=Path(file_path).stat().st_mtime, is_memory=is_mem)
 
 
 def _is_supported_image_file(file_path: str) -> bool:

klaude_code/core/tool/file/write_tool.py

@@ -64,10 +64,10 @@ class WriteTool(ToolABC):
         exists = file_exists(file_path)
 
         if exists:
-            tracked_mtime: float | None = None
+            tracked_status: model.FileStatus | None = None
             if file_tracker is not None:
-                tracked_mtime = file_tracker.get(file_path)
-            if tracked_mtime is None:
+                tracked_status = file_tracker.get(file_path)
+            if tracked_status is None:
                 return model.ToolResultItem(
                     status="error",
                     output=("File has not been read yet. Read it first before writing to it."),
@@ -75,8 +75,8 @@ class WriteTool(ToolABC):
             try:
                 current_mtime = Path(file_path).stat().st_mtime
             except Exception:
-                current_mtime = tracked_mtime
-            if current_mtime != tracked_mtime:
+                current_mtime = tracked_status.mtime
+            if current_mtime != tracked_status.mtime:
                 return model.ToolResultItem(
                     status="error",
                     output=(
@@ -100,7 +100,9 @@ class WriteTool(ToolABC):
 
         if file_tracker is not None:
             with contextlib.suppress(Exception):
-                file_tracker[file_path] = Path(file_path).stat().st_mtime
+                existing = file_tracker.get(file_path)
+                is_mem = existing.is_memory if existing else False
+                file_tracker[file_path] = model.FileStatus(mtime=Path(file_path).stat().st_mtime, is_memory=is_mem)
 
         # Build diff between previous and new content
         after = args.content

klaude_code/core/tool/shell/bash_tool.py

@@ -1,7 +1,11 @@
 import asyncio
+import contextlib
+import os
 import re
+import signal
 import subprocess
 from pathlib import Path
+from typing import Any
 
 from pydantic import BaseModel
 
@@ -87,22 +91,94 @@ class BashTool(ToolABC):
 
         # Run the command using bash -lc so shell semantics work (pipes, &&, etc.)
         # Capture stdout/stderr, respect timeout, and return a ToolMessage.
+        #
+        # Important: this tool is intentionally non-interactive.
+        # - Always detach stdin (DEVNULL) so interactive programs can't steal REPL input.
+        # - Always disable pagers/editors to avoid launching TUI subprocesses that can
+        #   leave the terminal in a bad state.
         cmd = ["bash", "-lc", args.command]
         timeout_sec = max(0.0, args.timeout_ms / 1000.0)
 
+        env = os.environ.copy()
+        env.update(
+            {
+                # Avoid blocking on git/jj prompts.
+                "GIT_TERMINAL_PROMPT": "0",
+                # Avoid pagers.
+                "PAGER": "cat",
+                "GIT_PAGER": "cat",
+                # Avoid opening editors.
+                "EDITOR": "true",
+                "VISUAL": "true",
+                "GIT_EDITOR": "true",
+                "JJ_EDITOR": "true",
+                # Encourage non-interactive output.
+                "TERM": "dumb",
+            }
+        )
+
+        async def _terminate_process(proc: asyncio.subprocess.Process) -> None:
+            # Best-effort termination. Ensure we don't hang on cancellation.
+            if proc.returncode is not None:
+                return
+
+            try:
+                if os.name == "posix":
+                    os.killpg(proc.pid, signal.SIGTERM)
+                else:
+                    proc.terminate()
+            except ProcessLookupError:
+                return
+            except Exception:
+                # Fall back to kill below.
+                pass
+
+            with contextlib.suppress(Exception):
+                await asyncio.wait_for(proc.wait(), timeout=1.0)
+                return
+
+            # Escalate to hard kill if it didn't exit quickly.
+            with contextlib.suppress(Exception):
+                if os.name == "posix":
+                    os.killpg(proc.pid, signal.SIGKILL)
+                else:
+                    proc.kill()
+            with contextlib.suppress(Exception):
+                await asyncio.wait_for(proc.wait(), timeout=1.0)
+
         try:
-            completed = await asyncio.to_thread(
-                subprocess.run,
-                cmd,
-                capture_output=True,
-                text=True,
-                timeout=timeout_sec,
-                check=False,
-            )
+            # Create a dedicated process group so we can terminate the whole tree.
+            # (macOS/Linux support start_new_session; Windows does not.)
+            kwargs: dict[str, Any] = {
+                "stdin": asyncio.subprocess.DEVNULL,
+                "stdout": asyncio.subprocess.PIPE,
+                "stderr": asyncio.subprocess.PIPE,
+                "env": env,
+            }
+            if os.name == "posix":
+                kwargs["start_new_session"] = True
+            elif os.name == "nt":  # pragma: no cover
+                kwargs["creationflags"] = getattr(subprocess, "CREATE_NEW_PROCESS_GROUP", 0)
 
-            stdout = _ANSI_ESCAPE_RE.sub("", completed.stdout or "")
-            stderr = _ANSI_ESCAPE_RE.sub("", completed.stderr or "")
-            rc = completed.returncode
+            proc = await asyncio.create_subprocess_exec(*cmd, **kwargs)
+            try:
+                stdout_b, stderr_b = await asyncio.wait_for(proc.communicate(), timeout=timeout_sec)
+            except TimeoutError:
+                with contextlib.suppress(Exception):
+                    await _terminate_process(proc)
+                return model.ToolResultItem(
+                    status="error",
+                    output=f"Timeout after {args.timeout_ms} ms running: {args.command}",
+                )
+            except asyncio.CancelledError:
+                # Ensure subprocess is stopped and propagate cancellation.
+                with contextlib.suppress(Exception):
+                    await asyncio.shield(_terminate_process(proc))
+                raise
+
+            stdout = _ANSI_ESCAPE_RE.sub("", (stdout_b or b"").decode(errors="replace"))
+            stderr = _ANSI_ESCAPE_RE.sub("", (stderr_b or b"").decode(errors="replace"))
+            rc = proc.returncode
 
             if rc == 0:
                 output = stdout if stdout else ""
@@ -125,17 +201,14 @@ class BashTool(ToolABC):
                     status="error",
                     output=combined.strip(),
                 )
-
-        except subprocess.TimeoutExpired:
-            return model.ToolResultItem(
-                status="error",
-                output=f"Timeout after {args.timeout_ms} ms running: {args.command}",
-            )
         except FileNotFoundError:
             return model.ToolResultItem(
                 status="error",
                 output="bash not found on system path",
             )
+        except asyncio.CancelledError:
+            # Propagate cooperative cancellation so outer layers can handle interrupts correctly.
+            raise
         except Exception as e:  # safeguard against unexpected failures
             return model.ToolResultItem(
                 status="error",

klaude_code/core/tool/sub_agent_tool.py

@@ -10,7 +10,7 @@ import asyncio
 import json
 from typing import TYPE_CHECKING, ClassVar
 
-from klaude_code.core.tool.tool_abc import ToolABC
+from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy, ToolMetadata
 from klaude_code.core.tool.tool_context import current_run_subtask_callback
 from klaude_code.protocol import llm_param, model
 
@@ -36,6 +36,10 @@ class SubAgentTool(ToolABC):
             {"_profile": profile},
         )
 
+    @classmethod
+    def metadata(cls) -> ToolMetadata:
+        return ToolMetadata(concurrency_policy=ToolConcurrencyPolicy.CONCURRENT, has_side_effects=True)
+
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:
         profile = cls._profile

klaude_code/core/tool/tool_abc.py

@@ -1,5 +1,7 @@
 import string
 from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
 from pathlib import Path
 
 from klaude_code.protocol import llm_param, model
@@ -14,6 +16,10 @@ def load_desc(path: Path, substitutions: dict[str, str] | None = None) -> str:
 
 
 class ToolABC(ABC):
+    @classmethod
+    def metadata(cls) -> "ToolMetadata":
+        return ToolMetadata()
+
     @classmethod
     @abstractmethod
     def schema(cls) -> llm_param.ToolSchema:
@@ -23,3 +29,15 @@ class ToolABC(ABC):
     @abstractmethod
     async def call(cls, arguments: str) -> model.ToolResultItem:
         raise NotImplementedError
+
+
+class ToolConcurrencyPolicy(str, Enum):
+    SEQUENTIAL = "sequential"
+    CONCURRENT = "concurrent"
+
+
+@dataclass(frozen=True)
+class ToolMetadata:
+    concurrency_policy: ToolConcurrencyPolicy = ToolConcurrencyPolicy.SEQUENTIAL
+    has_side_effects: bool = False
+    requires_tool_context: bool = True

klaude_code/core/tool/tool_context.py

@@ -9,6 +9,8 @@ from klaude_code.protocol import model
 from klaude_code.protocol.sub_agent import SubAgentResult
 from klaude_code.session.session import Session
 
+type FileTracker = MutableMapping[str, model.FileStatus]
+
 
 @dataclass
 class TodoContext:
@@ -44,15 +46,13 @@ class ToolContextToken:
     finishes running.
     """
 
-    file_tracker_token: Token[MutableMapping[str, float] | None] | None
+    file_tracker_token: Token[FileTracker | None] | None
     todo_token: Token[TodoContext | None] | None
 
 
 # Holds the current file tracker mapping for tool execution context.
 # Set by Agent/Reminder right before invoking a tool.
-current_file_tracker_var: ContextVar[MutableMapping[str, float] | None] = ContextVar(
-    "current_file_tracker", default=None
-)
+current_file_tracker_var: ContextVar[FileTracker | None] = ContextVar("current_file_tracker", default=None)
 
 
 # Holds the todo access context for tools.
@@ -83,7 +83,7 @@ def reset_tool_context(token: ToolContextToken) -> None:
 
 
 @contextmanager
-def tool_context(file_tracker: MutableMapping[str, float], todo_ctx: TodoContext) -> Generator[ToolContextToken]:
+def tool_context(file_tracker: FileTracker, todo_ctx: TodoContext) -> Generator[ToolContextToken]:
     """Context manager for setting and resetting tool execution context."""
 
     file_tracker_token = current_file_tracker_var.set(file_tracker)
@@ -102,7 +102,7 @@ def build_todo_context(session: Session) -> TodoContext:
     return TodoContext(get_todos=store.get, set_todos=store.set)
 
 
-def get_current_file_tracker() -> MutableMapping[str, float] | None:
+def get_current_file_tracker() -> FileTracker | None:
     """Return the current file tracker mapping for this tool context."""
 
     return current_file_tracker_var.get()

klaude_code/core/tool/tool_runner.py

@@ -4,13 +4,9 @@ from dataclasses import dataclass
 
 from klaude_code import const
 from klaude_code.core.tool.report_back_tool import ReportBackTool
-from klaude_code.core.tool.tool_abc import ToolABC
+from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy
 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:
@@ -214,14 +210,18 @@ class ToolExecutor:
 
         task.add_done_callback(_cleanup)
 
-    @staticmethod
     def _partition_tool_calls(
+        self,
         tool_calls: list[model.ToolCallItem],
     ) -> tuple[list[model.ToolCallItem], 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) or tool_call.name in _CONCURRENT_TOOLS:
+            tool_cls = self._registry.get(tool_call.name)
+            policy = (
+                tool_cls.metadata().concurrency_policy if tool_cls is not None else ToolConcurrencyPolicy.SEQUENTIAL
+            )
+            if policy == ToolConcurrencyPolicy.CONCURRENT:
                 concurrent_tool_calls.append(tool_call)
             else:
                 sequential_tool_calls.append(tool_call)

klaude_code/core/tool/web/mermaid_tool.md

@@ -17,5 +17,31 @@ Diagrams are especially valuable for visualizing:
 - Sequence and timing of operations
 - Decision trees and conditional logic
 
+# Syntax
+- ALWAYS wrap node labels in double quotes, especially when they contain spaces, special characters, or non-ASCII text
+- This applies to all node types: regular nodes, subgraph titles, and edge labels
+
+Examples:
+```mermaid
+graph LR
+  A["User Input"] --> B["Process Data"]
+  B --> C["Output Result"]
+```
+
+```mermaid
+flowchart TD
+  subgraph auth["Authentication Module"]
+    login["Login Service"]
+    oauth["OAuth Provider"]
+  end
+```
+
+```mermaid
+sequenceDiagram
+  participant client as "Web Client"
+  participant server as "API Server"
+  client ->> server: "Send Request"
+```
+
 # Styling
 - When defining custom classDefs, always define fill color, stroke color, and text color ("fill", "stroke", "color") explicitly

klaude_code/core/tool/web/web_fetch_tool.py

@@ -6,12 +6,12 @@ import urllib.error
 import urllib.request
 from http.client import HTTPResponse
 from pathlib import Path
-from urllib.parse import urlparse
+from urllib.parse import quote, urlparse, urlunparse
 
 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_abc import ToolABC, ToolConcurrencyPolicy, ToolMetadata, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
@@ -20,15 +20,70 @@ 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:
-    """Extract the base content type without charset parameters."""
-    content_type = response.getheader("Content-Type", "")
-    return content_type.split(";")[0].strip().lower()
+def _encode_url(url: str) -> str:
+    """Encode non-ASCII characters in URL to make it safe for HTTP requests."""
+    parsed = urlparse(url)
+    encoded_path = quote(parsed.path, safe="/-_.~")
+    encoded_query = quote(parsed.query, safe="=&-_.~")
+    # Handle IDN (Internationalized Domain Names) by encoding to punycode
+    try:
+        netloc = parsed.netloc.encode("idna").decode("ascii")
+    except UnicodeError:
+        netloc = parsed.netloc
+    return urlunparse((parsed.scheme, netloc, encoded_path, parsed.params, encoded_query, parsed.fragment))
+
+
+def _extract_content_type_and_charset(response: HTTPResponse) -> tuple[str, str | None]:
+    """Extract the base content type and charset from Content-Type header."""
+    content_type_header = response.getheader("Content-Type", "")
+    parts = content_type_header.split(";")
+    content_type = parts[0].strip().lower()
+
+    charset = None
+    for part in parts[1:]:
+        part = part.strip()
+        if part.lower().startswith("charset="):
+            charset = part[8:].strip().strip("\"'")
+            break
+
+    return content_type, charset
+
+
+def _detect_encoding(data: bytes, declared_charset: str | None) -> str:
+    """Detect the encoding of the data."""
+    # 1. Use declared charset from HTTP header if available
+    if declared_charset:
+        return declared_charset
+
+    # 2. Try to detect from HTML meta tags (check first 2KB)
+    head = data[:2048].lower()
+    # <meta charset="xxx">
+    if match := re.search(rb'<meta[^>]+charset=["\']?([^"\'\s>]+)', head):
+        return match.group(1).decode("ascii", errors="ignore")
+    # <meta http-equiv="Content-Type" content="text/html; charset=xxx">
+    if match := re.search(rb'content=["\'][^"\']*charset=([^"\'\s;]+)', head):
+        return match.group(1).decode("ascii", errors="ignore")
+
+    # 3. Use chardet for automatic detection
+    import chardet
 
+    result = chardet.detect(data)
+    if result["encoding"] and result["confidence"] and result["confidence"] > 0.7:
+        return result["encoding"]
 
-def _validate_utf8(data: bytes) -> str:
-    """Validate and decode bytes as UTF-8."""
-    return data.decode("utf-8")
+    # 4. Default to UTF-8
+    return "utf-8"
+
+
+def _decode_content(data: bytes, declared_charset: str | None) -> str:
+    """Decode bytes to string with automatic encoding detection."""
+    encoding = _detect_encoding(data, declared_charset)
+
+    try:
+        return data.decode(encoding)
+    except (UnicodeDecodeError, LookupError):
+        # Fallback: try UTF-8 with replacement for invalid chars
+        return data.decode("utf-8", errors="replace")
 
 
 def _convert_html_to_markdown(html: str) -> str:
@@ -98,17 +153,22 @@ def _fetch_url(url: str, timeout: int = DEFAULT_TIMEOUT_SEC) -> tuple[str, str]:
         "Accept": "text/markdown, */*",
         "User-Agent": DEFAULT_USER_AGENT,
     }
-    request = urllib.request.Request(url, headers=headers)
+    encoded_url = _encode_url(url)
+    request = urllib.request.Request(encoded_url, headers=headers)
 
     with urllib.request.urlopen(request, timeout=timeout) as response:
-        content_type = _extract_content_type(response)
+        content_type, charset = _extract_content_type_and_charset(response)
         data = response.read()
-        text = _validate_utf8(data)
+        text = _decode_content(data, charset)
         return content_type, text
 
 
 @register(tools.WEB_FETCH)
 class WebFetchTool(ToolABC):
+    @classmethod
+    def metadata(cls) -> ToolMetadata:
+        return ToolMetadata(concurrency_policy=ToolConcurrencyPolicy.CONCURRENT, has_side_effects=True)
+
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:
         return llm_param.ToolSchema(
@@ -149,7 +209,7 @@ class WebFetchTool(ToolABC):
         if not url.startswith(("http://", "https://")):
             return model.ToolResultItem(
                 status="error",
-                output="Invalid URL: must start with http:// or https://",
+                output=f"Invalid URL: must start with http:// or https:// (url={url})",
             )
 
         try:
@@ -170,25 +230,20 @@ class WebFetchTool(ToolABC):
         except urllib.error.HTTPError as e:
             return model.ToolResultItem(
                 status="error",
-                output=f"HTTP error {e.code}: {e.reason}",
+                output=f"HTTP error {e.code}: {e.reason} (url={url})",
             )
         except urllib.error.URLError as e:
             return model.ToolResultItem(
                 status="error",
-                output=f"URL error: {e.reason}",
-            )
-        except UnicodeDecodeError as e:
-            return model.ToolResultItem(
-                status="error",
-                output=f"Content is not valid UTF-8: {e}",
+                output=f"URL error: {e.reason} (url={url})",
             )
         except TimeoutError:
             return model.ToolResultItem(
                 status="error",
-                output=f"Request timed out after {DEFAULT_TIMEOUT_SEC} seconds",
+                output=f"Request timed out after {DEFAULT_TIMEOUT_SEC} seconds (url={url})",
             )
         except Exception as e:
             return model.ToolResultItem(
                 status="error",
-                output=f"Failed to fetch URL: {e}",
+                output=f"Failed to fetch URL: {e} (url={url})",
             )

klaude_code/core/tool/web/web_search_tool.py

@@ -4,7 +4,7 @@ from pathlib import Path
 
 from pydantic import BaseModel
 
-from klaude_code.core.tool.tool_abc import ToolABC, load_desc
+from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy, ToolMetadata, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
@@ -62,6 +62,10 @@ def _format_results(results: list[SearchResult]) -> str:
 
 @register(tools.WEB_SEARCH)
 class WebSearchTool(ToolABC):
+    @classmethod
+    def metadata(cls) -> ToolMetadata:
+        return ToolMetadata(concurrency_policy=ToolConcurrencyPolicy.CONCURRENT, has_side_effects=False)
+
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:
         return llm_param.ToolSchema(