klaude-code 1.2.2__py3-none-any.whl → 1.2.4__py3-none-any.whl

klaude_code/core/executor.py

@@ -5,19 +5,86 @@ This module implements the submission_loop equivalent for klaude,
 handling operations submitted from the CLI and coordinating with agents.
 """
 
+from __future__ import annotations
+
 import asyncio
 from dataclasses import dataclass
+from dataclasses import field as dataclass_field
 
-from klaude_code.command import dispatch_command
+from klaude_code.command import InputAction, InputActionType, dispatch_command
+from klaude_code.config import Config, load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
-from klaude_code.core.sub_agent import SubAgentResult
 from klaude_code.core.tool import current_run_subtask_callback
-from klaude_code.llm import LLMClients
-from klaude_code.protocol import events, model, op
+from klaude_code.llm.client import LLMClientABC
+from klaude_code.llm.registry import create_llm_client
+from klaude_code.protocol import commands, events, model, op
+from klaude_code.protocol.op_handler import OperationHandler
+from klaude_code.protocol.sub_agent import SubAgentResult, get_sub_agent_profile
+from klaude_code.protocol.tools import SubAgentType
 from klaude_code.session.session import Session
 from klaude_code.trace import DebugType, log_debug
 
 
+@dataclass
+class LLMClients:
+    """Container for LLM clients used by main agent and sub-agents."""
+
+    main: LLMClientABC
+    sub_clients: dict[SubAgentType, LLMClientABC] = dataclass_field(default_factory=lambda: {})
+
+    def get_client(self, sub_agent_type: SubAgentType | None = None) -> LLMClientABC:
+        """Get client for given sub-agent type, or main client if None."""
+        if sub_agent_type is None:
+            return self.main
+        return self.sub_clients.get(sub_agent_type) or self.main
+
+    @classmethod
+    def from_config(
+        cls,
+        config: Config,
+        model_override: str | None = None,
+        enabled_sub_agents: list[SubAgentType] | None = None,
+    ) -> LLMClients:
+        """Create LLMClients from application config.
+
+        Args:
+            config: Application configuration
+            model_override: Optional model name to override the main model
+            enabled_sub_agents: List of sub-agent types to initialize clients for
+
+        Returns:
+            LLMClients instance
+        """
+        # Resolve main agent LLM config
+        if model_override:
+            llm_config = config.get_model_config(model_override)
+        else:
+            llm_config = config.get_main_model_config()
+
+        log_debug(
+            "Main LLM config",
+            llm_config.model_dump_json(exclude_none=True),
+            style="yellow",
+            debug_type=DebugType.LLM_CONFIG,
+        )
+
+        main_client = create_llm_client(llm_config)
+        sub_clients: dict[SubAgentType, LLMClientABC] = {}
+
+        # Initialize sub-agent clients
+        for sub_agent_type in enabled_sub_agents or []:
+            model_name = config.subagent_models.get(sub_agent_type)
+            if not model_name:
+                continue
+            profile = get_sub_agent_profile(sub_agent_type)
+            if not profile.enabled_for_model(main_client.model_name):
+                continue
+            sub_llm_config = config.get_model_config(model_name)
+            sub_clients[sub_agent_type] = create_llm_client(sub_llm_config)
+
+        return cls(main=main_client, sub_clients=sub_clients)
+
+
 @dataclass
 class ActiveTask:
     """Track an in-flight task and its owning session."""
@@ -32,6 +99,8 @@ class ExecutorContext:
 
     This context is passed to operations when they execute, allowing them
     to access shared resources like the event queue and active sessions.
+
+    Implements the OperationHandler protocol via structural subtyping.
     """
 
     def __init__(
@@ -65,7 +134,6 @@ class ExecutorContext:
         agent = Agent(
             session=session,
             profile=profile,
-            model_profile_provider=self.model_profile_provider,
         )
 
         async for evt in agent.replay_history():
@@ -109,8 +177,12 @@ class ExecutorContext:
         )
 
         result = await dispatch_command(user_input.text, agent)
