klaude-code 1.2.6__py3-none-any.whl → 1.2.7__py3-none-any.whl

klaude_code/llm/responses/client.py

@@ -1,7 +1,7 @@
 import json
 import time
 from collections.abc import AsyncGenerator
-from typing import override
+from typing import TYPE_CHECKING, override
 
 import httpx
 from openai import AsyncAzureOpenAI, AsyncOpenAI, RateLimitError
@@ -15,6 +15,153 @@ from klaude_code.llm.usage import calculate_cost
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
+if TYPE_CHECKING:
+    from openai import AsyncStream
+    from openai.types.responses import ResponseStreamEvent
+
+
+async def parse_responses_stream(
+    stream: "AsyncStream[ResponseStreamEvent]",
+    param: llm_param.LLMCallParameter,
+    cost_config: llm_param.Cost | None,
+    request_start_time: float,
+) -> AsyncGenerator[model.ConversationItem, None]:
+    """Parse OpenAI Responses API stream events into ConversationItems."""
+    first_token_time: float | None = None
+    last_token_time: float | None = None
+    response_id: str | None = None
+
+    try:
+        async for event in stream:
+            log_debug(
+                f"[{event.type}]",
+                event.model_dump_json(exclude_none=True),
+                style="blue",
+                debug_type=DebugType.LLM_STREAM,
+            )
+            match event:
+                case responses.ResponseCreatedEvent() as event:
+                    response_id = event.response.id
+                    yield model.StartItem(response_id=response_id)
+                case responses.ResponseReasoningSummaryTextDoneEvent() as event:
+                    if event.text:
+                        yield model.ReasoningTextItem(
+                            content=event.text,
+                            response_id=response_id,
+                            model=str(param.model),
+                        )
+                case responses.ResponseTextDeltaEvent() as event:
+                    if first_token_time is None:
+                        first_token_time = time.time()
+                    last_token_time = time.time()
+                    yield model.AssistantMessageDelta(content=event.delta, response_id=response_id)
+                case responses.ResponseOutputItemAddedEvent() as event:
+                    if isinstance(event.item, responses.ResponseFunctionToolCall):
+                        yield model.ToolCallStartItem(
+                            response_id=response_id,
+                            call_id=event.item.call_id,
+                            name=event.item.name,
+                        )
+                case responses.ResponseOutputItemDoneEvent() as event:
+                    match event.item:
+                        case responses.ResponseReasoningItem() as item:
+                            if item.encrypted_content:
+                                yield model.ReasoningEncryptedItem(
+                                    id=item.id,
+                                    encrypted_content=item.encrypted_content,
+                                    response_id=response_id,
+                                    model=str(param.model),
+                                )
+                        case responses.ResponseOutputMessage() as item:
+                            yield model.AssistantMessageItem(
+                                content="\n".join(
+                                    [
+                                        part.text
+                                        for part in item.content
+                                        if isinstance(part, responses.ResponseOutputText)
+                                    ]
+                                ),
+                                id=item.id,
+                                response_id=response_id,
+                            )
+                        case responses.ResponseFunctionToolCall() as item:
+                            if first_token_time is None:
+                                first_token_time = time.time()
+                            last_token_time = time.time()
+                            yield model.ToolCallItem(
+                                name=item.name,
+                                arguments=item.arguments.strip(),
+                                call_id=item.call_id,
+                                id=item.id,
+                                response_id=response_id,
+                            )
+                        case _:
+                            pass
+                case responses.ResponseCompletedEvent() as event:
+                    usage: model.Usage | None = None
+                    error_reason: str | None = None
+                    if event.response.incomplete_details is not None:
+                        error_reason = event.response.incomplete_details.reason
+                    if event.response.usage is not None:
+                        total_tokens = event.response.usage.total_tokens
+                        context_usage_percent = (
+                            (total_tokens / param.context_limit) * 100 if param.context_limit else None
+                        )
+
+                        throughput_tps: float | None = None
+                        first_token_latency_ms: float | None = None
+
+                        if first_token_time is not None:
+                            first_token_latency_ms = (first_token_time - request_start_time) * 1000
+
+                        if (
+                            first_token_time is not None
+                            and last_token_time is not None
+                            and event.response.usage.output_tokens > 0
+                        ):
+                            time_duration = last_token_time - first_token_time
+                            if time_duration >= 0.15:
+                                throughput_tps = event.response.usage.output_tokens / time_duration
+
+                        usage = model.Usage(
+                            input_tokens=event.response.usage.input_tokens,
+                            cached_tokens=event.response.usage.input_tokens_details.cached_tokens,
+                            reasoning_tokens=event.response.usage.output_tokens_details.reasoning_tokens,
+                            output_tokens=event.response.usage.output_tokens,
+                            total_tokens=total_tokens,
+                            context_usage_percent=context_usage_percent,
+                            throughput_tps=throughput_tps,
+                            first_token_latency_ms=first_token_latency_ms,
+                        )
+                        calculate_cost(usage, cost_config)
+                    yield model.ResponseMetadataItem(
+                        usage=usage,
+                        response_id=response_id,
+                        model_name=str(param.model),
+                        status=event.response.status,
+                        error_reason=error_reason,
+                    )
+                    if event.response.status != "completed":
+                        error_message = f"LLM response finished with status '{event.response.status}'"
+                        if error_reason:
+                            error_message = f"{error_message}: {error_reason}"
+                        log_debug(
+                            "[LLM status warning]",
+                            error_message,
+                            style="red",
+                            debug_type=DebugType.LLM_STREAM,
+                        )
+                        yield model.StreamErrorItem(error=error_message)
+                case _:
+                    log_debug(
+                        "[Unhandled stream event]",
+                        str(event),
+                        style="red",
+                        debug_type=DebugType.LLM_STREAM,
+                    )
+    except RateLimitError as e:
+        yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+
 
 @register(llm_param.LLMClientProtocol.RESPONSES)
 class ResponsesClient(LLMClientABC):
