klaude-code 2.4.0__tar.gz → 2.4.2__tar.gz

{klaude_code-2.4.0 → klaude_code-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: klaude-code
-Version: 2.4.0
+Version: 2.4.2
 Summary: Minimal code agent CLI
 Requires-Dist: anthropic>=0.66.0
 Requires-Dist: chardet>=5.2.0
@@ -17,7 +17,7 @@ Requires-Dist: rich>=14.1.0
 Requires-Dist: term-image>=0.7.2
 Requires-Dist: trafilatura>=2.0.0
 Requires-Dist: typer>=0.17.3
-Requires-Python: >=3.13
+Requires-Python: >=3.13, <3.14
 Description-Content-Type: text/markdown
 
 # Klaude Code

{klaude_code-2.4.0 → klaude_code-2.4.2}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "uv_build"
 
 [project]
 name = "klaude-code"
-version = "2.4.0"
+version = "2.4.2"
 description = "Minimal code agent CLI"
 readme = "README.md"
-requires-python = ">=3.13"
+requires-python = ">=3.13,<3.14"
 dependencies = [
     "anthropic>=0.66.0",
     "chardet>=5.2.0",

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/config/sub_agent_model_helper.py

@@ -196,15 +196,6 @@ class SubAgentModelHelper:
                 result.append(name)
         return result
 
-    def get_enabled_sub_agent_types(self) -> set[SubAgentType]:
-        """Return set of sub-agent types that are enabled and available."""
-        enabled: set[SubAgentType] = set()
-        for name in sub_agent_tool_names(enabled_only=True):
-            profile = get_sub_agent_profile_by_tool(name)
-            if profile is not None and self.check_availability_requirement(profile.availability_requirement):
-                enabled.add(profile.name)
-        return enabled
-
     def build_sub_agent_client_configs(self) -> dict[SubAgentType, str]:
         """Return model names for each sub-agent that needs a dedicated client."""
         result: dict[SubAgentType, str] = {}

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/core/agent_profile.py

@@ -262,10 +262,6 @@ class ModelProfileProvider(Protocol):
         output_schema: dict[str, Any] | None = None,
     ) -> AgentProfile: ...
 
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        """Return set of sub-agent types enabled for this provider."""
-        ...
-
 
 class DefaultModelProfileProvider(ModelProfileProvider):
     """Default provider backed by global prompts/tool/reminder registries."""
@@ -281,28 +277,24 @@ class DefaultModelProfileProvider(ModelProfileProvider):
         output_schema: dict[str, Any] | None = None,
     ) -> AgentProfile:
         model_name = llm_client.model_name
+        llm_config = llm_client.get_llm_config()
+
+        # Image generation models should not have tools
+        if llm_config.modalities and "image" in llm_config.modalities:
+            agent_tools: list[llm_param.ToolSchema] = []
+        else:
+            agent_tools = load_agent_tools(model_name, sub_agent_type, config=self._config)
+
         profile = AgentProfile(
             llm_client=llm_client,
             system_prompt=load_system_prompt(model_name, llm_client.protocol, sub_agent_type),
-            tools=load_agent_tools(model_name, sub_agent_type, config=self._config),
+            tools=agent_tools,
             reminders=load_agent_reminders(model_name, sub_agent_type),
         )
         if output_schema:
             return with_structured_output(profile, output_schema)
         return profile
 
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        if self._config is None:
-            from klaude_code.protocol.sub_agent import get_sub_agent_profile_by_tool, sub_agent_tool_names
-
-            return {
-                profile.name
-                for name in sub_agent_tool_names(enabled_only=True)
-                if (profile := get_sub_agent_profile_by_tool(name)) is not None
-            }
-        helper = SubAgentModelHelper(self._config)
-        return helper.get_enabled_sub_agent_types()
-
 
 class VanillaModelProfileProvider(ModelProfileProvider):
     """Provider that strips prompts, reminders, and tools for vanilla mode."""