-        if not result.agent_input:
-            # If this command do not need run agent, we should append user message to session history here
+
+        actions: list[InputAction] = list(result.actions or [])
+
+        has_run_agent_action = any(action.type is InputActionType.RUN_AGENT for action in actions)
+        if not has_run_agent_action:
+            # No async agent task will run, append user message directly
             agent.session.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
 
         if result.events:
@@ -120,15 +192,80 @@ class ExecutorContext:
             for evt in result.events:
                 await self.emit_event(evt)
 
-        if result.agent_input:
-            # Construct new UserInputPayload with command-processed text, preserving original images
-            task_input = model.UserInputPayload(text=result.agent_input, images=user_input.images)
-            # Start task to process user input (do NOT await here so the executor loop stays responsive)
+        for action in actions:
+            await self._run_input_action(action, operation, agent)
+
+    async def _run_input_action(self, action: InputAction, operation: op.UserInputOperation, agent: Agent) -> None:
+        if operation.session_id is None:
+            raise ValueError("session_id cannot be None for input actions")
+
+        session_id = operation.session_id
+
+        if action.type == InputActionType.RUN_AGENT:
+            task_input = model.UserInputPayload(text=action.text, images=operation.input.images)
+
+            existing_active = self.active_tasks.get(operation.id)
+            if existing_active is not None and not existing_active.task.done():
+                raise RuntimeError(f"Active task already registered for operation {operation.id}")
+
             task: asyncio.Task[None] = asyncio.create_task(
                 self._run_agent_task(agent, task_input, operation.id, session_id)
             )
             self.active_tasks[operation.id] = ActiveTask(task=task, session_id=session_id)
-            # Do not await task here; completion will be tracked by the executor
+            return
+
+        if action.type == InputActionType.CHANGE_MODEL:
+            if not action.model_name:
+                raise ValueError("ChangeModel action requires model_name")
+
+            await self._apply_model_change(agent, action.model_name)
+            return
+
+        if action.type == InputActionType.CLEAR:
+            await self._apply_clear(agent)
+            return
+
+        raise ValueError(f"Unsupported input action type: {action.type}")
+
+    async def _apply_model_change(self, agent: Agent, model_name: str) -> None:
+        config = load_config()
+        if config is None:
+            raise ValueError("Configuration must be initialized before changing model")
+
+        llm_config = config.get_model_config(model_name)
+        llm_client = create_llm_client(llm_config)
+        agent.set_model_profile(self.model_profile_provider.build_profile(llm_client))
+
+        developer_item = model.DeveloperMessageItem(
+            content=f"switched to model: {model_name}",
+            command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
+        )
+        agent.session.append_history([developer_item])
+
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
+
+    async def _apply_clear(self, agent: Agent) -> None:
+        old_session_id = agent.session.id
+
+        # Create a new session instance to replace the current one
+        new_session = Session(work_dir=agent.session.work_dir)
+        new_session.model_name = agent.session.model_name
+
+        # Replace the agent's session with the new one
+        agent.session = new_session
+        agent.session.save()
+
+        # Update the active_agents mapping
+        self.active_agents.pop(old_session_id, None)
+        self.active_agents[new_session.id] = agent
+
+        developer_item = model.DeveloperMessageItem(
+            content="started new conversation",
+            command_output=model.CommandOutput(command_name=commands.CommandName.CLEAR),
+        )
+
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
     async def handle_interrupt(self, operation: op.InterruptOperation) -> None:
         """Handle an interrupt by invoking agent.cancel() and cancelling tasks."""
@@ -256,7 +393,6 @@ class ExecutorContext:
         child_agent = Agent(
             session=child_session,
             profile=child_profile,
-            model_profile_provider=self.model_profile_provider,
         )
 
         log_debug(
@@ -439,7 +575,7 @@ class Executor:
             )
 
             # Execute to spawn the agent task in context
