klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/core/executor.py

@@ -8,15 +8,23 @@ handling operations submitted from the CLI and coordinating with agents.
 from __future__ import annotations
 
 import asyncio
+import subprocess
+import sys
+from collections.abc import Callable
 from dataclasses import dataclass
+from pathlib import Path
 
-from klaude_code.command import InputAction, InputActionType, dispatch_command
+from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
-from klaude_code.core.manager import AgentManager, LLMClients, SubAgentManager
+from klaude_code.core.manager import LLMClients, SubAgentManager
 from klaude_code.core.tool import current_run_subtask_callback
-from klaude_code.protocol import events, model, op
+from klaude_code.llm.registry import create_llm_client
+from klaude_code.protocol import commands, events, model, op
+from klaude_code.protocol.llm_param import Thinking
 from klaude_code.protocol.op_handler import OperationHandler
 from klaude_code.protocol.sub_agent import SubAgentResult
+from klaude_code.session.export import build_export_html, get_default_export_path
+from klaude_code.session.session import Session
 from klaude_code.trace import DebugType, log_debug
 
 
@@ -87,153 +95,272 @@ class ExecutorContext:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
         self.event_queue: asyncio.Queue[events.Event] = event_queue
+        self.llm_clients: LLMClients = llm_clients
 
         resolved_profile_provider = model_profile_provider or DefaultModelProfileProvider()
         self.model_profile_provider: ModelProfileProvider = resolved_profile_provider
 
-        # Delegate responsibilities to helper components
-        self.agent_manager = AgentManager(event_queue, llm_clients, resolved_profile_provider)
         self.task_manager = TaskManager()
-        self.subagent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
+        self.sub_agent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
+        self._on_model_change = on_model_change
+        self._agent: Agent | None = None
 
     async def emit_event(self, event: events.Event) -> None:
         """Emit an event to the UI display system."""
         await self.event_queue.put(event)
 
+    def current_session_id(self) -> str | None:
+        """Return the primary active session id, if any.
+
+        This is a convenience wrapper used by the CLI, which conceptually
+        operates on a single interactive session per process.
+        """
+
+        agent = self._agent
+        if agent is None:
+            return None
+        return agent.session.id
+
     @property
-    def active_agents(self) -> dict[str, Agent]:
-        """Expose currently active agents keyed by session id.
+    def current_agent(self) -> Agent | None:
+        """Return the currently active agent, if any."""
+
+        return self._agent
 
-        This property preserves the previous public attribute used by the
-        CLI status provider while delegating storage to :class:`AgentManager`.
+    async def _ensure_agent(self, session_id: str | None = None) -> Agent:
+        """Return the active agent, creating or loading a session as needed.
+
+        If ``session_id`` is ``None``, a new session is created with an
+        auto-generated ID. If provided, the executor attempts to resume the
+        session from disk or creates a new one if not found.
         """
 
-        return self.agent_manager.all_active_agents()
+        # Fast-path: reuse current agent when the session id already matches.
+        if session_id is not None and self._agent is not None and self._agent.session.id == session_id:
+            return self._agent
+
+        session = Session.create() if session_id is None else Session.load(session_id)
+
+        if (
+            session.model_thinking is not None
+            and session.model_name
+            and session.model_name == self.llm_clients.main.model_name
+        ):
+            self.llm_clients.main.get_llm_config().thinking = session.model_thinking
+
+        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)
+
+        await self.emit_event(
+            events.WelcomeEvent(
+                work_dir=str(session.work_dir),
+                llm_config=self.llm_clients.main.get_llm_config(),
+            )
+        )
+
+        self._agent = agent
+        log_debug(
+            f"Initialized agent for session: {session.id}",
+            style="cyan",
+            debug_type=DebugType.EXECUTION,
+        )
+        return agent
 
     async def handle_init_agent(self, operation: op.InitAgentOperation) -> None:
         """Initialize an agent for a session and replay history to UI."""
-        if operation.session_id is None:
-            raise ValueError("session_id cannot be None")
-
-        await self.agent_manager.ensure_agent(operation.session_id)
+        await self._ensure_agent(operation.session_id)
 
     async def handle_user_input(self, operation: op.UserInputOperation) -> None:
-        """Handle a user input operation by running it through an agent."""
+        """Handle a user input operation.
+
+        Core should not parse slash commands. The UI/CLI layer is responsible for
+        turning raw user input into one or more operations.
+        """
 
         if operation.session_id is None:
             raise ValueError("session_id cannot be None")
 
         session_id = operation.session_id
-        agent = await self.agent_manager.ensure_agent(session_id)
+        agent = await self._ensure_agent(session_id)
         user_input = operation.input
 
-        # emit user input event
         await self.emit_event(
             events.UserMessageEvent(content=user_input.text, session_id=session_id, images=user_input.images)
         )
+        agent.session.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
 
-        result = await dispatch_command(user_input.text, agent)
-
-        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:
-            agent.session.append_history(
-                [evt.item for evt in result.events if isinstance(evt, events.DeveloperMessageEvent)]
+        await self.handle_run_agent(
+            op.RunAgentOperation(
+                id=operation.id,
+                session_id=session_id,
+                input=user_input,
             )
-            for evt in result.events:
-                await self.emit_event(evt)
+        )
 
-        for action in actions:
-            await self._run_input_action(action, operation, agent)
+    async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        existing_active = self.task_manager.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, operation.input, operation.id, operation.session_id)
+        )
+        self.task_manager.register(operation.id, task, operation.session_id)
 
-    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")
+    async def handle_change_model(self, operation: op.ChangeModelOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        config = load_config()
 
-        session_id = operation.session_id
+        llm_config = config.get_model_config(operation.model_name)
+        llm_client = create_llm_client(llm_config)
+        agent.set_model_profile(self.model_profile_provider.build_profile(llm_client))
 
-        if action.type == InputActionType.RUN_AGENT:
-            task_input = model.UserInputPayload(text=action.text, images=operation.input.images)
+        agent.session.model_config_name = operation.model_name
+        agent.session.model_thinking = llm_config.thinking
 
-            existing_active = self.task_manager.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}")
+        if operation.save_as_default:
+            config.main_model = operation.model_name
+            await config.save()
 
-            task: asyncio.Task[None] = asyncio.create_task(
-                self._run_agent_task(agent, task_input, operation.id, session_id)
+        if operation.emit_switch_message:
+            default_note = " (saved as default)" if operation.save_as_default else ""
+            developer_item = model.DeveloperMessageItem(
+                content=f"Switched to: {llm_config.model}{default_note}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.MODEL),
             )
-            self.task_manager.register(operation.id, task, session_id)
-            return
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
-        if action.type == InputActionType.CHANGE_MODEL:
-            if not action.model_name:
-                raise ValueError("ChangeModel action requires model_name")
+        if self._on_model_change is not None:
+            self._on_model_change(llm_client.model_name)
 
-            await self.agent_manager.apply_model_change(agent, action.model_name)
-            return
+        if operation.emit_welcome_event:
+            await self.emit_event(events.WelcomeEvent(llm_config=llm_config, work_dir=str(agent.session.work_dir)))
 
-        if action.type == InputActionType.CLEAR:
-            await self.agent_manager.apply_clear(agent)
-            return
+    async def handle_change_thinking(self, operation: op.ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation.
 
-        raise ValueError(f"Unsupported input action type: {action.type}")
+        Interactive thinking selection must happen in the UI/CLI layer. Core only
+        applies a concrete thinking configuration.
+        """
+        agent = await self._ensure_agent(operation.session_id)
+
+        config = agent.profile.llm_client.get_llm_config()
+
+        def _format_thinking_for_display(thinking: Thinking | None) -> str:
+            if thinking is None:
+                return "not configured"
+            if thinking.reasoning_effort:
+                return f"reasoning_effort={thinking.reasoning_effort}"
+            if thinking.type == "disabled":
+                return "off"
+            if thinking.type == "enabled":
+                if thinking.budget_tokens is None:
+                    return "enabled"
+                return f"enabled (budget_tokens={thinking.budget_tokens})"
+            return "not set"
+
+        if operation.thinking is None:
+            raise ValueError("thinking must be provided; interactive selection belongs to UI")
+
+        current = _format_thinking_for_display(config.thinking)
+        config.thinking = operation.thinking
+        agent.session.model_thinking = operation.thinking
+        new_status = _format_thinking_for_display(config.thinking)
+
+        if operation.emit_switch_message:
+            developer_item = model.DeveloperMessageItem(
+                content=f"Thinking changed: {current} -> {new_status}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.THINKING),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
+        if operation.emit_welcome_event:
+            await self.emit_event(events.WelcomeEvent(work_dir=str(agent.session.work_dir), llm_config=config))
+
+    async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        new_session = Session.create(work_dir=agent.session.work_dir)
+        new_session.model_name = agent.session.model_name
+        new_session.model_config_name = agent.session.model_config_name
+        new_session.model_thinking = agent.session.model_thinking
+        agent.session = new_session
+
+        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."""
+    async def handle_resume_session(self, operation: op.ResumeSessionOperation) -> None:
+        target_session = Session.load(operation.target_session_id)
+        if (
+            target_session.model_thinking is not None
+            and target_session.model_name
+            and target_session.model_name == self.llm_clients.main.model_name
+        ):
+            self.llm_clients.main.get_llm_config().thinking = target_session.model_thinking
 
-        # Determine affected sessions
-        if operation.target_session_id is not None:
-            session_ids: list[str] = [operation.target_session_id]
-        else:
-            session_ids = self.agent_manager.active_session_ids()
+        profile = self.model_profile_provider.build_profile(self.llm_clients.main)
+        from klaude_code.core.agent import Agent
 
-        # Call cancel() on each affected agent to persist an interrupt marker
-        for sid in session_ids:
-            agent = self.agent_manager.get_active_agent(sid)
-            if agent is not None:
-                for evt in agent.cancel():
-                    await self.emit_event(evt)
+        agent = Agent(session=target_session, profile=profile)
 
-        # emit interrupt event
-        await self.emit_event(events.InterruptEvent(session_id=operation.target_session_id or "all"))
+        async for evt in agent.replay_history():
+            await self.emit_event(evt)
 
-        # Find tasks to cancel (filter by target sessions if provided)
-        if operation.target_session_id is None:
-            session_filter: set[str] | None = None
-        else:
-            session_filter = {operation.target_session_id}
-
-        tasks_to_cancel = self.task_manager.cancel_tasks_for_sessions(session_filter)
+        await self.emit_event(
+            events.WelcomeEvent(
+                work_dir=str(target_session.work_dir),
+                llm_config=self.llm_clients.main.get_llm_config(),
+            )
+        )
 
-        scope = operation.target_session_id or "all"
+        self._agent = agent
         log_debug(
-            f"Interrupting {len(tasks_to_cancel)} task(s) for: {scope}",
-            style="yellow",
+            f"Resumed session: {target_session.id}",
+            style="cyan",
             debug_type=DebugType.EXECUTION,
         )
 
-        # Cancel the tasks
-        for task_id, task in tasks_to_cancel:
-            task.cancel()
-            # Remove from active tasks immediately
-            self.task_manager.remove(task_id)
+    async def handle_export_session(self, operation: op.ExportSessionOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        try:
+            output_path = self._resolve_export_output_path(operation.output_path, agent.session)
+            html_doc = self._build_export_html(agent)
+            await asyncio.to_thread(output_path.parent.mkdir, parents=True, exist_ok=True)
+            await asyncio.to_thread(output_path.write_text, html_doc, "utf-8")
+            await asyncio.to_thread(self._open_file, output_path)
+            developer_item = model.DeveloperMessageItem(
+                content=f"Session exported and opened: {output_path}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        except Exception as exc:  # pragma: no cover
+            import traceback
+
+            developer_item = model.DeveloperMessageItem(
+                content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT, is_error=True),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
 
     async def _run_agent_task(
-        self, agent: Agent, user_input: model.UserInputPayload, task_id: str, session_id: str
+        self,
+        agent: Agent,
+        user_input: model.UserInputPayload,
+        task_id: str,
+        session_id: str,
     ) -> None:
-        """
-        Run an agent task and forward all events to the UI.
-
-        This method wraps the agent's run_task method and handles any exceptions
-        that might occur during execution.
-        """
         try:
             log_debug(
                 f"Starting agent task {task_id} for session {session_id}",
@@ -241,20 +368,17 @@ class ExecutorContext:
                 debug_type=DebugType.EXECUTION,
             )
 
-            # Inject subtask runner into tool context for nested Task tool usage
             async def _runner(state: model.SubAgentState) -> SubAgentResult:
-                return await self.subagent_manager.run_subagent(agent, state)
+                return await self.sub_agent_manager.run_sub_agent(agent, state)
 
             token = current_run_subtask_callback.set(_runner)
             try:
-                # Forward all events from the agent to the UI
                 async for event in agent.run_task(user_input):
                     await self.emit_event(event)
             finally:
                 current_run_subtask_callback.reset(token)
 
         except asyncio.CancelledError:
-            # Task was cancelled (likely due to interrupt)
             log_debug(
                 f"Agent task {task_id} was cancelled",
                 style="yellow",
@@ -263,24 +387,21 @@ class ExecutorContext:
             await self.emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
 
         except Exception as e:
-            # Handle any other exceptions
             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} {traceback.format_exc()}",
                     can_retry=False,
                 )
             )
-
         finally:
-            # Clean up the task from active tasks
             self.task_manager.remove(task_id)
             log_debug(
                 f"Cleaned up agent task {task_id}",
@@ -288,6 +409,88 @@ class ExecutorContext:
                 debug_type=DebugType.EXECUTION,
             )
 
+    def _resolve_export_output_path(self, raw: str | None, session: Session) -> Path:
+        trimmed = (raw or "").strip()
+        if trimmed:
+            candidate = Path(trimmed).expanduser()
+            if not candidate.is_absolute():
+                candidate = Path(session.work_dir) / candidate
+            if candidate.suffix.lower() != ".html":
+                candidate = candidate.with_suffix(".html")
+            return candidate
+        return get_default_export_path(session)
+
+    def _build_export_html(self, agent: Agent) -> str:
+        profile = agent.profile
+        system_prompt = (profile.system_prompt if profile else "") or ""
+        tool_schemas = profile.tools if profile else []
+        model_name = profile.llm_client.model_name if profile else "unknown"
+        return build_export_html(agent.session, system_prompt, tool_schemas, model_name)
+
+    def _open_file(self, path: Path) -> None:
+        # Select platform-appropriate command
+        if sys.platform == "darwin":
+            cmd = "open"
+        elif sys.platform == "win32":
+            cmd = "start"
+        else:
+            cmd = "xdg-open"
+
+        try:
+            # Detach stdin to prevent interference with prompt_toolkit's terminal state
+            if sys.platform == "win32":
+                # Windows 'start' requires shell=True
+                subprocess.run(f'start "" "{path}"', shell=True, stdin=subprocess.DEVNULL, check=True)
+            else:
+                subprocess.run([cmd, str(path)], stdin=subprocess.DEVNULL, check=True)
+        except FileNotFoundError as exc:  # pragma: no cover
+            msg = f"`{cmd}` command not found; please open the HTML manually."
+            raise RuntimeError(msg) from exc
+        except subprocess.CalledProcessError as exc:  # pragma: no cover
+            msg = f"Failed to open HTML with `{cmd}`: {exc}"
+            raise RuntimeError(msg) from exc
+
+    async def handle_interrupt(self, operation: op.InterruptOperation) -> None:
+        """Handle an interrupt by invoking agent.cancel() and cancelling tasks."""
+
+        # Determine affected sessions
+        if operation.target_session_id is not None:
+            session_ids: list[str] = [operation.target_session_id]
+        else:
+            agent = self._agent
+            session_ids = [agent.session.id] if agent is not None else []
+
+        # Call cancel() on each affected agent to persist an interrupt marker
+        for sid in session_ids:
+            agent = self._get_active_agent(sid)
+            if agent is not None:
+                for evt in agent.cancel():
+                    await self.emit_event(evt)
+
+        # emit interrupt event
+        await self.emit_event(events.InterruptEvent(session_id=operation.target_session_id or "all"))
+
+        # Find tasks to cancel (filter by target sessions if provided)
+        if operation.target_session_id is None:
+            session_filter: set[str] | None = None
+        else:
+            session_filter = {operation.target_session_id}
+
+        tasks_to_cancel = self.task_manager.cancel_tasks_for_sessions(session_filter)
+
+        scope = operation.target_session_id or "all"
+        log_debug(
+            f"Interrupting {len(tasks_to_cancel)} task(s) for: {scope}",
+            style="yellow",
+            debug_type=DebugType.EXECUTION,
+        )
+
+        # Cancel the tasks
+        for task_id, task in tasks_to_cancel:
+            task.cancel()
+            # Remove from active tasks immediately
+            self.task_manager.remove(task_id)
+
     def get_active_task(self, submission_id: str) -> asyncio.Task[None] | None:
         """Return the asyncio.Task for a submission id if one is registered."""
 
@@ -301,6 +504,16 @@ class ExecutorContext:
 
         return self.task_manager.get(submission_id) is not None
 
+    def _get_active_agent(self, session_id: str) -> Agent | None:
+        """Return the active agent if its session id matches ``session_id``."""
+
+        agent = self._agent
+        if agent is None:
+            return None
+        if agent.session.id != session_id:
+            return None
+        return agent
+
 
 class Executor:
     """
@@ -315,11 +528,13 @@ class Executor:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
-        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider)
+        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider, on_model_change)
         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:
         """
@@ -391,12 +606,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:
@@ -423,7 +638,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,
             )
@@ -463,17 +678,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:
@@ -482,4 +697,4 @@ class Executor:
 
 # 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]
+_: type[OperationHandler] = ExecutorContext

klaude_code/core/manager/__init__.py

@@ -1,18 +1,16 @@
 """Core runtime and state management components.
 
 Expose the manager layer via package imports to reduce module churn in
