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

klaude_code/core/manager/agent_manager.py

@@ -0,0 +1,127 @@
+"""Agent and session manager.
+
+This module contains :class:`AgentManager`, a helper responsible for
+creating and tracking agents per session, applying model changes, and
+clearing conversations. It is used by the executor context to keep
+agent-related responsibilities separate from operation dispatch.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from klaude_code.config import load_config
+from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
+from klaude_code.core.manager.llm_clients import LLMClients
+from klaude_code.llm.registry import create_llm_client
+from klaude_code.protocol import commands, events, model
+from klaude_code.session.session import Session
+from klaude_code.trace import DebugType, log_debug
+
+
+class AgentManager:
+    """Manager component that tracks agents and their sessions."""
+
+    def __init__(
+        self,
+        event_queue: asyncio.Queue[events.Event],
+        llm_clients: LLMClients,
+        model_profile_provider: ModelProfileProvider | None = None,
+    ) -> None:
+        self._event_queue: asyncio.Queue[events.Event] = event_queue
+        self._llm_clients: LLMClients = llm_clients
+        self._model_profile_provider: ModelProfileProvider = model_profile_provider or DefaultModelProfileProvider()
+        self._active_agents: dict[str, Agent] = {}
+
+    async def emit_event(self, event: events.Event) -> None:
+        """Emit an event to the shared event queue."""
+
+        await self._event_queue.put(event)
+
+    async def ensure_agent(self, session_id: str) -> Agent:
+        """Return an existing agent for the session or create a new one."""
+
+        agent = self._active_agents.get(session_id)
+        if agent is not None:
+            return agent
+
+        session = Session.load(session_id)
+        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._active_agents[session_id] = agent
+        log_debug(
+            f"Initialized agent for session: {session_id}",
+            style="cyan",
+            debug_type=DebugType.EXECUTION,
+        )
+        return agent
+
+    async def apply_model_change(self, agent: Agent, model_name: str) -> None:
+        """Change the model used by an agent and notify the UI."""
+
+        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:
+        """Start a new conversation for an agent and notify the UI."""
+
+        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))
+
+    def get_active_agent(self, session_id: str) -> Agent | None:
+        """Return the active agent for a session id if present."""
+
+        return self._active_agents.get(session_id)
+
+    def active_session_ids(self) -> list[str]:
+        """Return a snapshot list of session ids that currently have agents."""
+
+        return list(self._active_agents.keys())
+
+    def all_active_agents(self) -> dict[str, Agent]:
+        """Return a snapshot of all active agents keyed by session id."""
+
+        return dict(self._active_agents)

klaude_code/core/manager/llm_clients.py

@@ -0,0 +1,42 @@
+"""Container for main and sub-agent LLM clients."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from dataclasses import field as dataclass_field
+
+from klaude_code.llm.client import LLMClientABC
+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 {}
+
+
+@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=_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.
+        """
+
+        if sub_agent_type is None:
+            return self.main
+        return self.sub_clients.get(sub_agent_type) or self.main

klaude_code/core/manager/llm_clients_builder.py

@@ -0,0 +1,49 @@
+"""Factory helpers for building :class:`LLMClients` from config."""
+
+from __future__ import annotations
+
+from klaude_code.config import Config
+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 get_sub_agent_profile
+from klaude_code.protocol.tools import SubAgentType
+from klaude_code.trace import DebugType, log_debug
+
+
+def build_llm_clients(
+    config: Config,
+    *,
+    model_override: str | None = None,
+    enabled_sub_agents: list[SubAgentType] | None = None,
+) -> LLMClients:
+    """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()
+
+    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 LLMClients(main=main_client, sub_clients=sub_clients)

klaude_code/core/manager/sub_agent_manager.py

