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

klaude_code/llm/openrouter/reasoning.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel
 
 from klaude_code.llm.openai_compatible.stream import ReasoningDeltaResult, ReasoningHandlerABC
-from klaude_code.protocol import model
+from klaude_code.protocol import message
 from klaude_code.trace import log
 
 
@@ -42,7 +42,7 @@ class ReasoningStreamHandler(ReasoningHandlerABC):
         if not reasoning_details:
             return ReasoningDeltaResult(handled=False, outputs=[])
 
-        outputs: list[str | model.ConversationItem] = []
+        outputs: list[str | message.Part] = []
         for item in reasoning_details:
             try:
                 reasoning_detail = ReasoningDetail.model_validate(item)
@@ -56,16 +56,16 @@ class ReasoningStreamHandler(ReasoningHandlerABC):
 
         return ReasoningDeltaResult(handled=True, outputs=outputs)
 
-    def on_detail(self, detail: ReasoningDetail) -> list[model.ConversationItem]:
-        """Process a single reasoning detail and return streamable items."""
-        items: list[model.ConversationItem] = []
+    def on_detail(self, detail: ReasoningDetail) -> list[message.Part]:
+        """Process a single reasoning detail and return streamable parts."""
+        items: list[message.Part] = []
 
         if detail.type == "reasoning.encrypted":
             self._reasoning_id = detail.id
             # Flush accumulated text before encrypted content
             items.extend(self._flush_text())
-            if encrypted_item := self._build_encrypted_item(detail.data, detail):
-                items.append(encrypted_item)
+            if signature_part := self._build_signature_part(detail.data, detail):
+                items.append(signature_part)
             return items
 
         if detail.type in ("reasoning.text", "reasoning.summary"):
@@ -77,42 +77,40 @@ class ReasoningStreamHandler(ReasoningHandlerABC):
             # Flush on signature (encrypted content)
             if detail.signature:
                 items.extend(self._flush_text())
-                if encrypted_item := self._build_encrypted_item(detail.signature, detail):
-                    items.append(encrypted_item)
+                if signature_part := self._build_signature_part(detail.signature, detail):
+                    items.append(signature_part)
 
         return items
 
-    def flush(self) -> list[model.ConversationItem]:
+    def flush(self) -> list[message.Part]:
         """Flush buffered reasoning text on finalize."""
         return self._flush_text()
 
-    def _flush_text(self) -> list[model.ConversationItem]:
-        """Flush accumulated reasoning text as a single item."""
+    def _flush_text(self) -> list[message.Part]:
+        """Flush accumulated reasoning text as a single part."""
         if not self._accumulated_reasoning:
             return []
-        item = self._build_text_item("".join(self._accumulated_reasoning))
+        item = self._build_text_part("".join(self._accumulated_reasoning))
         self._accumulated_reasoning = []
         return [item]
 
