PyPI - klaude-code - Versions diffs - 1.2.12__py3-none-any.whl → 1.2.13__py3-none-any.whl - Mend

klaude-code 1.2.12py3-none-any.whl → 1.2.13py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (74) hide show

klaude_code/auth/codex/oauth.py +3 -3
klaude_code/cli/main.py +5 -5
klaude_code/cli/runtime.py +19 -27
klaude_code/cli/session_cmd.py +6 -8
klaude_code/command/__init__.py +6 -6
klaude_code/command/export_cmd.py +3 -3
klaude_code/command/registry.py +1 -1
klaude_code/command/terminal_setup_cmd.py +2 -2
klaude_code/command/thinking_cmd.py +8 -6
klaude_code/config/__init__.py +1 -1
klaude_code/config/list_model.py +1 -1
klaude_code/core/agent.py +13 -61
klaude_code/core/executor.py +11 -10
klaude_code/core/manager/agent_manager.py +4 -4
klaude_code/core/manager/llm_clients.py +10 -49
klaude_code/core/manager/llm_clients_builder.py +8 -21
klaude_code/core/manager/sub_agent_manager.py +3 -3
klaude_code/core/prompt.py +2 -2
klaude_code/core/reminders.py +1 -1
klaude_code/core/task.py +2 -2
klaude_code/core/tool/__init__.py +16 -25
klaude_code/core/tool/file/_utils.py +1 -1
klaude_code/core/tool/file/apply_patch.py +17 -25
klaude_code/core/tool/file/apply_patch_tool.py +4 -7
klaude_code/core/tool/file/edit_tool.py +4 -11
klaude_code/core/tool/file/multi_edit_tool.py +2 -3
klaude_code/core/tool/file/read_tool.py +3 -4
klaude_code/core/tool/file/write_tool.py +2 -3
klaude_code/core/tool/memory/memory_tool.py +2 -8
klaude_code/core/tool/memory/skill_loader.py +3 -2
klaude_code/core/tool/shell/command_safety.py +0 -1
klaude_code/core/tool/tool_context.py +1 -3
klaude_code/core/tool/tool_registry.py +2 -1
klaude_code/core/tool/tool_runner.py +1 -1
klaude_code/core/tool/truncation.py +2 -5
klaude_code/core/turn.py +9 -3
klaude_code/llm/anthropic/client.py +6 -2
klaude_code/llm/client.py +1 -1
klaude_code/llm/codex/client.py +2 -2
klaude_code/llm/input_common.py +2 -2
klaude_code/llm/openai_compatible/client.py +11 -8
klaude_code/llm/openai_compatible/stream_processor.py +2 -1
klaude_code/llm/openrouter/client.py +20 -8
klaude_code/llm/openrouter/reasoning_handler.py +19 -132
klaude_code/llm/registry.py +6 -5
klaude_code/llm/responses/client.py +10 -5
klaude_code/protocol/events.py +7 -0
klaude_code/protocol/model.py +7 -1
klaude_code/protocol/sub_agent.py +2 -1
klaude_code/session/selector.py +2 -2
klaude_code/session/session.py +2 -4
klaude_code/trace/__init__.py +1 -1
klaude_code/trace/log.py +1 -1
klaude_code/ui/__init__.py +4 -9
klaude_code/ui/core/stage_manager.py +7 -4
klaude_code/ui/modes/repl/__init__.py +1 -1
klaude_code/ui/modes/repl/completers.py +3 -4
klaude_code/ui/modes/repl/display.py +3 -4
klaude_code/ui/modes/repl/event_handler.py +63 -5
klaude_code/ui/modes/repl/key_bindings.py +2 -3
klaude_code/ui/modes/repl/renderer.py +2 -1
klaude_code/ui/renderers/diffs.py +1 -4
klaude_code/ui/rich/markdown.py +3 -3
klaude_code/ui/rich/searchable_text.py +6 -6
klaude_code/ui/rich/status.py +3 -4
klaude_code/ui/rich/theme.py +1 -4
klaude_code/ui/terminal/control.py +7 -16
klaude_code/ui/terminal/notifier.py +2 -4
klaude_code/ui/utils/common.py +1 -1
klaude_code/ui/utils/debouncer.py +2 -2
{klaude_code-1.2.12.dist-info → klaude_code-1.2.13.dist-info}/METADATA +1 -1
{klaude_code-1.2.12.dist-info → klaude_code-1.2.13.dist-info}/RECORD +74 -74
{klaude_code-1.2.12.dist-info → klaude_code-1.2.13.dist-info}/WHEEL +0 -0
{klaude_code-1.2.12.dist-info → klaude_code-1.2.13.dist-info}/entry_points.txt +0 -0