@@ -0,0 +1,86 @@
+"""Manager for running nested sub-agent tasks.
+
+The :class:`SubAgentManager` encapsulates the logic for creating child
+sessions, selecting appropriate LLM clients for sub-agents, and streaming
+their events back to the shared event queue.
+"""
+
+from __future__ import annotations
+
+import asyncio
+
+from klaude_code.core.agent import Agent, ModelProfileProvider
+from klaude_code.core.manager.llm_clients import LLMClients
+from klaude_code.protocol import events, model
+from klaude_code.protocol.sub_agent import SubAgentResult
+from klaude_code.session.session import Session
+from klaude_code.trace import DebugType, log_debug
+
+
+class SubAgentManager:
+    """Run sub-agent tasks and forward their events to the UI."""
+
+    def __init__(
+        self,
+        event_queue: asyncio.Queue[events.Event],
+        llm_clients: LLMClients,
+        model_profile_provider: ModelProfileProvider,
+    ) -> None:
+        self._event_queue: asyncio.Queue[events.Event] = event_queue
+        self._llm_clients: LLMClients = llm_clients
+        self._model_profile_provider: ModelProfileProvider = model_profile_provider
+
+    async def emit_event(self, event: events.Event) -> None:
+        """Emit an event to the shared event queue."""
+
+        await self._event_queue.put(event)
+
+    async def run_subagent(self, parent_agent: Agent, state: model.SubAgentState) -> SubAgentResult:
+        """Run a nested sub-agent task and return its result."""
+
+        # Create a child session under the same workdir
+        parent_session = parent_agent.session
+        child_session = Session(work_dir=parent_session.work_dir)
+        child_session.sub_agent_state = state
+
+        child_profile = self._model_profile_provider.build_profile(
+            self._llm_clients.get_client(state.sub_agent_type),
+            state.sub_agent_type,
+        )
+        child_agent = Agent(session=child_session, profile=child_profile)
+
+        log_debug(
+            f"Running sub-agent {state.sub_agent_type} in session {child_session.id}",
+            style="cyan",
+            debug_type=DebugType.EXECUTION,
+        )
+
+        try:
+            # Not emit the subtask's user input since task tool call is already rendered
+            result: str = ""
+            sub_agent_input = model.UserInputPayload(text=state.sub_agent_prompt, images=None)
+            async for event in child_agent.run_task(sub_agent_input):
+                # Capture TaskFinishEvent content for return
+                if isinstance(event, events.TaskFinishEvent):
+                    result = event.task_result
+                await self.emit_event(event)
+            return SubAgentResult(task_result=result, session_id=child_session.id)
+        except asyncio.CancelledError:
+            # Propagate cancellation so tooling can treat it as user interrupt
+            log_debug(
+                f"Subagent task for {state.sub_agent_type} was cancelled",
+                style="yellow",
+                debug_type=DebugType.EXECUTION,
+            )
+            raise
+        except Exception as exc:  # pragma: no cover - defensive logging
+            log_debug(
+                f"Subagent task failed: [{exc.__class__.__name__}] {str(exc)}",
+                style="red",
+                debug_type=DebugType.EXECUTION,
+            )
+            return SubAgentResult(
+                task_result=f"Subagent task failed: [{exc.__class__.__name__}] {str(exc)}",
+                session_id="",
+                error=True,
+            )

klaude_code/core/tool/shell/bash_tool.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from pydantic import BaseModel
 
 from klaude_code import const
-from klaude_code.core.tool.shell.command_safety import is_safe_command, strip_bash_lc
+from klaude_code.core.tool.shell.command_safety import is_safe_command
 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
@@ -57,10 +57,8 @@ class BashTool(ToolABC):
 
     @classmethod
     async def call_with_args(cls, args: BashArguments) -> model.ToolResultItem:
-        command_str = strip_bash_lc(args.command)
-
         # Safety check: only execute commands proven as "known safe"