-    def _build_text_item(self, content: str) -> model.ReasoningTextItem:
-        return model.ReasoningTextItem(
+    def _build_text_part(self, content: str) -> message.ThinkingTextPart:
+        return message.ThinkingTextPart(
             id=self._reasoning_id,
-            content=content,
-            response_id=self._response_id,
-            model=self._param_model,
+            text=content,
+            model_id=self._param_model,
         )
 
-    def _build_encrypted_item(
+    def _build_signature_part(
         self,
         content: str | None,
         detail: ReasoningDetail,
-    ) -> model.ReasoningEncryptedItem | None:
+    ) -> message.ThinkingSignaturePart | None:
         if not content:
             return None
-        return model.ReasoningEncryptedItem(
+        return message.ThinkingSignaturePart(
             id=detail.id,
-            encrypted_content=content,
+            signature=content,
             format=detail.format,
-            response_id=self._response_id,
-            model=self._param_model,
+            model_id=self._param_model,
         )

klaude_code/llm/registry.py

@@ -12,29 +12,34 @@ _T = TypeVar("_T", bound=type["LLMClientABC"])
 # Track which protocols have been loaded
 _loaded_protocols: set[llm_param.LLMClientProtocol] = set()
 _REGISTRY: dict[llm_param.LLMClientProtocol, type["LLMClientABC"]] = {}
+_PROTOCOL_MODULES: dict[llm_param.LLMClientProtocol, str] = {
+    llm_param.LLMClientProtocol.ANTHROPIC: "klaude_code.llm.anthropic",
+    llm_param.LLMClientProtocol.CLAUDE_OAUTH: "klaude_code.llm.claude",
+    llm_param.LLMClientProtocol.BEDROCK: "klaude_code.llm.bedrock",
+    llm_param.LLMClientProtocol.CODEX_OAUTH: "klaude_code.llm.codex",
+    llm_param.LLMClientProtocol.OPENAI: "klaude_code.llm.openai_compatible",
+    llm_param.LLMClientProtocol.OPENROUTER: "klaude_code.llm.openrouter",
+    llm_param.LLMClientProtocol.RESPONSES: "klaude_code.llm.responses",
+    llm_param.LLMClientProtocol.GOOGLE: "klaude_code.llm.google",
+}
 
 
 def _load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
     """Load the module for a specific protocol on demand."""
     if protocol in _loaded_protocols:
         return
-    _loaded_protocols.add(protocol)
+    module_path = _PROTOCOL_MODULES.get(protocol)
+    if module_path is None:
+        raise ValueError(f"Unknown LLMClient protocol: {protocol}")
 
     # Import only the needed module to trigger @register decorator
-    if protocol == llm_param.LLMClientProtocol.ANTHROPIC:
-        importlib.import_module("klaude_code.llm.anthropic")
-    elif protocol == llm_param.LLMClientProtocol.BEDROCK:
-        importlib.import_module("klaude_code.llm.bedrock")
-    elif protocol == llm_param.LLMClientProtocol.CODEX:
-        importlib.import_module("klaude_code.llm.codex")
-    elif protocol == llm_param.LLMClientProtocol.OPENAI:
-        importlib.import_module("klaude_code.llm.openai_compatible")
-    elif protocol == llm_param.LLMClientProtocol.OPENROUTER:
-        importlib.import_module("klaude_code.llm.openrouter")
-    elif protocol == llm_param.LLMClientProtocol.RESPONSES:
-        importlib.import_module("klaude_code.llm.responses")
-    elif protocol == llm_param.LLMClientProtocol.GOOGLE:
-        importlib.import_module("klaude_code.llm.google")
+    importlib.import_module(module_path)
+    _loaded_protocols.add(protocol)
+
+
+def load_protocol(protocol: llm_param.LLMClientProtocol) -> None:
+    """Load the module for a specific protocol on demand."""
+    _load_protocol(protocol)
 
 
 def register(name: llm_param.LLMClientProtocol) -> Callable[[_T], _T]:

klaude_code/llm/responses/client.py

@@ -1,6 +1,6 @@
 import json
 from collections.abc import AsyncGenerator
-from typing import TYPE_CHECKING, override
+from typing import TYPE_CHECKING, Literal, override
 
 import httpx
 import openai
@@ -8,12 +8,13 @@ from openai import AsyncAzureOpenAI, AsyncOpenAI
 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.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 MetadataTracker
-from klaude_code.protocol import llm_param, model
+from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.protocol import llm_param, message, model
 from klaude_code.trace import DebugType, log_debug
 
 if TYPE_CHECKING:
@@ -59,9 +60,57 @@ 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."""
+) -> 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(
+                message.ThinkingTextPart(
+                    text="".join(accumulated_thinking),
+                    model_id=str(param.model),
+                )
+            )
+            accumulated_thinking.clear()
+        if pending_signature:
+            assistant_parts.append(
+                message.ThinkingSignaturePart(
+                    signature=pending_signature,
+                    model_id=str(param.model),
+                    format="openai_reasoning",
+                )
+            )
+            pending_signature = None
+
+    def flush_text() -> None:
+        if not accumulated_text:
+            return
+        assistant_parts.append(message.TextPart(text="".join(accumulated_text)))
+        accumulated_text.clear()
+
+    def map_stop_reason(status: str | None, reason: str | None) -> model.StopReason | None:
+        if reason:
+            normalized = reason.strip().lower()
+            if normalized in {"max_output_tokens", "length", "max_tokens"}:
+                return "length"
+            if normalized in {"content_filter", "safety"}:
+                return "error"
+            if normalized in {"cancelled", "canceled", "aborted"}:
+                return "aborted"
+        if status == "completed":
+            return "stop"
+        if status in {"failed", "error"}:
+            return "error"
+        return None
 
     try:
         async for event in stream:
@@ -74,29 +123,29 @@ async def parse_responses_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,
-                        )
+                        if stage == "assistant":
+                            flush_text()
+                        stage = "thinking"
+                        accumulated_thinking.append(event.delta)
+                        yield message.ThinkingTextDelta(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),
-                        )
+                    if event.text and not accumulated_thinking:
+                        accumulated_thinking.append(event.text)
                 case responses.ResponseTextDeltaEvent() as event:
                     if event.delta:
                         metadata_tracker.record_token()
-                    yield model.AssistantMessageDelta(content=event.delta, response_id=response_id)
+                        if stage == "thinking":
+                            flush_thinking()
+                        stage = "assistant"
+                        accumulated_text.append(event.delta)
+                        yield message.AssistantTextDelta(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(
+                        yield message.ToolCallStartItem(
                             response_id=response_id,
                             call_id=event.item.call_id,
                             name=event.item.name,
@@ -105,34 +154,30 @@ async def parse_responses_stream(
                     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),
-                                )
+                                pending_signature = item.encrypted_content
                         case responses.ResponseOutputMessage() as item:
-                            metadata_tracker.record_token()
-                            yield model.AssistantMessageItem(
-                                content="\n".join(
+                            if not accumulated_text:
+                                text_content = "\n".join(
                                     [
                                         part.text
                                         for part in item.content
                                         if isinstance(part, responses.ResponseOutputText)
                                     ]
-                                ),
-                                id=item.id,
-                                response_id=response_id,
-                            )
+                                )
+                                if text_content:
+                                    accumulated_text.append(text_content)
                         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,
+                            flush_thinking()
+                            flush_text()
+                            stage = "tool"
+                            assistant_parts.append(
+                                message.ToolCallPart(
+                                    call_id=item.call_id,
+                                    id=item.id,
+                                    tool_name=item.name,
+                                    arguments_json=item.arguments.strip(),
+                                )
                             )
                         case _:
                             pass
@@ -154,7 +199,7 @@ async def parse_responses_stream(
                         )
                     metadata_tracker.set_model_name(str(param.model))
                     metadata_tracker.set_response_id(response_id)
-                    yield metadata_tracker.finalize()
+                    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:
@@ -165,7 +210,7 @@ async def parse_responses_stream(
                             style="red",
                             debug_type=DebugType.LLM_STREAM,
                         )
-                        yield model.StreamErrorItem(error=error_message)
+                        yield message.StreamErrorItem(error=error_message)
                 case _:
                     log_debug(
                         "[Unhandled stream event]",
@@ -174,7 +219,18 @@ async def parse_responses_stream(
                         debug_type=DebugType.LLM_STREAM,
                     )
     except (openai.OpenAIError, httpx.HTTPError) as e:
-        yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+        yield message.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+
+    flush_thinking()
+    flush_text()
+    metadata_tracker.set_response_id(response_id)
+    metadata = metadata_tracker.finalize()
+    yield message.AssistantMessage(
+        parts=assistant_parts,
+        response_id=response_id,
+        usage=metadata,
+        stop_reason=stop_reason,
+    )
 
 
 @register(llm_param.LLMClientProtocol.RESPONSES)
@@ -188,13 +244,17 @@ class ResponsesClient(LLMClientABC):
                 api_key=config.api_key,
                 azure_endpoint=str(config.base_url),
                 api_version=config.azure_api_version,
-                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+                timeout=httpx.Timeout(
+                    LLM_HTTP_TIMEOUT_TOTAL, connect=LLM_HTTP_TIMEOUT_CONNECT, read=LLM_HTTP_TIMEOUT_READ
+                ),
             )
         else:
             client = AsyncOpenAI(
                 api_key=config.api_key,
                 base_url=config.base_url,
-                timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+                timeout=httpx.Timeout(
+                    LLM_HTTP_TIMEOUT_TOTAL, connect=LLM_HTTP_TIMEOUT_CONNECT, read=LLM_HTTP_TIMEOUT_READ
+                ),
             )
         self.client: AsyncAzureOpenAI | AsyncOpenAI = client
 
@@ -204,7 +264,7 @@ class ResponsesClient(LLMClientABC):
         return cls(config)
 
     @override
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[message.LLMStreamItem]:
         param = apply_config_defaults(param, self.get_llm_config())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
@@ -222,7 +282,9 @@ class ResponsesClient(LLMClientABC):
                 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}")
+            error_message = f"{e.__class__.__name__} {e!s}"
+            for item in error_stream_items(metadata_tracker, error=error_message):
+                yield item
             return
 
         async for item in parse_responses_stream(stream, param, metadata_tracker):