@@ -47,20 +194,15 @@ class ResponsesClient(LLMClientABC):
         param = apply_config_defaults(param, self.get_llm_config())
 
         request_start_time = time.time()
-        first_token_time: float | None = None
-        last_token_time: float | None = None
-        response_id: str | None = None
 
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
 
-        parallel_tool_calls = True
-
-        stream = call_with_logged_payload(
+        stream = await call_with_logged_payload(
             self.client.responses.create,
             model=str(param.model),
             tool_choice="auto",
-            parallel_tool_calls=parallel_tool_calls,  # OpenAI's Codex is always False, we try to enable it here. It seems gpt-5-codex has bugs when parallel_tool_calls is True.
+            parallel_tool_calls=True,
             include=[
                 "reasoning.encrypted_content",
             ],
@@ -75,6 +217,7 @@ class ResponsesClient(LLMClientABC):
             text={
                 "verbosity": param.verbosity,
             },
+            prompt_cache_key=param.session_id or "",
             reasoning={
                 "effort": param.thinking.reasoning_effort,
                 "summary": param.thinking.reasoning_summary,
@@ -84,133 +227,5 @@ class ResponsesClient(LLMClientABC):
             extra_headers={"extra": json.dumps({"session_id": param.session_id})},
         )
 
-        try:
-            async for event in await stream:
-                log_debug(
-                    f"[{event.type}]",
-                    event.model_dump_json(exclude_none=True),
-                    style="blue",
-                    debug_type=DebugType.LLM_STREAM,
-                )
-                match event:
-                    case responses.ResponseCreatedEvent() as event:
-                        response_id = event.response.id
-                        yield model.StartItem(response_id=response_id)
-                    case responses.ResponseReasoningSummaryTextDoneEvent() as event:
-                        if event.text:
-                            yield model.ReasoningTextItem(
-                                content=event.text,
-                                response_id=response_id,
-                                model=str(param.model),
-                            )
-                    case responses.ResponseTextDeltaEvent() as event:
-                        if first_token_time is None:
-                            first_token_time = time.time()
-                        last_token_time = time.time()
-                        yield model.AssistantMessageDelta(content=event.delta, response_id=response_id)
-                    case responses.ResponseOutputItemAddedEvent() as event:
-                        if isinstance(event.item, responses.ResponseFunctionToolCall):
-                            yield model.ToolCallStartItem(
-                                response_id=response_id,
-                                call_id=event.item.call_id,
-                                name=event.item.name,
-                            )
-                    case responses.ResponseOutputItemDoneEvent() as event:
-                        match event.item:
-                            case responses.ResponseReasoningItem() as item:
-                                if item.encrypted_content:
-                                    yield model.ReasoningEncryptedItem(
-                                        id=item.id,
-                                        encrypted_content=item.encrypted_content,
-                                        response_id=response_id,
-                                        model=str(param.model),
-                                    )
-                            case responses.ResponseOutputMessage() as item:
-                                yield model.AssistantMessageItem(
-                                    content="\n".join(
-                                        [
-                                            part.text
-                                            for part in item.content
-                                            if isinstance(part, responses.ResponseOutputText)
-                                        ]
-                                    ),
-                                    id=item.id,
-                                    response_id=response_id,
-                                )
-                            case responses.ResponseFunctionToolCall() as item:
-                                if first_token_time is None:
-                                    first_token_time = time.time()
-                                last_token_time = time.time()
-                                yield model.ToolCallItem(
-                                    name=item.name,
-                                    arguments=item.arguments.strip(),
-                                    call_id=item.call_id,
-                                    id=item.id,
-                                    response_id=response_id,
-                                )
-                            case _:
-                                pass
-                    case responses.ResponseCompletedEvent() as event:
-                        usage: model.Usage | None = None
-                        error_reason: str | None = None
-                        if event.response.incomplete_details is not None:
-                            error_reason = event.response.incomplete_details.reason
-                        if event.response.usage is not None:
-                            total_tokens = event.response.usage.total_tokens
-                            context_usage_percent = (
-                                (total_tokens / param.context_limit) * 100 if param.context_limit else None
-                            )
-
-                            throughput_tps: float | None = None
-                            first_token_latency_ms: float | None = None
-
-                            if first_token_time is not None:
-                                first_token_latency_ms = (first_token_time - request_start_time) * 1000
-
-                            if (
-                                first_token_time is not None
-                                and last_token_time is not None
-                                and event.response.usage.output_tokens > 0
-                            ):
-                                time_duration = last_token_time - first_token_time
-                                if time_duration >= 0.15:
-                                    throughput_tps = event.response.usage.output_tokens / time_duration
-
-                            usage = model.Usage(
-                                input_tokens=event.response.usage.input_tokens,
-                                cached_tokens=event.response.usage.input_tokens_details.cached_tokens,
-                                reasoning_tokens=event.response.usage.output_tokens_details.reasoning_tokens,
-                                output_tokens=event.response.usage.output_tokens,
-                                total_tokens=total_tokens,
-                                context_usage_percent=context_usage_percent,
-                                throughput_tps=throughput_tps,
-                                first_token_latency_ms=first_token_latency_ms,
-                            )
-                            calculate_cost(usage, self._config.cost)
-                        yield model.ResponseMetadataItem(
-                            usage=usage,
-                            response_id=response_id,
-                            model_name=str(param.model),
-                            status=event.response.status,
-                            error_reason=error_reason,
-                        )
-                        if event.response.status != "completed":
-                            error_message = f"LLM response finished with status '{event.response.status}'"
-                            if error_reason:
-                                error_message = f"{error_message}: {error_reason}"
-                            log_debug(
-                                "[LLM status warning]",
-                                error_message,
-                                style="red",
-                                debug_type=DebugType.LLM_STREAM,
-                            )
-                            yield model.StreamErrorItem(error=error_message)
-                    case _:
-                        log_debug(
-                            "[Unhandled stream event]",
-                            str(event),
-                            style="red",
-                            debug_type=DebugType.LLM_STREAM,
-                        )
-        except RateLimitError as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+        async for item in parse_responses_stream(stream, param, self._config.cost, request_start_time):
+            yield item

klaude_code/llm/usage.py

@@ -14,6 +14,9 @@ def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> No
     if cost_config is None:
         return
 
+    # Set currency
+    usage.currency = cost_config.currency
+
     # Non-cached input tokens cost
     non_cached_input = usage.input_tokens - usage.cached_tokens
     usage.input_cost = (non_cached_input / 1_000_000) * cost_config.input

klaude_code/protocol/llm_param.py

@@ -12,6 +12,7 @@ class LLMClientProtocol(Enum):
     RESPONSES = "responses"
     OPENROUTER = "openrouter"
     ANTHROPIC = "anthropic"
+    CODEX = "codex"
 
 
 class ToolSchema(BaseModel):
@@ -36,12 +37,13 @@ class Thinking(BaseModel):
 
 
 class Cost(BaseModel):
-    """Cost configuration per million tokens (USD)."""
+    """Cost configuration per million tokens."""
 
     input: float  # Input token price per million tokens
     output: float  # Output token price per million tokens
     cache_read: float = 0.0  # Cache read price per million tokens
     cache_write: float = 0.0  # Cache write price per million tokens (ignored in calculation for now)
+    currency: Literal["USD", "CNY"] = "USD"  # Currency for cost display
 
 
 class OpenRouterProviderRouting(BaseModel):

klaude_code/protocol/model.py

@@ -21,11 +21,12 @@ class Usage(BaseModel):
     throughput_tps: float | None = None
     first_token_latency_ms: float | None = None
 
-    # Cost in USD (calculated from token counts and cost config)
+    # Cost (calculated from token counts and cost config)
     input_cost: float | None = None  # Cost for non-cached input tokens
     output_cost: float | None = None  # Cost for output tokens (including reasoning)
     cache_read_cost: float | None = None  # Cost for cached tokens
     total_cost: float | None = None  # Total cost (input + output + cache_read)
+    currency: str = "USD"  # Currency for cost display (USD or CNY)
 
 
 class TodoItem(BaseModel):

klaude_code/protocol/sub_agent.py

@@ -245,7 +245,8 @@ register_sub_agent(
 EXPLORE_DESCRIPTION = """\
 Spin up a fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), \
 search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?")\
-When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions\
+When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.
+Always spawn multiple search agents in parallel to maximise speed.\
 """
 
 EXPLORE_PARAMETERS = {

klaude_code/session/export.py

@@ -154,8 +154,9 @@ def _format_token_count(count: int) -> str:
     return f"{m}M" if rem == 0 else f"{m}M{rem}k"
 
 
-def _format_cost(cost: float) -> str:
-    return f"${cost:.4f}"
+def _format_cost(cost: float, currency: str = "USD") -> str:
+    symbol = "¥" if currency == "CNY" else "$"
+    return f"{symbol}{cost:.4f}"
 
 
 def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
@@ -175,26 +176,24 @@ def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
         # Input with cost
         input_stat = f"input: {_format_token_count(u.input_tokens)}"
         if u.input_cost is not None:
-            input_stat += f"({_format_cost(u.input_cost)})"
+            input_stat += f"({_format_cost(u.input_cost, u.currency)})"
         parts.append(f'<span class="metadata-stat">{input_stat}</span>')
 
         # Cached with cost
         if u.cached_tokens > 0:
             cached_stat = f"cached: {_format_token_count(u.cached_tokens)}"
             if u.cache_read_cost is not None:
-                cached_stat += f"({_format_cost(u.cache_read_cost)})"
+                cached_stat += f"({_format_cost(u.cache_read_cost, u.currency)})"
             parts.append(f'<span class="metadata-stat">{cached_stat}</span>')
 
         # Output with cost
         output_stat = f"output: {_format_token_count(u.output_tokens)}"
         if u.output_cost is not None:
-            output_stat += f"({_format_cost(u.output_cost)})"
+            output_stat += f"({_format_cost(u.output_cost, u.currency)})"
         parts.append(f'<span class="metadata-stat">{output_stat}</span>')
 
         if u.reasoning_tokens > 0:
-            parts.append(
-                f'<span class="metadata-stat">thinking: {_format_token_count(u.reasoning_tokens)}</span>'
-            )
+            parts.append(f'<span class="metadata-stat">thinking: {_format_token_count(u.reasoning_tokens)}</span>')
         if u.context_usage_percent is not None:
             parts.append(f'<span class="metadata-stat">context: {u.context_usage_percent:.1f}%</span>')
         if u.throughput_tps is not None:
@@ -205,16 +204,12 @@ def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
 
     # Total cost
     if item.usage is not None and item.usage.total_cost is not None:
-        parts.append(f'<span class="metadata-stat">cost: {_format_cost(item.usage.total_cost)}</span>')
+        parts.append(f'<span class="metadata-stat">cost: {_format_cost(item.usage.total_cost, item.usage.currency)}</span>')
 
     divider = '<span class="metadata-divider">/</span>'
     joined_html = divider.join(parts)
 
-    return (
-        f'<div class="response-metadata">'
-        f'<div class="metadata-line">{joined_html}</div>'
-        f"</div>"
-    )
+    return f'<div class="response-metadata"><div class="metadata-line">{joined_html}</div></div>'
 
 
 def _render_assistant_message(index: int, content: str, timestamp: datetime) -> str:

klaude_code/session/templates/export_session.html

@@ -1077,6 +1077,11 @@
       });
     </script>
     <script>
+      // Trim whitespace from pre-wrap content to avoid formatting artifacts
+      document.querySelectorAll(".system-prompt-content").forEach((el) => {
+        el.textContent = el.textContent.trim();
+      });
+
       // Markdown rendering and Syntax Highlighting
       document.querySelectorAll(".markdown-content").forEach((el) => {
         const raw = el.dataset.raw;

klaude_code/ui/modes/repl/completers.py

@@ -27,8 +27,11 @@ from prompt_toolkit.formatted_text import HTML
 
 from klaude_code.command import get_commands
 
-# Pattern to match @token for completion refresh (used by key bindings)
-AT_TOKEN_PATTERN = re.compile(r"(^|\s)@(?P<frag>[^\s]*)$")
+# Pattern to match @token for completion refresh (used by key bindings).
+# Supports both plain tokens like `@src/file.py` and quoted tokens like
+# `@"path with spaces/file.py"` so that filenames with spaces remain a
+# single logical token.
+AT_TOKEN_PATTERN = re.compile(r'(^|\s)@(?P<frag>"[^"]*"|[^\s]*)$')
 
 
 def create_repl_completer() -> Completer:
@@ -182,31 +185,48 @@ class _AtFilesCompleter(Completer):
         if not m:
             return []  # type: ignore[reportUnknownVariableType]
 
-        frag = m.group("frag")  # text after '@' and before cursor (no spaces)
+        frag = m.group("frag")  # raw text after '@' and before cursor (may be quoted)
+        # Normalize fragment for search: support optional quoting syntax @"...".
+        is_quoted = frag.startswith('"')
+        search_frag = frag
+        if is_quoted:
+            # Drop leading quote; if user already closed the quote, drop trailing quote as well.
+            search_frag = search_frag[1:]
+            if search_frag.endswith('"'):
+                search_frag = search_frag[:-1]
+
         token_start_in_input = len(text_before) - len(f"@{frag}")
 
         cwd = Path.cwd()
 
         # If no fragment yet, show lightweight suggestions from current directory
-        if frag.strip() == "":
+        if search_frag.strip() == "":
             suggestions = self._suggest_for_empty_fragment(cwd)
             if not suggestions:
                 return []  # type: ignore[reportUnknownVariableType]
             start_position = token_start_in_input - len(text_before)
             for s in suggestions[: self._max_results]:
-                yield Completion(text=f"@{s} ", start_position=start_position, display=s)
+                yield Completion(
+                    text=self._format_completion_text(s, is_quoted=is_quoted),
+                    start_position=start_position,
+                    display=s,
+                )
             return []  # type: ignore[reportUnknownVariableType]
 
         # Gather suggestions with debounce/caching based on search keyword
-        suggestions = self._complete_paths(cwd, frag)
+        suggestions = self._complete_paths(cwd, search_frag)
         if not suggestions:
             return []  # type: ignore[reportUnknownVariableType]
 
         # Prepare Completion objects. Replace from the '@' character.
         start_position = token_start_in_input - len(text_before)  # negative
         for s in suggestions[: self._max_results]:
-            # Insert '@<path> ' so that subsequent typing does not keep triggering
-            yield Completion(text=f"@{s} ", start_position=start_position, display=s)
+            # Insert formatted text (with quoting when needed) so that subsequent typing does not keep triggering
+            yield Completion(
+                text=self._format_completion_text(s, is_quoted=is_quoted),
+                start_position=start_position,
+                display=s,
+            )
 
     # ---- Core logic ----
     def _complete_paths(self, cwd: Path, keyword: str) -> list[str]:
@@ -318,6 +338,19 @@ class _AtFilesCompleter(Completer):
                 uniq.append(s)
         return uniq
 
+    def _format_completion_text(self, suggestion: str, *, is_quoted: bool) -> str:
+        """Format completion insertion text for a given suggestion.
+
+        Paths that contain whitespace are always wrapped in quotes so that they
+        can be parsed correctly by the @-file reader. If the user explicitly
+        started a quoted token (e.g. @"foo), we preserve quoting even when the
+        suggested path itself does not contain spaces.
+        """
+        needs_quotes = any(ch.isspace() for ch in suggestion)
+        if needs_quotes or is_quoted:
+            return f'@"{suggestion}" '
+        return f"@{suggestion} "
+
     def _same_scope(self, prev_key: str, cur_key: str) -> bool:
         # Consider same scope if they share the same base directory and one prefix startswith the other
         try: