klaude-code 1.2.12__py3-none-any.whl → 1.2.14__py3-none-any.whl

klaude_code/command/__init__.py

@@ -28,15 +28,15 @@ def ensure_commands_loaded() -> None:
 
     # Import and register commands in display order
     from .clear_cmd import ClearCommand
-    from .model_cmd import ModelCommand
-    from .status_cmd import StatusCommand
     from .diff_cmd import DiffCommand
     from .export_cmd import ExportCommand
-    from .thinking_cmd import ThinkingCommand
     from .help_cmd import HelpCommand
+    from .model_cmd import ModelCommand
     from .refresh_cmd import RefreshTerminalCommand
-    from .terminal_setup_cmd import TerminalSetupCommand
     from .release_notes_cmd import ReleaseNotesCommand
+    from .status_cmd import StatusCommand
+    from .terminal_setup_cmd import TerminalSetupCommand
+    from .thinking_cmd import ThinkingCommand
 
     # Register in desired display order
     register(ExportCommand())
@@ -86,8 +86,8 @@ __all__ = [
     "InputAction",
     "InputActionType",
     "dispatch_command",
+    "ensure_commands_loaded",
     "get_commands",
-    "is_slash_command_name",
     "has_interactive_command",
-    "ensure_commands_loaded",
+    "is_slash_command_name",
 ]

klaude_code/command/export_cmd.py

@@ -31,7 +31,7 @@ class ExportCommand(CommandABC):
     def is_interactive(self) -> bool:
         return False
 
-    async def run(self, raw: str, agent: "Agent") -> CommandResult:
+    async def run(self, raw: str, agent: Agent) -> CommandResult:
         try:
             output_path = self._resolve_output_path(raw, agent)
             html_doc = self._build_html(agent)
@@ -58,7 +58,7 @@ class ExportCommand(CommandABC):
             )
             return CommandResult(events=[event])
 
-    def _resolve_output_path(self, raw: str, agent: "Agent") -> Path:
+    def _resolve_output_path(self, raw: str, agent: Agent) -> Path:
         trimmed = raw.strip()
         if trimmed:
             candidate = Path(trimmed).expanduser()
@@ -79,7 +79,7 @@ class ExportCommand(CommandABC):
             msg = f"Failed to open HTML with `open`: {exc}"
             raise RuntimeError(msg) from exc
 
-    def _build_html(self, agent: "Agent") -> str:
+    def _build_html(self, agent: Agent) -> str:
         profile = agent.profile
         system_prompt = (profile.system_prompt if profile else "") or ""
         tools = profile.tools if profile else []

klaude_code/command/model_cmd.py

@@ -2,7 +2,7 @@ import asyncio
 from typing import TYPE_CHECKING
 
 from klaude_code.command.command_abc import CommandABC, CommandResult, InputAction
-from klaude_code.config import select_model_from_config
+from klaude_code.config.select_model import select_model_from_config
 from klaude_code.protocol import commands, events, model
 
 if TYPE_CHECKING:

klaude_code/command/registry.py

@@ -94,7 +94,7 @@ async def dispatch_command(raw: str, agent: "Agent") -> CommandResult:
                 events.DeveloperMessageEvent(
                     session_id=agent.session.id,
                     item=model.DeveloperMessageItem(
-                        content=f"Command {command_identifier} error: [{e.__class__.__name__}] {str(e)}",
+                        content=f"Command {command_identifier} error: [{e.__class__.__name__}] {e!s}",
                         command_output=command_output,
                     ),
                 )

klaude_code/command/terminal_setup_cmd.py

@@ -43,7 +43,7 @@ class TerminalSetupCommand(CommandABC):
             return self._create_success_result(agent, message)
 
         except Exception as e:
-            return self._create_error_result(agent, f"Error configuring terminal: {str(e)}")
+            return self._create_error_result(agent, f"Error configuring terminal: {e!s}")
 
     def _setup_ghostty(self) -> str:
         """Configure shift+enter newline for Ghostty terminal"""
@@ -113,7 +113,7 @@ class TerminalSetupCommand(CommandABC):
                 )
 
         except Exception as e:
