klaude-code 1.2.1__py3-none-any.whl → 1.2.3__py3-none-any.whl

klaude_code/core/tool/web/mermaid_tool.py

@@ -9,14 +9,12 @@ from pydantic import BaseModel, Field
 
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol.llm_parameter import ToolSchema
-from klaude_code.protocol.model import MermaidLinkUIExtra, ToolResultItem, ToolResultUIExtra, ToolResultUIExtraType
-from klaude_code.protocol.tools import MERMAID
+from klaude_code.protocol import llm_param, model, tools
 
 _MERMAID_LIVE_PREFIX = "https://mermaid.live/view#pako:"
 
 
-@register(MERMAID)
+@register(tools.MERMAID)
 class MermaidTool(ToolABC):
     """Create shareable Mermaid.live links for diagram rendering."""
 
@@ -24,9 +22,9 @@ class MermaidTool(ToolABC):
         code: str = Field(description="The Mermaid diagram code to render")
 
     @classmethod
-    def schema(cls) -> ToolSchema:
-        return ToolSchema(
-            name=MERMAID,
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.MERMAID,
             type="function",
             description=load_desc(Path(__file__).parent / "mermaid_tool.md"),
             parameters={
@@ -43,26 +41,26 @@ class MermaidTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> ToolResultItem:
+    async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = cls.MermaidArguments.model_validate_json(arguments)
         except Exception as exc:  # pragma: no cover - defensive
-            return ToolResultItem(status="error", output=f"Invalid arguments: {exc}")
+            return model.ToolResultItem(status="error", output=f"Invalid arguments: {exc}")
 
         link = cls._build_link(args.code)
         line_count = cls._count_lines(args.code)
-        ui_extra = ToolResultUIExtra(
-            type=ToolResultUIExtraType.MERMAID_LINK,
-            mermaid_link=MermaidLinkUIExtra(link=link, line_count=line_count),
+        ui_extra = model.ToolResultUIExtra(
+            type=model.ToolResultUIExtraType.MERMAID_LINK,
+            mermaid_link=model.MermaidLinkUIExtra(link=link, line_count=line_count),
         )
         output = f"Mermaid diagram rendered successfully ({line_count} lines)."
-        return ToolResultItem(status="success", output=output, ui_extra=ui_extra)
+        return model.ToolResultItem(status="success", output=output, ui_extra=ui_extra)
 
     @staticmethod
     def _build_link(code: str) -> str:
         state = {
             "code": code,
-            "mermaid": {"theme": "default"},
+            "mermaid": {"theme": "neutral"},
             "autoSync": True,
             "updateDiagram": True,
         }

klaude_code/core/tool/web/web_fetch_tool.py

@@ -9,9 +9,7 @@ from pydantic import BaseModel
 
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
-from klaude_code.protocol.llm_parameter import ToolSchema
-from klaude_code.protocol.model import ToolResultItem
-from klaude_code.protocol.tools import WEB_FETCH
+from klaude_code.protocol import llm_param, model, tools
 
 DEFAULT_TIMEOUT_SEC = 30
 DEFAULT_USER_AGENT = "Mozilla/5.0 (compatible; KlaudeCode/1.0)"
@@ -80,12 +78,12 @@ def _fetch_url(url: str, timeout: int = DEFAULT_TIMEOUT_SEC) -> tuple[str, str]:
         return content_type, text
 
 
-@register(WEB_FETCH)
+@register(tools.WEB_FETCH)
 class WebFetchTool(ToolABC):
     @classmethod
-    def schema(cls) -> ToolSchema:
-        return ToolSchema(
-            name=WEB_FETCH,
+    def schema(cls) -> llm_param.ToolSchema:
+        return llm_param.ToolSchema(
+            name=tools.WEB_FETCH,
             type="function",
             description=load_desc(Path(__file__).parent / "web_fetch_tool.md"),
             parameters={
@@ -104,23 +102,23 @@ class WebFetchTool(ToolABC):
         url: str
 
     @classmethod
-    async def call(cls, arguments: str) -> ToolResultItem:
+    async def call(cls, arguments: str) -> model.ToolResultItem:
         try:
             args = WebFetchTool.WebFetchArguments.model_validate_json(arguments)
         except ValueError as e:
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=f"Invalid arguments: {e}",
             )
         return await cls.call_with_args(args)
 
     @classmethod
-    async def call_with_args(cls, args: WebFetchArguments) -> ToolResultItem:
+    async def call_with_args(cls, args: WebFetchArguments) -> model.ToolResultItem:
         url = args.url
 
         # Basic URL validation
         if not url.startswith(("http://", "https://")):
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output="Invalid URL: must start with http:// or https://",
             )
@@ -129,33 +127,33 @@ class WebFetchTool(ToolABC):
             content_type, text = await asyncio.to_thread(_fetch_url, url)
             processed = _process_content(content_type, text)
 
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="success",
                 output=processed,
             )
 
         except urllib.error.HTTPError as e:
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=f"HTTP error {e.code}: {e.reason}",
             )
         except urllib.error.URLError as e:
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=f"URL error: {e.reason}",
             )
         except UnicodeDecodeError as e:
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=f"Content is not valid UTF-8: {e}",
             )
         except TimeoutError:
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=f"Request timed out after {DEFAULT_TIMEOUT_SEC} seconds",
             )
         except Exception as e:
