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

klaude_code/llm/responses/client.py

@@ -1,20 +1,181 @@
 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
+import openai
+from openai import AsyncAzureOpenAI, AsyncOpenAI
 from openai.types import responses
+from openai.types.responses.response_create_params import ResponseCreateParamsStreaming
 
-from klaude_code.llm.client import LLMClientABC, call_with_logged_payload
+from klaude_code.llm.client import LLMClientABC
 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
 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
+
+
+def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:
+    """Build OpenAI Responses API request parameters."""
+    inputs = convert_history_to_input(param.input, param.model)
+    tools = convert_tool_schema(param.tools)
+
+    payload: ResponseCreateParamsStreaming = {
+        "model": str(param.model),
+        "tool_choice": "auto",
+        "parallel_tool_calls": True,
+        "include": [
+            "reasoning.encrypted_content",
+        ],
+        "store": False,
+        "stream": True,
+        "temperature": param.temperature,
+        "max_output_tokens": param.max_tokens,
+        "input": inputs,
+        "instructions": param.system,
+        "tools": tools,
+        "prompt_cache_key": param.session_id or "",
+    }
+
+    if param.thinking and param.thinking.reasoning_effort:
+        payload["reasoning"] = {
+            "effort": param.thinking.reasoning_effort,
+            "summary": param.thinking.reasoning_summary,
+        }
+
+    if param.verbosity:
+        payload["text"] = {"verbosity": param.verbosity}
+
+    return payload
+
+
+async def parse_responses_stream(
+    stream: "AsyncStream[ResponseStreamEvent]",
+    param: llm_param.LLMCallParameter,
+    metadata_tracker: MetadataTracker,
+) -> AsyncGenerator[model.ConversationItem]:
+    """Parse OpenAI Responses API stream events into ConversationItems."""
+    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.ResponseReasoningSummaryTextDeltaEvent() as event:
+                    if event.delta:
+                        metadata_tracker.record_token()
+                        yield model.ReasoningTextDelta(
+                            content=event.delta,
+                            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 event.delta:
+                        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):
+                        metadata_tracker.record_token()
+                        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:
+                                metadata_tracker.record_token()
+                                yield model.ReasoningEncryptedItem(
+                                    id=item.id,
+                                    encrypted_content=item.encrypted_content,
+                                    response_id=response_id,
+                                    model=str(param.model),
+                                )
+                        case responses.ResponseOutputMessage() as item:
+                            metadata_tracker.record_token()
+                            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:
+                            metadata_tracker.record_token()
+                            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:
+                    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:
+                        metadata_tracker.set_usage(
+                            model.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,
+                                context_size=event.response.usage.total_tokens,
+                                context_limit=param.context_limit,
+                                max_tokens=param.max_tokens,
+                            )
+                        )
+                    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:
+                            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 (openai.OpenAIError, httpx.HTTPError) as e:
+        yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+
 
 @register(llm_param.LLMClientProtocol.RESPONSES)
 class ResponsesClient(LLMClientABC):
@@ -43,174 +204,26 @@ class ResponsesClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         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(
-            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.
-            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,
-            },
-            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:
-            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
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
-                            if first_token_time is not None:
-                                first_token_latency_ms = (first_token_time - request_start_time) * 1000
+        payload = build_payload(param)
 
-                            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
+        log_debug(
+            json.dumps(payload, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+        try:
+            stream = await self.client.responses.create(
+                **payload,
+                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__} {e!s}")
+            return
 
-                            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, metadata_tracker):
+            yield item

klaude_code/llm/responses/input.py

@@ -1,5 +1,6 @@
 # pyright: reportReturnType=false
 # pyright: reportArgumentType=false
+# pyright: reportAssignmentType=false
 
 from typing import Any
 
@@ -34,7 +35,7 @@ def _build_tool_result_item(tool: model.ToolResultItem) -> responses.ResponseInp
         "call_id": tool.call_id,
         "output": content_parts,
     }
