klaude-code 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/llm/openrouter/reasoning_handler.py

@@ -0,0 +1,209 @@
+from enum import Enum
+
+from pydantic import BaseModel
+
+from klaude_code.protocol import model
+
+
+class ReasoningDetail(BaseModel):
+    """OpenRouter's https://openrouter.ai/docs/use-cases/reasoning-tokens#reasoning_details-array-structure"""
+
+    type: str
+    format: str
+    index: int
+    id: str | None = None
+    data: str | None = None  # OpenAI's encrypted content
+    summary: str | None = None
+    text: str | None = None
+    signature: str | None = None  # Claude's signature
+
+
+class ReasoningMode(str, Enum):
+    COMPLETE_CHUNK = "complete_chunk"
+    GPT5_SECTIONS = "gpt5_sections"
+    ACCUMULATE = "accumulate"
+
+
+class ReasoningStreamHandler:
+    """Encapsulates reasoning stream handling across different model behaviors."""
+
+    def __init__(
+        self,
+        param_model: str,
+        response_id: str | None,
+    ) -> None:
+        self._param_model = param_model
+        self._response_id = response_id
+
+        self._reasoning_id: str | None = None
+        self._accumulated_reasoning: list[str] = []
+        self._gpt5_line_buffer: str = ""
+        self._gpt5_section_lines: list[str] = []
+
+    def set_response_id(self, response_id: str | None) -> None:
+        """Update the response identifier used for emitted items."""
+
+        self._response_id = response_id
+
+    def on_detail(self, detail: ReasoningDetail) -> list[model.ConversationItem]:
+        """Process a single reasoning detail and return streamable items."""
+
+        items: list[model.ConversationItem] = []
+
+        if detail.type == "reasoning.encrypted":
+            self._reasoning_id = detail.id
+            if encrypted_item := self._build_encrypted_item(detail.data, detail):
+                items.append(encrypted_item)
+            return items
+
+        if detail.type in ("reasoning.text", "reasoning.summary"):
+            self._reasoning_id = detail.id
+            if encrypted_item := self._build_encrypted_item(detail.signature, detail):
+                items.append(encrypted_item)
+            text = detail.text if detail.type == "reasoning.text" else detail.summary
+            if text:
+                items.extend(self._handle_text(text))
+
+        return items
+
+    def flush(self) -> list[model.ConversationItem]:
+        """Flush buffered reasoning text and encrypted payloads."""
+
+        items: list[model.ConversationItem] = []
+        mode = self._resolve_mode()
+
+        if mode is ReasoningMode.GPT5_SECTIONS:
+            for section in self._drain_gpt5_sections():
+                items.append(self._build_text_item(section))
+        elif self._accumulated_reasoning and mode is ReasoningMode.ACCUMULATE:
+            items.append(self._build_text_item("".join(self._accumulated_reasoning)))
+            self._accumulated_reasoning = []
+
+        return items
+
+    def _handle_text(self, text: str) -> list[model.ReasoningTextItem]:
+        mode = self._resolve_mode()
+        if mode is ReasoningMode.COMPLETE_CHUNK:
+            return [self._build_text_item(text)]
+        if mode is ReasoningMode.GPT5_SECTIONS:
+            sections = self._process_gpt5_text(text)
+            return [self._build_text_item(section) for section in sections]
+        self._accumulated_reasoning.append(text)
+        return []
+
+    def _build_text_item(self, content: str) -> model.ReasoningTextItem:
+        return model.ReasoningTextItem(
+            id=self._reasoning_id,
+            content=content,
+            response_id=self._response_id,
+            model=self._param_model,
+        )
+
+    def _build_encrypted_item(
+        self,
+        content: str | None,
+        detail: ReasoningDetail,
+    ) -> model.ReasoningEncryptedItem | None:
+        if not content:
+            return None
+        return model.ReasoningEncryptedItem(
+            id=detail.id,
+            encrypted_content=content,
+            format=detail.format,
+            response_id=self._response_id,
+            model=self._param_model,
+        )
+
+    def _process_gpt5_text(self, text: str) -> list[str]:
+        emitted_sections: list[str] = []
+        self._gpt5_line_buffer += text
+        while True:
+            newline_index = self._gpt5_line_buffer.find("\n")
+            if newline_index == -1:
+                break
+            line = self._gpt5_line_buffer[:newline_index]
+            self._gpt5_line_buffer = self._gpt5_line_buffer[newline_index + 1 :]
+            remainder = line
+            while True:
+                split_result = self._split_gpt5_title_line(remainder)
+                if split_result is None:
+                    break
+                prefix_segment, title_segment, remainder = split_result
+                if prefix_segment:
+                    if not self._gpt5_section_lines:
+                        self._gpt5_section_lines = []
+                    self._gpt5_section_lines.append(f"{prefix_segment}\n")
+                if self._gpt5_section_lines:
+                    emitted_sections.append("".join(self._gpt5_section_lines))
+                self._gpt5_section_lines = [f"{title_segment}  \n"]  # Add two spaces for markdown line break
+            if remainder:
+                if not self._gpt5_section_lines:
+                    self._gpt5_section_lines = []
+                self._gpt5_section_lines.append(f"{remainder}\n")
+        return emitted_sections
+
+    def _drain_gpt5_sections(self) -> list[str]:
+        sections: list[str] = []
+        if self._gpt5_line_buffer:
+            if not self._gpt5_section_lines:
+                self._gpt5_section_lines = [self._gpt5_line_buffer]
+            else:
+                self._gpt5_section_lines.append(self._gpt5_line_buffer)
+            self._gpt5_line_buffer = ""
+        if self._gpt5_section_lines:
+            sections.append("".join(self._gpt5_section_lines))
+            self._gpt5_section_lines = []
+        return sections
+
+    def _is_gpt5(self) -> bool:
+        return "gpt-5" in self._param_model.lower()
+
+    def _is_complete_chunk_reasoning_model(self) -> bool:
+        """Whether the current model emits reasoning in complete chunks (e.g. Gemini)."""
+
+        return self._param_model.startswith("google/gemini")
+
+    def _resolve_mode(self) -> ReasoningMode:
+        if self._is_complete_chunk_reasoning_model():
+            return ReasoningMode.COMPLETE_CHUNK
+        if self._is_gpt5():
+            return ReasoningMode.GPT5_SECTIONS
+        return ReasoningMode.ACCUMULATE
+
+    def _is_gpt5_title_line(self, line: str) -> bool:
+        stripped = line.strip()
+        if not stripped:
+            return False
+        return stripped.startswith("**") and stripped.endswith("**") and stripped.count("**") >= 2
+
+    def _split_gpt5_title_line(self, line: str) -> tuple[str | None, str, str] | None:
+        if not line:
+            return None
+        search_start = 0
+        while True:
+            opening_index = line.find("**", search_start)
+            if opening_index == -1:
+                return None
+            closing_index = line.find("**", opening_index + 2)
+            if closing_index == -1:
+                return None
+            title_candidate = line[opening_index : closing_index + 2]
+            stripped_title = title_candidate.strip()
+            if self._is_gpt5_title_line(stripped_title):
+                # Treat as a GPT-5 title only when everything after the
+                # bold segment is either whitespace or starts a new bold
+                # title. This prevents inline bold like `**xxx**yyyy`
+                # from being misclassified as a section title while
+                # preserving support for consecutive titles in one line.
+                after = line[closing_index + 2 :]
+                if after.strip() and not after.lstrip().startswith("**"):
+                    search_start = closing_index + 2
+                    continue
+                prefix_segment = line[:opening_index]
+                remainder_segment = after
+                return (
+                    prefix_segment if prefix_segment else None,
+                    stripped_title,
+                    remainder_segment,
+                )
+            search_start = closing_index + 2

