klaude-code 1.2.11__py3-none-any.whl → 1.2.13__py3-none-any.whl

klaude_code/llm/anthropic/client.py

@@ -15,17 +15,48 @@ from anthropic.types.beta.beta_signature_delta import BetaSignatureDelta
 from anthropic.types.beta.beta_text_delta import BetaTextDelta
 from anthropic.types.beta.beta_thinking_delta import BetaThinkingDelta
 from anthropic.types.beta.beta_tool_use_block import BetaToolUseBlock
+from anthropic.types.beta.message_create_params import MessageCreateParamsStreaming
 
 from klaude_code import const
 from klaude_code.llm.anthropic.input import convert_history_to_input, convert_system_to_input, convert_tool_schema
-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.usage import MetadataTracker, convert_anthropic_usage
+from klaude_code.llm.usage import MetadataTracker
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
 
+def build_payload(param: llm_param.LLMCallParameter) -> MessageCreateParamsStreaming:
+    """Build Anthropic API request parameters."""
+    messages = convert_history_to_input(param.input, param.model)
+    tools = convert_tool_schema(param.tools)
+    system = convert_system_to_input(param.system)
+
+    payload: MessageCreateParamsStreaming = {
+        "model": str(param.model),
+        "tool_choice": {
+            "type": "auto",
+            "disable_parallel_tool_use": False,
+        },
+        "stream": True,
+        "max_tokens": param.max_tokens or const.DEFAULT_MAX_TOKENS,
+        "temperature": param.temperature or const.DEFAULT_TEMPERATURE,
+        "messages": messages,
+        "system": system,
+        "tools": tools,
+        "betas": ["interleaved-thinking-2025-05-14", "context-1m-2025-08-07"],
+    }
+
+    if param.thinking and param.thinking.type == "enabled":
+        payload["thinking"] = anthropic.types.ThinkingConfigEnabledParam(
+            type="enabled",
+            budget_tokens=param.thinking.budget_tokens or const.DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS,
+        )
+
+    return payload
+
+
 @register(llm_param.LLMClientProtocol.ANTHROPIC)
 class AnthropicClient(LLMClientABC):
     def __init__(self, config: llm_param.LLMConfigParameter):
