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

klaude_code/llm/openrouter/client.py

@@ -1,5 +1,5 @@
 from collections.abc import AsyncGenerator
-from typing import Literal, override
+from typing import override
 
 import httpx
 import openai
@@ -7,7 +7,7 @@ import openai
 from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.openai_compatible.input import convert_tool_schema
-from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
+from klaude_code.llm.openai_compatible.stream_processor import StreamStateManager
 from klaude_code.llm.openrouter.input import convert_history_to_input, is_claude_model
 from klaude_code.llm.openrouter.reasoning_handler import ReasoningDetail, ReasoningStreamHandler
 from klaude_code.llm.registry import register
@@ -77,36 +77,14 @@ class OpenRouterClient(LLMClientABC):
             extra_headers=extra_headers,  # pyright: ignore[reportUnknownArgumentType]
         )
 
-        stage: Literal["waiting", "reasoning", "assistant", "tool", "done"] = "waiting"
-        response_id: str | None = None
-        accumulated_content: list[str] = []
-        accumulated_tool_calls: ToolCallAccumulatorABC = BasicToolCallAccumulator()
-        emitted_tool_start_indices: set[int] = set()
         reasoning_handler = ReasoningStreamHandler(
             param_model=str(param.model),
-            response_id=response_id,
+            response_id=None,
+        )
+        state = StreamStateManager(
+            param_model=str(param.model),
+            reasoning_flusher=reasoning_handler.flush,
         )
-
-        def flush_reasoning_items() -> list[model.ConversationItem]:
-            return reasoning_handler.flush()
-
-        def flush_assistant_items() -> list[model.ConversationItem]:
-            nonlocal accumulated_content
-            if len(accumulated_content) == 0:
-                return []
-            item = model.AssistantMessageItem(
-                content="".join(accumulated_content),
-                response_id=response_id,
-            )
-            accumulated_content = []
-            return [item]
-
-        def flush_tool_call_items() -> list[model.ToolCallItem]:
-            nonlocal accumulated_tool_calls
-            items: list[model.ToolCallItem] = accumulated_tool_calls.get()
-            if items:
-                accumulated_tool_calls.chunks_by_step = []  # pyright: ignore[reportAttributeAccessIssue]
-            return items
 
         try:
             async for event in await stream:
@@ -115,11 +93,10 @@ class OpenRouterClient(LLMClientABC):
                     style="blue",
                     debug_type=DebugType.LLM_STREAM,
                 )
-                if not response_id and event.id:
-                    response_id = event.id
-                    reasoning_handler.set_response_id(response_id)
-                    accumulated_tool_calls.response_id = response_id
-                    yield model.StartItem(response_id=response_id)
+                if not state.response_id and event.id:
+                    state.set_response_id(event.id)
+                    reasoning_handler.set_response_id(event.id)
+                    yield model.StartItem(response_id=event.id)
                 if (
                     event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison]
                 ):  # gcp gemini will return None usage field
@@ -140,7 +117,7 @@ class OpenRouterClient(LLMClientABC):
                         try:
                             reasoning_detail = ReasoningDetail.model_validate(item)
                             metadata_tracker.record_token()
-                            stage = "reasoning"
+                            state.stage = "reasoning"
                             for conversation_item in reasoning_handler.on_detail(reasoning_detail):
                                 yield conversation_item
                         except Exception as e:
@@ -148,53 +125,46 @@ class OpenRouterClient(LLMClientABC):
 
                 # Assistant
                 if delta.content and (
-                    stage == "assistant" or delta.content.strip()
+                    state.stage == "assistant" or delta.content.strip()
                 ):  # Process all content in assistant stage, filter empty content in reasoning stage
                     metadata_tracker.record_token()
-                    if stage == "reasoning":
-                        for item in flush_reasoning_items():
+                    if state.stage == "reasoning":
+                        for item in state.flush_reasoning():
                             yield item
-                    stage = "assistant"
-                    accumulated_content.append(delta.content)
+                    state.stage = "assistant"
+                    state.accumulated_content.append(delta.content)
                     yield model.AssistantMessageDelta(
                         content=delta.content,
-                        response_id=response_id,
+                        response_id=state.response_id,
                     )
 
                 # Tool
                 if delta.tool_calls and len(delta.tool_calls) > 0:
                     metadata_tracker.record_token()
-                    if stage == "reasoning":
-                        for item in flush_reasoning_items():
+                    if state.stage == "reasoning":
+                        for item in state.flush_reasoning():
                             yield item
-                    elif stage == "assistant":
-                        for item in flush_assistant_items():
+                    elif state.stage == "assistant":
+                        for item in state.flush_assistant():
                             yield item
-                    stage = "tool"
+                    state.stage = "tool"
                     # Emit ToolCallStartItem for new tool calls
                     for tc in delta.tool_calls:
-                        if tc.index not in emitted_tool_start_indices and tc.function and tc.function.name:
-                            emitted_tool_start_indices.add(tc.index)
+                        if tc.index not in state.emitted_tool_start_indices and tc.function and tc.function.name:
+                            state.emitted_tool_start_indices.add(tc.index)
                             yield model.ToolCallStartItem(
-                                response_id=response_id,
+                                response_id=state.response_id,
                                 call_id=tc.id or "",
                                 name=tc.function.name,
                             )
-                    accumulated_tool_calls.add(delta.tool_calls)
+                    state.accumulated_tool_calls.add(delta.tool_calls)
 
         except (openai.OpenAIError, httpx.HTTPError) as e:
             yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
 
         # Finalize
-        for item in flush_reasoning_items():
-            yield item
-
-        for item in flush_assistant_items():
+        for item in state.flush_all():
             yield item
 
-        if stage == "tool":
-            for tool_call_item in flush_tool_call_items():
-                yield tool_call_item
-
-        metadata_tracker.set_response_id(response_id)
+        metadata_tracker.set_response_id(state.response_id)
         yield metadata_tracker.finalize()

klaude_code/llm/openrouter/input.py

@@ -7,9 +7,9 @@
 # pyright: reportGeneralTypeIssues=false
 
 from openai.types import chat
-from openai.types.chat import ChatCompletionContentPartParam
 
-from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, merge_reminder_text, parse_message_groups
+from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, parse_message_groups
+from klaude_code.llm.openai_compatible.input import tool_group_to_openai_message, user_group_to_openai_message
 from klaude_code.protocol import model
 
 
@@ -25,29 +25,6 @@ def is_gemini_model(model_name: str | None) -> bool:
     return model_name is not None and model_name.startswith("google/gemini")
 
 
-def _user_group_to_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
-    parts: list[ChatCompletionContentPartParam] = []
-    for text in group.text_parts:
-        parts.append({"type": "text", "text": text + "\n"})
-    for image in group.images:
-        parts.append({"type": "image_url", "image_url": {"url": image.image_url.url}})
-    if not parts:
-        parts.append({"type": "text", "text": ""})
-    return {"role": "user", "content": parts}
-
-
-def _tool_group_to_message(group: ToolGroup) -> chat.ChatCompletionMessageParam:
-    merged_text = merge_reminder_text(
-        group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
-        group.reminder_texts,
-    )
-    return {
-        "role": "tool",
-        "content": [{"type": "text", "text": merged_text}],
-        "tool_call_id": group.tool_result.call_id,
-    }
-
-
 def _assistant_group_to_message(group: AssistantGroup, model_name: str | None) -> chat.ChatCompletionMessageParam:
     assistant_message: dict[str, object] = {"role": "assistant"}
 