klaude_code/llm/registry.py

@@ -1,22 +1,14 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable, TypeVar
+from typing import Callable, TypeVar
 
 from klaude_code.llm.client import LLMClientABC
-from klaude_code.protocol.llm_parameter import LLMClientProtocol, LLMConfigParameter
-from klaude_code.protocol.tools import SubAgentType
-from klaude_code.trace import DebugType, log_debug
-
-if TYPE_CHECKING:
-    from klaude_code.config.config import Config
+from klaude_code.protocol import llm_param
 
-_REGISTRY: dict[LLMClientProtocol, type[LLMClientABC]] = {}
+_REGISTRY: dict[llm_param.LLMClientProtocol, type[LLMClientABC]] = {}
 
 T = TypeVar("T", bound=LLMClientABC)
 
 
-def register(name: LLMClientProtocol) -> Callable[[type[T]], type[T]]:
+def register(name: llm_param.LLMClientProtocol) -> Callable[[type[T]], type[T]]:
     def _decorator(cls: type[T]) -> type[T]:
         _REGISTRY[name] = cls
         return cls
@@ -24,69 +16,7 @@ def register(name: LLMClientProtocol) -> Callable[[type[T]], type[T]]:
     return _decorator
 
 
-def create_llm_client(config: LLMConfigParameter) -> LLMClientABC:
+def create_llm_client(config: llm_param.LLMConfigParameter) -> LLMClientABC:
     if config.protocol not in _REGISTRY:
         raise ValueError(f"Unknown LLMClient protocol: {config.protocol}")
     return _REGISTRY[config.protocol].create(config)