-            raise Exception(f"Error configuring iTerm: {str(e)}")
+            raise Exception(f"Error configuring iTerm: {e!s}") from e
 
     def _setup_vscode_family(self) -> str:
         """Configure shift+enter newline for VS Code family terminals (VS Code, Windsurf, Cursor).

klaude_code/command/thinking_cmd.py

@@ -95,12 +95,14 @@ def _format_current_thinking(config: llm_param.LLMConfigParameter) -> str:
     return "unknown protocol"
 
 
-SELECT_STYLE = questionary.Style([
-    ("instruction", "ansibrightblack"),
-    ("pointer", "ansicyan"),
-    ("highlighted", "ansicyan"),
-    ("text", "ansibrightblack"),
-])
+SELECT_STYLE = questionary.Style(
+    [
+        ("instruction", "ansibrightblack"),
+        ("pointer", "ansicyan"),
+        ("highlighted", "ansicyan"),
+        ("text", "ansibrightblack"),
+    ]
+)
 
 
 def _select_responses_thinking_sync(model_name: str | None) -> llm_param.Thinking | None:

klaude_code/config/__init__.py

@@ -1,11 +1,7 @@
 from .config import Config, config_path, load_config
-from .list_model import display_models_and_providers
-from .select_model import select_model_from_config
 
 __all__ = [
     "Config",
-    "load_config",
     "config_path",
-    "display_models_and_providers",
-    "select_model_from_config",
+    "load_config",
 ]

klaude_code/config/config.py

@@ -71,7 +71,8 @@ class Config(BaseModel):
 
         def _save_config() -> None:
             config_path.parent.mkdir(parents=True, exist_ok=True)
-            _ = config_path.write_text(yaml.dump(config_dict, default_flow_style=False, sort_keys=False))
+            yaml_content = yaml.dump(config_dict, default_flow_style=False, sort_keys=False)
+            _ = config_path.write_text(str(yaml_content or ""))
 
         await asyncio.to_thread(_save_config)
 
@@ -142,8 +143,7 @@ def get_example_config() -> Config:
     )
 
 
-@lru_cache(maxsize=1)
-def load_config() -> Config | None:
+def _load_config_uncached() -> Config | None:
     if not config_path.exists():
         log(f"Config file not found: {config_path}")
         example_config = get_example_config()
@@ -151,7 +151,7 @@ def load_config() -> Config | None:
         config_dict = example_config.model_dump(mode="json", exclude_none=True)
 
         # Comment out all example config lines
-        yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False)
+        yaml_str = yaml.dump(config_dict, default_flow_style=False, sort_keys=False) or ""
         commented_yaml = "\n".join(f"# {line}" if line.strip() else "#" for line in yaml_str.splitlines())
         _ = config_path.write_text(commented_yaml)
 
@@ -175,3 +175,30 @@ def load_config() -> Config | None:
         raise ValueError(f"Invalid config file: {config_path}") from e
 
     return config
+
+
+@lru_cache(maxsize=1)
+def _load_config_cached() -> Config | None:
+    return _load_config_uncached()
+
+
+def load_config() -> Config | None:
+    """Load config from disk, caching only successful parses.
+
+    Returns:
+        Config object on success, or None when the config is missing/empty/commented out.
+    """
+
+    try:
+        config = _load_config_cached()
+    except ValueError:
+        _load_config_cached.cache_clear()
+        raise
+
+    if config is None:
+        _load_config_cached.cache_clear()
+    return config
+
+
+# Expose cache control for tests and callers that need to invalidate the cache.
+load_config.cache_clear = _load_config_cached.cache_clear  # type: ignore[attr-defined]

klaude_code/config/list_model.py

@@ -34,7 +34,7 @@ def _display_codex_status(console: Console) -> None:
             )
         )
     else:
-        expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.timezone.utc)
+        expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
         console.print(
             Text.assemble(
                 ("Codex Status: ", "bold"),

klaude_code/const/__init__.py

@@ -4,6 +4,8 @@ This module consolidates all magic numbers and configuration values
 that were previously scattered across the codebase.
 """
 
+from pathlib import Path
+
 # =============================================================================
 # Agent Configuration
 # =============================================================================
@@ -116,15 +118,18 @@ STATUS_SHIMMER_ALPHA_SCALE = 0.7
 # Spinner breathing animation
 # Duration in seconds for one full breathe-in + breathe-out cycle
 # Keep in sync with STATUS_SHIMMER_SWEEP_SECONDS for visual consistency
-SPINNER_BREATH_PERIOD_SECONDS = 2
+SPINNER_BREATH_PERIOD_SECONDS: float = 2.0
 
 
 # =============================================================================
 # Debug / Logging
 # =============================================================================
 