@@ -325,9 +317,6 @@ class VanillaModelProfileProvider(ModelProfileProvider):
             return with_structured_output(profile, output_schema)
         return profile
 
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        return set()
-
 
 class NanoBananaModelProfileProvider(ModelProfileProvider):
     """Provider for the Nano Banana image generation model.
@@ -352,6 +341,3 @@ class NanoBananaModelProfileProvider(ModelProfileProvider):
         if output_schema:
             return with_structured_output(profile, output_schema)
         return profile
-
-    def enabled_sub_agent_types(self) -> set[tools.SubAgentType]:
-        return set()

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/core/executor.py

@@ -17,14 +17,14 @@ from pathlib import Path
 from klaude_code.config import load_config
 from klaude_code.config.sub_agent_model_helper import SubAgentModelHelper
 from klaude_code.core.agent import Agent
-from klaude_code.core.agent_profile import DefaultModelProfileProvider, ModelProfileProvider
+from klaude_code.core.agent_profile import AgentProfile, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
 from klaude_code.llm.registry import create_llm_client
 from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import commands, events, message, model, op
 from klaude_code.protocol.llm_param import LLMConfigParameter, Thinking
 from klaude_code.protocol.op_handler import OperationHandler
-from klaude_code.protocol.sub_agent import SubAgentResult
+from klaude_code.protocol.sub_agent import SubAgentResult, get_sub_agent_profile_by_tool
 from klaude_code.session.export import build_export_html, get_default_export_path
 from klaude_code.session.session import Session
 
@@ -110,13 +110,17 @@ class AgentRuntime:
     def current_agent(self) -> Agent | None:
         return self._agent
 
-    def _get_sub_agent_models(self) -> dict[str, LLMConfigParameter]:
-        """Build a dict of sub-agent type to LLMConfigParameter."""
-        enabled = self._model_profile_provider.enabled_sub_agent_types()
+    def _get_sub_agent_models(self, profile: AgentProfile) -> dict[str, LLMConfigParameter]:
+        """Build a dict of sub-agent type to LLMConfigParameter based on profile tools."""
+        enabled_types: set[str] = set()
+        for tool in profile.tools:
+            sub_profile = get_sub_agent_profile_by_tool(tool.name)
+            if sub_profile is not None:
+                enabled_types.add(sub_profile.name)
         return {
             sub_agent_type: client.get_llm_config()
             for sub_agent_type, client in self._llm_clients.sub_clients.items()
-            if sub_agent_type in enabled
+            if sub_agent_type in enabled_types
         }
 
     async def ensure_agent(self, session_id: str | None = None) -> Agent:
@@ -145,7 +149,7 @@ class AgentRuntime:
                 session_id=session.id,
                 work_dir=str(session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
-                sub_agent_models=self._get_sub_agent_models(),
+                sub_agent_models=self._get_sub_agent_models(profile),
             )
         )
 
@@ -202,7 +206,7 @@ class AgentRuntime:
                 session_id=agent.session.id,
                 work_dir=str(agent.session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
-                sub_agent_models=self._get_sub_agent_models(),
+                sub_agent_models=self._get_sub_agent_models(agent.profile),
             )
         )
 
@@ -226,7 +230,7 @@ class AgentRuntime:
                 session_id=target_session.id,
                 work_dir=str(target_session.work_dir),
                 llm_config=self._llm_clients.main.get_llm_config(),
-                sub_agent_models=self._get_sub_agent_models(),
+                sub_agent_models=self._get_sub_agent_models(profile),
             )
         )
 
@@ -410,15 +414,6 @@ class ExecutorContext:
         """Emit an event to the UI display system."""
         await self.event_queue.put(event)
 
-    def _get_sub_agent_models(self) -> dict[str, LLMConfigParameter]:
-        """Build a dict of sub-agent type to LLMConfigParameter."""
-        enabled = self.model_profile_provider.enabled_sub_agent_types()
-        return {
-            sub_agent_type: client.get_llm_config()
-            for sub_agent_type, client in self.llm_clients.sub_clients.items()
-            if sub_agent_type in enabled
-        }
-
     def current_session_id(self) -> str | None:
         """Return the primary active session id, if any.
 

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/core/turn.py

@@ -366,6 +366,7 @@ class TurnExecutor:
                         response_id=msg.response_id,
                         tool_call_id=msg.call_id,
                         tool_name=msg.name,
+                        model_id=ctx.llm_client.model_name,
                     )
                 case _:
                     continue

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/protocol/events/streaming.py

@@ -34,6 +34,7 @@ class AssistantImageDeltaEvent(ResponseEvent):
 class ToolCallStartEvent(ResponseEvent):
     tool_call_id: str
     tool_name: str
+    model_id: str | None = None
 
 
 class ResponseCompleteEvent(ResponseEvent):

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/tui/components/sub_agent.py

@@ -81,6 +81,7 @@ def render_sub_agent_result(
     *,
     has_structured_output: bool = False,
     description: str | None = None,
+    sub_agent_color: Style | None = None,
 ) -> RenderableType:
     stripped_result = result.strip()
     main_content, agent_id_footer = _extract_agent_id_footer(stripped_result)
