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

klaude_code/llm/openrouter/client.py

@@ -1,19 +1,69 @@
+import json
 from collections.abc import AsyncGenerator
-from typing import Literal, override
+from typing import Any, override
 
 import httpx
 import openai
+from openai.types.chat.completion_create_params import CompletionCreateParamsStreaming
 
-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.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 import parse_chat_completions_stream
 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.openrouter.reasoning import ReasoningStreamHandler
 from klaude_code.llm.registry import register
-from klaude_code.llm.usage import MetadataTracker, convert_usage
+from klaude_code.llm.usage import MetadataTracker
 from klaude_code.protocol import llm_param, model
-from klaude_code.trace import DebugType, log, log_debug
+from klaude_code.trace import DebugType, is_debug_enabled, log_debug
+
+
+def build_payload(
+    param: llm_param.LLMCallParameter,
+) -> tuple[CompletionCreateParamsStreaming, dict[str, object], dict[str, str]]:
+    """Build OpenRouter API request parameters."""
+    messages = convert_history_to_input(param.input, param.system, param.model)
+    tools = convert_tool_schema(param.tools)
+
+    extra_body: dict[str, object] = {
+        "usage": {"include": True},  # To get the cache tokens at the end of the response
+    }
+    if is_debug_enabled():
+        extra_body["debug"] = {
+            "echo_upstream_body": True
+        }  # https://openrouter.ai/docs/api/reference/errors-and-debugging#debug-option-shape
+    extra_headers: dict[str, str] = {}
+
+    if param.thinking:
+        if param.thinking.type != "disabled" and param.thinking.budget_tokens is not None:
+            extra_body["reasoning"] = {
+                "max_tokens": param.thinking.budget_tokens,
+                "enable": True,
+            }  # OpenRouter: https://openrouter.ai/docs/use-cases/reasoning-tokens#anthropic-models-with-reasoning-tokens
+        elif param.thinking.reasoning_effort is not None:
+            extra_body["reasoning"] = {
+                "effort": param.thinking.reasoning_effort,
+            }
+
+    if param.provider_routing:
+        extra_body["provider"] = param.provider_routing.model_dump(exclude_none=True)
+
+    if is_claude_model(param.model):
+        extra_headers["x-anthropic-beta"] = "fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14"
+
+    payload: CompletionCreateParamsStreaming = {
+        "model": str(param.model),
+        "tool_choice": "auto",
+        "parallel_tool_calls": True,
+        "stream": True,
+        "messages": messages,
+        "temperature": param.temperature,
+        "max_tokens": param.max_tokens,
+        "tools": tools,
+        "verbosity": param.verbosity,
+    }
+
+    return payload, extra_body, extra_headers
 
 
 @register(llm_param.LLMClientProtocol.OPENROUTER)
@@ -33,168 +83,47 @@ class OpenRouterClient(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())
-        messages = convert_history_to_input(param.input, param.system, param.model)
-        tools = convert_tool_schema(param.tools)
-
-        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
-
-        extra_body: dict[str, object] = {
-            "usage": {"include": True}  # To get the cache tokens at the end of the response
-        }
-        extra_headers = {}
-
-        if param.thinking:
-            if param.thinking.budget_tokens is not None:
-                extra_body["reasoning"] = {
-                    "max_tokens": param.thinking.budget_tokens,
-                    "enable": True,
-                }  # OpenRouter: https://openrouter.ai/docs/use-cases/reasoning-tokens#anthropic-models-with-reasoning-tokens
-            elif param.thinking.reasoning_effort is not None:
-                extra_body["reasoning"] = {
-                    "effort": param.thinking.reasoning_effort,
-                }
-        if param.provider_routing:
-            extra_body["provider"] = param.provider_routing.model_dump(exclude_none=True)
-        if is_claude_model(param.model):
-            extra_headers["anthropic-beta"] = (
-                "interleaved-thinking-2025-05-14"  # Not working yet, maybe OpenRouter's issue, or Anthropic: Interleaved thinking is only supported for tools used via the Messages API.
-            )
 