-# Default debug log file path
-DEFAULT_DEBUG_LOG_FILE = "debug.log"
+# Default debug log directory (user cache)
+DEFAULT_DEBUG_LOG_DIR = Path.home() / ".klaude" / "logs"
+
+# Default debug log file path (symlink to latest session)
+DEFAULT_DEBUG_LOG_FILE = DEFAULT_DEBUG_LOG_DIR / "debug.log"
 
 # Maximum log file size before rotation (10MB)
 LOG_MAX_BYTES = 10 * 1024 * 1024

klaude_code/core/agent.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-from collections.abc import AsyncGenerator, Callable, Iterable
+from collections.abc import AsyncGenerator, Iterable
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Protocol
+from typing import Protocol
 
 from klaude_code.core.prompt import load_system_prompt
 from klaude_code.core.reminders import Reminder, load_agent_reminders
@@ -14,38 +14,21 @@ from klaude_code.protocol.model import UserInputPayload
 from klaude_code.session import Session
 from klaude_code.trace import DebugType, log_debug
 
-if TYPE_CHECKING:
-    from klaude_code.core.manager.llm_clients import LLMClients
-
 
 @dataclass(frozen=True)
 class AgentProfile:
     """Encapsulates the active LLM client plus prompts/tools/reminders."""
 
-    llm_client_factory: Callable[[], LLMClientABC]
+    llm_client: LLMClientABC
     system_prompt: str | None
     tools: list[llm_param.ToolSchema]
     reminders: list[Reminder]
 
-    _llm_client: LLMClientABC | None = None
-
-    @property
-    def llm_client(self) -> LLMClientABC:
-        if self._llm_client is None:
-            object.__setattr__(self, "_llm_client", self.llm_client_factory())
-        return self._llm_client  # type: ignore[return-value]
-
 
 class ModelProfileProvider(Protocol):
     """Strategy interface for constructing agent profiles."""
 
     def build_profile(
-        self,
-        llm_clients: LLMClients,
-        sub_agent_type: tools.SubAgentType | None = None,
-    ) -> AgentProfile: ...
-
-    def build_profile_eager(
         self,
         llm_client: LLMClientABC,
         sub_agent_type: tools.SubAgentType | None = None,
@@ -56,27 +39,14 @@ class DefaultModelProfileProvider(ModelProfileProvider):
     """Default provider backed by global prompts/tool/reminder registries."""
 
     def build_profile(
-        self,
-        llm_clients: LLMClients,
-        sub_agent_type: tools.SubAgentType | None = None,
-    ) -> AgentProfile:
-        model_name = llm_clients.main_model_name
-        return AgentProfile(
-            llm_client_factory=lambda: llm_clients.main,
-            system_prompt=load_system_prompt(model_name, sub_agent_type),
-            tools=load_agent_tools(model_name, sub_agent_type),
-            reminders=load_agent_reminders(model_name, sub_agent_type),
-        )
-
-    def build_profile_eager(
         self,
         llm_client: LLMClientABC,
         sub_agent_type: tools.SubAgentType | None = None,
     ) -> AgentProfile:
         model_name = llm_client.model_name
         return AgentProfile(
-            llm_client_factory=lambda: llm_client,
-            system_prompt=load_system_prompt(model_name, sub_agent_type),
+            llm_client=llm_client,
+            system_prompt=load_system_prompt(model_name, llm_client.protocol, sub_agent_type),
             tools=load_agent_tools(model_name, sub_agent_type),
             reminders=load_agent_reminders(model_name, sub_agent_type),
         )
@@ -86,26 +56,13 @@ class VanillaModelProfileProvider(ModelProfileProvider):
     """Provider that strips prompts, reminders, and tools for vanilla mode."""
 
     def build_profile(
-        self,
-        llm_clients: LLMClients,
-        sub_agent_type: tools.SubAgentType | None = None,
-    ) -> AgentProfile:
-        model_name = llm_clients.main_model_name
-        return AgentProfile(
-            llm_client_factory=lambda: llm_clients.main,
-            system_prompt=None,
-            tools=load_agent_tools(model_name, vanilla=True),
-            reminders=load_agent_reminders(model_name, vanilla=True),
-        )
-
-    def build_profile_eager(
         self,
         llm_client: LLMClientABC,
         sub_agent_type: tools.SubAgentType | None = None,
     ) -> AgentProfile:
         model_name = llm_client.model_name
         return AgentProfile(
-            llm_client_factory=lambda: llm_client,
+            llm_client=llm_client,
             system_prompt=None,
             tools=load_agent_tools(model_name, vanilla=True),
             reminders=load_agent_reminders(model_name, vanilla=True),
@@ -117,13 +74,12 @@ class Agent:
         self,
         session: Session,
         profile: AgentProfile,
-        model_name: str | None = None,
     ):
         self.session: Session = session
         self.profile: AgentProfile = profile
         self._current_task: TaskExecutor | None = None
-        if not self.session.model_name and model_name:
-            self.session.model_name = model_name
+        if not self.session.model_name:
+            self.session.model_name = profile.llm_client.model_name
 
     def cancel(self) -> Iterable[events.Event]:
         """Handle agent cancellation and persist an interrupt marker and tool cancellations.
@@ -136,8 +92,7 @@ class Agent:
         """
         # First, cancel any running task so it stops emitting events.
         if self._current_task is not None:
-            for ui_event in self._current_task.cancel():
-                yield ui_event
+            yield from self._current_task.cancel()
             self._current_task = None
 
         # Record an interrupt marker in the session history
@@ -148,7 +103,7 @@ class Agent:
             debug_type=DebugType.EXECUTION,
         )
 