-            await submission.operation.execute(self.context)
+            await submission.operation.execute(handler=self.context)
 
             async def _await_agent_and_complete() -> None:
                 # Wait for the agent task tied to this submission id
@@ -474,3 +610,8 @@ class Executor:
             event = self._completion_events.get(submission.id)
             if event is not None:
                 event.set()
+
+
+# Static type check: ExecutorContext must satisfy OperationHandler protocol.
+# If this line causes a type error, ExecutorContext is missing required methods.
+_: type[OperationHandler] = ExecutorContext  # pyright: ignore[reportUnusedVariable]

klaude_code/core/prompts/prompt-gemini.md

@@ -1,4 +1,4 @@
-You are a very strong reasoner and planner. Use these critical instructions to structure your plans, thoughts, and responses.
+You are an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
 
 Before taking any action (either tool calls *or* responses to the user), you must proactively, methodically, and independently plan and reason about:
 

klaude_code/core/reminders.py

@@ -241,6 +241,28 @@ class Memory(BaseModel):
     content: str
 
 
+def get_last_user_message_image_count(session: Session) -> int:
+    """Get image count from the last user message in conversation history."""
+    for item in reversed(session.conversation_history):
+        if isinstance(item, model.ToolResultItem):
+            return 0
+        if isinstance(item, model.UserMessageItem):
+            return len(item.images) if item.images else 0
+    return 0
+
+
+async def image_reminder(session: Session) -> model.DeveloperMessageItem | None:
+    """Remind agent about images attached by user in the last message."""
+    image_count = get_last_user_message_image_count(session)
+    if image_count == 0:
+        return None
+
+    return model.DeveloperMessageItem(
+        content=f"<system-reminder>User attached {image_count} image{'s' if image_count > 1 else ''} in their message. Make sure to analyze and reference these images as needed.</system-reminder>",
+        user_image_count=image_count,
+    )
+
+
 async def memory_reminder(session: Session) -> model.DeveloperMessageItem | None:
     """CLAUDE.md AGENTS.md"""
     memory_paths = get_memory_paths()
@@ -386,6 +408,7 @@ ALL_REMINDERS = [
     memory_reminder,
     last_path_memory_reminder,
     at_file_reader_reminder,
+    image_reminder,
 ]
 
 
@@ -415,6 +438,7 @@ def load_agent_reminders(
             last_path_memory_reminder,
             at_file_reader_reminder,
             file_changed_externally_reminder,
+            image_reminder,
         ]
     )
 

klaude_code/core/task.py

@@ -62,6 +62,16 @@ class MetadataAccumulator:
                     self._throughput_weighted_sum += usage.throughput_tps * current_output
                     self._throughput_tracked_tokens += current_output
 
+            # Accumulate costs
+            if usage.input_cost is not None:
+                acc_usage.input_cost = (acc_usage.input_cost or 0.0) + usage.input_cost
+            if usage.output_cost is not None:
+                acc_usage.output_cost = (acc_usage.output_cost or 0.0) + usage.output_cost
+            if usage.cache_read_cost is not None:
+                acc_usage.cache_read_cost = (acc_usage.cache_read_cost or 0.0) + usage.cache_read_cost
+            if usage.total_cost is not None:
+                acc_usage.total_cost = (acc_usage.total_cost or 0.0) + usage.total_cost
+
         if turn_metadata.provider is not None:
             accumulated.provider = turn_metadata.provider
         if turn_metadata.model_name:

klaude_code/core/tool/shell/bash_tool.py

@@ -1,4 +1,5 @@
 import asyncio
+import re
 import subprocess
 from pathlib import Path
 
@@ -10,6 +11,9 @@ from klaude_code.core.tool.tool_abc import ToolABC, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, model, tools
 
+# Regex to strip ANSI escape sequences from command output
+_ANSI_ESCAPE_RE = re.compile(r"\x1b\[[0-9;]*m")
+
 
 @register(tools.BASH)
 class BashTool(ToolABC):