-        stream = call_with_logged_payload(
-            self.client.chat.completions.create,
-            model=str(param.model),
-            tool_choice="auto",
-            parallel_tool_calls=True,
-            stream=True,
-            messages=messages,
-            temperature=param.temperature,
-            max_tokens=param.max_tokens,
-            tools=tools,
-            verbosity=param.verbosity,
-            extra_body=extra_body,  # pyright: ignore[reportUnknownArgumentType]
-            extra_headers=extra_headers,  # pyright: ignore[reportUnknownArgumentType]
+        metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
+
+        payload, extra_body, extra_headers = build_payload(param)
+
+        log_debug(
+            json.dumps({**payload, **extra_body}, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
         )
 
-        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()
+        try:
+            stream = await self.client.chat.completions.create(
+                **payload,
+                extra_body=extra_body,
+                extra_headers=extra_headers,
+            )
+        except (openai.OpenAIError, httpx.HTTPError) as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
+            yield metadata_tracker.finalize()
+            return
+
         reasoning_handler = ReasoningStreamHandler(
             param_model=str(param.model),
-            response_id=response_id,
+            response_id=None,
         )
 
-        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,
+        def on_event(event: Any) -> None:
+            log_debug(
+                event.model_dump_json(exclude_none=True),
+                style="blue",
+                debug_type=DebugType.LLM_STREAM,
             )
-            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:
-                log_debug(
-                    event.model_dump_json(exclude_none=True),
-                    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 (
-                    event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison]
-                ):  # gcp gemini will return None usage field
-                    metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit))
-                if event.model:
-                    metadata_tracker.set_model_name(event.model)
-                if provider := getattr(event, "provider", None):
-                    metadata_tracker.set_provider(str(provider))
-
-                if len(event.choices) == 0:
-                    continue
-                delta = event.choices[0].delta
-
-                # Reasoning
-                if hasattr(delta, "reasoning_details") and getattr(delta, "reasoning_details"):
-                    reasoning_details = getattr(delta, "reasoning_details")
-                    for item in reasoning_details:
-                        try:
-                            reasoning_detail = ReasoningDetail.model_validate(item)
-                            metadata_tracker.record_token()
-                            stage = "reasoning"
-                            for conversation_item in reasoning_handler.on_detail(reasoning_detail):
-                                yield conversation_item
-                        except Exception as e:
-                            log("reasoning_details error", str(e), style="red")
-
-                # Assistant
-                if delta.content and (
-                    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():
-                            yield item
-                    stage = "assistant"
-                    accumulated_content.append(delta.content)
-                    yield model.AssistantMessageDelta(
-                        content=delta.content,
-                        response_id=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():
-                            yield item
-                    elif stage == "assistant":
-                        for item in flush_assistant_items():
-                            yield item
-                    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)
-                            yield model.ToolCallStartItem(
-                                response_id=response_id,
-                                call_id=tc.id or "",
-                                name=tc.function.name,
-                            )
-                    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():
+        async for item in parse_chat_completions_stream(
+            stream,
+            param=param,
+            metadata_tracker=metadata_tracker,
+            reasoning_handler=reasoning_handler,
+            on_event=on_event,
+        ):
             yield item
-
-        for item in flush_assistant_items():
-            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)
-        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,35 +25,9 @@ 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"}
 