-callers. This keeps long-lived runtime state helpers (agents, tasks,
-LLM clients, sub-agents) distinct from per-session execution logic in
+callers. This keeps long-lived runtime state helpers (LLM clients and
+sub-agents) distinct from per-session execution logic in
 ``klaude_code.core``.
 """
 
-from klaude_code.core.manager.agent_manager import AgentManager
 from klaude_code.core.manager.llm_clients import LLMClients
 from klaude_code.core.manager.llm_clients_builder import build_llm_clients
 from klaude_code.core.manager.sub_agent_manager import SubAgentManager
 
 __all__ = [
-    "AgentManager",
     "LLMClients",
     "SubAgentManager",
     "build_llm_clients",

klaude_code/core/manager/llm_clients.py

@@ -10,12 +10,6 @@ from klaude_code.protocol.tools import SubAgentType
 
 
 def _default_sub_clients() -> dict[SubAgentType, LLMClientABC]:
-    """Return an empty mapping for sub-agent clients.
-
-    Defined separately so static type checkers can infer the dictionary
-    key and value types instead of treating them as ``Unknown``.
-    """
-
     return {}
 
 
@@ -27,15 +21,7 @@ class LLMClients:
     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.
-
-        Args:
-            sub_agent_type: Optional sub-agent type whose client should be returned.
-
-        Returns:
-            The LLM client corresponding to the sub-agent type, or the main client
-            when no specialized client is available.
-        """
+        """Return client for a sub-agent type or the main client."""
 
         if sub_agent_type is None:
             return self.main