klaude-code 1.2.6__py3-none-any.whl

klaude_code/llm/anthropic/client.py

@@ -0,0 +1,221 @@
+import json
+import time
+from collections.abc import AsyncGenerator
+from typing import override
+
+import anthropic
+import httpx
+from anthropic import RateLimitError
+from anthropic.types.beta.beta_input_json_delta import BetaInputJSONDelta
+from anthropic.types.beta.beta_raw_content_block_delta_event import BetaRawContentBlockDeltaEvent
+from anthropic.types.beta.beta_raw_content_block_start_event import BetaRawContentBlockStartEvent
+from anthropic.types.beta.beta_raw_content_block_stop_event import BetaRawContentBlockStopEvent
+from anthropic.types.beta.beta_raw_message_delta_event import BetaRawMessageDeltaEvent
+from anthropic.types.beta.beta_raw_message_start_event import BetaRawMessageStartEvent
+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 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.input_common import apply_config_defaults
+from klaude_code.llm.registry import register
+from klaude_code.llm.usage import calculate_cost
+from klaude_code.protocol import llm_param, model
+from klaude_code.trace import DebugType, log_debug
+
+
+@register(llm_param.LLMClientProtocol.ANTHROPIC)
+class AnthropicClient(LLMClientABC):
+    def __init__(self, config: llm_param.LLMConfigParameter):
+        super().__init__(config)
+        client = anthropic.AsyncAnthropic(
+            api_key=config.api_key,
+            base_url=config.base_url,
+            timeout=httpx.Timeout(300.0, connect=15.0, read=285.0),
+        )
+        self.client: anthropic.AsyncAnthropic = client
+
+    @classmethod
+    @override
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+        return cls(config)
+
+    @override
+    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()
+        first_token_time: float | None = None
+        last_token_time: float | None = None
+
+        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",
+            ),
+            extra_headers={"extra": json.dumps({"session_id": param.session_id})},
+        )
+
+        accumulated_thinking: list[str] = []
+        accumulated_content: list[str] = []
+        response_id: str | None = None
+
+        current_tool_name: str | None = None
+        current_tool_call_id: str | None = None
+        current_tool_inputs: list[str] | None = None
+
+        input_tokens = 0
+        cached_tokens = 0
+        output_tokens = 0
+
+        try:
+            async for event in await stream:
+                log_debug(
+                    f"[{event.type}]",
+                    event.model_dump_json(exclude_none=True),
+                    style="blue",
+                    debug_type=DebugType.LLM_STREAM,
+                )
+                match event:
+                    case 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
+                        yield model.StartItem(response_id=response_id)
+                    case BetaRawContentBlockDeltaEvent() as event:
+                        match event.delta:
+                            case BetaThinkingDelta() as delta:
+                                if first_token_time is None:
+                                    first_token_time = time.time()
+                                last_token_time = time.time()
+                                accumulated_thinking.append(delta.thinking)
+                            case BetaSignatureDelta() as delta:
+                                if first_token_time is None:
+                                    first_token_time = time.time()
+                                last_token_time = time.time()
+                                yield model.ReasoningEncryptedItem(
+                                    encrypted_content=delta.signature,
+                                    response_id=response_id,
+                                    model=str(param.model),
+                                )
+                            case BetaTextDelta() as delta:
+                                if first_token_time is None:
+                                    first_token_time = time.time()
+                                last_token_time = time.time()
+                                accumulated_content.append(delta.text)
+                                yield model.AssistantMessageDelta(
+                                    content=delta.text,
+                                    response_id=response_id,
+                                )
+                            case BetaInputJSONDelta() as delta:
+                                if first_token_time is None:
+                                    first_token_time = time.time()
+                                last_token_time = time.time()
+                                if current_tool_inputs is not None:
+                                    current_tool_inputs.append(delta.partial_json)
+                            case _:
+                                pass
+                    case BetaRawContentBlockStartEvent() as event:
+                        match event.content_block:
+                            case BetaToolUseBlock() as block:
+                                yield model.ToolCallStartItem(
+                                    response_id=response_id,
+                                    call_id=block.id,
+                                    name=block.name,
+                                )
+                                current_tool_name = block.name
+                                current_tool_call_id = block.id
+                                current_tool_inputs = []
+                            case _:
+                                pass
+                    case BetaRawContentBlockStopEvent() as event:
+                        if len(accumulated_thinking) > 0:
+                            full_thinking = "".join(accumulated_thinking)
+                            yield model.ReasoningTextItem(
+                                content=full_thinking,
+                                response_id=response_id,
+                                model=str(param.model),
+                            )
+                            accumulated_thinking.clear()
+                        if len(accumulated_content) > 0:
+                            yield model.AssistantMessageItem(
+                                content="".join(accumulated_content),
+                                response_id=response_id,
+                            )
+                            accumulated_content.clear()
+                        if current_tool_name and current_tool_call_id:
+                            yield model.ToolCallItem(
+                                name=current_tool_name,
+                                call_id=current_tool_call_id,
+                                arguments="".join(current_tool_inputs) if current_tool_inputs else "",
+                                response_id=response_id,
+                            )
+                            current_tool_name = None
+                            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
+                        total_tokens = input_tokens + cached_tokens + output_tokens
+                        context_usage_percent = (
+                            (total_tokens / param.context_limit) * 100 if param.context_limit else None
+                        )
+
+                        throughput_tps: float | None = None
+                        first_token_latency_ms: float | None = None
+
+                        if first_token_time is not None:
+                            first_token_latency_ms = (first_token_time - request_start_time) * 1000
+
+                        if first_token_time is not None and last_token_time is not None and output_tokens > 0:
+                            time_duration = last_token_time - first_token_time
+                            if time_duration >= 0.15:
+                                throughput_tps = output_tokens / time_duration
+
+                        usage = model.Usage(
+                            input_tokens=input_tokens,
+                            output_tokens=output_tokens,
+                            cached_tokens=cached_tokens,
+                            total_tokens=total_tokens,
+                            context_usage_percent=context_usage_percent,
+                            throughput_tps=throughput_tps,
+                            first_token_latency_ms=first_token_latency_ms,
+                        )
+                        calculate_cost(usage, self._config.cost)
+                        yield model.ResponseMetadataItem(
+                            usage=usage,
+                            response_id=response_id,
+                            model_name=str(param.model),
+                        )
+                    case _:
+                        pass
+        except RateLimitError as e:
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")