@@ -78,8 +82,8 @@ class BashTool(ToolABC):
                 check=False,
             )
 
-            stdout = completed.stdout or ""
-            stderr = completed.stderr or ""
+            stdout = _ANSI_ESCAPE_RE.sub("", completed.stdout or "")
+            stderr = _ANSI_ESCAPE_RE.sub("", completed.stderr or "")
             rc = completed.returncode
 
             if rc == 0:

klaude_code/core/tool/sub_agent_tool.py

@@ -15,7 +15,7 @@ from klaude_code.core.tool.tool_context import current_run_subtask_callback
 from klaude_code.protocol import llm_param, model
 
 if TYPE_CHECKING:
-    from klaude_code.core.sub_agent import SubAgentProfile
+    from klaude_code.protocol.sub_agent import SubAgentProfile
 
 
 class SubAgentTool(ToolABC):

klaude_code/core/tool/tool_context.py

@@ -5,8 +5,8 @@ from contextlib import contextmanager
 from contextvars import ContextVar, Token
 from dataclasses import dataclass
 
-from klaude_code.core.sub_agent import SubAgentResult
 from klaude_code.protocol import model
+from klaude_code.protocol.sub_agent import SubAgentResult
 from klaude_code.session.session import Session
 
 

klaude_code/core/tool/tool_registry.py

@@ -1,9 +1,9 @@
 from typing import Callable, TypeVar
 
-from klaude_code.core.sub_agent import get_sub_agent_profile, iter_sub_agent_profiles, sub_agent_tool_names
 from klaude_code.core.tool.sub_agent_tool import SubAgentTool
 from klaude_code.core.tool.tool_abc import ToolABC
 from klaude_code.protocol import llm_param, tools
+from klaude_code.protocol.sub_agent import get_sub_agent_profile, iter_sub_agent_profiles, sub_agent_tool_names
 
 _REGISTRY: dict[str, type[ToolABC]] = {}
 

klaude_code/core/tool/tool_runner.py

@@ -3,10 +3,10 @@ from collections.abc import AsyncGenerator, Callable, Iterable, Sequence
 from dataclasses import dataclass
 
 from klaude_code import const
-from klaude_code.core.sub_agent import is_sub_agent_tool
 from klaude_code.core.tool.tool_abc import ToolABC
 from klaude_code.core.tool.truncation import truncate_tool_output
 from klaude_code.protocol import model
+from klaude_code.protocol.sub_agent import is_sub_agent_tool
 
 
 async def run_tool(tool_call: model.ToolCallItem, registry: dict[str, type[ToolABC]]) -> model.ToolResultItem:

klaude_code/core/tool/web/mermaid_tool.py

@@ -60,7 +60,7 @@ class MermaidTool(ToolABC):
     def _build_link(code: str) -> str:
         state = {
             "code": code,
-            "mermaid": {"theme": "default"},
+            "mermaid": {"theme": "neutral"},
             "autoSync": True,
             "updateDiagram": True,
         }

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

@@ -22,6 +22,7 @@ from klaude_code.llm.anthropic.input import convert_history_to_input, convert_sy
 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
 
@@ -199,16 +200,18 @@ 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),
                         )

klaude_code/llm/openai_compatible/client.py

@@ -8,10 +8,10 @@ from openai import APIError, RateLimitError
 
 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.metadata_tracker import MetadataTracker
 from klaude_code.llm.openai_compatible.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
 from klaude_code.llm.registry import register
+from klaude_code.llm.usage import MetadataTracker, convert_usage
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
@@ -48,7 +48,7 @@ class OpenAICompatibleClient(LLMClientABC):
         messages = convert_history_to_input(param.input, param.system, param.model)
         tools = convert_tool_schema(param.tools)
 
-        metadata_tracker = MetadataTracker()
+        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
 
         extra_body = {}
         extra_headers = {"extra": json.dumps({"session_id": param.session_id})}