-    return item  # type: ignore[return-value]
+    return item
 
 
 def convert_history_to_input(
@@ -51,6 +52,7 @@ def convert_history_to_input(
     items: list[responses.ResponseInputItemParam] = []
 
     pending_reasoning_text: str | None = None
+    degraded_thinking_texts: list[str] = []
 
     for item in history:
         match item:
@@ -60,6 +62,9 @@ def convert_history_to_input(
                 # or we can choose to output it if the next item is NOT reasoning?
                 # For now, based on instructions, we pair them.
                 if model_name != item.model:
+                    # Cross-model: collect thinking text for degradation
+                    if item.content:
+                        degraded_thinking_texts.append(item.content)
                     continue
                 pending_reasoning_text = item.content
 
@@ -130,6 +135,20 @@ def convert_history_to_input(
                 # Other items may be Metadata
                 continue
 
+    # Cross-model: degrade thinking to plain text with <thinking> tags
+    if degraded_thinking_texts:
+        degraded_item: responses.ResponseInputItemParam = {
+            "type": "message",
+            "role": "assistant",
+            "content": [
+                {
+                    "type": "output_text",
+                    "text": "<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>",
+                }
+            ],
+        }
+        items.insert(0, degraded_item)
+
     return items
 
 

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
@@ -24,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."""
@@ -81,7 +81,7 @@ class MetadataTracker:
             ) * 1000
 
             if self._last_token_time is not None and self._metadata_item.usage.output_tokens > 0:
-                time_duration = self._last_token_time - self._first_token_time
+                time_duration = self._last_token_time - self._request_start_time
                 if time_duration >= 0.15:
                     self._metadata_item.usage.throughput_tps = self._metadata_item.usage.output_tokens / time_duration
 
@@ -92,18 +92,23 @@ class MetadataTracker:
         return self._metadata_item
 
 
-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
+def convert_usage(
+    usage: openai.types.CompletionUsage,
+    context_limit: int | None = None,
+    max_tokens: int | None = None,
+) -> model.Usage:
+    """Convert OpenAI CompletionUsage to internal Usage model.
+
+    context_token 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_size=usage.total_tokens,
+        context_limit=context_limit,
+        max_tokens=max_tokens,
     )

klaude_code/protocol/commands.py

@@ -1,9 +1,20 @@
+from dataclasses import dataclass
 from enum import Enum
 
 
+@dataclass(frozen=True, slots=True)
+class CommandInfo:
+    """Lightweight command metadata for UI purposes (no logic)."""
+
+    name: str
+    summary: str
+    support_addition_params: bool = False
+    placeholder: str = ""
+
+
 class CommandName(str, Enum):
     INIT = "init"
-    DIFF = "diff"
+    DEBUG = "debug"
     HELP = "help"
     MODEL = "model"
     COMPACT = "compact"
@@ -11,7 +22,12 @@ class CommandName(str, Enum):
     CLEAR = "clear"
     TERMINAL_SETUP = "terminal-setup"
     EXPORT = "export"
+    EXPORT_ONLINE = "export-online"
     STATUS = "status"
+    RELEASE_NOTES = "release-notes"
+    THINKING = "thinking"
+    FORK_SESSION = "fork-session"
+    RESUME = "resume"
     # 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

@@ -16,6 +16,7 @@ class EndEvent(BaseModel):
 class ErrorEvent(BaseModel):
     error_message: str
     can_retry: bool = False
+    session_id: str | None = None
 
 
 class TaskStartEvent(BaseModel):
@@ -26,6 +27,7 @@ class TaskStartEvent(BaseModel):
 class TaskFinishEvent(BaseModel):
     session_id: str
     task_result: str
+    has_structured_output: bool = False
 
 
 class TurnStartEvent(BaseModel):
@@ -54,6 +56,12 @@ class ThinkingEvent(BaseModel):
     content: str
 
 
+class ThinkingDeltaEvent(BaseModel):
+    session_id: str
+    response_id: str | None = None
+    content: str
+
+
 class AssistantMessageDeltaEvent(BaseModel):
     session_id: str
     response_id: str | None = None
@@ -79,7 +87,6 @@ class ToolCallEvent(BaseModel):
     tool_call_id: str
     tool_name: str
     arguments: str
-    is_replay: bool = False
 
 
 class ToolResultEvent(BaseModel):
@@ -90,16 +97,23 @@ class ToolResultEvent(BaseModel):
     result: str
     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
@@ -120,16 +134,26 @@ class TodoChangeEvent(BaseModel):
     todos: list[model.TodoItem]
 
 
+class ContextUsageEvent(BaseModel):
+    """Real-time context usage update during task execution."""
+
+    session_id: str
+    context_percent: float  # Context usage percentage (0-100)
+
+
 HistoryItemEvent = (
     ThinkingEvent
+    | TaskStartEvent
+    | TaskFinishEvent
     | TurnStartEvent  # This event is used for UI to print new empty line
     | AssistantMessageEvent
     | ToolCallEvent
     | ToolResultEvent
     | UserMessageEvent
-    | ResponseMetadataEvent
+    | TaskMetadataEvent
     | InterruptEvent
     | DeveloperMessageEvent
+    | ErrorEvent
 )
 
 
@@ -144,11 +168,13 @@ Event = (
     TaskStartEvent
     | TaskFinishEvent
     | ThinkingEvent
+    | ThinkingDeltaEvent
     | AssistantMessageDeltaEvent
     | AssistantMessageEvent
     | ToolCallEvent
     | ToolResultEvent
     | ResponseMetadataEvent
+    | TaskMetadataEvent
     | ReplayHistoryEvent
     | ErrorEvent
     | EndEvent
@@ -160,4 +186,5 @@ Event = (
     | TurnStartEvent
     | TurnEndEvent
     | TurnToolCallStartEvent
+    | ContextUsageEvent
 )