-        result = is_safe_command(command_str)
+        result = is_safe_command(args.command)
         if not result.is_safe:
             return model.ToolResultItem(
                 status="error",
@@ -69,7 +67,7 @@ class BashTool(ToolABC):
 
         # Run the command using bash -lc so shell semantics work (pipes, &&, etc.)
         # Capture stdout/stderr, respect timeout, and return a ToolMessage.
-        cmd = ["bash", "-lc", command_str]
+        cmd = ["bash", "-lc", args.command]
         timeout_sec = max(0.0, args.timeout_ms / 1000.0)
 
         try:
@@ -111,7 +109,7 @@ class BashTool(ToolABC):
         except subprocess.TimeoutExpired:
             return model.ToolResultItem(
                 status="error",
-                output=f"Timeout after {args.timeout_ms} ms running: {command_str}",
+                output=f"Timeout after {args.timeout_ms} ms running: {args.command}",
             )
         except FileNotFoundError:
             return model.ToolResultItem(

klaude_code/core/tool/shell/command_safety.py

@@ -18,43 +18,6 @@ def _is_valid_sed_n_arg(s: str | None) -> bool:
     return bool(re.fullmatch(r"\d+(,\d+)?p", s))
 
 
-def _has_shell_redirection(argv: list[str]) -> bool:  # pyright: ignore
-    """Detect whether argv contains shell redirection or control operators."""
-
-    if len(argv) <= 1:
-        return False
-
-    # Heuristic detection: look for tokens that represent redirection or control operators
-    redir_prefixes = ("<>", ">>", ">", "<<<", "<<-", "<<", "<&", ">&", "|")
-    control_tokens = {"|", "||", "&&", ";"}
-
-    for token in argv[1:]:
-        if not token:
-            continue
-
-        if token in control_tokens:
-            return True
-
-        # Allow literal angle-bracket text such as <tag> by skipping tokens
-        # that contain both '<' and '>' characters.
-        if "<" in token and ">" in token:
-            continue
-
-        # Strip leading file descriptor numbers (e.g., 2>file, 1<&0)
-        stripped = token.lstrip("0123456789")
-        if not stripped:
-            continue
-
-        for prefix in redir_prefixes:
-            if stripped.startswith(prefix):
-                # Handle the pipeline-with-stderr prefix specifically
-                if prefix == "|":
-                    return True
-                return True
-
-    return False
-
-
 def _is_safe_awk_program(program: str) -> SafetyCheckResult:
     lowered = program.lower()
 
@@ -367,236 +330,6 @@ def _is_safe_argv(argv: list[str]) -> SafetyCheckResult:
     return SafetyCheckResult(True)
 
 
-def parse_command_sequence(script: str) -> tuple[list[list[str]] | None, str]:
-    """Parse command sequence separated by logical or pipe operators."""
-    if not script.strip():
-        return None, "Empty script"
-
-    # Tokenize with shlex so quotes/escapes are handled by the stdlib.
-    # Treat '|', '&', ';' as punctuation so they become standalone tokens.
-    try:
-        lexer = shlex.shlex(script, posix=True, punctuation_chars="|;&")
-        tokens = list(lexer)
-    except ValueError as e:
-        # Preserve error format expected by callers/tests
-        return None, f"Shell parsing error: {e}"
-
-    commands: list[list[str]] = []
-    cur: list[str] = []
-
-    i = 0
-    n = len(tokens)
-    while i < n:
-        t = tokens[i]
-
-        # Semicolon separator
-        if t == ";":
-            if not cur:
-                return None, "Empty command in sequence"
-            commands.append(cur)
-            cur = []
-            i += 1
-            continue
-
-        # Pipe or logical OR separators
-        if t == "|" or t == "||":
-            # Treat both '|' and '||' as separators between commands
-            if not cur:
-                return None, "Empty command in sequence"
-            commands.append(cur)
-            cur = []
-            # If '|' and next is also '|', consume both; if already '||', consume one
-            if t == "|" and i + 1 < n and tokens[i + 1] == "|":
-                i += 2
-            else:
-                i += 1
-            continue
-
-        # Logical AND separator or background '&'
-        if t == "&&" or t == "&":
-            if t == "&&" or (i + 1 < n and tokens[i + 1] == "&"):
-                if not cur:
-                    return None, "Empty command in sequence"
-                commands.append(cur)
-                cur = []
-                # If token is single '&' but next is '&', consume both; otherwise it's '&&' already
-                if t == "&":
-                    i += 2
-                else:
-                    i += 1
-                continue
-            # Single '&' becomes a normal token in argv (background op)
-            cur.append(t)
-            i += 1
-            continue
-
-        # Regular argument token
-        cur.append(t)
-        i += 1
-
-    if not cur:
-        return None, "Empty command in sequence"
-    commands.append(cur)
-    return commands, ""
-
-
-def _find_unquoted_token(command: str, token: str) -> int | None:
-    """Locate token position ensuring it appears outside quoted regions."""
-
-    in_single = False
-    in_double = False
-    i = 0
-    length = len(command)
-
-    while i < length:
-        ch = command[i]
-        if ch == "\\":
-            i += 2
-            continue
-        if ch == "'" and not in_double:
-            in_single = not in_single
-            i += 1
-            continue
-        if ch == '"' and not in_single:
-            in_double = not in_double
-            i += 1
-            continue
-
-        if not in_single and not in_double and command.startswith(token, i):
-            before_ok = i == 0 or command[i - 1].isspace()
-            after_idx = i + len(token)
-            after_ok = after_idx >= length or command[after_idx].isspace()
-            if before_ok and after_ok:
-                return i
-        i += 1
-
-    return None
-
-
-def _split_script_tail(tail: str) -> tuple[str | None, list[str]]:
-    """Split the -c tail into script and remaining tokens."""
-
-    tail = tail.lstrip()
-    if not tail:
-        return None, []
-
-    if tail[0] in {'"', "'"}:
-        quote = tail[0]
-        escaped = False
-        in_single = False
-        in_double = False
-        i = 1
-        while i < len(tail):
-            ch = tail[i]
-            if escaped:
-                escaped = False
-                i += 1
-                continue
-            if ch == "\\":
-                escaped = True
-                i += 1
-                continue
-            if ch == "'" and quote == '"':
-                in_single = not in_single
-                i += 1
-                continue
-            if ch == '"' and quote == "'":
-                in_double = not in_double
-                i += 1
-                continue
-            if ch == quote and not in_single and not in_double:
-                script = tail[1:i]
-                rest = tail[i + 1 :].lstrip()
-                break
-            i += 1
-        else:
-            # Unterminated quote: treat the remainder as script
-            return tail[1:], []
-    else:
-        match = re.search(r"\s", tail)
-        if match:
-            script = tail[: match.start()]
-            rest = tail[match.end() :].lstrip()
-        else:
-            return tail, []
-
-    if not rest:
-        return script, []
-
-    try:
-        rest_tokens = shlex.split(rest, posix=True)
-    except ValueError:
-        rest_tokens = rest.split()
-
-    return script, rest_tokens
-
-
-def _split_bash_lc_relaxed(command: str) -> list[str] | None:
-    """Attempt relaxed parsing for bash -lc commands with inline scripts."""
-
-    idx = _find_unquoted_token(command, "-c")
-    if idx is None:
-        return None
-
-    head = command[:idx].strip()
-    try:
-        head_tokens = shlex.split(head, posix=True) if head else []
-    except ValueError:
-        return None
-
-    flag = "-c"
-    tail = command[idx + len(flag) :]
-    script, rest_tokens = _split_script_tail(tail)
-
-    result: list[str] = head_tokens + [flag]
-    if script is not None:
-        result.append(script)
-    result.extend(rest_tokens)
-    return result
-
-
-def strip_bash_lc_argv(argv: list[str]) -> list[str]:
-    """Extract the actual command from bash -lc format if present in argv list."""
-    if len(argv) >= 3 and argv[0] == "bash" and argv[1] == "-lc":
-        command = argv[2]
-        try:
-            parsed = shlex.split(command, posix=True)
-        except ValueError:
-            relaxed = _split_bash_lc_relaxed(command)
-            if relaxed:
-                return relaxed
-            # If parsing fails, return the original command string as single item
-            return [command]
-        if "-c" in parsed:
-            idx = parsed.index("-c")
-            if len(parsed) > idx + 2:
-                relaxed = _split_bash_lc_relaxed(command)
-                if relaxed:
-                    return relaxed
-        return parsed
-
-    # If not bash -lc format, return original argv
-    return argv
-
-
-def strip_bash_lc(command: str) -> str:
-    """Extract the actual command from bash -lc format if present."""
-    try:
-        # Parse the command into tokens
-        argv = shlex.split(command, posix=True)
-
-        # Check if it's a bash -lc command
-        if len(argv) >= 3 and argv[0] == "bash" and argv[1] == "-lc":
-            # Return the actual command (third argument)
-            return argv[2]
-
-        # If not bash -lc format, return original command
-        return command
-    except ValueError:
-        # If parsing fails, return original command
-        return command
-
-
 def is_safe_command(command: str) -> SafetyCheckResult:
     """Determine if a command is safe enough to run.
 

klaude_code/core/tool/tool_registry.py

@@ -68,6 +68,8 @@ def load_agent_tools(
     # Main agent tools
     if "gpt-5" in model_name:
         tool_names = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.UPDATE_PLAN]
+    elif "gemini-3" in model_name:
+        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE]
     else:
         tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.TODO_WRITE]
 

klaude_code/llm/anthropic/input.py

@@ -75,7 +75,10 @@ def _user_group_to_message(group: UserGroup) -> BetaMessageParam:
 
 def _tool_group_to_message(group: ToolGroup) -> BetaMessageParam:
     tool_content: list[BetaTextBlockParam | BetaImageBlockParam] = []
-    merged_text = merge_reminder_text(group.tool_result.output, group.reminder_texts)
+    merged_text = merge_reminder_text(
+        group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
+        group.reminder_texts,
+    )
     tool_content.append({"type": "text", "text": merged_text})
     for image in group.tool_result.images or []:
         tool_content.append(_image_part_to_block(image))

klaude_code/llm/openai_compatible/input.py

@@ -22,9 +22,10 @@ def _user_group_to_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
 
 
 def _tool_group_to_message(group: ToolGroup) -> chat.ChatCompletionMessageParam:
-    merged_text = merge_reminder_text(group.tool_result.output, group.reminder_texts)
-    if not merged_text:
-        merged_text = "<system-reminder>Tool ran without output or errors</system-reminder>"
+    merged_text = merge_reminder_text(
+        group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
+        group.reminder_texts,
+    )
     return {
         "role": "tool",
         "content": [{"type": "text", "text": merged_text}],

klaude_code/llm/openrouter/input.py

@@ -37,9 +37,10 @@ def _user_group_to_message(group: UserGroup) -> chat.ChatCompletionMessageParam:
 
 
 def _tool_group_to_message(group: ToolGroup) -> chat.ChatCompletionMessageParam:
-    merged_text = merge_reminder_text(group.tool_result.output, group.reminder_texts)
-    if not merged_text:
-        merged_text = "<system-reminder>Tool ran without output or errors</system-reminder>"
+    merged_text = merge_reminder_text(
+        group.tool_result.output or "<system-reminder>Tool ran without output or errors</system-reminder>",
+        group.reminder_texts,
+    )
     return {
         "role": "tool",
         "content": [{"type": "text", "text": merged_text}],

klaude_code/llm/responses/input.py

@@ -23,7 +23,7 @@ def _build_user_content_parts(
 
 def _build_tool_result_item(tool: model.ToolResultItem) -> responses.ResponseInputItemParam:
     content_parts: list[responses.ResponseInputContentParam] = []
-    text_output = tool.output or ""
+    text_output = tool.output or "<system-reminder>Tool ran without output or errors</system-reminder>"
     if text_output:
         content_parts.append({"type": "input_text", "text": text_output})
     for image in tool.images or []: