klaude-code 2.4.1__py3-none-any.whl → 2.5.0__py3-none-any.whl

klaude_code/llm/responses/client.py

@@ -9,11 +9,12 @@ from openai.types import responses
 from openai.types.responses.response_create_params import ResponseCreateParamsStreaming
 
 from klaude_code.const import LLM_HTTP_TIMEOUT_CONNECT, LLM_HTTP_TIMEOUT_READ, LLM_HTTP_TIMEOUT_TOTAL
-from klaude_code.llm.client import LLMClientABC
+from klaude_code.llm.client import LLMClientABC, LLMStreamABC
 from klaude_code.llm.input_common import apply_config_defaults
+from klaude_code.llm.partial_message import degrade_thinking_to_text
 from klaude_code.llm.registry import register
 from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
-from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.llm.usage import MetadataTracker, error_llm_stream
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message, model
 
@@ -56,46 +57,79 @@ def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStre
     return payload
 
 
-async def parse_responses_stream(
-    stream: "AsyncStream[ResponseStreamEvent]",
-    param: llm_param.LLMCallParameter,
-    metadata_tracker: MetadataTracker,
-) -> AsyncGenerator[message.LLMStreamItem]:
-    """Parse OpenAI Responses API stream events into stream items."""
-    response_id: str | None = None
-    stage: Literal["waiting", "thinking", "assistant", "tool"] = "waiting"
-
-    accumulated_thinking: list[str] = []
-    accumulated_text: list[str] = []
-    pending_signature: str | None = None
-    assistant_parts: list[message.Part] = []
-    stop_reason: model.StopReason | None = None
-
-    def flush_thinking() -> None:
-        nonlocal pending_signature
-        if accumulated_thinking:
-            assistant_parts.append(
+class ResponsesStreamStateManager:
+    """Manages streaming state for Responses API and provides partial message access."""
+
+    def __init__(self, model_id: str) -> None:
+        self.model_id = model_id
+        self.response_id: str | None = None
+        self.stage: Literal["waiting", "thinking", "assistant", "tool"] = "waiting"
+        self.accumulated_thinking: list[str] = []
+        self.accumulated_text: list[str] = []
+        self.pending_signature: str | None = None
+        self.assistant_parts: list[message.Part] = []
+        self.stop_reason: model.StopReason | None = None
+
+    def flush_thinking(self) -> None:
+        """Flush accumulated thinking content into parts."""
+        if self.accumulated_thinking:
+            self.assistant_parts.append(
                 message.ThinkingTextPart(
-                    text="".join(accumulated_thinking),
-                    model_id=str(param.model_id),
+                    text="".join(self.accumulated_thinking),
+                    model_id=self.model_id,
                 )
             )
-            accumulated_thinking.clear()
-        if pending_signature:
-            assistant_parts.append(
+            self.accumulated_thinking.clear()
+        if self.pending_signature:
+            self.assistant_parts.append(
                 message.ThinkingSignaturePart(
-                    signature=pending_signature,
-                    model_id=str(param.model_id),
+                    signature=self.pending_signature,
+                    model_id=self.model_id,
                     format="openai_reasoning",
                 )
             )
-            pending_signature = None
+            self.pending_signature = None
 
-    def flush_text() -> None:
-        if not accumulated_text:
+    def flush_text(self) -> None:
+        """Flush accumulated text content into parts."""
+        if not self.accumulated_text:
             return
-        assistant_parts.append(message.TextPart(text="".join(accumulated_text)))
-        accumulated_text.clear()
+        self.assistant_parts.append(message.TextPart(text="".join(self.accumulated_text)))
+        self.accumulated_text.clear()
+
+    def flush_all(self) -> list[message.Part]:
+        """Flush all accumulated content and return parts."""
+        self.flush_thinking()
+        self.flush_text()
+        return list(self.assistant_parts)
+
+    def get_partial_message(self) -> message.AssistantMessage | None:
+        """Build a partial AssistantMessage from accumulated state."""
+        parts = self.flush_all()
+        filtered_parts: list[message.Part] = []
+        for part in parts:
+            if isinstance(part, message.ToolCallPart):
+                continue
+            filtered_parts.append(part)
+
+        filtered_parts = degrade_thinking_to_text(filtered_parts)
+        if not filtered_parts:
+            return None
+        return message.AssistantMessage(
+            parts=filtered_parts,
+            response_id=self.response_id,
+            stop_reason="aborted",
+        )
+
+
+async def parse_responses_stream(
+    stream: "AsyncStream[ResponseStreamEvent]",
+    *,
+    state: ResponsesStreamStateManager,
+    param: llm_param.LLMCallParameter,
+    metadata_tracker: MetadataTracker,
+) -> AsyncGenerator[message.LLMStreamItem]:
+    """Parse OpenAI Responses API stream events into stream items."""
 
     def map_stop_reason(status: str | None, reason: str | None) -> model.StopReason | None:
         if reason:
@@ -122,31 +156,31 @@ async def parse_responses_stream(
             )
             match event:
                 case responses.ResponseCreatedEvent() as event:
-                    response_id = event.response.id
+                    state.response_id = event.response.id
                 case responses.ResponseReasoningSummaryTextDeltaEvent() as event:
                     if event.delta:
                         metadata_tracker.record_token()
-                        if stage == "assistant":
-                            flush_text()
-                        stage = "thinking"
-                        accumulated_thinking.append(event.delta)
-                        yield message.ThinkingTextDelta(content=event.delta, response_id=response_id)
+                        if state.stage == "assistant":
+                            state.flush_text()
+                        state.stage = "thinking"
+                        state.accumulated_thinking.append(event.delta)
+                        yield message.ThinkingTextDelta(content=event.delta, response_id=state.response_id)
                 case responses.ResponseReasoningSummaryTextDoneEvent() as event:
-                    if event.text and not accumulated_thinking:
-                        accumulated_thinking.append(event.text)
+                    if event.text and not state.accumulated_thinking:
+                        state.accumulated_thinking.append(event.text)
                 case responses.ResponseTextDeltaEvent() as event:
                     if event.delta:
                         metadata_tracker.record_token()
-                        if stage == "thinking":
-                            flush_thinking()
-                        stage = "assistant"
-                        accumulated_text.append(event.delta)
-                        yield message.AssistantTextDelta(content=event.delta, response_id=response_id)
+                        if state.stage == "thinking":
+                            state.flush_thinking()
+                        state.stage = "assistant"
+                        state.accumulated_text.append(event.delta)
+                        yield message.AssistantTextDelta(content=event.delta, response_id=state.response_id)
                 case responses.ResponseOutputItemAddedEvent() as event:
                     if isinstance(event.item, responses.ResponseFunctionToolCall):
                         metadata_tracker.record_token()
                         yield message.ToolCallStartDelta(
-                            response_id=response_id,
+                            response_id=state.response_id,
                             call_id=event.item.call_id,
                             name=event.item.name,
                         )
@@ -154,9 +188,9 @@ async def parse_responses_stream(
                     match event.item:
                         case responses.ResponseReasoningItem() as item:
                             if item.encrypted_content:
-                                pending_signature = item.encrypted_content
+                                state.pending_signature = item.encrypted_content
                         case responses.ResponseOutputMessage() as item:
-                            if not accumulated_text:
+                            if not state.accumulated_text:
                                 text_content = "\n".join(
                                     [
                                         part.text
@@ -165,13 +199,13 @@ async def parse_responses_stream(
                                     ]
                                 )
                                 if text_content:
-                                    accumulated_text.append(text_content)
+                                    state.accumulated_text.append(text_content)
                         case responses.ResponseFunctionToolCall() as item:
                             metadata_tracker.record_token()
-                            flush_thinking()
-                            flush_text()
-                            stage = "tool"
-                            assistant_parts.append(
+                            state.flush_thinking()
+                            state.flush_text()
+                            state.stage = "tool"
+                            state.assistant_parts.append(
                                 message.ToolCallPart(
                                     call_id=item.call_id,
                                     id=item.id,
@@ -198,8 +232,8 @@ async def parse_responses_stream(
                             )
                         )
                     metadata_tracker.set_model_name(str(param.model_id))
-                    metadata_tracker.set_response_id(response_id)
-                    stop_reason = map_stop_reason(event.response.status, error_reason)
+                    metadata_tracker.set_response_id(state.response_id)
+                    state.stop_reason = map_stop_reason(event.response.status, error_reason)
                     if event.response.status != "completed":
                         error_message = f"LLM response finished with status '{event.response.status}'"
                         if error_reason:
@@ -221,18 +255,53 @@ async def parse_responses_stream(
     except (openai.OpenAIError, httpx.HTTPError) as e:
         yield message.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
 
-    flush_thinking()
-    flush_text()
-    metadata_tracker.set_response_id(response_id)
+    parts = state.flush_all()
+    metadata_tracker.set_response_id(state.response_id)
     metadata = metadata_tracker.finalize()
     yield message.AssistantMessage(
-        parts=assistant_parts,
-        response_id=response_id,
+        parts=parts,
+        response_id=state.response_id,
         usage=metadata,
-        stop_reason=stop_reason,
+        stop_reason=state.stop_reason,
     )
 
 
+class ResponsesLLMStream(LLMStreamABC):
+    """LLMStream implementation for Responses API clients."""
+
+    def __init__(
+        self,
+        stream: "AsyncStream[ResponseStreamEvent]",
+        *,
+        param: llm_param.LLMCallParameter,
+        metadata_tracker: MetadataTracker,
+    ) -> None:
+        self._stream = stream
+        self._param = param
+        self._metadata_tracker = metadata_tracker
+        self._state = ResponsesStreamStateManager(str(param.model_id))
+        self._completed = False
+
+    def __aiter__(self) -> AsyncGenerator[message.LLMStreamItem]:
+        return self._iterate()
+
+    async def _iterate(self) -> AsyncGenerator[message.LLMStreamItem]:
+        async for item in parse_responses_stream(
+            self._stream,
+            state=self._state,
+            param=self._param,
+            metadata_tracker=self._metadata_tracker,
+        ):
+            if isinstance(item, message.AssistantMessage):
+                self._completed = True
+            yield item
+
+    def get_partial_message(self) -> message.AssistantMessage | None:
+        if self._completed:
+            return None
+        return self._state.get_partial_message()
+
+
 @register(llm_param.LLMClientProtocol.RESPONSES)
 class ResponsesClient(LLMClientABC):
     def __init__(self, config: llm_param.LLMConfigParameter):
@@ -264,7 +333,7 @@ class ResponsesClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[message.LLMStreamItem]:
+    async def call(self, param: llm_param.LLMCallParameter) -> LLMStreamABC:
         param = apply_config_defaults(param, self.get_llm_config())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
@@ -283,9 +352,6 @@ class ResponsesClient(LLMClientABC):
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
             error_message = f"{e.__class__.__name__} {e!s}"
-            for item in error_stream_items(metadata_tracker, error=error_message):
-                yield item
-            return
+            return error_llm_stream(metadata_tracker, error=error_message)
 
-        async for item in parse_responses_stream(stream, param, metadata_tracker):
-            yield item
+        return ResponsesLLMStream(stream, param=param, metadata_tracker=metadata_tracker)

klaude_code/llm/usage.py

@@ -1,8 +1,10 @@
 import time
+from collections.abc import AsyncGenerator
 
 import openai.types
 
 from klaude_code.const import THROUGHPUT_MIN_DURATION_SEC
+from klaude_code.llm.client import LLMStreamABC
 from klaude_code.protocol import llm_param, message, model
 
 
@@ -114,6 +116,34 @@ def error_stream_items(
     ]
 
 
+class ErrorLLMStream(LLMStreamABC):
+    """LLMStream implementation for error scenarios."""
+
+    def __init__(self, items: list[message.LLMStreamItem]) -> None:
+        self._items = list(items)
+
+    def __aiter__(self) -> AsyncGenerator[message.LLMStreamItem]:
+        return self._iterate()
+
+    async def _iterate(self) -> AsyncGenerator[message.LLMStreamItem]:
+        for item in self._items:
+            yield item
+
+    def get_partial_message(self) -> message.AssistantMessage | None:
+        return None
+
+
+def error_llm_stream(
+    metadata_tracker: MetadataTracker,
+    *,
+    error: str,
+    response_id: str | None = None,
+) -> ErrorLLMStream:
+    """Create an LLMStream that yields error items."""
+    items = error_stream_items(metadata_tracker, error=error, response_id=response_id)
+    return ErrorLLMStream(items)
+
+
 def convert_usage(
     usage: openai.types.CompletionUsage,
     context_limit: int | None = None,

klaude_code/protocol/commands.py

@@ -28,10 +28,6 @@ class CommandName(str, Enum):
     FORK_SESSION = "fork-session"
     RESUME = "resume"
     COPY = "copy"
-    # PLAN and DOC are dynamically registered now, but kept here if needed for reference
-    # or we can remove them if no code explicitly imports them.
-    # PLAN = "plan"
-    # DOC = "doc"
 
     def __str__(self) -> str:
         return self.value

klaude_code/protocol/events/metadata.py

@@ -13,3 +13,4 @@ class UsageEvent(ResponseEvent):
 
 class TaskMetadataEvent(Event):
     metadata: model.TaskMetadataItem
+    cancelled: bool = False

klaude_code/protocol/events/streaming.py

@@ -34,6 +34,7 @@ class AssistantImageDeltaEvent(ResponseEvent):
 class ToolCallStartEvent(ResponseEvent):
     tool_call_id: str
     tool_name: str
+    model_id: str | None = None
 
 
 class ResponseCompleteEvent(ResponseEvent):

klaude_code/protocol/events/system.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from pydantic import Field
-
 from klaude_code.protocol import llm_param
 from klaude_code.protocol.events.chat import DeveloperMessageEvent, UserMessageEvent
 from klaude_code.protocol.events.lifecycle import TaskFinishEvent, TaskStartEvent, TurnStartEvent
@@ -16,8 +14,6 @@ class WelcomeEvent(Event):
     work_dir: str
     llm_config: llm_param.LLMConfigParameter
     show_klaude_code_info: bool = True
-    show_sub_agent_models: bool = True
-    sub_agent_models: dict[str, llm_param.LLMConfigParameter] = Field(default_factory=dict)
 
 
 class ErrorEvent(Event):

klaude_code/protocol/model.py

@@ -75,6 +75,7 @@ class TaskMetadata(BaseModel):
     usage: Usage | None = None
     model_name: str = ""
     provider: str | None = None
+    description: str | None = None
     task_duration_s: float | None = None
     turn_count: int = 0
 
@@ -216,13 +217,6 @@ class MermaidLinkUIExtra(BaseModel):
     line_count: int
 
 
-class TruncationUIExtra(BaseModel):
-    type: Literal["truncation"] = "truncation"
-    saved_file_path: str
-    original_length: int
-    truncated_length: int
-
-
 class MarkdownDocUIExtra(BaseModel):
     type: Literal["markdown_doc"] = "markdown_doc"
     file_path: str
@@ -237,13 +231,7 @@ class SessionStatusUIExtra(BaseModel):
 
 
 MultiUIExtraItem = (
-    DiffUIExtra
-    | TodoListUIExtra
-    | SessionIdUIExtra
-    | MermaidLinkUIExtra
-    | TruncationUIExtra
-    | MarkdownDocUIExtra
-    | SessionStatusUIExtra
+    DiffUIExtra | TodoListUIExtra | SessionIdUIExtra | MermaidLinkUIExtra | MarkdownDocUIExtra | SessionStatusUIExtra
 )
 
 
@@ -263,7 +251,6 @@ ToolResultUIExtra = Annotated[
     | TodoListUIExtra
     | SessionIdUIExtra
     | MermaidLinkUIExtra
-    | TruncationUIExtra
     | MarkdownDocUIExtra
     | SessionStatusUIExtra
     | MultiUIExtra,

klaude_code/protocol/sub_agent/explore.py

@@ -8,16 +8,6 @@ Spin up a fast agent specialized for exploring codebases. Use this when you need
 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.
 Always spawn multiple search agents in parallel to maximise speed.
-
-Structured output:
-- Provide an `output_format` (JSON Schema) parameter for structured data back from the sub-agent
-- Example: `output_format={"type": "object", "properties": {"files": {"type": "array", "items": {"type": "string"}, "description": "List of file paths that match the search criteria, e.g. ['src/main.py', 'src/utils/helper.py']"}}, "required": ["files"]}`\
-
-- Agents can be resumed using the `resume` parameter by passing the agent ID from a previous invocation. When resumed, the agent
-continues with its full previous context preserved. When NOT resuming, each invocation starts fresh and you should provide a detailed
-task description with all necessary context.
-- When the agent is done, it will return a single message back to you along with its agent ID. You can use this ID to resume the agent
-later if needed for follow-up work.
 """
 
 EXPLORE_PARAMETERS = {

klaude_code/protocol/sub_agent/image_gen.py

@@ -30,13 +30,6 @@ including the generated image, so you don't need to pass `image_paths` again.
   1. Call ImageGen with prompt="Generate a watercolor painting of a mountain lake" -> returns agent_id
   2. Call ImageGen with resume=agent_id, prompt="Add a wooden cabin on the shore" -> edits the previous image
   3. Call ImageGen with resume=agent_id, prompt="Change to sunset lighting" -> continues editing
-
-- Agents can be resumed using the `resume` parameter by passing the agent ID from a previous invocation. When resumed, the agent
-continues with its full previous context preserved. When NOT resuming, each invocation starts fresh and you should provide a detailed
-task description with all necessary context.
-- When the agent is done, it will return a single message back to you along with its agent ID. You can use this ID to resume the agent
-later if needed for follow-up work.
-
 """
 
 

klaude_code/protocol/sub_agent/task.py

@@ -20,16 +20,6 @@ Usage notes:
 - Clearly tell the agent whether you expect it to write code or just to do research (search, file reads, etc.), since it is not aware of the user's intent
 - If the agent description mentions that it should be used proactively, then you should try your best to use it without the user having to ask for it first. Use your judgement.
 - If the user specifies that they want you to run agents "in parallel", you MUST send a single message with multiple Task tool use content blocks. For example, if you need to launch both a code-reviewer agent and a test-runner agent in parallel, send a single message with both tool calls.
-
-Structured output:
-- Provide an `output_format` (JSON Schema) parameter for structured data back from the agent
-- Example: `output_format={"type": "object", "properties": {"files": {"type": "array", "items": {"type": "string"}, "description": "List of file paths that match the search criteria, e.g. ['src/main.py', 'src/utils/helper.py']"}}, "required": ["files"]}`\
-
-- Agents can be resumed using the `resume` parameter by passing the agent ID from a previous invocation. When resumed, the agent
-continues with its full previous context preserved. When NOT resuming, each invocation starts fresh and you should provide a detailed
-task description with all necessary context.
-- When the agent is done, it will return a single message back to you along with its agent ID. You can use this ID to resume the agent
-later if needed for follow-up work.
 """
 
 TASK_PARAMETERS = {

klaude_code/protocol/sub_agent/web.py

@@ -11,28 +11,20 @@ Launch a sub-agent to search the web, fetch pages, and analyze content. Use this
 - Gathering comprehensive information from multiple web sources
 
 Capabilities:
-- Search the web to find relevant pages (no URL required)
-- Fetch and parse web pages (HTML-to-Markdown conversion)
-- Follow links across multiple pages autonomously
+- Search the web to find relevant pages
+- Fetch and parse web pages
+- Follow links across multiple pages
 - Aggregate findings from multiple sources
 
 How to use:
 - Write a clear prompt describing what information you need - the agent will search and fetch as needed
 - 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.
 - Provide the url if you already know the target page
-- Use `output_format` (JSON Schema) to get structured data back from the agent
 
 What you receive:
 - The agent returns a text response summarizing its findings
-- With `output_format`, you receive structured JSON matching your schema
 - The response is the agent's analysis, not raw web content
-- Web content is saved to local files (paths included in Sources) - read them directly if you need full content\
-
-- Agents can be resumed using the `resume` parameter by passing the agent ID from a previous invocation. When resumed, the agent
-continues with its full previous context preserved. When NOT resuming, each invocation starts fresh and you should provide a detailed
-task description with all necessary context.
-- When the agent is done, it will return a single message back to you along with its agent ID. You can use this ID to resume the agent
-later if needed for follow-up work.
+- Web content is saved to local files (paths included in Sources) - read them directly if you need full content
 """
 
 WEB_AGENT_PARAMETERS = {

klaude_code/session/templates/export_session.html

@@ -9,11 +9,11 @@
       href="data:image/svg+xml,<svg xmlns=%22http://www.w3.org/2000/svg%22 viewBox=%220 0 24 24%22 fill=%22none%22 stroke=%22%230b5bd3%22 stroke-width=%222%22 stroke-linecap=%22round%22 stroke-linejoin=%22round%22><polyline points=%2216 18 22 12 16 6%22></polyline><polyline points=%228 6 2 12 8 18%22></polyline></svg>"
     />
     <link
-      href="https://cdn.jsdelivr.net/npm/@fontsource/jetbrains-mono/400.css"
+      href="https://cdn.jsdelivr.net/npm/@fontsource/lilex/400.css"
       rel="stylesheet"
     />
     <link
-      href="https://cdn.jsdelivr.net/npm/@fontsource/jetbrains-mono/700.css"
+      href="https://cdn.jsdelivr.net/npm/@fontsource/lilex/700.css"
       rel="stylesheet"
     />
     <link
@@ -57,8 +57,8 @@
         --error: #c62828;
         --fg-inline-code: #1f4fbf;
         --font-sans: "Inter", -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
-        --font-mono: "TX-02", "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
-        --font-markdown-mono: "TX-02", "JetBrains Mono", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
+        --font-mono: "Lilex", "TX-02", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
+        --font-markdown-mono: "Lilex", "TX-02", ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, Liberation Mono, Courier New, monospace;
         --font-markdown: var(--font-sans);
         --font-weight-bold: 700;
         --font-size-xs: 12px;

klaude_code/skill/manager.py

@@ -84,7 +84,8 @@ def format_available_skills_for_system_prompt() -> str:
         if not skills_xml:
             return ""
 
-        return f"""\
+        return f"""
+
 # Skills
 
 Skills are optional task-specific instructions stored as `SKILL.md` files.