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

klaude_code/llm/anthropic/client.py

@@ -19,16 +19,38 @@ 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.const import (
+    ANTHROPIC_BETA_INTERLEAVED_THINKING,
+    CLAUDE_CODE_IDENTITY,
+    DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS,
+    DEFAULT_MAX_TOKENS,
+    DEFAULT_TEMPERATURE,
+    LLM_HTTP_TIMEOUT_CONNECT,
+    LLM_HTTP_TIMEOUT_READ,
+    LLM_HTTP_TIMEOUT_TOTAL,
+)
 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
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
-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
 
-_IDENTITY = "You are Claude Code, Anthropic's official CLI for Claude."
+
+def _map_anthropic_stop_reason(reason: str) -> model.StopReason | None:
+    mapping: dict[str, model.StopReason] = {
+        "end_turn": "stop",
+        "stop_sequence": "stop",
+        "max_tokens": "length",
+        "tool_use": "tool_use",
+        "content_filter": "error",
+        "error": "error",
+        "cancelled": "aborted",
+        "canceled": "aborted",
+        "aborted": "aborted",
+    }
+    return mapping.get(reason)
 
 
 def build_payload(
@@ -44,17 +66,18 @@ def build_payload(
     """
     messages = convert_history_to_input(param.input, param.model)
     tools = convert_tool_schema(param.tools)
-    system = convert_system_to_input(param.system)
+    system_messages = [msg for msg in param.input if isinstance(msg, message.SystemMessage)]
+    system = convert_system_to_input(param.system, system_messages)
 
     # Add identity block at the beginning of the system prompt
     identity_block: BetaTextBlockParam = {
         "type": "text",
-        "text": _IDENTITY,
+        "text": CLAUDE_CODE_IDENTITY,
         "cache_control": {"type": "ephemeral"},
     }
     system = [identity_block, *system]
 
-    betas = ["interleaved-thinking-2025-05-14"]
+    betas = [ANTHROPIC_BETA_INTERLEAVED_THINKING]
     if extra_betas:
         # Prepend extra betas, avoiding duplicates
         betas = [b for b in extra_betas if b not in betas] + betas
@@ -66,8 +89,8 @@ def build_payload(
             "disable_parallel_tool_use": False,
         },
         "stream": True,
-        "max_tokens": param.max_tokens or const.DEFAULT_MAX_TOKENS,
-        "temperature": param.temperature or const.DEFAULT_TEMPERATURE,
+        "max_tokens": param.max_tokens or DEFAULT_MAX_TOKENS,
+        "temperature": param.temperature or DEFAULT_TEMPERATURE,
         "messages": messages,
         "system": system,
         "tools": tools,
@@ -77,7 +100,7 @@ def build_payload(
     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,
+            budget_tokens=param.thinking.budget_tokens or DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS,
         )
 
     return payload
@@ -87,14 +110,14 @@ async def parse_anthropic_stream(
     stream: Any,
     param: llm_param.LLMCallParameter,
     metadata_tracker: MetadataTracker,
-) -> AsyncGenerator[model.ConversationItem]:
-    """Parse Anthropic beta messages stream and yield conversation items.
-
-    This function is shared between AnthropicClient and BedrockClient.
-    """
+) -> AsyncGenerator[message.LLMStreamItem]:
+    """Parse Anthropic beta messages stream and yield stream items."""
     accumulated_thinking: list[str] = []
     accumulated_content: list[str] = []
+    parts: list[message.Part] = []
     response_id: str | None = None
+    stop_reason: model.StopReason | None = None
+    pending_signature: str | None = None
 
     current_tool_name: str | None = None
     current_tool_call_id: str | None = None
@@ -115,28 +138,23 @@ async def parse_anthropic_stream(
                 response_id = event.message.id
                 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:
                         if delta.thinking:
                             metadata_tracker.record_token()
                         accumulated_thinking.append(delta.thinking)
-                        yield model.ReasoningTextDelta(
+                        yield message.ThinkingTextDelta(
                             content=delta.thinking,
                             response_id=response_id,
                         )
                     case BetaSignatureDelta() as delta:
-                        yield model.ReasoningEncryptedItem(
-                            encrypted_content=delta.signature,
-                            response_id=response_id,
-                            model=str(param.model),
-                        )
+                        pending_signature = delta.signature
                     case BetaTextDelta() as delta:
                         if delta.text:
                             metadata_tracker.record_token()
                         accumulated_content.append(delta.text)
-                        yield model.AssistantMessageDelta(
+                        yield message.AssistantTextDelta(
                             content=delta.text,
                             response_id=response_id,
                         )
@@ -151,7 +169,7 @@ async def parse_anthropic_stream(
                 match event.content_block:
                     case BetaToolUseBlock() as block:
                         metadata_tracker.record_token()
-                        yield model.ToolCallStartItem(
+                        yield message.ToolCallStartItem(
                             response_id=response_id,
                             call_id=block.id,
                             name=block.name,
@@ -162,29 +180,32 @@ async def parse_anthropic_stream(
                     case _:
                         pass
             case BetaRawContentBlockStopEvent():
-                if len(accumulated_thinking) > 0:
+                if accumulated_thinking:
                     metadata_tracker.record_token()
                     full_thinking = "".join(accumulated_thinking)
-                    yield model.ReasoningTextItem(
-                        content=full_thinking,
-                        response_id=response_id,
-                        model=str(param.model),
-                    )
+                    parts.append(message.ThinkingTextPart(text=full_thinking, model_id=str(param.model)))
+                    if pending_signature:
+                        parts.append(
+                            message.ThinkingSignaturePart(
+                                signature=pending_signature,
+                                model_id=str(param.model),
+                                format="anthropic",
+                            )
+                        )
                     accumulated_thinking.clear()
-                if len(accumulated_content) > 0:
+                    pending_signature = None
+                if accumulated_content:
                     metadata_tracker.record_token()
-                    yield model.AssistantMessageItem(
-                        content="".join(accumulated_content),
-                        response_id=response_id,
-                    )
+                    parts.append(message.TextPart(text="".join(accumulated_content)))
                     accumulated_content.clear()
                 if current_tool_name and current_tool_call_id:
                     metadata_tracker.record_token()
-                    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,
+                    parts.append(
+                        message.ToolCallPart(
+                            call_id=current_tool_call_id,
+                            tool_name=current_tool_name,
+                            arguments_json="".join(current_tool_inputs) if current_tool_inputs else "",
+                        )
                     )
                     current_tool_name = None
                     current_tool_call_id = None
@@ -202,10 +223,20 @@ async def parse_anthropic_stream(
                 )
                 metadata_tracker.set_model_name(str(param.model))
                 metadata_tracker.set_response_id(response_id)
-                yield metadata_tracker.finalize()
+                raw_stop_reason = getattr(event, "stop_reason", None)
+                if isinstance(raw_stop_reason, str):
+                    stop_reason = _map_anthropic_stop_reason(raw_stop_reason)
             case _:
                 pass
 
+    metadata = metadata_tracker.finalize()
+    yield message.AssistantMessage(
+        parts=parts,
+        response_id=response_id,
+        usage=metadata,
+        stop_reason=stop_reason,
+    )
+
 
 @register(llm_param.LLMClientProtocol.ANTHROPIC)
 class AnthropicClient(LLMClientABC):
@@ -220,7 +251,9 @@ class AnthropicClient(LLMClientABC):
             client = anthropic.AsyncAnthropic(
                 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
+                ),
             )
         finally:
             if saved_auth_token is not None:
@@ -233,7 +266,7 @@ class AnthropicClient(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)
@@ -255,4 +288,6 @@ class AnthropicClient(LLMClientABC):
             async for item in parse_anthropic_stream(stream, param, metadata_tracker):
                 yield item
         except (APIError, 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

klaude_code/llm/anthropic/input.py

@@ -4,10 +4,7 @@
 # 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
@@ -17,8 +14,15 @@ 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
+from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
+from klaude_code.llm.image import parse_data_url
+from klaude_code.llm.input_common import (
+    DeveloperAttachment,
+    attach_developer_messages,
+    merge_reminder_text,
+    split_thinking_parts,
+)
+from klaude_code.protocol import llm_param, message
 
 AllowedMediaType = Literal["image/png", "image/jpeg", "image/gif", "image/webp"]
 _INLINE_IMAGE_MEDIA_TYPES: tuple[AllowedMediaType, ...] = (
@@ -29,25 +33,12 @@ _INLINE_IMAGE_MEDIA_TYPES: tuple[AllowedMediaType, ...] = (
 )
 
 
-def _image_part_to_block(image: model.ImageURLPart) -> BetaImageBlockParam:
-    url = image.image_url.url
+def _image_part_to_block(image: message.ImageURLPart) -> BetaImageBlockParam:
+    url = image.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]
+        media_type, base64_payload, _ = parse_data_url(url)
         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,
             {
@@ -62,97 +53,108 @@ def _image_part_to_block(image: model.ImageURLPart) -> BetaImageBlockParam:
     return {"type": "image", "source": source_url}
 
 
-def _user_group_to_message(group: UserGroup) -> BetaMessageParam:
+def _user_message_to_message(
+    msg: message.UserMessage,
+    attachment: DeveloperAttachment,
+) -> BetaMessageParam:
     blocks: list[BetaTextBlockParam | BetaImageBlockParam] = []
-    for text in group.text_parts:
-        blocks.append({"type": "text", "text": text + "\n"})
-    for image in group.images:
+    for part in msg.parts:
+        if isinstance(part, message.TextPart):
+            blocks.append({"type": "text", "text": part.text})
+        elif isinstance(part, message.ImageURLPart):
+            blocks.append(_image_part_to_block(part))
+    if attachment.text:
+        blocks.append({"type": "text", "text": attachment.text})
+    for image in attachment.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_block(group: ToolGroup) -> dict[str, object]:
-    """Convert a single ToolGroup to a tool_result block."""
+def _tool_message_to_block(
+    msg: message.ToolResultMessage,
+    attachment: DeveloperAttachment,
+) -> dict[str, object]:
+    """Convert a single tool result message to a tool_result block."""
     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,
+        msg.output_text or EMPTY_TOOL_OUTPUT_MESSAGE,
+        attachment.text,
     )
     tool_content.append({"type": "text", "text": merged_text})
-    for image in group.tool_result.images or []:
+    for image in [part for part in msg.parts if isinstance(part, message.ImageURLPart)]:
         tool_content.append(_image_part_to_block(image))
-    for image in group.reminder_images:
+    for image in attachment.images:
         tool_content.append(_image_part_to_block(image))
     return {
         "type": "tool_result",
-        "tool_use_id": group.tool_result.call_id,
-        "is_error": group.tool_result.status == "error",
+        "tool_use_id": msg.call_id,
+        "is_error": msg.status != "success",
         "content": tool_content,
     }
 
 
-def _tool_groups_to_message(groups: list[ToolGroup]) -> BetaMessageParam:
-    """Convert one or more ToolGroups to a single user message with multiple tool_result blocks."""
+def _tool_blocks_to_message(blocks: list[dict[str, object]]) -> BetaMessageParam:
+    """Convert one or more tool_result blocks to a single user message."""
     return {
         "role": "user",
-        "content": [_tool_group_to_block(group) for group in groups],
+        "content": blocks,
     }
 
 
-def _assistant_group_to_message(group: AssistantGroup, model_name: str | None) -> BetaMessageParam:
+def _assistant_message_to_message(msg: message.AssistantMessage, model_name: str | None) -> BetaMessageParam:
     content: list[dict[str, object]] = []
-    current_reasoning_content: str | None = None
-    degraded_thinking_texts: list[str] = []
-
-    # Process reasoning items in original order so that text and
-    # encrypted parts are paired correctly for the given model.
-    # For cross-model scenarios, degrade thinking to plain text.
-    for item in group.reasoning_items:
-        if isinstance(item, model.ReasoningTextItem):
-            if model_name != item.model:
-                # Cross-model: collect thinking text for degradation
-                if item.content:
-                    degraded_thinking_texts.append(item.content)
-            else:
-                current_reasoning_content = item.content
-        else:
-            # Same model: preserve signature
-            if model_name == item.model and item.encrypted_content and len(item.encrypted_content) > 0:
+    current_thinking_content: str | None = None
+    native_thinking_parts, degraded_thinking_texts = split_thinking_parts(msg, model_name)
+    native_thinking_ids = {id(part) for part in native_thinking_parts}
+
+    def _flush_thinking() -> None:
+        nonlocal current_thinking_content
+        if current_thinking_content is None:
+            return
+        content.append({"type": "thinking", "thinking": current_thinking_content})
+        current_thinking_content = None
+
+    for part in msg.parts:
+        if isinstance(part, message.ThinkingTextPart):
+            if id(part) not in native_thinking_ids:
+                continue
+            current_thinking_content = part.text
+            continue
+        if isinstance(part, message.ThinkingSignaturePart):
+            if id(part) not in native_thinking_ids:
+                continue
+            if part.signature:
                 content.append(
                     {
                         "type": "thinking",
-                        "thinking": current_reasoning_content or "",
-                        "signature": item.encrypted_content,
+                        "thinking": current_thinking_content or "",
+                        "signature": part.signature,
                     }
                 )
-                current_reasoning_content = None
+                current_thinking_content = None
+            continue
+
+        _flush_thinking()
+        if isinstance(part, message.TextPart):
+            content.append({"type": "text", "text": part.text})
+        elif isinstance(part, message.ToolCallPart):
+            content.append(
+                {
+                    "type": "tool_use",
+                    "id": part.call_id,
+                    "name": part.tool_name,
+                    "input": json.loads(part.arguments_json) if part.arguments_json else None,
+                }
+            )
+
+    _flush_thinking()
 
-    # 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})
-
-    # Cross-model: degrade thinking to plain text with <thinking> tags
     if degraded_thinking_texts:
         degraded_text = "<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>"
         content.insert(0, {"type": "text", "text": degraded_text})
 
-    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}
 
 
@@ -167,45 +169,51 @@ def _add_cache_control(messages: list[BetaMessageParam]) -> None:
 
 
 def convert_history_to_input(
-    history: list[model.ConversationItem],
+    history: list[message.Message],
     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
-    """
+    """Convert a list of messages to beta message params."""
     messages: list[BetaMessageParam] = []
-    pending_tool_groups: list[ToolGroup] = []
-
-    def flush_tool_groups() -> None:
-        nonlocal pending_tool_groups
-        if pending_tool_groups:
-            messages.append(_tool_groups_to_message(pending_tool_groups))
-            pending_tool_groups = []
-
-    for group in parse_message_groups(history):
-        match group:
-            case UserGroup():
-                flush_tool_groups()
-                messages.append(_user_group_to_message(group))
-            case ToolGroup():
-                pending_tool_groups.append(group)
-            case AssistantGroup():
-                flush_tool_groups()
-                messages.append(_assistant_group_to_message(group, model_name))
-
-    flush_tool_groups()
+    pending_tool_blocks: list[dict[str, object]] = []
+
+    def flush_tool_blocks() -> None:
+        nonlocal pending_tool_blocks
+        if pending_tool_blocks:
+            messages.append(_tool_blocks_to_message(pending_tool_blocks))
+            pending_tool_blocks = []
+
+    for msg, attachment in attach_developer_messages(history):
+        match msg:
+            case message.ToolResultMessage():
+                pending_tool_blocks.append(_tool_message_to_block(msg, attachment))
+            case message.UserMessage():
+                flush_tool_blocks()
+                messages.append(_user_message_to_message(msg, attachment))
+            case message.AssistantMessage():
+                flush_tool_blocks()
+                messages.append(_assistant_message_to_message(msg, model_name))
+            case message.SystemMessage():
+                continue
+            case _:
+                continue
+
+    flush_tool_blocks()
     _add_cache_control(messages)
     return messages
 
 
-def convert_system_to_input(system: str | None) -> list[BetaTextBlockParam]:
-    if system is None:
+def convert_system_to_input(
+    system: str | None, system_messages: list[message.SystemMessage] | None = None
+) -> list[BetaTextBlockParam]:
+    parts: list[str] = []
+    if system:
+        parts.append(system)
+    if system_messages:
+        for msg in system_messages:
+            parts.append("\n".join(part.text for part in msg.parts))
+    if not parts:
         return []
-    return [{"type": "text", "text": system, "cache_control": {"type": "ephemeral"}}]
+    return [{"type": "text", "text": "\n".join(parts), "cache_control": {"type": "ephemeral"}}]
 
 
 def convert_tool_schema(

klaude_code/llm/bedrock/client.py

@@ -8,12 +8,13 @@ import anthropic
 import httpx
 from anthropic import APIError
 
+from klaude_code.const import LLM_HTTP_TIMEOUT_CONNECT, LLM_HTTP_TIMEOUT_READ, LLM_HTTP_TIMEOUT_TOTAL
 from klaude_code.llm.anthropic.client import build_payload, parse_anthropic_stream
 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
-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
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -29,7 +30,7 @@ class BedrockClient(LLMClientABC):
             aws_region=config.aws_region,
             aws_session_token=config.aws_session_token,
             aws_profile=config.aws_profile,
-            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),
         )
 
     @classmethod
@@ -38,7 +39,7 @@ class BedrockClient(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)
@@ -57,4 +58,6 @@ class BedrockClient(LLMClientABC):
             async for item in parse_anthropic_stream(stream, param, metadata_tracker):
                 yield item
         except (APIError, 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

klaude_code/llm/claude/client.py

@@ -9,17 +9,25 @@ from anthropic import APIError
 from klaude_code.auth.claude.exceptions import ClaudeNotLoggedInError
 from klaude_code.auth.claude.oauth import ClaudeOAuth
 from klaude_code.auth.claude.token_manager import ClaudeTokenManager
+from klaude_code.const import (
+    ANTHROPIC_BETA_FINE_GRAINED_TOOL_STREAMING,
+    ANTHROPIC_BETA_INTERLEAVED_THINKING,
+    ANTHROPIC_BETA_OAUTH,
+    LLM_HTTP_TIMEOUT_CONNECT,
+    LLM_HTTP_TIMEOUT_READ,
+    LLM_HTTP_TIMEOUT_TOTAL,
+)
 from klaude_code.llm.anthropic.client import build_payload, parse_anthropic_stream
 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
-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
 from klaude_code.trace import DebugType, log_debug
 
 _CLAUDE_OAUTH_REQUIRED_BETAS: tuple[str, ...] = (
-    "oauth-2025-04-20",
-    "fine-grained-tool-streaming-2025-05-14",
+    ANTHROPIC_BETA_OAUTH,
+    ANTHROPIC_BETA_FINE_GRAINED_TOOL_STREAMING,
 )
 
 
@@ -45,7 +53,7 @@ class ClaudeClient(LLMClientABC):
         token = self._oauth.ensure_valid_token()
         return anthropic.AsyncAnthropic(
             auth_token=token,
-            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),
         )
 
     def _ensure_valid_token(self) -> None:
@@ -63,7 +71,7 @@ class ClaudeClient(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]:
         self._ensure_valid_token()
         param = apply_config_defaults(param, self.get_llm_config())
 
@@ -75,7 +83,7 @@ class ClaudeClient(LLMClientABC):
 
         # Keep the interleaved-thinking beta in sync with configured thinking.
         if not (param.thinking and param.thinking.type == "enabled"):
-            payload["betas"] = [b for b in payload.get("betas", []) if b != "interleaved-thinking-2025-05-14"]
+            payload["betas"] = [b for b in payload.get("betas", []) if b != ANTHROPIC_BETA_INTERLEAVED_THINKING]
 
         log_debug(
             json.dumps(payload, ensure_ascii=False, default=str),
@@ -92,4 +100,6 @@ class ClaudeClient(LLMClientABC):
             async for item in parse_anthropic_stream(stream, param, metadata_tracker):
                 yield item
         except (APIError, 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