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

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 []:

klaude_code/session/export.py

@@ -159,62 +159,60 @@ def _format_cost(cost: float) -> str:
 
 
 def _render_metadata_item(item: model.ResponseMetadataItem) -> str:
-    # Line 1: Model Name [@ Provider]
+    # Model Name [@ Provider]
+    parts: list[str] = []
+
     model_parts = [f'<span class="metadata-model">{_escape_html(item.model_name)}</span>']
     if item.provider:
         provider = _escape_html(item.provider.lower().replace(" ", "-"))
         model_parts.append(f'<span class="metadata-provider">@{provider}</span>')
 
-    line1 = "".join(model_parts)
+    parts.append("".join(model_parts))
 
-    # Line 2: Stats
-    stats_parts: list[str] = []
+    # Stats
     if item.usage:
         u = item.usage
         # Input with cost
         input_stat = f"input: {_format_token_count(u.input_tokens)}"
         if u.input_cost is not None:
             input_stat += f"({_format_cost(u.input_cost)})"
-        stats_parts.append(f'<span class="metadata-stat">{input_stat}</span>')
+        parts.append(f'<span class="metadata-stat">{input_stat}</span>')
 
         # Cached with cost
         if u.cached_tokens > 0:
             cached_stat = f"cached: {_format_token_count(u.cached_tokens)}"
             if u.cache_read_cost is not None:
                 cached_stat += f"({_format_cost(u.cache_read_cost)})"
-            stats_parts.append(f'<span class="metadata-stat">{cached_stat}</span>')
+            parts.append(f'<span class="metadata-stat">{cached_stat}</span>')
 
         # Output with cost
         output_stat = f"output: {_format_token_count(u.output_tokens)}"
         if u.output_cost is not None:
             output_stat += f"({_format_cost(u.output_cost)})"
-        stats_parts.append(f'<span class="metadata-stat">{output_stat}</span>')
+        parts.append(f'<span class="metadata-stat">{output_stat}</span>')
 
         if u.reasoning_tokens > 0:
-            stats_parts.append(
+            parts.append(
                 f'<span class="metadata-stat">thinking: {_format_token_count(u.reasoning_tokens)}</span>'
             )
         if u.context_usage_percent is not None:
-            stats_parts.append(f'<span class="metadata-stat">context: {u.context_usage_percent:.1f}%</span>')
+            parts.append(f'<span class="metadata-stat">context: {u.context_usage_percent:.1f}%</span>')
         if u.throughput_tps is not None:
-            stats_parts.append(f'<span class="metadata-stat">tps: {u.throughput_tps:.1f}</span>')
+            parts.append(f'<span class="metadata-stat">tps: {u.throughput_tps:.1f}</span>')
 
     if item.task_duration_s is not None:
-        stats_parts.append(f'<span class="metadata-stat">time: {item.task_duration_s:.1f}s</span>')
+        parts.append(f'<span class="metadata-stat">time: {item.task_duration_s:.1f}s</span>')
 
     # Total cost
     if item.usage is not None and item.usage.total_cost is not None:
-        stats_parts.append(f'<span class="metadata-stat">cost: {_format_cost(item.usage.total_cost)}</span>')
+        parts.append(f'<span class="metadata-stat">cost: {_format_cost(item.usage.total_cost)}</span>')
 
-    stats_html = ""
-    if stats_parts:
-        divider = '<span class="metadata-divider">/</span>'
-        stats_html = divider.join(stats_parts)
+    divider = '<span class="metadata-divider">/</span>'
+    joined_html = divider.join(parts)
 
     return (
         f'<div class="response-metadata">'
-        f'<div class="metadata-line">{line1}</div>'
-        f'<div class="metadata-line">{stats_html}</div>'
+        f'<div class="metadata-line">{joined_html}</div>'
         f"</div>"
     )