@@ -150,9 +127,9 @@ def convert_history_to_input(
     for group in parse_message_groups(history):
         match group:
             case UserGroup():
-                messages.append(_user_group_to_message(group))
+                messages.append(user_group_to_openai_message(group))
             case ToolGroup():
-                messages.append(_tool_group_to_message(group))
+                messages.append(tool_group_to_openai_message(group))
             case AssistantGroup():
                 messages.append(_assistant_group_to_message(group, model_name))
 

klaude_code/llm/responses/client.py

@@ -1,17 +1,17 @@
 import json
-import time
 from collections.abc import AsyncGenerator
 from typing import TYPE_CHECKING, override
 
 import httpx
-from openai import AsyncAzureOpenAI, AsyncOpenAI, RateLimitError
+import openai
+from openai import AsyncAzureOpenAI, AsyncOpenAI
 from openai.types import responses
 
 from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
 from klaude_code.llm.input_common import apply_config_defaults
 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 calculate_cost
+from klaude_code.llm.usage import MetadataTracker, convert_responses_usage
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
@@ -23,12 +23,9 @@ if TYPE_CHECKING:
 async def parse_responses_stream(
     stream: "AsyncStream[ResponseStreamEvent]",
     param: llm_param.LLMCallParameter,
-    cost_config: llm_param.Cost | None,
-    request_start_time: float,
+    metadata_tracker: MetadataTracker,
 ) -> 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:
@@ -51,9 +48,7 @@ async def parse_responses_stream(
                             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()
+                    metadata_tracker.record_token()
                     yield model.AssistantMessageDelta(content=event.delta, response_id=response_id)
                 case responses.ResponseOutputItemAddedEvent() as event:
                     if isinstance(event.item, responses.ResponseFunctionToolCall):
@@ -85,9 +80,7 @@ async def parse_responses_stream(
                                 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()
+                            metadata_tracker.record_token()
                             yield model.ToolCallItem(
                                 name=item.name,
                                 arguments=item.arguments.strip(),
@@ -98,49 +91,22 @@ async def parse_responses_stream(
                         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(
+                        usage = convert_responses_usage(
                             input_tokens=event.response.usage.input_tokens,
+                            output_tokens=event.response.usage.output_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,
+                            total_tokens=event.response.usage.total_tokens,
+                            context_limit=param.context_limit,
                         )
-                        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,
-                    )
+                        metadata_tracker.set_usage(usage)
+                    metadata_tracker.set_model_name(str(param.model))
+                    metadata_tracker.set_response_id(response_id)
+                    yield metadata_tracker.finalize()
                     if event.response.status != "completed":
                         error_message = f"LLM response finished with status '{event.response.status}'"
                         if error_reason:
@@ -159,7 +125,7 @@ async def parse_responses_stream(
                         style="red",
                         debug_type=DebugType.LLM_STREAM,
                     )
-    except RateLimitError as e:
+    except (openai.OpenAIError, httpx.HTTPError) as e:
         yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
 
 
@@ -193,39 +159,43 @@ class ResponsesClient(LLMClientABC):
     async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
         param = apply_config_defaults(param, self.get_llm_config())
 
-        request_start_time = time.time()
+        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
 
         inputs = convert_history_to_input(param.input, param.model)
         tools = convert_tool_schema(param.tools)
 
-        stream = await call_with_logged_payload(
-            self.client.responses.create,
-            model=str(param.model),
-            tool_choice="auto",
-            parallel_tool_calls=True,
-            include=[
-                "reasoning.encrypted_content",
-            ],
-            store=param.store,
-            previous_response_id=param.previous_response_id,
-            stream=True,
-            temperature=param.temperature,
-            max_output_tokens=param.max_tokens,
-            input=inputs,
-            instructions=param.system,
-            tools=tools,
-            text={
-                "verbosity": param.verbosity,
-            },
-            prompt_cache_key=param.session_id or "",
-            reasoning={
-                "effort": param.thinking.reasoning_effort,
-                "summary": param.thinking.reasoning_summary,
-            }
-            if param.thinking and param.thinking.reasoning_effort
-            else None,
-            extra_headers={"extra": json.dumps({"session_id": param.session_id})},
-        )
+        try:
+            stream = await call_with_logged_payload(
+                self.client.responses.create,
+                model=str(param.model),
+                tool_choice="auto",
+                parallel_tool_calls=True,
+                include=[
+                    "reasoning.encrypted_content",
+                ],
+                store=param.store,
+                previous_response_id=param.previous_response_id,
+                stream=True,
+                temperature=param.temperature,
+                max_output_tokens=param.max_tokens,
+                input=inputs,
+                instructions=param.system,
+                tools=tools,
+                text={
+                    "verbosity": param.verbosity,
+                },
+                prompt_cache_key=param.session_id or "",
+                reasoning={
+                    "effort": param.thinking.reasoning_effort,
+                    "summary": param.thinking.reasoning_summary,
+                }
+                if param.thinking and param.thinking.reasoning_effort
+                else None,
+                extra_headers={"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)},
+            )
+        except (openai.OpenAIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            return
 
-        async for item in parse_responses_stream(stream, param, self._config.cost, request_start_time):
+        async for item in parse_responses_stream(stream, param, metadata_tracker):
             yield item

klaude_code/llm/usage.py

@@ -27,9 +27,6 @@ def calculate_cost(usage: model.Usage, cost_config: llm_param.Cost | None) -> No
     # Cache read cost
     usage.cache_read_cost = (usage.cached_tokens / 1_000_000) * cost_config.cache_read
 
-    # Total cost
-    usage.total_cost = usage.input_cost + usage.output_cost + usage.cache_read_cost
-
 
 class MetadataTracker:
     """Tracks timing and metadata for LLM responses."""
@@ -96,17 +93,61 @@ class MetadataTracker:
 
 
 def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None = None) -> model.Usage:
-    """Convert OpenAI CompletionUsage to internal Usage model."""
-    total_tokens = usage.total_tokens
-    context_usage_percent = (total_tokens / context_limit) * 100 if context_limit else None
+    """Convert OpenAI CompletionUsage to internal Usage model.
+
+    context_window_size is set to total_tokens from the API response,
+    representing the actual context window usage for this turn.
+    """
     return model.Usage(
         input_tokens=usage.prompt_tokens,
         cached_tokens=(usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0) or 0,
         reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
         or 0,
         output_tokens=usage.completion_tokens,
-        total_tokens=total_tokens,
-        context_usage_percent=context_usage_percent,
-        throughput_tps=None,
-        first_token_latency_ms=None,
+        context_window_size=usage.total_tokens,
+        context_limit=context_limit,
+    )
+
+
+def convert_anthropic_usage(
+    input_tokens: int,
+    output_tokens: int,
+    cached_tokens: int,
+    context_limit: int | None = None,
+) -> model.Usage:
+    """Convert Anthropic usage data to internal Usage model.
+
+    context_window_size is computed from input + cached + output tokens,
+    representing the actual context window usage for this turn.
+    """
+    context_window_size = input_tokens + cached_tokens + output_tokens
+    return model.Usage(
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cached_tokens=cached_tokens,
+        context_window_size=context_window_size,
+        context_limit=context_limit,
+    )
+
+
+def convert_responses_usage(
+    input_tokens: int,
+    output_tokens: int,
+    cached_tokens: int,
+    reasoning_tokens: int,
+    total_tokens: int,
+    context_limit: int | None = None,
+) -> model.Usage:
+    """Convert OpenAI Responses API usage data to internal Usage model.
+
+    context_window_size is set to total_tokens from the API response,
+    representing the actual context window usage for this turn.
+    """
+    return model.Usage(
+        input_tokens=input_tokens,
+        output_tokens=output_tokens,
+        cached_tokens=cached_tokens,
+        reasoning_tokens=reasoning_tokens,
+        context_window_size=total_tokens,
+        context_limit=context_limit,
     )

klaude_code/protocol/commands.py

@@ -12,6 +12,7 @@ class CommandName(str, Enum):
     TERMINAL_SETUP = "terminal-setup"
     EXPORT = "export"
     STATUS = "status"
+    RELEASE_NOTES = "release-notes"
     # 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"

klaude_code/protocol/events.py

@@ -91,15 +91,23 @@ class ToolResultEvent(BaseModel):
     ui_extra: model.ToolResultUIExtra | None = None
     status: Literal["success", "error"]
     is_replay: bool = False
+    task_metadata: model.TaskMetadata | None = None  # Sub-agent task metadata
 
 
 class ResponseMetadataEvent(BaseModel):
-    """Showing model name, usage tokens, task duration, and turn count."""
+    """Internal event for turn-level metadata. Not exposed to UI directly."""
 
     session_id: str
     metadata: model.ResponseMetadataItem
 
 
+class TaskMetadataEvent(BaseModel):
+    """Task-level aggregated metadata for UI display."""
+
+    session_id: str
+    metadata: model.TaskMetadataItem
+
+
 class UserMessageEvent(BaseModel):
     session_id: str
     content: str
@@ -127,9 +135,10 @@ HistoryItemEvent = (
     | ToolCallEvent
     | ToolResultEvent
     | UserMessageEvent
-    | ResponseMetadataEvent
+    | TaskMetadataEvent
     | InterruptEvent
     | DeveloperMessageEvent
+    | ErrorEvent
 )
 
 
@@ -149,6 +158,7 @@ Event = (
     | ToolCallEvent
     | ToolResultEvent
     | ResponseMetadataEvent
+    | TaskMetadataEvent
     | ReplayHistoryEvent
     | ErrorEvent
     | EndEvent