klaude_code/auth/codex/oauth.py CHANGED Viewed

@@ -78,13 +78,13 @@ class OAuthCallbackHandler(BaseHTTPRequestHandler):
         self.end_headers()
         if OAuthCallbackHandler.error:
-            html = """
+            html = f"""
             <html><body style="font-family: sans-serif; text-align: center; padding: 50px;">
             <h1>Authentication Failed</h1>
-            <p>Error: {}</p>
+            <p>Error: {OAuthCallbackHandler.error}</p>
             <p>Please close this window and try again.</p>
             </body></html>
-            """.format(OAuthCallbackHandler.error)
+            """
         else:
             html = """
             <html><body style="font-family: sans-serif; text-align: center; padding: 50px;">

klaude_code/cli/main.py CHANGED Viewed

@@ -67,7 +67,7 @@ def login_command(
         if state and not state.is_expired():
             log(("You are already logged in to Codex.", "green"))
             log(f"  Account ID: {state.account_id[:8]}...")
-            expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.timezone.utc)
+            expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
             log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
             if not typer.confirm("Do you want to re-login?"):
                 return
@@ -80,11 +80,11 @@ def login_command(
         state = oauth.login()
         log(("Login successful!", "green"))
         log(f"  Account ID: {state.account_id[:8]}...")
-        expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.timezone.utc)
+        expires_dt = datetime.datetime.fromtimestamp(state.expires_at, tz=datetime.UTC)
         log(f"  Expires: {expires_dt.strftime('%Y-%m-%d %H:%M:%S UTC')}")
     except Exception as e:
         log((f"Login failed: {e}", "red"))
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 @app.command("logout")
@@ -173,11 +173,11 @@ def edit_config() -> None:
             subprocess.run([editor, str(config_path)], check=True)
     except subprocess.CalledProcessError as e:
         log((f"Error: Failed to open editor: {e}", "red"))
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
     except FileNotFoundError:
         log((f"Error: Editor '{editor}' not found", "red"))
         log("Please install a text editor or set your $EDITOR environment variable")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from None
 @app.command("exec")

klaude_code/cli/runtime.py CHANGED Viewed

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import sys
 from dataclasses import dataclass
 from typing import Any, Protocol
@@ -169,32 +170,26 @@ async def cleanup_app_components(components: AppComponents) -> None:
         await components.display_task
     finally:
         # Always attempt to clear Ghostty progress bar and restore cursor visibility
-        try:
+        # Best-effort only; never fail cleanup due to OSC errors
+        with contextlib.suppress(Exception):
             emit_osc94(OSC94States.HIDDEN)
-        except Exception:
-            # Best-effort only; never fail cleanup due to OSC errors
-            pass
-        try:
-            # Ensure the terminal cursor is visible even if Rich's Status spinner
-            # did not get a chance to stop cleanly (e.g. on KeyboardInterrupt).
+        # Ensure the terminal cursor is visible even if Rich's Status spinner
+        # did not get a chance to stop cleanly (e.g. on KeyboardInterrupt).
+        # If this fails the shell can still recover via `reset`/`stty sane`.
+        with contextlib.suppress(Exception):
             stream = getattr(sys, "__stdout__", None) or sys.stdout
             stream.write("\033[?25h")
             stream.flush()
-        except Exception:
-            # If this fails the shell can still recover via `reset`/`stty sane`.
-            pass
 async def _handle_keyboard_interrupt(executor: Executor) -> None:
     """Handle Ctrl+C by logging and sending a global interrupt."""
     log("Bye!")
-    try:
+    # Executor might already be stopping
+    with contextlib.suppress(Exception):
         await executor.submit(op.InterruptOperation(target_session_id=None))
-    except Exception:
-        # Executor might already be stopping
-        pass
 async def run_exec(init_config: AppInitConfig, input_content: str) -> None:
@@ -259,9 +254,12 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             if isinstance(components.display, ui.REPLDisplay):
                 printer = components.display.renderer
             # Check if it's a DebugEventDisplay wrapping a REPLDisplay
-            elif isinstance(components.display, ui.DebugEventDisplay) and components.display.wrapped_display:
-                if isinstance(components.display.wrapped_display, ui.REPLDisplay):
-                    printer = components.display.wrapped_display.renderer
+            elif (
+                isinstance(components.display, ui.DebugEventDisplay)
+                and components.display.wrapped_display
+                and isinstance(components.display.wrapped_display, ui.REPLDisplay)
+            ):
+                printer = components.display.wrapped_display.renderer
             if printer is not None:
                 printer.print(Text(f" {MSG} ", style="bold yellow reverse"))
@@ -272,10 +270,8 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
             print(MSG, file=sys.stderr)
     def _hide_progress() -> None:
-        try:
+        with contextlib.suppress(Exception):
             emit_osc94(OSC94States.HIDDEN)
-        except Exception:
-            pass
     restore_sigint = install_sigint_double_press_exit(_show_toast_once, _hide_progress)
@@ -315,17 +311,13 @@ async def run_interactive(init_config: AppInitConfig, session_id: str | None = N
                 finally:
                     # Stop ESC monitor and wait for it to finish cleaning up TTY
                     stop_event.set()
-                    try:
+                    with contextlib.suppress(Exception):
                         await esc_task
-                    except Exception:
-                        pass
     except KeyboardInterrupt:
         await _handle_keyboard_interrupt(components.executor)
     finally:
-        try:
-            # Restore original SIGINT handler
+        # Restore original SIGINT handler
+        with contextlib.suppress(Exception):
             restore_sigint()
-        except Exception:
-            pass
         await cleanup_app_components(components)

klaude_code/cli/session_cmd.py CHANGED Viewed

@@ -46,10 +46,9 @@ def session_clean(
         log(f"No sessions with fewer than {min_messages} messages found.")
         return
-    if not yes:
-        if not _session_confirm(to_delete, "Delete these sessions?"):
-            log("Aborted.")
-            return
+    if not yes and not _session_confirm(to_delete, "Delete these sessions?"):
+        log("Aborted.")
+        return
     deleted = Session.clean_small_sessions(min_messages)
     log(f"Deleted {deleted} session(s).")
@@ -65,10 +64,9 @@ def session_clean_all(
         log("No sessions found.")
         return
-    if not yes:
-        if not _session_confirm(sessions, "Delete ALL sessions? This cannot be undone."):
-            log("Aborted.")
-            return
+    if not yes and not _session_confirm(sessions, "Delete ALL sessions? This cannot be undone."):
+        log("Aborted.")
+        return
     deleted = Session.clean_all_sessions()
     log(f"Deleted {deleted} session(s).")

klaude_code/command/__init__.py CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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/registry.py CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -4,8 +4,8 @@ from .select_model import select_model_from_config
 __all__ = [
     "Config",
-    "load_config",
     "config_path",
     "display_models_and_providers",
+    "load_config",
     "select_model_from_config",
 ]

klaude_code/config/list_model.py CHANGED Viewed

@@ -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/core/agent.py CHANGED Viewed

@@ -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,26 +39,13 @@ 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,
+            llm_client=llm_client,
             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),
@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 1.2.12__py3-none-any.whl → 1.2.13__py3-none-any.whl

klaude-code 1.2.12py3-none-any.whl → 1.2.13py3-none-any.whl