-    if group.text_content:
-        assistant_message["content"] = group.text_content
-
     if group.tool_calls:
         assistant_message["tool_calls"] = [
             {
@@ -71,9 +45,14 @@ def _assistant_group_to_message(group: AssistantGroup, model_name: str | None) -
     # The order of items in reasoning_details must match the original
     # stream order from the provider, so we iterate reasoning_items
     # instead of the separated reasoning_text / reasoning_encrypted lists.
+    # For cross-model scenarios, degrade thinking to plain text.
     reasoning_details: list[dict[str, object]] = []
+    degraded_thinking_texts: list[str] = []
     for item in group.reasoning_items:
         if model_name != item.model:
+            # Cross-model: collect thinking text for degradation
+            if isinstance(item, model.ReasoningTextItem) and item.content:
+                degraded_thinking_texts.append(item.content)
             continue
         if isinstance(item, model.ReasoningEncryptedItem):
             if item.encrypted_content and len(item.encrypted_content) > 0:
@@ -98,6 +77,15 @@ def _assistant_group_to_message(group: AssistantGroup, model_name: str | None) -
     if reasoning_details:
         assistant_message["reasoning_details"] = reasoning_details
 
+    # Build content with optional degraded thinking prefix
+    content_parts: list[str] = []
+    if degraded_thinking_texts:
+        content_parts.append("<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>")
+    if group.text_content:
+        content_parts.append(group.text_content)
+    if content_parts:
+        assistant_message["content"] = "\n".join(content_parts)
+
     return assistant_message
 
 
@@ -150,9 +138,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/openrouter/reasoning.py

@@ -0,0 +1,118 @@
+from pydantic import BaseModel
+
+from klaude_code.llm.openai_compatible.stream import ReasoningDeltaResult, ReasoningHandlerABC
+from klaude_code.protocol import model
+from klaude_code.trace import log
+
+
+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 ReasoningStreamHandler(ReasoningHandlerABC):
+    """Accumulates OpenRouter reasoning details and emits ordered outputs."""
+
+    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] = []
+
+    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_delta(self, delta: object) -> ReasoningDeltaResult:
+        """Parse OpenRouter's reasoning_details and return ordered stream outputs."""
+        reasoning_details = getattr(delta, "reasoning_details", None)
+        if not reasoning_details:
+            return ReasoningDeltaResult(handled=False, outputs=[])
+
+        outputs: list[str | model.ConversationItem] = []
+        for item in reasoning_details:
+            try:
+                reasoning_detail = ReasoningDetail.model_validate(item)
+                if reasoning_detail.text:
+                    outputs.append(reasoning_detail.text)
+                if reasoning_detail.summary:
+                    outputs.append(reasoning_detail.summary)
+                outputs.extend(self.on_detail(reasoning_detail))
+            except Exception as e:
+                log("reasoning_details error", str(e), style="red")
+
+        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] = []
+
+        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)
+            return items
+
+        if detail.type in ("reasoning.text", "reasoning.summary"):
+            self._reasoning_id = detail.id
+            # Accumulate text
+            text = detail.text if detail.type == "reasoning.text" else detail.summary
+            if text:
+                self._accumulated_reasoning.append(text)
+            # 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)
+
+        return items
+
+    def flush(self) -> list[model.ConversationItem]:
+        """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."""
+        if not self._accumulated_reasoning:
+            return []
+        item = self._build_text_item("".join(self._accumulated_reasoning))
+        self._accumulated_reasoning = []
+        return [item]
+
+    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,
+        )

klaude_code/llm/registry.py

@@ -1,22 +1,54 @@
-from typing import Callable, TypeVar
+import importlib
+from collections.abc import Callable
+from typing import TYPE_CHECKING, TypeVar
 
-from klaude_code.llm.client import LLMClientABC
 from klaude_code.protocol import llm_param
 
-_REGISTRY: dict[llm_param.LLMClientProtocol, type[LLMClientABC]] = {}
+if TYPE_CHECKING:
+    from klaude_code.llm.client import LLMClientABC
 
-T = TypeVar("T", bound=LLMClientABC)
+_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"]] = {}
 
-def register(name: llm_param.LLMClientProtocol) -> Callable[[type[T]], type[T]]:
-    def _decorator(cls: type[T]) -> type[T]:
+
+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)
+
+    # 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")
+
+
+def register(name: llm_param.LLMClientProtocol) -> Callable[[_T], _T]:
+    """Decorator to register an LLM client class for a protocol."""
+
+    def _decorator(cls: _T) -> _T:
         _REGISTRY[name] = cls
         return cls
 
     return _decorator
 
 
-def create_llm_client(config: llm_param.LLMConfigParameter) -> LLMClientABC:
+def create_llm_client(config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+    _load_protocol(config.protocol)
     if config.protocol not in _REGISTRY:
         raise ValueError(f"Unknown LLMClient protocol: {config.protocol}")
     return _REGISTRY[config.protocol].create(config)