-            return ToolResultItem(
+            return model.ToolResultItem(
                 status="error",
                 output=f"Failed to fetch URL: {e}",
             )

klaude_code/core/turn.py

@@ -3,8 +3,7 @@ from __future__ import annotations
 from collections.abc import AsyncGenerator, Callable, MutableMapping, Sequence
 from dataclasses import dataclass
 
-from klaude_code.core.tool.tool_abc import ToolABC
-from klaude_code.core.tool.tool_context import TodoContext, tool_context
+from klaude_code.core.tool import TodoContext, ToolABC, tool_context
 from klaude_code.core.tool.tool_runner import (
     ToolExecutionCallStarted,
     ToolExecutionResult,
@@ -12,8 +11,8 @@ from klaude_code.core.tool.tool_runner import (
     ToolExecutor,
     ToolExecutorEvent,
 )
-from klaude_code.llm.client import LLMClientABC
-from klaude_code.protocol import events, llm_parameter, model
+from klaude_code.llm import LLMClientABC
+from klaude_code.protocol import events, llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -32,7 +31,7 @@ class TurnExecutionContext:
     append_history: Callable[[Sequence[model.ConversationItem]], None]
     llm_client: LLMClientABC
     system_prompt: str | None
-    tools: list[llm_parameter.ToolSchema]
+    tools: list[llm_param.ToolSchema]
     tool_registry: dict[str, type[ToolABC]]
     # For tool context
     file_tracker: MutableMapping[str, float]
@@ -121,7 +120,7 @@ class TurnExecutor:
         error_message: str | None = None
 
         async for response_item in ctx.llm_client.call(
-            llm_parameter.LLMCallParameter(
+            llm_param.LLMCallParameter(
                 input=ctx.get_conversation_history(),
                 system=ctx.system_prompt,
                 tools=ctx.tools,
@@ -172,7 +171,20 @@ class TurnExecutor:
                 case model.StreamErrorItem() as item:
                     response_failed = True
                     error_message = item.error
-                    log_debug("[StreamError]", item.error, style="red", debug_type=DebugType.RESPONSE)
+                    log_debug(
+                        "[StreamError]",
+                        item.error,
+                        style="red",
+                        debug_type=DebugType.RESPONSE,
+                    )
+                case model.ToolCallStartItem() as item:
+                    yield events.TurnToolCallStartEvent(
+                        session_id=ctx.session_id,
+                        response_id=item.response_id,
+                        tool_call_id=item.call_id,
+                        tool_name=item.name,
+                        arguments="",
+                    )
                 case model.ToolCallItem() as item:
                     turn_tool_calls.append(item)
                 case _:

klaude_code/llm/__init__.py

@@ -1,19 +1,18 @@
 """LLM package init.
 
-Ensures built-in clients are imported so their `@register` decorators run
-and they become available via the registry.
+Imports built-in LLM clients so their ``@register`` decorators run and they
+become available via the registry.
 """
 
 from .anthropic import AnthropicClient
 from .client import LLMClientABC
 from .openai_compatible import OpenAICompatibleClient
 from .openrouter import OpenRouterClient
-from .registry import LLMClients, create_llm_client
+from .registry import create_llm_client
 from .responses import ResponsesClient
 
 __all__ = [
     "LLMClientABC",
-    "LLMClients",
     "ResponsesClient",
     "OpenAICompatibleClient",
     "OpenRouterClient",

klaude_code/llm/anthropic/client.py

@@ -1,7 +1,7 @@
 import json
 import time
 from collections.abc import AsyncGenerator
-from typing import Callable, ParamSpec, TypeVar, override
+from typing import override
 
 import anthropic
 import httpx
@@ -17,42 +17,19 @@ 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
+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.protocol import llm_parameter, model
-from klaude_code.protocol.llm_parameter import (
-    LLMCallParameter,
-    LLMClientProtocol,
-    LLMConfigParameter,
-    apply_config_defaults,
-)
-from klaude_code.protocol.model import StreamErrorItem
+from klaude_code.llm.usage import calculate_cost
+from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
-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)
-
-
-@register(LLMClientProtocol.ANTHROPIC)
+@register(llm_param.LLMClientProtocol.ANTHROPIC)
 class AnthropicClient(LLMClientABC):
-    def __init__(self, config: LLMConfigParameter):
+    def __init__(self, config: llm_param.LLMConfigParameter):
         super().__init__(config)
         client = anthropic.AsyncAnthropic(
             api_key=config.api_key,
@@ -63,11 +40,11 @@ class AnthropicClient(LLMClientABC):
 
     @classmethod
     @override
-    def create(cls, config: LLMConfigParameter) -> "LLMClientABC":
+    def create(cls, config: llm_param.LLMConfigParameter) -> "LLMClientABC":
         return cls(config)
 
     @override
-    async def call(self, param: LLMCallParameter) -> AsyncGenerator[model.ConversationItem, None]:
+    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()
@@ -86,15 +63,15 @@ class AnthropicClient(LLMClientABC):
                 "disable_parallel_tool_use": False,
             },
             stream=True,
-            max_tokens=param.max_tokens or llm_parameter.DEFAULT_MAX_TOKENS,
-            temperature=param.temperature or llm_parameter.DEFAULT_TEMPERATURE,
+            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 llm_parameter.DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS,
+                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(
@@ -168,6 +145,11 @@ class AnthropicClient(LLMClientABC):
                     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 = []
@@ -218,20 +200,22 @@ class AnthropicClient(LLMClientABC):
                             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=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,
-                            ),
+                            usage=usage,
                             response_id=response_id,
                             model_name=str(param.model),
                         )
                     case _:
                         pass
         except RateLimitError as e:
-            yield StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")
+            yield model.StreamErrorItem(error=f"{e.__class__.__name__} {str(e)}")

klaude_code/llm/anthropic/input.py

@@ -17,15 +17,8 @@ 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 model as protocol_model
-from klaude_code.protocol import llm_parameter, model
+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, ...] = (
@@ -108,7 +101,7 @@ def _assistant_group_to_message(group: AssistantGroup, model_name: str | 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, protocol_model.ReasoningTextItem):
+        if isinstance(item, model.ReasoningTextItem):
             if model_name != item.model:
                 continue
             current_reasoning_content = item.content
@@ -189,7 +182,7 @@ def convert_system_to_input(system: str | None) -> list[BetaTextBlockParam]:
 
 
 def convert_tool_schema(
-    tools: list[llm_parameter.ToolSchema] | None,
+    tools: list[llm_param.ToolSchema] | None,
 ) -> list[BetaToolParam]:
     if tools is None:
         return []

klaude_code/llm/client.py

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

klaude_code/llm/input_common.py

@@ -8,19 +8,14 @@ since it uses a flat item list matching our internal protocol.
 from collections.abc import Iterator
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Iterable
+from typing import TYPE_CHECKING, Iterable
 
-from klaude_code.protocol.model import (
-    AssistantMessageItem,
-    ConversationItem,
-    DeveloperMessageItem,
-    ImageURLPart,
-    ReasoningEncryptedItem,
-    ReasoningTextItem,
-    ToolCallItem,
-    ToolResultItem,
-    UserMessageItem,
-)
+from klaude_code import const
+
+if TYPE_CHECKING:
+    from klaude_code.protocol.llm_param import LLMCallParameter, LLMConfigParameter
+
+from klaude_code.protocol import model
 
 
 class GroupKind(Enum):
@@ -36,16 +31,16 @@ class UserGroup:
     """Aggregated user message group (UserMessageItem + DeveloperMessageItem)."""
 
     text_parts: list[str] = field(default_factory=lambda: [])
-    images: list[ImageURLPart] = field(default_factory=lambda: [])
+    images: list[model.ImageURLPart] = field(default_factory=lambda: [])
 
 
 @dataclass
 class ToolGroup:
     """Aggregated tool result group (ToolResultItem + trailing DeveloperMessageItems)."""
 
-    tool_result: ToolResultItem
+    tool_result: model.ToolResultItem
     reminder_texts: list[str] = field(default_factory=lambda: [])
-    reminder_images: list[ImageURLPart] = field(default_factory=lambda: [])
+    reminder_images: list[model.ImageURLPart] = field(default_factory=lambda: [])
 
 
 @dataclass
@@ -53,32 +48,35 @@ class AssistantGroup:
     """Aggregated assistant message group."""
 
     text_content: str | None = None
-    tool_calls: list[ToolCallItem] = field(default_factory=lambda: [])
-    reasoning_text: list[ReasoningTextItem] = field(default_factory=lambda: [])
-    reasoning_encrypted: list[ReasoningEncryptedItem] = field(default_factory=lambda: [])
+    tool_calls: list[model.ToolCallItem] = field(default_factory=lambda: [])
+    reasoning_text: list[model.ReasoningTextItem] = field(default_factory=lambda: [])
+    reasoning_encrypted: list[model.ReasoningEncryptedItem] = field(default_factory=lambda: [])
     # Preserve original ordering of reasoning items for providers that
     # need to emit them as an ordered stream (e.g. OpenRouter).
-    reasoning_items: list[ReasoningTextItem | ReasoningEncryptedItem] = field(default_factory=lambda: [])
+    reasoning_items: list[model.ReasoningTextItem | model.ReasoningEncryptedItem] = field(default_factory=lambda: [])
 
 
 MessageGroup = UserGroup | ToolGroup | AssistantGroup
 
 
-def _kind_of(item: ConversationItem) -> GroupKind:
-    if isinstance(item, (ReasoningTextItem, ReasoningEncryptedItem, AssistantMessageItem, ToolCallItem)):
+def _kind_of(item: model.ConversationItem) -> GroupKind:
+    if isinstance(
+        item,
+        (model.ReasoningTextItem, model.ReasoningEncryptedItem, model.AssistantMessageItem, model.ToolCallItem),
+    ):
         return GroupKind.ASSISTANT
-    if isinstance(item, UserMessageItem):
+    if isinstance(item, model.UserMessageItem):
         return GroupKind.USER
-    if isinstance(item, ToolResultItem):
+    if isinstance(item, model.ToolResultItem):
         return GroupKind.TOOL
-    if isinstance(item, DeveloperMessageItem):
+    if isinstance(item, model.DeveloperMessageItem):
         return GroupKind.DEVELOPER
     return GroupKind.OTHER
 
 
 def group_response_items_gen(
-    items: Iterable[ConversationItem],
-) -> Iterator[tuple[GroupKind, list[ConversationItem]]]:
+    items: Iterable[model.ConversationItem],
+) -> Iterator[tuple[GroupKind, list[model.ConversationItem]]]:
     """Group response items into sublists with predictable attachment rules.
 
     - Consecutive assistant-side items (ReasoningTextItem | ReasoningEncryptedItem |
@@ -88,10 +86,10 @@ def group_response_items_gen(
       DeveloperMessage to attach to it.
     - DeveloperMessage only attaches to the previous UserMessage/ToolMessage group.
     """
-    buffer: list[ConversationItem] = []
+    buffer: list[model.ConversationItem] = []
     buffer_kind: GroupKind | None = None
 
-    def flush() -> Iterator[tuple[GroupKind, list[ConversationItem]]]:
+    def flush() -> Iterator[tuple[GroupKind, list[model.ConversationItem]]]:
         """Yield current group and reset buffer state."""
 
         nonlocal buffer, buffer_kind
@@ -138,7 +136,7 @@ def group_response_items_gen(
         yield (buffer_kind, buffer)
 
 
-def parse_message_groups(history: list[ConversationItem]) -> list[MessageGroup]:
+def parse_message_groups(history: list[model.ConversationItem]) -> list[MessageGroup]:
     """Parse conversation history into aggregated message groups.
 
     This is the shared grouping logic for Anthropic, OpenAI-compatible, and OpenRouter.
@@ -153,7 +151,7 @@ def parse_message_groups(history: list[ConversationItem]) -> list[MessageGroup]:
             case GroupKind.USER:
                 group = UserGroup()
                 for item in items:
-                    if isinstance(item, (UserMessageItem, DeveloperMessageItem)):
+                    if isinstance(item, (model.UserMessageItem, model.DeveloperMessageItem)):
                         if item.content:
                             group.text_parts.append(item.content)
                         if item.images:
@@ -161,12 +159,12 @@ def parse_message_groups(history: list[ConversationItem]) -> list[MessageGroup]:
                 groups.append(group)
 
             case GroupKind.TOOL:
-                if not items or not isinstance(items[0], ToolResultItem):
+                if not items or not isinstance(items[0], model.ToolResultItem):
                     continue
                 tool_result = items[0]
                 group = ToolGroup(tool_result=tool_result)
                 for item in items[1:]:
-                    if isinstance(item, DeveloperMessageItem):
+                    if isinstance(item, model.DeveloperMessageItem):
                         if item.content:
                             group.reminder_texts.append(item.content)
                         if item.images:
@@ -177,18 +175,18 @@ def parse_message_groups(history: list[ConversationItem]) -> list[MessageGroup]:
                 group = AssistantGroup()
                 for item in items:
                     match item:
-                        case AssistantMessageItem():
+                        case model.AssistantMessageItem():
                             if item.content:
                                 if group.text_content is None:
                                     group.text_content = item.content
                                 else:
                                     group.text_content += item.content
-                        case ToolCallItem():
+                        case model.ToolCallItem():
                             group.tool_calls.append(item)
-                        case ReasoningTextItem():
+                        case model.ReasoningTextItem():
                             group.reasoning_text.append(item)
                             group.reasoning_items.append(item)
-                        case ReasoningEncryptedItem():
+                        case model.ReasoningEncryptedItem():
                             group.reasoning_encrypted.append(item)
                             group.reasoning_items.append(item)
                         case _:
@@ -207,3 +205,35 @@ def merge_reminder_text(tool_output: str | None, reminder_texts: list[str]) -> s
     if reminder_texts:
         base += "\n" + "\n".join(reminder_texts)
     return base
+
+
+def apply_config_defaults(param: "LLMCallParameter", config: "LLMConfigParameter") -> "LLMCallParameter":
+    """Apply config defaults to LLM call parameters."""
+    if param.model is None:
+        param.model = config.model
+    if param.temperature is None:
+        param.temperature = config.temperature
+    if param.max_tokens is None:
+        param.max_tokens = config.max_tokens
+    if param.context_limit is None:
+        param.context_limit = config.context_limit
+    if param.verbosity is None:
+        param.verbosity = config.verbosity
+    if param.thinking is None:
+        param.thinking = config.thinking
+    if param.provider_routing is None:
+        param.provider_routing = config.provider_routing
+
+    if param.model is None:
+        raise ValueError("Model is required")
+    if param.max_tokens is None:
+        param.max_tokens = const.DEFAULT_MAX_TOKENS
+    if param.temperature is None:
+        param.temperature = const.DEFAULT_TEMPERATURE
+    if param.thinking is not None and param.thinking.type == "enabled" and param.thinking.budget_tokens is None:
+        param.thinking.budget_tokens = const.DEFAULT_ANTHROPIC_THINKING_BUDGET_TOKENS
+
+    if param.model and "gpt-5" in param.model:
+        param.temperature = 1.0  # Required for GPT-5
+
+    return param