-    async def run_task(self, user_input: UserInputPayload) -> AsyncGenerator[events.Event, None]:
+    async def run_task(self, user_input: UserInputPayload) -> AsyncGenerator[events.Event]:
         session_ctx = SessionContext(
             session_id=self.session.id,
             get_conversation_history=lambda: self.session.conversation_history,
@@ -173,7 +128,7 @@ class Agent:
         finally:
             self._current_task = None
 
-    async def replay_history(self) -> AsyncGenerator[events.Event, None]:
+    async def replay_history(self) -> AsyncGenerator[events.Event]:
         """Yield UI events reconstructed from saved conversation history."""
 
         if len(self.session.conversation_history) == 0:
@@ -185,21 +140,18 @@ class Agent:
             session_id=self.session.id,
         )
 
-    async def _process_reminder(self, reminder: Reminder) -> AsyncGenerator[events.DeveloperMessageEvent, None]:
+    async def _process_reminder(self, reminder: Reminder) -> AsyncGenerator[events.DeveloperMessageEvent]:
         """Process a single reminder and yield events if it produces output."""
         item = await reminder(self.session)
         if item is not None:
             self.session.append_history([item])
             yield events.DeveloperMessageEvent(session_id=self.session.id, item=item)
 
-    def set_model_profile(self, profile: AgentProfile, model_name: str | None = None) -> None:
+    def set_model_profile(self, profile: AgentProfile) -> None:
         """Apply a fully constructed profile to the agent."""
 
         self.profile = profile
-        if model_name:
-            self.session.model_name = model_name
-        elif not self.session.model_name:
-            self.session.model_name = profile.llm_client.model_name
+        self.session.model_name = profile.llm_client.model_name
 
     def get_llm_client(self) -> LLMClientABC:
         return self.profile.llm_client

klaude_code/core/executor.py

@@ -264,14 +264,14 @@ class ExecutorContext:
             import traceback
 
             log_debug(
-                f"Agent task {task_id} failed: {str(e)}",
+                f"Agent task {task_id} failed: {e!s}",
                 style="red",
                 debug_type=DebugType.EXECUTION,
             )
             log_debug(traceback.format_exc(), style="red", debug_type=DebugType.EXECUTION)
             await self.emit_event(
                 events.ErrorEvent(
-                    error_message=f"Agent task failed: [{e.__class__.__name__}] {str(e)}",
+                    error_message=f"Agent task failed: [{e.__class__.__name__}] {e!s}",
                     can_retry=False,
                 )
             )
@@ -317,6 +317,7 @@ class Executor:
         self.submission_queue: asyncio.Queue[op.Submission] = asyncio.Queue()
         # Track completion events for all submissions (not just those with ActiveTask)
         self._completion_events: dict[str, asyncio.Event] = {}