@@ -88,7 +89,14 @@ def render_sub_agent_result(
 
     elements: list[RenderableType] = []
     if description:
-        elements.append(Text(f"---\n{description}", style=ThemeKey.TOOL_RESULT))
+        elements.append(
+            Text(
+                f"---\n{description}",
+                style=Style(bold=True, color=sub_agent_color.color, frame=True)
+                if sub_agent_color
+                else ThemeKey.TOOL_RESULT_BOLD,
+            )
+        )
 
     # Try structured JSON output first
     use_text_rendering = True

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/tui/machine.py

@@ -10,7 +10,7 @@ from klaude_code.const import (
     STATUS_DEFAULT_TEXT,
     STATUS_THINKING_TEXT,
 )
-from klaude_code.protocol import events, model
+from klaude_code.protocol import events, model, tools
 from klaude_code.tui.commands import (
     AppendAssistant,
     AppendThinking,
@@ -48,6 +48,33 @@ from klaude_code.tui.components.rich.theme import ThemeKey
 from klaude_code.tui.components.thinking import extract_last_bold_header, normalize_thinking_content
 from klaude_code.tui.components.tools import get_tool_active_form, is_sub_agent_tool
 
+# Tools that complete quickly and don't benefit from streaming activity display.
+# For models without fine-grained tool JSON streaming (e.g., Gemini), showing these
+# in the activity state causes a flash-and-disappear effect.
+FAST_TOOLS: frozenset[str] = frozenset(
+    {
+        tools.READ,
+        tools.EDIT,
+        tools.WRITE,
+        tools.BASH,
+        tools.TODO_WRITE,
+        tools.UPDATE_PLAN,
+        tools.APPLY_PATCH,
+        tools.REPORT_BACK,
+    }
+)
+
+
+def _should_skip_tool_activity(tool_name: str, model_id: str | None) -> bool:
+    """Check if tool activity should be skipped for non-streaming models."""
+    if model_id is None:
+        return False
+    if tool_name not in FAST_TOOLS:
+        return False
+    # Gemini and Grok models don't stream tool JSON at fine granularity
+    model_lower = model_id.lower()
+    return "gemini" in model_lower or "grok" in model_lower
+
 
 @dataclass
 class SubAgentThinkingHeaderState:
@@ -142,7 +169,8 @@ class ActivityState:
 
             if self._sub_agent_tool_calls:
                 _append_counts(self._sub_agent_tool_calls)
-                activity_text.append(" | ")
+                if self._tool_calls:
+                    activity_text.append(" , ")
 
             if self._tool_calls:
                 _append_counts(self._tool_calls)
@@ -497,11 +525,14 @@ class DisplayStateMachine:
 
                 self._spinner.set_composing(False)
 
-                tool_active_form = get_tool_active_form(e.tool_name)
-                if is_sub_agent_tool(e.tool_name):
-                    self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
-                else:
-                    self._spinner.add_tool_call(tool_active_form)
+                # Skip activity state for fast tools on non-streaming models (e.g., Gemini)
+                # to avoid flash-and-disappear effect
+                if not _should_skip_tool_activity(e.tool_name, e.model_id):
+                    tool_active_form = get_tool_active_form(e.tool_name)
+                    if is_sub_agent_tool(e.tool_name):
+                        self._spinner.add_sub_agent_tool_call(e.tool_call_id, tool_active_form)
+                    else:
+                        self._spinner.add_tool_call(tool_active_form)
 
                 cmds.extend(self._spinner_update_commands())
                 return cmds

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/tui/renderer.py

@@ -569,6 +569,7 @@ class TUICommandRenderer:
                         event.task_result,
                         has_structured_output=event.has_structured_output,
                         description=description,
+                        sub_agent_color=self._current_sub_agent_color,
                     )
                 )
 

{klaude_code-2.4.0 → klaude_code-2.4.2}/src/klaude_code/tui/terminal/selector.py

@@ -54,17 +54,16 @@ def build_model_select_items(models: list[Any]) -> list[SelectItem[str]]:
     items: list[SelectItem[str]] = []
     for idx, m in enumerate(models, 1):
         model_id_str = m.model_id or "N/A"
-        # Display the base model name only; provider stays in the meta section.
         display_name = m.model_name
         first_line_prefix = f"{display_name:<{max_model_name_length}} → "
-        meta_parts: list[str] = [m.provider]
-        meta_parts.extend(format_model_params(m))
-        meta_str = " · ".join(meta_parts)
+        provider_model = f"{m.provider}/{model_id_str}"
+        meta_parts = format_model_params(m)
+        meta_str = " · ".join(meta_parts) if meta_parts else ""
         title = [
             ("class:meta", f"{idx:>{num_width}}. "),
             ("class:msg", first_line_prefix),
-            ("class:msg bold", model_id_str),
-            ("class:meta", f"  {meta_str}\n"),
+            ("class:msg bold", provider_model),
+            ("class:meta", f"  {meta_str}\n" if meta_str else "\n"),
         ]
         search_text = f"{m.selector} {m.model_name} {model_id_str} {m.provider}"
         items.append(SelectItem(title=title, value=m.selector, search_text=search_text))