-
-
-@dataclass
-class LLMClients:
-    """Container for LLM clients used by main agent and sub-agents."""
-
-    main: LLMClientABC
-    sub_clients: dict[SubAgentType, LLMClientABC] = field(default_factory=lambda: {})
-
-    def get_client(self, sub_agent_type: SubAgentType | None = None) -> LLMClientABC:
-        """Get client for given sub-agent type, or main client if None."""
-        if sub_agent_type is None:
-            return self.main
-        return self.sub_clients.get(sub_agent_type) or self.main
-
-    @classmethod
-    def from_config(
-        cls,
-        config: Config,
-        model_override: str | None = None,
-        enabled_sub_agents: list[SubAgentType] | None = None,
-    ) -> LLMClients:
-        """Create LLMClients from application config.
-
-        Args:
-            config: Application configuration
-            model_override: Optional model name to override the main model
-            enabled_sub_agents: List of sub-agent types to initialize clients for
-
-        Returns:
-            LLMClients instance
-        """
-        from klaude_code.core.sub_agent import get_sub_agent_profile
-
-        # Resolve main agent LLM config
-        if model_override:
-            llm_config = config.get_model_config(model_override)
-        else:
-            llm_config = config.get_main_model_config()
-
-        log_debug(
-            "Main LLM config",
-            llm_config.model_dump_json(exclude_none=True),
-            style="yellow",
-            debug_type=DebugType.LLM_CONFIG,
-        )
-
-        main_client = create_llm_client(llm_config)
-        sub_clients: dict[SubAgentType, LLMClientABC] = {}
-
-        # Initialize sub-agent clients
-        for sub_agent_type in enabled_sub_agents or []:
-            model_name = config.subagent_models.get(sub_agent_type)
-            if not model_name:
-                continue
-            profile = get_sub_agent_profile(sub_agent_type)
-            if not profile.enabled_for_model(main_client.model_name):
-                continue
-            sub_llm_config = config.get_model_config(model_name)
-            sub_clients[sub_agent_type] = create_llm_client(sub_llm_config)
-
-        return cls(main=main_client, sub_clients=sub_clients)

klaude_code/llm/responses/client.py

@@ -1,58 +1,24 @@
 import json
 import time
 from collections.abc import AsyncGenerator
-from typing import Callable, ParamSpec, TypeVar, override
+from typing import override
 
 import httpx
 from openai import AsyncAzureOpenAI, AsyncOpenAI, RateLimitError
 from openai.types import responses
 
-from klaude_code.llm.client import LLMClientABC
+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.protocol.llm_parameter import (
-    LLMCallParameter,
-    LLMClientProtocol,
-    LLMConfigParameter,
-    apply_config_defaults,
-)
-from klaude_code.protocol.model import (
-    AssistantMessageDelta,
-    AssistantMessageItem,
-    ConversationItem,
-    ReasoningEncryptedItem,
-    ReasoningTextItem,
-    ResponseMetadataItem,
-    StartItem,
-    StreamErrorItem,
-    ToolCallItem,
-    Usage,
-)
+from klaude_code.llm.usage import calculate_cost
+from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
-P = ParamSpec("P")
-R = TypeVar("R")
 
-
-def call_with_logged_payload(func: Callable[P, R], *args: P.args, **kwargs: P.kwargs) -> R:
-    """Call an SDK function while logging the JSON payload.
-
-    The function reuses the original callable's type signature via ParamSpec
-    so static type checkers can validate arguments at the call site.
-    """
-
-    payload = {k: v for k, v in kwargs.items() if v is not None}
-    log_debug(
-        json.dumps(payload, ensure_ascii=False, default=str),
-        style="yellow",
-        debug_type=DebugType.LLM_PAYLOAD,
-    )
-    return func(*args, **kwargs)
-
-
-@register(LLMClientProtocol.RESPONSES)
+@register(llm_param.LLMClientProtocol.RESPONSES)
 class ResponsesClient(LLMClientABC):
