klaude-code 1.2.16__py3-none-any.whl → 1.2.18__py3-none-any.whl

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,
     )
 
 
@@ -292,10 +311,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 +334,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/report_back_tool.py

@@ -1,10 +1,35 @@
 """ReportBackTool for sub-agents to return structured output."""
 
-from typing import Any, ClassVar
+from typing import Any, ClassVar, cast
 
 from klaude_code.protocol import llm_param, model, tools
 
 
+def _normalize_schema_types(schema: dict[str, Any]) -> dict[str, Any]:
+    """Recursively normalize JSON schema type values to lowercase.
+
+    Some LLMs (e.g., Gemini 3) generate type values in uppercase like "OBJECT", "STRING".
+    Standard JSON Schema requires lowercase type values.
+    """
+    result: dict[str, Any] = {}
+    for key, value in schema.items():
+        if key == "type" and isinstance(value, str):
+            result[key] = value.lower()
+        elif isinstance(value, dict):
+            result[key] = _normalize_schema_types(cast(dict[str, Any], value))
+        elif isinstance(value, list):
+            normalized_list: list[Any] = []
+            for item in cast(list[Any], value):
+                if isinstance(item, dict):
+                    normalized_list.append(_normalize_schema_types(cast(dict[str, Any], item)))
+                else:
+                    normalized_list.append(item)
+            result[key] = normalized_list
+        else:
+            result[key] = value
+    return result
+
+
 class ReportBackTool:
     """Special tool for sub-agents to return structured output and end the task.
 
@@ -29,7 +54,8 @@ class ReportBackTool:
         Returns:
             A new class with the schema set as a class variable.
         """
-        return type("ReportBackTool", (ReportBackTool,), {"_schema": schema})
+        normalized = _normalize_schema_types(schema)
+        return type("ReportBackTool", (ReportBackTool,), {"_schema": normalized})
 
     @classmethod
     def schema(cls) -> llm_param.ToolSchema:

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_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/tool/web/web_search_tool.md

@@ -0,0 +1,23 @@
+- Search the web and use the results to inform responses
+- Provides up-to-date information for current events and recent data
+- Returns search result information formatted as search result blocks, including links as markdown hyperlinks
+- Use this tool for accessing information beyond your knowledge cutoff
+- Searches are performed automatically within a single API call
+
+CRITICAL REQUIREMENT - You MUST follow this:
+- After answering the user's question, you MUST include a "Sources:" section at the end of your response
+- In the Sources section, list all relevant URLs from the search results as markdown hyperlinks: [Title](URL)
+- This is MANDATORY - never skip including sources in your response
+- Example format:
+
+[Your answer here]
+
+Sources:
+- [Source Title 1](https://example.com/1)
+- [Source Title 2](https://example.com/2)
+
+Usage notes:
+- Domain filtering is supported to include or block specific websites
+- Web search is only available in the US
+- Account for "Today's date" in <env>. For example, if <env> says "Today's date: 2025-07-01", and the user wants the latest docs, do not use 2024 in the search query. Use 2025.
+

klaude_code/core/tool/web/web_search_tool.py

@@ -0,0 +1,126 @@
+import asyncio
+from dataclasses import dataclass
+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_registry import register
+from klaude_code.protocol import llm_param, model, tools
+
+DEFAULT_MAX_RESULTS = 10
+MAX_RESULTS_LIMIT = 20
+
+
+@dataclass
+class SearchResult:
+    """A single search result from DuckDuckGo."""
+
+    title: str
+    url: str
+    snippet: str
+    position: int
+
+
+def _search_duckduckgo(query: str, max_results: int) -> list[SearchResult]:
+    """Perform a web search using ddgs library."""
+    from ddgs import DDGS  # type: ignore
+
+    results: list[SearchResult] = []
+
+    with DDGS() as ddgs:
+        for i, r in enumerate(ddgs.text(query, max_results=max_results)):
+            results.append(
+                SearchResult(
+                    title=r.get("title", ""),
+                    url=r.get("href", ""),
+                    snippet=r.get("body", ""),
+                    position=i + 1,
+                )
+            )
+
+    return results
+
+
+def _format_results(results: list[SearchResult]) -> str:
+    """Format search results for LLM consumption."""
+    if not results:
+        return (
+            "No results were found for your search query. "
+            "Please try rephrasing your search or using different keywords."
+        )
+
+    lines = [f"Found {len(results)} search results:\n"]
+
+    for result in results:
+        lines.append(f"{result.position}. {result.title}")
+        lines.append(f"   URL: {result.url}")
+        lines.append(f"   Summary: {result.snippet}\n")
+
+    return "\n".join(lines)
+
+
+@register(tools.WEB_SEARCH)
+class WebSearchTool(ToolABC):
+    @classmethod
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.WEB_SEARCH,
+            type="function",
+            description=load_desc(Path(__file__).parent / "web_search_tool.md"),
+            parameters={
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query to use",
+                    },
+                    "max_results": {
+                        "type": "integer",
+                        "description": f"Maximum number of results to return (default: {DEFAULT_MAX_RESULTS}, max: {MAX_RESULTS_LIMIT})",
+                    },
+                },
+                "required": ["query"],
+            },
+        )
+
+    class WebSearchArguments(BaseModel):
+        query: str
+        max_results: int = DEFAULT_MAX_RESULTS
+
+    @classmethod
+    async def call(cls, arguments: str) -> model.ToolResultItem:
+        try:
+            args = WebSearchTool.WebSearchArguments.model_validate_json(arguments)
+        except ValueError as e:
+            return model.ToolResultItem(
+                status="error",
+                output=f"Invalid arguments: {e}",
+            )
+        return await cls.call_with_args(args)
+
+    @classmethod
+    async def call_with_args(cls, args: WebSearchArguments) -> model.ToolResultItem:
+        query = args.query.strip()
+        if not query:
+            return model.ToolResultItem(
+                status="error",
+                output="Query cannot be empty",
+            )
+
+        max_results = min(max(args.max_results, 1), MAX_RESULTS_LIMIT)
+
+        try:
+            results = await asyncio.to_thread(_search_duckduckgo, query, max_results)
+            formatted = _format_results(results)
+
+            return model.ToolResultItem(
+                status="success",
+                output=formatted,
+            )
+
+        except Exception as e:
+            return model.ToolResultItem(
+                status="error",
+                output=f"Search failed: {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/protocol/commands.py

@@ -3,6 +3,7 @@ from enum import Enum
 
 class CommandName(str, Enum):
     INIT = "init"
+    DEBUG = "debug"
     DIFF = "diff"
     HELP = "help"
     MODEL = "model"
@@ -11,6 +12,7 @@ class CommandName(str, Enum):
     CLEAR = "clear"
     TERMINAL_SETUP = "terminal-setup"
     EXPORT = "export"
+    EXPORT_ONLINE = "export-online"
     STATUS = "status"
     RELEASE_NOTES = "release-notes"
     THINKING = "thinking"