@@ -43,37 +74,21 @@ class AnthropicClient(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())
 
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
-        messages = convert_history_to_input(param.input, param.model)
-        tools = convert_tool_schema(param.tools)
-        system = convert_system_to_input(param.system)
-
-        stream = call_with_logged_payload(
-            self.client.beta.messages.create,
-            model=str(param.model),
-            tool_choice={
-                "type": "auto",
-                "disable_parallel_tool_use": False,
-            },
-            stream=True,
-            max_tokens=param.max_tokens or const.DEFAULT_MAX_TOKENS,
-            temperature=param.temperature or const.DEFAULT_TEMPERATURE,
-            messages=messages,
-            system=system,
-            tools=tools,
-            betas=["interleaved-thinking-2025-05-14", "context-1m-2025-08-07"],
-            thinking=anthropic.types.ThinkingConfigEnabledParam(
-                type=param.thinking.type,
-                budget_tokens=param.thinking.budget_tokens or const.DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS,
-            )
-            if param.thinking and param.thinking.type == "enabled"
-            else anthropic.types.ThinkingConfigDisabledParam(
-                type="disabled",
-            ),
+        payload = build_payload(param)
+
+        log_debug(
+            json.dumps(payload, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+
+        stream = self.client.beta.messages.create(
+            **payload,
             extra_headers={"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)},
         )
 
@@ -85,9 +100,8 @@ class AnthropicClient(LLMClientABC):
         current_tool_call_id: str | None = None
         current_tool_inputs: list[str] | None = None
 
-        input_tokens = 0
-        cached_tokens = 0
-        output_tokens = 0
+        input_token = 0
+        cached_token = 0
 
         try:
             async for event in await stream:
@@ -100,17 +114,18 @@ class AnthropicClient(LLMClientABC):
                 match event:
                     case BetaRawMessageStartEvent() as event:
                         response_id = event.message.id
-                        cached_tokens = event.message.usage.cache_read_input_tokens or 0
-                        input_tokens = (event.message.usage.input_tokens or 0) + (
-                            event.message.usage.cache_creation_input_tokens or 0
-                        )
-                        output_tokens = event.message.usage.output_tokens or 0
+                        cached_token = event.message.usage.cache_read_input_tokens or 0
+                        input_token = event.message.usage.input_tokens
                         yield model.StartItem(response_id=response_id)
                     case BetaRawContentBlockDeltaEvent() as event:
                         match event.delta:
                             case BetaThinkingDelta() as delta:
                                 metadata_tracker.record_token()
                                 accumulated_thinking.append(delta.thinking)
+                                yield model.ReasoningTextDelta(
+                                    content=delta.thinking,
+                                    response_id=response_id,
+                                )
                             case BetaSignatureDelta() as delta:
                                 metadata_tracker.record_token()
                                 yield model.ReasoningEncryptedItem(
@@ -170,22 +185,20 @@ class AnthropicClient(LLMClientABC):
                             current_tool_call_id = None
                             current_tool_inputs = None
                     case BetaRawMessageDeltaEvent() as event:
-                        input_tokens += (event.usage.input_tokens or 0) + (event.usage.cache_creation_input_tokens or 0)
-                        output_tokens += event.usage.output_tokens or 0
-                        cached_tokens += event.usage.cache_read_input_tokens or 0
-
-                        usage = convert_anthropic_usage(
-                            input_tokens=input_tokens,
-                            output_tokens=output_tokens,
-                            cached_tokens=cached_tokens,
-                            context_limit=param.context_limit,
-                            max_tokens=param.max_tokens,
+                        metadata_tracker.set_usage(
+                            model.Usage(
+                                input_tokens=input_token + cached_token,
+                                output_tokens=event.usage.output_tokens,
+                                cached_tokens=cached_token,
+                                context_size=input_token + cached_token + event.usage.output_tokens,
+                                context_limit=param.context_limit,
+                                max_tokens=param.max_tokens,
+                            )
                         )
-                        metadata_tracker.set_usage(usage)
                         metadata_tracker.set_model_name(str(param.model))
                         metadata_tracker.set_response_id(response_id)
                         yield metadata_tracker.finalize()
                     case _:
                         pass
         except (APIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")

klaude_code/llm/client.py

@@ -1,10 +1,8 @@
-import json
 from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator
-from typing import Callable, ParamSpec, TypeVar, cast
+from typing import ParamSpec, TypeVar, cast
 
 from klaude_code.protocol import llm_param, model
-from klaude_code.trace import DebugType, log_debug
 
 
 class LLMClientABC(ABC):
@@ -17,7 +15,7 @@ class LLMClientABC(ABC):
         pass
 
     @abstractmethod
-    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem]:
         raise NotImplementedError
         yield cast(model.ConversationItem, None)
 
@@ -31,19 +29,3 @@ class LLMClientABC(ABC):
 
 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)

klaude_code/llm/codex/client.py

@@ -1,22 +1,61 @@
 """Codex LLM client using ChatGPT subscription via OAuth."""
 
+import json
 from collections.abc import AsyncGenerator
 from typing import override
 
 import httpx
 import openai
 from openai import AsyncOpenAI
+from openai.types.responses.response_create_params import ResponseCreateParamsStreaming
 
 from klaude_code.auth.codex.exceptions import CodexNotLoggedInError
 from klaude_code.auth.codex.oauth import CodexOAuth
 from klaude_code.auth.codex.token_manager import CodexTokenManager
-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.client import parse_responses_stream
 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.trace import DebugType, log_debug
+
+
+def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:
+    """Build Codex API request parameters."""
+    inputs = convert_history_to_input(param.input, param.model)
+    tools = convert_tool_schema(param.tools)
+
+    session_id = param.session_id or ""
+
+    payload: ResponseCreateParamsStreaming = {
+        "model": str(param.model),
+        "tool_choice": "auto",
+        "parallel_tool_calls": True,
+        "include": [
+            "reasoning.encrypted_content",
+        ],
+        "store": False,
+        "stream": True,
+        "input": inputs,
+        "instructions": param.system,
+        "tools": tools,
+        "prompt_cache_key": session_id,
+        # max_output_token and temperature is not supported in Codex API
+    }
+
+    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
+
 
 # Codex API configuration
 CODEX_BASE_URL = "https://chatgpt.com/backend-api/codex"
@@ -75,55 +114,35 @@ class CodexClient(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]:
         # Ensure token is valid before API call
         self._ensure_valid_token()
 
         param = apply_config_defaults(param, self.get_llm_config())
 
-        # Codex API requires store=False
-        param.store = False
-
         metadata_tracker = MetadataTracker(cost_config=self.get_llm_config().cost)
 
-        inputs = convert_history_to_input(param.input, param.model)
-        tools = convert_tool_schema(param.tools)
+        payload = build_payload(param)
 
         session_id = param.session_id or ""
-        # Must send conversation_id/session_id headers to improve ChatGPT backend prompt cache hit rate.
         extra_headers: dict[str, str] = {}
         if session_id:
+            # Must send conversation_id/session_id headers to improve ChatGPT backend prompt cache hit rate.
             extra_headers["conversation_id"] = session_id
             extra_headers["session_id"] = session_id
 
+        log_debug(
+            json.dumps(payload, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
         try:
-            stream = await call_with_logged_payload(
-                self.client.responses.create,
-                model=str(param.model),
-                tool_choice="auto",
-                parallel_tool_calls=True,
-                include=[
-                    "reasoning.encrypted_content",
-                ],
-                store=False,  # Always False for Codex
-                stream=True,
-                input=inputs,
-                instructions=param.system,
-                tools=tools,
-                text={
-                    "verbosity": param.verbosity,
-                },
-                prompt_cache_key=session_id,
-                reasoning={
-                    "effort": param.thinking.reasoning_effort,
-                    "summary": param.thinking.reasoning_summary,
-                }
-                if param.thinking and param.thinking.reasoning_effort
-                else None,
+            stream = await self.client.responses.create(
+                **payload,
                 extra_headers=extra_headers,
             )
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
             return
 
         async for item in parse_responses_stream(stream, param, metadata_tracker):

klaude_code/llm/input_common.py

@@ -5,10 +5,10 @@ This module provides shared abstractions for providers that require message grou
 since it uses a flat item list matching our internal protocol.
 """
 
-from collections.abc import Iterator
+from collections.abc import Iterable, Iterator
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING
 
 from klaude_code import const
 

klaude_code/llm/openai_compatible/client.py

@@ -4,8 +4,9 @@ from typing import 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_history_to_input, convert_tool_schema
 from klaude_code.llm.openai_compatible.stream_processor import StreamStateManager
@@ -15,6 +16,35 @@ from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
 
+def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreateParamsStreaming, dict[str, object]]:
+    """Build OpenAI 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] = {}
+
+    if param.thinking:
+        extra_body["thinking"] = {
+            "type": param.thinking.type,
+            "budget": param.thinking.budget_tokens,
+        }
+
+    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,
+        "reasoning_effort": param.thinking.reasoning_effort if param.thinking else None,
+        "verbosity": param.verbosity,
+    }
+
+    return payload, extra_body
+
+
 @register(llm_param.LLMClientProtocol.OPENAI)
 class OpenAICompatibleClient(LLMClientABC):
     def __init__(self, config: llm_param.LLMConfigParameter):
@@ -42,34 +72,23 @@ class OpenAICompatibleClient(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.get_llm_config().cost)
 
-        extra_body = {}
-        extra_headers = {"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)}
-
-        if param.thinking:
-            extra_body["thinking"] = {
-                "type": param.thinking.type,
-                "budget": param.thinking.budget_tokens,
-            }
-        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,
-            reasoning_effort=param.thinking.reasoning_effort if param.thinking else None,
-            verbosity=param.verbosity,
-            extra_body=extra_body,  # pyright: ignore[reportUnknownArgumentType]
+        payload, extra_body = build_payload(param)
+        extra_headers: dict[str, str] = {"extra": json.dumps({"session_id": param.session_id}, sort_keys=True)}
+
+        log_debug(
+            json.dumps({**payload, **extra_body}, ensure_ascii=False, default=str),
+            style="yellow",
+            debug_type=DebugType.LLM_PAYLOAD,
+        )
+
+        stream = self.client.chat.completions.create(
+            **payload,
+            extra_body=extra_body,
             extra_headers=extra_headers,
         )
 
@@ -85,9 +104,7 @@ class OpenAICompatibleClient(LLMClientABC):
                 if not state.response_id and event.id:
                     state.set_response_id(event.id)
                     yield model.StartItem(response_id=event.id)
-                if (
-                    event.usage is not None and event.usage.completion_tokens is not None  # pyright: ignore[reportUnnecessaryComparison] gcp gemini will return None usage field
-                ):
+                if event.usage is not None:
                     metadata_tracker.set_usage(convert_usage(event.usage, param.context_limit, param.max_tokens))
                 if event.model:
                     metadata_tracker.set_model_name(event.model)
@@ -96,28 +113,32 @@ class OpenAICompatibleClient(LLMClientABC):
 
                 if len(event.choices) == 0:
                     continue
-                delta = event.choices[0].delta
 
-                # Support Kimi K2's usage field in choice
-                if hasattr(event.choices[0], "usage") and getattr(event.choices[0], "usage"):
+                # Support Moonshot Kimi K2's usage field in choice
+                if usage := getattr(event.choices[0], "usage", None):
                     metadata_tracker.set_usage(
                         convert_usage(
-                            openai.types.CompletionUsage.model_validate(getattr(event.choices[0], "usage")),
+                            openai.types.CompletionUsage.model_validate(usage),
                             param.context_limit,
                             param.max_tokens,
                         )
                     )
 
+                delta = event.choices[0].delta
+
                 # Reasoning
-                reasoning_content = ""
-                if hasattr(delta, "reasoning") and getattr(delta, "reasoning"):
-                    reasoning_content = getattr(delta, "reasoning")
-                if hasattr(delta, "reasoning_content") and getattr(delta, "reasoning_content"):
-                    reasoning_content = getattr(delta, "reasoning_content")
-                if reasoning_content:
+                if (
+                    reasoning_content := getattr(delta, "reasoning_content", None)
+                    or getattr(delta, "reasoning", None)
+                    or ""
+                ):
                     metadata_tracker.record_token()
                     state.stage = "reasoning"
                     state.accumulated_reasoning.append(reasoning_content)
+                    yield model.ReasoningTextDelta(
+                        content=reasoning_content,
+                        response_id=state.response_id,
+                    )
 
                 # Assistant
                 if delta.content and (
@@ -158,7 +179,7 @@ class OpenAICompatibleClient(LLMClientABC):
                             )
                     state.accumulated_tool_calls.add(delta.tool_calls)
         except (openai.OpenAIError, httpx.HTTPError) as e:
-            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {e!s}")
 
         # Finalize
         for item in state.flush_all():

klaude_code/llm/openai_compatible/stream_processor.py

@@ -5,7 +5,8 @@ logic for accumulating and flushing reasoning, assistant content, and tool calls
 across different LLM providers (OpenAI-compatible, OpenRouter).
 """
 
-from typing import Callable, Literal
+from collections.abc import Callable
+from typing import Literal
 
 from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
 from klaude_code.protocol import model