+        self._background_tasks: set[asyncio.Task[None]] = set()
 
     async def submit(self, operation: op.Operation) -> str:
         """
@@ -388,12 +389,12 @@ class Executor:
             except Exception as e:
                 # Handle unexpected errors
                 log_debug(
-                    f"Executor error: {str(e)}",
+                    f"Executor error: {e!s}",
                     style="red",
                     debug_type=DebugType.EXECUTION,
                 )
                 await self.context.emit_event(
-                    events.ErrorEvent(error_message=f"Executor error: {str(e)}", can_retry=False)
+                    events.ErrorEvent(error_message=f"Executor error: {e!s}", can_retry=False)
                 )
 
     async def stop(self) -> None:
@@ -420,7 +421,7 @@ class Executor:
             await self.submission_queue.put(submission)
         except Exception as e:
             log_debug(
-                f"Failed to send EndOperation: {str(e)}",
+                f"Failed to send EndOperation: {e!s}",
                 style="red",
                 debug_type=DebugType.EXECUTION,
             )
@@ -460,17 +461,17 @@ class Executor:
                     event.set()
             else:
                 # Run in background so the submission loop can continue (e.g., to handle interrupts)
-                asyncio.create_task(_await_agent_and_complete(task))
+                background_task = asyncio.create_task(_await_agent_and_complete(task))
+                self._background_tasks.add(background_task)
+                background_task.add_done_callback(self._background_tasks.discard)
 
         except Exception as e:
             log_debug(
-                f"Failed to handle submission {submission.id}: {str(e)}",
+                f"Failed to handle submission {submission.id}: {e!s}",
                 style="red",
                 debug_type=DebugType.EXECUTION,
             )
-            await self.context.emit_event(
-                events.ErrorEvent(error_message=f"Operation failed: {str(e)}", can_retry=False)
-            )
+            await self.context.emit_event(events.ErrorEvent(error_message=f"Operation failed: {e!s}", can_retry=False))
             # Set completion event even on error to prevent wait_for_completion from hanging
             event = self._completion_events.get(submission.id)
             if event is not None:

klaude_code/core/manager/agent_manager.py

@@ -51,8 +51,8 @@ class AgentManager:
             if agent is not None:
                 return agent
             session = Session.load(session_id)
-        profile = self._model_profile_provider.build_profile(self._llm_clients)
-        agent = Agent(session=session, profile=profile, model_name=self._llm_clients.main_model_name)
+        profile = self._model_profile_provider.build_profile(self._llm_clients.main)
+        agent = Agent(session=session, profile=profile)
 
         async for evt in agent.replay_history():
             await self.emit_event(evt)
@@ -60,7 +60,7 @@ class AgentManager:
         await self.emit_event(
             events.WelcomeEvent(
                 work_dir=str(session.work_dir),
-                llm_config=self._llm_clients.get_llm_config(),
+                llm_config=self._llm_clients.main.get_llm_config(),
             )
         )
 
@@ -81,7 +81,7 @@ class AgentManager:
 
         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_eager(llm_client), model_name=model_name)
+        agent.set_model_profile(self._model_profile_provider.build_profile(llm_client))
 
         developer_item = model.DeveloperMessageItem(
             content=f"switched to model: {model_name}",

klaude_code/core/manager/llm_clients.py

@@ -2,66 +2,27 @@
 
 from __future__ import annotations
 
-from collections.abc import Callable
+from dataclasses import dataclass
+from dataclasses import field as dataclass_field
 
 from klaude_code.llm.client import LLMClientABC
-from klaude_code.protocol import llm_param
 from klaude_code.protocol.tools import SubAgentType
 
 
-class LLMClients:
-    """Container for LLM clients used by main agent and sub-agents."""
-
-    def __init__(
-        self,
-        main_factory: Callable[[], LLMClientABC],
-        main_model_name: str,
-        main_llm_config: llm_param.LLMConfigParameter,
-    ) -> None:
-        self._main_factory: Callable[[], LLMClientABC] | None = main_factory
-        self._main_client: LLMClientABC | None = None
-        self._main_model_name: str = main_model_name
-        self._main_llm_config: llm_param.LLMConfigParameter = main_llm_config
-        self._sub_clients: dict[SubAgentType, LLMClientABC] = {}
-        self._sub_factories: dict[SubAgentType, Callable[[], LLMClientABC]] = {}
+def _default_sub_clients() -> dict[SubAgentType, LLMClientABC]:
+    return {}
 
-    @property
-    def main_model_name(self) -> str:
-        return self._main_model_name
 
-    def get_llm_config(self) -> llm_param.LLMConfigParameter:
-        return self._main_llm_config
-
-    @property
-    def main(self) -> LLMClientABC:
-        if self._main_client is None:
-            if self._main_factory is None:
-                raise RuntimeError("Main client factory not set")
-            self._main_client = self._main_factory()
-            self._main_factory = None
-        return self._main_client
+@dataclass
+class LLMClients:
+    """Container for LLM clients used by main agent and sub-agents."""
 
-    def register_sub_client_factory(
-        self,
-        sub_agent_type: SubAgentType,
-        factory: Callable[[], LLMClientABC],
-    ) -> None:
-        self._sub_factories[sub_agent_type] = factory
+    main: LLMClientABC
+    sub_clients: dict[SubAgentType, LLMClientABC] = dataclass_field(default_factory=_default_sub_clients)
 
     def get_client(self, sub_agent_type: SubAgentType | None = None) -> LLMClientABC:
         """Return client for a sub-agent type or the main client."""
 
         if sub_agent_type is None:
             return self.main
-
-        existing = self._sub_clients.get(sub_agent_type)
-        if existing is not None:
-            return existing
-
-        factory = self._sub_factories.get(sub_agent_type)
-        if factory is None:
-            return self.main
-
-        client = factory()
-        self._sub_clients[sub_agent_type] = client
-        return client
+        return self.sub_clients.get(sub_agent_type) or self.main

klaude_code/core/manager/llm_clients_builder.py

@@ -7,6 +7,7 @@ from klaude_code.core.manager.llm_clients import LLMClients
 from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.registry import create_llm_client
 from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
+from klaude_code.protocol.tools import SubAgentType
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -18,10 +19,7 @@ def build_llm_clients(
     """Create an ``LLMClients`` bundle driven by application config."""
 
     # Resolve main agent LLM config
-    if model_override:
-        llm_config = config.get_model_config(model_override)
-    else:
-        llm_config = config.get_main_model_config()
+    llm_config = config.get_model_config(model_override) if model_override else config.get_main_model_config()
 
     log_debug(
         "Main LLM config",
@@ -30,29 +28,18 @@ def build_llm_clients(
         debug_type=DebugType.LLM_CONFIG,
     )
 
-    main_model_name = str(llm_config.model)
-
-    def _main_factory() -> LLMClientABC:
-        return create_llm_client(llm_config)
-
-    clients = LLMClients(
-        main_factory=_main_factory,
-        main_model_name=main_model_name,
-        main_llm_config=llm_config,
-    )
+    main_client = create_llm_client(llm_config)
+    sub_clients: dict[SubAgentType, LLMClientABC] = {}
 
     for profile in iter_sub_agent_profiles():
         model_name = config.subagent_models.get(profile.name)
         if not model_name:
             continue
 
-        if not profile.enabled_for_model(main_model_name):
+        if not profile.enabled_for_model(main_client.model_name):
             continue
 
-        def _factory(model_name_for_factory: str = model_name) -> LLMClientABC:
-            sub_llm_config = config.get_model_config(model_name_for_factory)
-            return create_llm_client(sub_llm_config)
-
-        clients.register_sub_client_factory(profile.name, _factory)
+        sub_llm_config = config.get_model_config(model_name)
+        sub_clients[profile.name] = create_llm_client(sub_llm_config)
 
-    return clients
+    return LLMClients(main=main_client, sub_clients=sub_clients)

klaude_code/core/manager/sub_agent_manager.py

@@ -43,7 +43,7 @@ class SubAgentManager:
         child_session = Session(work_dir=parent_session.work_dir)
         child_session.sub_agent_state = state
 
-        child_profile = self._model_profile_provider.build_profile_eager(
+        child_profile = self._model_profile_provider.build_profile(
             self._llm_clients.get_client(state.sub_agent_type),
             state.sub_agent_type,
         )
@@ -79,12 +79,12 @@ class SubAgentManager:
             raise
         except Exception as exc:  # pragma: no cover - defensive logging
             log_debug(
-                f"Subagent task failed: [{exc.__class__.__name__}] {str(exc)}",
+                f"Subagent task failed: [{exc.__class__.__name__}] {exc!s}",
                 style="red",
                 debug_type=DebugType.EXECUTION,
             )
             return SubAgentResult(
-                task_result=f"Subagent task failed: [{exc.__class__.__name__}] {str(exc)}",
+                task_result=f"Subagent task failed: [{exc.__class__.__name__}] {exc!s}",
                 session_id="",
                 error=True,
             )