@@ -209,19 +209,3 @@ class OpenAICompatibleClient(LLMClientABC):
 
         metadata_tracker.set_response_id(response_id)
         yield metadata_tracker.finalize()
-
-
-def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None = None) -> model.Usage:
-    total_tokens = usage.total_tokens
-    context_usage_percent = (total_tokens / context_limit) * 100 if context_limit else None
-    return model.Usage(
-        input_tokens=usage.prompt_tokens,
-        cached_tokens=(usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0) or 0,
-        reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
-        or 0,
-        output_tokens=usage.completion_tokens,
-        total_tokens=total_tokens,
-        context_usage_percent=context_usage_percent,
-        throughput_tps=None,
-        first_token_latency_ms=None,
-    )

klaude_code/llm/openai_compatible/tool_call_accumulator.py

@@ -8,7 +8,7 @@ from klaude_code.protocol import model
 
 class ToolCallAccumulatorABC(ABC):
     @abstractmethod
-    def add(self, chunks: list[ChoiceDeltaToolCall]):
+    def add(self, chunks: list[ChoiceDeltaToolCall]) -> None:
         pass
 
     @abstractmethod
@@ -50,7 +50,7 @@ class BasicToolCallAccumulator(ToolCallAccumulatorABC, BaseModel):
     chunks_by_step: list[list[ChoiceDeltaToolCall]] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
     response_id: str | None = None
 
-    def add(self, chunks: list[ChoiceDeltaToolCall]):
+    def add(self, chunks: list[ChoiceDeltaToolCall]) -> None:
         self.chunks_by_step.append(chunks)
 
     def get(self) -> list[model.ToolCallItem]:

klaude_code/llm/openrouter/client.py

@@ -6,12 +6,12 @@ import openai
 
 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.metadata_tracker import MetadataTracker
 from klaude_code.llm.openai_compatible.input import convert_tool_schema
 from klaude_code.llm.openai_compatible.tool_call_accumulator import BasicToolCallAccumulator, ToolCallAccumulatorABC
 from klaude_code.llm.openrouter.input import convert_history_to_input, is_claude_model
 from klaude_code.llm.openrouter.reasoning_handler import ReasoningDetail, ReasoningStreamHandler
 from klaude_code.llm.registry import register
+from klaude_code.llm.usage import MetadataTracker, convert_usage
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log, log_debug
 
@@ -38,7 +38,7 @@ class OpenRouterClient(LLMClientABC):
         messages = convert_history_to_input(param.input, param.system, param.model)
         tools = convert_tool_schema(param.tools)
 