-    def __init__(self, config: LLMConfigParameter):
+    def __init__(self, config: llm_param.LLMConfigParameter):
         super().__init__(config)
         if config.is_azure:
             if not config.base_url:
@@ -73,11 +39,11 @@ class ResponsesClient(LLMClientABC):
 
     @classmethod
     @override
-    def create(cls, config: LLMConfigParameter) -> "LLMClientABC":
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
         return cls(config)
 
     @override
-    async def call(self, param: LLMCallParameter) -> AsyncGenerator[ConversationItem, None]:
+    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()
@@ -129,10 +95,10 @@ class ResponsesClient(LLMClientABC):
                 match event:
                     case responses.ResponseCreatedEvent() as event:
                         response_id = event.response.id
-                        yield StartItem(response_id=response_id)
+                        yield model.StartItem(response_id=response_id)
                     case responses.ResponseReasoningSummaryTextDoneEvent() as event:
                         if event.text:
-                            yield ReasoningTextItem(
+                            yield model.ReasoningTextItem(
                                 content=event.text,
                                 response_id=response_id,
                                 model=str(param.model),
@@ -141,19 +107,26 @@ class ResponsesClient(LLMClientABC):
                         if first_token_time is None:
                             first_token_time = time.time()
                         last_token_time = time.time()
-                        yield AssistantMessageDelta(content=event.delta, response_id=response_id)
+                        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 ReasoningEncryptedItem(
+                                    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 AssistantMessageItem(
+                                yield model.AssistantMessageItem(
                                     content="\n".join(
                                         [
                                             part.text
@@ -168,7 +141,7 @@ class ResponsesClient(LLMClientABC):
                                 if first_token_time is None:
                                     first_token_time = time.time()
                                 last_token_time = time.time()
-                                yield ToolCallItem(
+                                yield model.ToolCallItem(
                                     name=item.name,
                                     arguments=item.arguments.strip(),
                                     call_id=item.call_id,
@@ -178,7 +151,7 @@ class ResponsesClient(LLMClientABC):
                             case _:
                                 pass
                     case responses.ResponseCompletedEvent() as event:
-                        usage: Usage | None = None
+                        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
@@ -203,7 +176,7 @@ class ResponsesClient(LLMClientABC):
                                 if time_duration >= 0.15:
                                     throughput_tps = event.response.usage.output_tokens / time_duration
 
-                            usage = Usage(
+                            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,
@@ -213,7 +186,8 @@ class ResponsesClient(LLMClientABC):
                                 throughput_tps=throughput_tps,
                                 first_token_latency_ms=first_token_latency_ms,
                             )
-                        yield ResponseMetadataItem(
+                            calculate_cost(usage, self._config.cost)
+                        yield model.ResponseMetadataItem(
                             usage=usage,
                             response_id=response_id,
                             model_name=str(param.model),
@@ -230,8 +204,13 @@ class ResponsesClient(LLMClientABC):
                                 style="red",
                                 debug_type=DebugType.LLM_STREAM,
                             )
-                            yield StreamErrorItem(error=error_message)
+                            yield model.StreamErrorItem(error=error_message)
                     case _:
-                        log_debug("[Unhandled stream event]", str(event), style="red", debug_type=DebugType.LLM_STREAM)
+                        log_debug(
+                            "[Unhandled stream event]",
+                            str(event),
+                            style="red",
+                            debug_type=DebugType.LLM_STREAM,
+                        )
         except RateLimitError as e:
-            yield StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")

klaude_code/llm/responses/input.py

@@ -5,20 +5,12 @@ from typing import Any
 
 from openai.types import responses
 
-from klaude_code.protocol.llm_parameter import ToolSchema
-from klaude_code.protocol.model import (
-    AssistantMessageItem,
-    ConversationItem,
-    DeveloperMessageItem,
-    ReasoningEncryptedItem,
-    ReasoningTextItem,
-    ToolCallItem,
-    ToolResultItem,
-    UserMessageItem,
-)
-
-
-def _build_user_content_parts(user: UserMessageItem) -> list[responses.ResponseInputContentParam]:
+from klaude_code.protocol import llm_param, model
+
+
+def _build_user_content_parts(
+    user: model.UserMessageItem,
+) -> list[responses.ResponseInputContentParam]:
     parts: list[responses.ResponseInputContentParam] = []
     if user.content is not None:
         parts.append({"type": "input_text", "text": user.content})
@@ -29,7 +21,7 @@ def _build_user_content_parts(user: UserMessageItem) -> list[responses.ResponseI
     return parts
 
 
-def _build_tool_result_item(tool: ToolResultItem) -> responses.ResponseInputItemParam:
+def _build_tool_result_item(tool: model.ToolResultItem) -> responses.ResponseInputItemParam:
     content_parts: list[responses.ResponseInputContentParam] = []
     text_output = tool.output or ""
     if text_output:
@@ -46,7 +38,7 @@ def _build_tool_result_item(tool: ToolResultItem) -> responses.ResponseInputItem
 
 
 def convert_history_to_input(
-    history: list[ConversationItem],
+    history: list[model.ConversationItem],
     model_name: str | None = None,
 ) -> responses.ResponseInputParam:
     """
@@ -62,7 +54,7 @@ def convert_history_to_input(
 
     for item in history:
         match item:
-            case ReasoningTextItem() as item:
+            case model.ReasoningTextItem() as item:
                 # For now, we only store the text. We wait for the encrypted item to output both.
                 # If no encrypted item follows (e.g. incomplete stream?), this text might be lost
                 # or we can choose to output it if the next item is NOT reasoning?
@@ -71,13 +63,13 @@ def convert_history_to_input(
                     continue
                 pending_reasoning_text = item.content
 
-            case ReasoningEncryptedItem() as item:
+            case model.ReasoningEncryptedItem() as item:
                 if item.encrypted_content and len(item.encrypted_content) > 0 and model_name == item.model:
                     items.append(convert_reasoning_inputs(pending_reasoning_text, item))
                 # Reset pending text after consumption
                 pending_reasoning_text = None
 
-            case ToolCallItem() as t:
+            case model.ToolCallItem() as t:
                 items.append(
                     {
                         "type": "function_call",
@@ -87,9 +79,9 @@ def convert_history_to_input(
                         "id": t.id,
                     }
                 )
-            case ToolResultItem() as t:
+            case model.ToolResultItem() as t:
                 items.append(_build_tool_result_item(t))
-            case AssistantMessageItem() as a:
+            case model.AssistantMessageItem() as a:
                 items.append(
                     {
                         "type": "message",
@@ -103,7 +95,7 @@ def convert_history_to_input(
                         ],
                     }
                 )
-            case UserMessageItem() as u:
+            case model.UserMessageItem() as u:
                 items.append(
                     {
                         "type": "message",
@@ -112,12 +104,18 @@ def convert_history_to_input(
                         "content": _build_user_content_parts(u),
                     }
                 )
-            case DeveloperMessageItem() as d:
+            case model.DeveloperMessageItem() as d:
                 dev_parts: list[responses.ResponseInputContentParam] = []
                 if d.content is not None:
                     dev_parts.append({"type": "input_text", "text": d.content})
                 for image in d.images or []:
-                    dev_parts.append({"type": "input_image", "detail": "auto", "image_url": image.image_url.url})
+                    dev_parts.append(
+                        {
+                            "type": "input_image",
+                            "detail": "auto",
+                            "image_url": image.image_url.url,
+                        }
+                    )
                 if not dev_parts:
                     dev_parts.append({"type": "input_text", "text": ""})
                 items.append(
@@ -136,7 +134,7 @@ def convert_history_to_input(
 
 
 def convert_reasoning_inputs(
-    text_content: str | None, encrypted_item: ReasoningEncryptedItem
+    text_content: str | None, encrypted_item: model.ReasoningEncryptedItem
 ) -> responses.ResponseInputItemParam:
     result = {"type": "reasoning", "content": None}
 
@@ -154,7 +152,7 @@ def convert_reasoning_inputs(
 
 
 def convert_tool_schema(
-    tools: list[ToolSchema] | None,
+    tools: list[llm_param.ToolSchema] | None,
 ) -> list[responses.ToolParam]:
     if tools is None:
         return []