klaude_code/llm/anthropic/input.py

@@ -0,0 +1,200 @@
+# pyright: reportReturnType=false
+# pyright: reportArgumentType=false
+# pyright: reportUnknownMemberType=false
+# pyright: reportAttributeAccessIssue=false
+# pyright: reportUnknownVariableType=false
+
+
+import json
+from base64 import b64decode
+from binascii import Error as BinasciiError
+from typing import Literal, cast
+
+from anthropic.types.beta.beta_base64_image_source_param import BetaBase64ImageSourceParam
+from anthropic.types.beta.beta_image_block_param import BetaImageBlockParam
+from anthropic.types.beta.beta_message_param import BetaMessageParam
+from anthropic.types.beta.beta_text_block_param import BetaTextBlockParam
+from anthropic.types.beta.beta_tool_param import BetaToolParam
+from anthropic.types.beta.beta_url_image_source_param import BetaURLImageSourceParam
+
+from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, merge_reminder_text, parse_message_groups
+from klaude_code.protocol import llm_param, model
+
+AllowedMediaType = Literal["image/png", "image/jpeg", "image/gif", "image/webp"]
+_INLINE_IMAGE_MEDIA_TYPES: tuple[AllowedMediaType, ...] = (
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+)
+
+
+def _image_part_to_block(image: model.ImageURLPart) -> BetaImageBlockParam:
+    url = image.image_url.url
+    if url.startswith("data:"):
+        header_and_media = url.split(",", 1)
+        if len(header_and_media) != 2:
+            raise ValueError("Invalid data URL for image: missing comma separator")
+        header, base64_data = header_and_media
+        if ";base64" not in header:
+            raise ValueError("Invalid data URL for image: missing base64 marker")
+        media_type = header[5:].split(";", 1)[0]
+        if media_type not in _INLINE_IMAGE_MEDIA_TYPES:
+            raise ValueError(f"Unsupported inline image media type: {media_type}")
+        base64_payload = base64_data.strip()
+        if base64_payload == "":
+            raise ValueError("Inline image data is empty")
+        try:
+            b64decode(base64_payload, validate=True)
+        except (BinasciiError, ValueError) as exc:
+            raise ValueError("Inline image data is not valid base64") from exc
+        source = cast(
+            BetaBase64ImageSourceParam,
+            {
+                "type": "base64",
+                "media_type": media_type,
+                "data": base64_payload,
+            },
+        )
+        return {"type": "image", "source": source}
+
+    source_url: BetaURLImageSourceParam = {"type": "url", "url": url}
+    return {"type": "image", "source": source_url}
+
+
+def _user_group_to_message(group: UserGroup) -> BetaMessageParam:
+    blocks: list[BetaTextBlockParam | BetaImageBlockParam] = []
+    for text in group.text_parts:
+        blocks.append({"type": "text", "text": text + "\n"})
+    for image in group.images:
+        blocks.append(_image_part_to_block(image))
+    if not blocks:
+        blocks.append({"type": "text", "text": ""})
+    return {"role": "user", "content": blocks}
+
+
+def _tool_group_to_message(group: ToolGroup) -> BetaMessageParam:
+    tool_content: list[BetaTextBlockParam | BetaImageBlockParam] = []
+    merged_text = merge_reminder_text(
+        group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
+        group.reminder_texts,
+    )
+    tool_content.append({"type": "text", "text": merged_text})
+    for image in group.tool_result.images or []:
+        tool_content.append(_image_part_to_block(image))
+    for image in group.reminder_images:
+        tool_content.append(_image_part_to_block(image))
+    return {
+        "role": "user",
+        "content": [
+            {
+                "type": "tool_result",
+                "tool_use_id": group.tool_result.call_id,
+                "is_error": group.tool_result.status == "error",
+                "content": tool_content,
+            }
+        ],
+    }
+
+
+def _assistant_group_to_message(group: AssistantGroup, model_name: str | None) -> BetaMessageParam:
+    content: list[dict[str, object]] = []
+    current_reasoning_content: str | None = None
+
+    # Process reasoning items in original order so that text and
+    # encrypted parts are paired correctly for the given model.
+    for item in group.reasoning_items:
+        if isinstance(item, model.ReasoningTextItem):
+            if model_name != item.model:
+                continue
+            current_reasoning_content = item.content
+        else:
+            if model_name != item.model:
+                continue
+            if item.encrypted_content and len(item.encrypted_content) > 0:
+                content.append(
+                    {
+                        "type": "thinking",
+                        "thinking": current_reasoning_content or "",
+                        "signature": item.encrypted_content,
+                    }
+                )
+                current_reasoning_content = None
+
+    # Moonshot.ai's Kimi does not always send reasoning signatures;
+    # if we saw reasoning text without any matching encrypted item,
+    # emit it as a plain thinking block.
+    if len(current_reasoning_content or "") > 0:
+        content.insert(0, {"type": "thinking", "thinking": current_reasoning_content})
+
+    if group.text_content:
+        content.append({"type": "text", "text": group.text_content})
+
+    for tc in group.tool_calls:
+        content.append(
+            {
+                "type": "tool_use",
+                "id": tc.call_id,
+                "name": tc.name,
+                "input": json.loads(tc.arguments) if tc.arguments else None,
+            }
+        )
+
+    return {"role": "assistant", "content": content}
+
+
+def _add_cache_control(messages: list[BetaMessageParam]) -> None:
+    if len(messages) > 0:
+        last_message = messages[-1]
+        content_list = list(last_message.get("content", []))
+        if content_list:
+            last_content_part = content_list[-1]
+            if last_content_part.get("type", "") in ["text", "tool_result", "tool_use"]:
+                last_content_part["cache_control"] = {"type": "ephemeral"}  # type: ignore
+
+
+def convert_history_to_input(
+    history: list[model.ConversationItem],
+    model_name: str | None,
+) -> list[BetaMessageParam]:
+    """
+    Convert a list of conversation items to a list of beta message params.
+
+    Args:
+        history: List of conversation items.
+        model_name: Model name. Used to verify that signatures are valid for the same model
+    """
+    messages: list[BetaMessageParam] = []
+    for group in parse_message_groups(history):
+        match group:
+            case UserGroup():
+                messages.append(_user_group_to_message(group))
+            case ToolGroup():
+                messages.append(_tool_group_to_message(group))
+            case AssistantGroup():
+                messages.append(_assistant_group_to_message(group, model_name))
+
+    _add_cache_control(messages)
+    return messages
+
+
+def convert_system_to_input(system: str | None) -> list[BetaTextBlockParam]:
+    if system is None:
+        return []
+    return [{"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}]
+
+
+def convert_tool_schema(
+    tools: list[llm_param.ToolSchema] | None,
+) -> list[BetaToolParam]:
+    if tools is None:
+        return []
+    return [
+        {
+            "input_schema": tool.parameters,
+            "type": "custom",
+            "name": tool.name,
+            "description": tool.description,
+        }
+        for tool in tools
+    ]

klaude_code/llm/client.py

@@ -0,0 +1,49 @@
+import json
+from abc import ABC, abstractmethod
+from collections.abc import AsyncGenerator
+from typing import Callable, ParamSpec, TypeVar, cast
+
+from klaude_code.protocol import llm_param, model
+from klaude_code.trace import DebugType, log_debug
+
+
+class LLMClientABC(ABC):
+    def __init__(self, config: llm_param.LLMConfigParameter) -> None:
+        self._config = config
+
+    @classmethod
+    @abstractmethod
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
+        pass
+
+    @abstractmethod
+    async def call(self, param: llm_param.LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+        raise NotImplementedError
+        yield cast(model.ConversationItem, None)  # pyright: ignore[reportUnreachable]
+
+    def get_llm_config(self) -> llm_param.LLMConfigParameter:
+        return self._config
+
+    @property
+    def model_name(self) -> str:
+        return self._config.model or ""
+
+
+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)