-        metadata_tracker = MetadataTracker()
+        metadata_tracker = MetadataTracker(cost_config=self._config.cost)
 
         extra_body: dict[str, object] = {
             "usage": {"include": True}  # To get the cache tokens at the end of the response
@@ -198,19 +198,3 @@ class OpenRouterClient(LLMClientABC):
 
         metadata_tracker.set_response_id(response_id)
         yield metadata_tracker.finalize()
-
-
-def convert_usage(usage: openai.types.CompletionUsage, context_limit: int | None = None) -> model.Usage:
-    total_tokens = usage.total_tokens
-    context_usage_percent = (total_tokens / context_limit) * 100 if context_limit else None
-    return model.Usage(
-        input_tokens=usage.prompt_tokens,
-        cached_tokens=(usage.prompt_tokens_details.cached_tokens if usage.prompt_tokens_details else 0) or 0,
-        reasoning_tokens=(usage.completion_tokens_details.reasoning_tokens if usage.completion_tokens_details else 0)
-        or 0,
-        output_tokens=usage.completion_tokens,
-        total_tokens=total_tokens,
-        context_usage_percent=context_usage_percent,
-        throughput_tps=None,
-        first_token_latency_ms=None,
-    )

klaude_code/llm/openrouter/input.py

@@ -13,11 +13,15 @@ from klaude_code.llm.input_common import AssistantGroup, ToolGroup, UserGroup, m
 from klaude_code.protocol import model
 
 
-def is_claude_model(model_name: str | None):
+def is_claude_model(model_name: str | None) -> bool:
+    """Return True if the model name represents an Anthropic Claude model."""
+
     return model_name is not None and model_name.startswith("anthropic/claude")
 
 
-def is_gemini_model(model_name: str | None):
+def is_gemini_model(model_name: str | None) -> bool:
+    """Return True if the model name represents a Google Gemini model."""
+
     return model_name is not None and model_name.startswith("google/gemini")
 
 

klaude_code/llm/registry.py

@@ -1,14 +1,7 @@
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Callable, TypeVar
+from typing import Callable, TypeVar
 
 from klaude_code.llm.client import LLMClientABC
-from klaude_code.protocol import llm_param, tools
-from klaude_code.trace import DebugType, log_debug
-
-if TYPE_CHECKING:
-    from klaude_code.config import Config
+from klaude_code.protocol import llm_param
 
 _REGISTRY: dict[llm_param.LLMClientProtocol, type[LLMClientABC]] = {}
 
@@ -27,65 +20,3 @@ def create_llm_client(config: llm_param.LLMConfigParameter) -> LLMClientABC:
     if config.protocol not in _REGISTRY:
         raise ValueError(f"Unknown LLMClient protocol: {config.protocol}")
     return _REGISTRY[config.protocol].create(config)
-
-
-@dataclass
-class LLMClients:
-    """Container for LLM clients used by main agent and sub-agents."""
-
-    main: LLMClientABC
-    sub_clients: dict[tools.SubAgentType, LLMClientABC] = field(default_factory=lambda: {})
-
-    def get_client(self, sub_agent_type: tools.SubAgentType | None = None) -> LLMClientABC:
-        """Get client for given sub-agent type, or main client if None."""
-        if sub_agent_type is None:
-            return self.main
-        return self.sub_clients.get(sub_agent_type) or self.main
-
-    @classmethod
-    def from_config(
-        cls,
-        config: Config,
-        model_override: str | None = None,
-        enabled_sub_agents: list[tools.SubAgentType] | None = None,
-    ) -> LLMClients:
-        """Create LLMClients from application config.
-
-        Args:
-            config: Application configuration
-            model_override: Optional model name to override the main model
-            enabled_sub_agents: List of sub-agent types to initialize clients for
-
-        Returns:
-            LLMClients instance
-        """
-        from klaude_code.core.sub_agent import get_sub_agent_profile
-
-        # Resolve main agent LLM config
-        if model_override:
-            llm_config = config.get_model_config(model_override)
-        else:
-            llm_config = config.get_main_model_config()
-
-        log_debug(
-            "Main LLM config",
-            llm_config.model_dump_json(exclude_none=True),
-            style="yellow",
-            debug_type=DebugType.LLM_CONFIG,
-        )
-
-        main_client = create_llm_client(llm_config)
-        sub_clients: dict[tools.SubAgentType, LLMClientABC] = {}
-
-        # Initialize sub-agent clients
-        for sub_agent_type in enabled_sub_agents or []:
-            model_name = config.subagent_models.get(sub_agent_type)
-            if not model_name:
-                continue
-            profile = get_sub_agent_profile(sub_agent_type)
-            if not profile.enabled_for_model(main_client.model_name):
-                continue
-            sub_llm_config = config.get_model_config(model_name)
-            sub_clients[sub_agent_type] = create_llm_client(sub_llm_config)
-
-        return cls(main=main_client, sub_clients=sub_clients)

klaude_code/llm/responses/client.py

@@ -11,6 +11,7 @@ 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.responses.input import convert_history_to_input, convert_tool_schema
+from klaude_code.llm.usage import calculate_cost
 from klaude_code.protocol import llm_param, model
 from klaude_code.trace import DebugType, log_debug
 
@@ -185,6 +186,7 @@ class ResponsesClient(LLMClientABC):
                                 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,