klaude-code 1.2.18__py3-none-any.whl → 1.2.20__py3-none-any.whl

klaude_code/core/executor.py

@@ -8,10 +8,12 @@ handling operations submitted from the CLI and coordinating with agents.
 from __future__ import annotations
 
 import asyncio
-from collections.abc import Awaitable, Callable
+import subprocess
+from collections.abc import Callable
 from dataclasses import dataclass
+from pathlib import Path
 
-from klaude_code.command import InputAction, InputActionType, dispatch_command
+from klaude_code.command import dispatch_command
 from klaude_code.config import load_config
 from klaude_code.core.agent import Agent, DefaultModelProfileProvider, ModelProfileProvider
 from klaude_code.core.manager import LLMClients, SubAgentManager
@@ -20,6 +22,7 @@ from klaude_code.llm.registry import create_llm_client
 from klaude_code.protocol import commands, events, model, op
 from klaude_code.protocol.op_handler import OperationHandler
 from klaude_code.protocol.sub_agent import SubAgentResult
+from klaude_code.session.export import build_export_html, get_default_export_path
 from klaude_code.session.session import Session
 from klaude_code.trace import DebugType, log_debug
 
@@ -76,164 +79,6 @@ class TaskManager:
         self._tasks.clear()
 
 
-class InputActionExecutor:
-    """Execute input actions returned by the command dispatcher.
-
-    This helper encapsulates the logic for running the main agent task,
-    applying model changes, and clearing conversations so that
-    :class:`ExecutorContext` stays focused on operation dispatch.
-    """
-
-    def __init__(
-        self,
-        task_manager: TaskManager,
-        sub_agent_manager: SubAgentManager,
-        model_profile_provider: ModelProfileProvider,
-        emit_event: Callable[[events.Event], Awaitable[None]],
-    ) -> None:
-        self._task_manager = task_manager
-        self._sub_agent_manager = sub_agent_manager
-        self._model_profile_provider = model_profile_provider
-        self._emit_event = emit_event
-
-    async def run(self, action: InputAction, operation: op.UserInputOperation, agent: Agent) -> None:
-        """Dispatch and execute a single input action."""
-
-        if operation.session_id is None:
-            raise ValueError("session_id cannot be None for input actions")
-
-        session_id = operation.session_id
-
-        if action.type == InputActionType.RUN_AGENT:
-            await self._run_agent_action(action, operation, agent, session_id)
-            return
-
-        if action.type == InputActionType.CHANGE_MODEL:
-            if not action.model_name:
-                raise ValueError("ChangeModel action requires model_name")
-
-            await self._apply_model_change(agent, action.model_name)
-            return
-
-        if action.type == InputActionType.CLEAR:
-            await self._apply_clear(agent)
-            return
-
-        raise ValueError(f"Unsupported input action type: {action.type}")
-
-    async def _run_agent_action(
-        self,
-        action: InputAction,
-        operation: op.UserInputOperation,
-        agent: Agent,
-        session_id: str,
-    ) -> None:
-        task_input = model.UserInputPayload(text=action.text, images=operation.input.images)
-
-        existing_active = self._task_manager.get(operation.id)
-        if existing_active is not None and not existing_active.task.done():
-            raise RuntimeError(f"Active task already registered for operation {operation.id}")
-
-        task: asyncio.Task[None] = asyncio.create_task(
-            self._run_agent_task(agent, task_input, operation.id, session_id)
-        )
-        self._task_manager.register(operation.id, task, session_id)
-
-    async def _run_agent_task(
-        self,
-        agent: Agent,
-        user_input: model.UserInputPayload,
-        task_id: str,
-        session_id: str,
-    ) -> None:
-        """Run the main agent task and forward events to the UI."""
-
-        try:
-            log_debug(
-                f"Starting agent task {task_id} for session {session_id}",
-                style="green",
-                debug_type=DebugType.EXECUTION,
-            )
-
-            async def _runner(state: model.SubAgentState) -> SubAgentResult:
-                return await self._sub_agent_manager.run_sub_agent(agent, state)
-
-            token = current_run_subtask_callback.set(_runner)
-            try:
-                async for event in agent.run_task(user_input):
-                    await self._emit_event(event)
-            finally:
-                current_run_subtask_callback.reset(token)
-
-        except asyncio.CancelledError:
-            log_debug(
-                f"Agent task {task_id} was cancelled",
-                style="yellow",
-                debug_type=DebugType.EXECUTION,
-            )
-            await self._emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
-
-        except Exception as e:
-            import traceback
-
-            log_debug(
-                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__}] {e!s}",
-                    can_retry=False,
-                )
-            )
-
-        finally:
-            self._task_manager.remove(task_id)
-            log_debug(
-                f"Cleaned up agent task {task_id}",
-                style="cyan",
-                debug_type=DebugType.EXECUTION,
-            )
-
-    async def _apply_model_change(self, agent: Agent, model_name: str) -> None:
-        """Change the model used by the active 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 the agent and notify the UI."""
-
-        new_session = Session(work_dir=agent.session.work_dir)
-        new_session.model_name = agent.session.model_name
-
-        agent.session = new_session
-        agent.session.save()
-
-        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))
-
-
 class ExecutorContext:
     """
     Context object providing shared state and operations for the executor.
@@ -249,6 +94,7 @@ class ExecutorContext:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
         self.event_queue: asyncio.Queue[events.Event] = event_queue
         self.llm_clients: LLMClients = llm_clients
@@ -258,12 +104,7 @@ class ExecutorContext:
 
         self.task_manager = TaskManager()
         self.sub_agent_manager = SubAgentManager(event_queue, llm_clients, resolved_profile_provider)
-        self._action_executor = InputActionExecutor(
-            task_manager=self.task_manager,
-            sub_agent_manager=self.sub_agent_manager,
-            model_profile_provider=resolved_profile_provider,
-            emit_event=self.emit_event,
-        )
+        self._on_model_change = on_model_change
         self._agent: Agent | None = None
 
     async def emit_event(self, event: events.Event) -> None:
@@ -302,6 +143,13 @@ class ExecutorContext:
 
         session = Session.create() if session_id is None else Session.load(session_id)
 
+        if (
+            session.model_thinking is not None
+            and session.model_name
+            and session.model_name == self.llm_clients.main.model_name
+        ):
+            self.llm_clients.main.get_llm_config().thinking = session.model_thinking
+
         profile = self.model_profile_provider.build_profile(self.llm_clients.main)
         agent = Agent(session=session, profile=profile)
 
@@ -328,7 +176,7 @@ class ExecutorContext:
         await self._ensure_agent(operation.session_id)
 
     async def handle_user_input(self, operation: op.UserInputOperation) -> None:
-        """Handle a user input operation by running it through an agent."""
+        """Handle a user input operation by dispatching it into operations."""
 
         if operation.session_id is None:
             raise ValueError("session_id cannot be None")
@@ -337,29 +185,187 @@ class ExecutorContext:
         agent = await self._ensure_agent(session_id)
         user_input = operation.input
 
-        # emit user input event
+        # Emit the original user input to UI (even if the persisted text differs).
         await self.emit_event(
             events.UserMessageEvent(content=user_input.text, session_id=session_id, images=user_input.images)
         )
 
-        result = await dispatch_command(user_input.text, agent)
+        result = await dispatch_command(user_input, agent, submission_id=operation.id)
+        ops: list[op.Operation] = list(result.operations or [])
 
-        actions: list[InputAction] = list(result.actions or [])
+        run_ops = [candidate for candidate in ops if isinstance(candidate, op.RunAgentOperation)]
+        if len(run_ops) > 1:
+            raise ValueError("Multiple RunAgentOperation results are not supported")
 
-        has_run_agent_action = any(action.type is InputActionType.RUN_AGENT for action in actions)
-        if not has_run_agent_action:
-            # No async agent task will run, append user message directly
-            agent.session.append_history([model.UserMessageItem(content=user_input.text, images=user_input.images)])
+        persisted_user_input = run_ops[0].input if run_ops else user_input
+        agent.session.append_history(
+            [model.UserMessageItem(content=persisted_user_input.text, images=persisted_user_input.images)]
+        )
 
         if result.events:
-            agent.session.append_history(
-                [evt.item for evt in result.events if isinstance(evt, events.DeveloperMessageEvent)]
-            )
             for evt in result.events:
+                if isinstance(evt, events.DeveloperMessageEvent):
+                    agent.session.append_history([evt.item])
                 await self.emit_event(evt)
 
-        for action in actions:
-            await self._action_executor.run(action, operation, agent)
+        for operation_item in ops:
+            await operation_item.execute(handler=self)
+
+    async def handle_run_agent(self, operation: op.RunAgentOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        existing_active = self.task_manager.get(operation.id)
+        if existing_active is not None and not existing_active.task.done():
+            raise RuntimeError(f"Active task already registered for operation {operation.id}")
+        task: asyncio.Task[None] = asyncio.create_task(
+            self._run_agent_task(agent, operation.input, operation.id, operation.session_id)
+        )
+        self.task_manager.register(operation.id, task, operation.session_id)
+
+    async def handle_change_model(self, operation: op.ChangeModelOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        config = load_config()
+        if config is None:
+            raise ValueError("Configuration must be initialized before changing model")
+
+        llm_config = config.get_model_config(operation.model_name)
+        llm_client = create_llm_client(llm_config)
+        agent.set_model_profile(self.model_profile_provider.build_profile(llm_client))
+
+        agent.session.model_config_name = operation.model_name
+        agent.session.model_thinking = llm_config.thinking
+
+        developer_item = model.DeveloperMessageItem(
+            content=f"switched to model: {operation.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)))
+
+        if self._on_model_change is not None:
+            self._on_model_change(llm_client.model_name)
+
+    async def handle_clear_session(self, operation: op.ClearSessionOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        new_session = Session.create(work_dir=agent.session.work_dir)
+        new_session.model_name = agent.session.model_name
+        new_session.model_config_name = agent.session.model_config_name
+        new_session.model_thinking = agent.session.model_thinking
+        agent.session = new_session
+
+        developer_item = model.DeveloperMessageItem(
+            content="started new conversation",
+            command_output=model.CommandOutput(command_name=commands.CommandName.CLEAR),
+        )
+        await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
+    async def handle_export_session(self, operation: op.ExportSessionOperation) -> None:
+        agent = await self._ensure_agent(operation.session_id)
+        try:
+            output_path = self._resolve_export_output_path(operation.output_path, agent.session)
+            html_doc = self._build_export_html(agent)
+            await asyncio.to_thread(output_path.parent.mkdir, parents=True, exist_ok=True)
+            await asyncio.to_thread(output_path.write_text, html_doc, "utf-8")
+            await asyncio.to_thread(self._open_file, output_path)
+            developer_item = model.DeveloperMessageItem(
+                content=f"Session exported and opened: {output_path}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+        except Exception as exc:  # pragma: no cover
+            import traceback
+
+            developer_item = model.DeveloperMessageItem(
+                content=f"Failed to export session: {exc}\n{traceback.format_exc()}",
+                command_output=model.CommandOutput(command_name=commands.CommandName.EXPORT, is_error=True),
+            )
+            agent.session.append_history([developer_item])
+            await self.emit_event(events.DeveloperMessageEvent(session_id=agent.session.id, item=developer_item))
+
+    async def _run_agent_task(
+        self,
+        agent: Agent,
+        user_input: model.UserInputPayload,
+        task_id: str,
+        session_id: str,
+    ) -> None:
+        try:
+            log_debug(
+                f"Starting agent task {task_id} for session {session_id}",
+                style="green",
+                debug_type=DebugType.EXECUTION,
+            )
+
+            async def _runner(state: model.SubAgentState) -> SubAgentResult:
+                return await self.sub_agent_manager.run_sub_agent(agent, state)
+
+            token = current_run_subtask_callback.set(_runner)
+            try:
+                async for event in agent.run_task(user_input):
+                    await self.emit_event(event)
+            finally:
+                current_run_subtask_callback.reset(token)
+
+        except asyncio.CancelledError:
+            log_debug(
+                f"Agent task {task_id} was cancelled",
+                style="yellow",
+                debug_type=DebugType.EXECUTION,
+            )
+            await self.emit_event(events.TaskFinishEvent(session_id=session_id, task_result="task cancelled"))
+
+        except Exception as e:
+            import traceback
+
+            log_debug(
+                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__}] {e!s}",
+                    can_retry=False,
+                )
+            )
+        finally:
+            self.task_manager.remove(task_id)
+            log_debug(
+                f"Cleaned up agent task {task_id}",
+                style="cyan",
+                debug_type=DebugType.EXECUTION,
+            )
+
+    def _resolve_export_output_path(self, raw: str | None, session: Session) -> Path:
+        trimmed = (raw or "").strip()
+        if trimmed:
+            candidate = Path(trimmed).expanduser()
+            if not candidate.is_absolute():
+                candidate = Path(session.work_dir) / candidate
+            if candidate.suffix.lower() != ".html":
+                candidate = candidate.with_suffix(".html")
+            return candidate
+        return get_default_export_path(session)
+
+    def _build_export_html(self, agent: Agent) -> str:
+        profile = agent.profile
+        system_prompt = (profile.system_prompt if profile else "") or ""
+        tool_schemas = profile.tools if profile else []
+        model_name = profile.llm_client.model_name if profile else "unknown"
+        return build_export_html(agent.session, system_prompt, tool_schemas, model_name)
+
+    def _open_file(self, path: Path) -> None:
+        try:
+            subprocess.run(["open", str(path)], check=True)
+        except FileNotFoundError as exc:  # pragma: no cover
+            msg = "`open` command not found; please open the HTML manually."
+            raise RuntimeError(msg) from exc
+        except subprocess.CalledProcessError as exc:  # pragma: no cover
+            msg = f"Failed to open HTML with `open`: {exc}"
+            raise RuntimeError(msg) from exc
 
     async def handle_interrupt(self, operation: op.InterruptOperation) -> None:
         """Handle an interrupt by invoking agent.cancel() and cancelling tasks."""
@@ -439,8 +445,9 @@ class Executor:
         event_queue: asyncio.Queue[events.Event],
         llm_clients: LLMClients,
         model_profile_provider: ModelProfileProvider | None = None,
+        on_model_change: Callable[[str], None] | None = None,
     ):
-        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider)
+        self.context = ExecutorContext(event_queue, llm_clients, model_profile_provider, on_model_change)
         self.submission_queue: asyncio.Queue[op.Submission] = asyncio.Queue()
         # Track completion events for all submissions (not just those with ActiveTask)
         self._completion_events: dict[str, asyncio.Event] = {}

klaude_code/core/manager/sub_agent_manager.py

@@ -80,6 +80,9 @@ Only the content passed to `report_back` will be returned to user.\
             result: str = ""
             task_metadata: model.TaskMetadata | None = None
             sub_agent_input = model.UserInputPayload(text=state.sub_agent_prompt, images=None)
+            child_session.append_history(
+                [model.UserMessageItem(content=sub_agent_input.text, images=sub_agent_input.images)]
+            )
             async for event in child_agent.run_task(sub_agent_input):
                 # Capture TaskFinishEvent content for return
                 if isinstance(event, events.TaskFinishEvent):

klaude_code/core/prompt.py

@@ -12,6 +12,7 @@ COMMAND_DESCRIPTIONS: dict[str, str] = {
     "fd": "simple and fast alternative to find",
     "tree": "directory listing as a tree",
     "sg": "ast-grep - AST-aware code search",
+    "jj": "jujutsu - Git-compatible version control system",
 }
 
 # Mapping from logical prompt keys to resource file paths under the core/prompt directory.
@@ -57,18 +58,20 @@ def _build_env_info(model_name: str) -> str:
     cwd = Path.cwd()
     today = datetime.datetime.now().strftime("%Y-%m-%d")
     is_git_repo = (cwd / ".git").exists()
+    is_empty_dir = not any(cwd.iterdir())
 
     available_tools: list[str] = []
     for command, desc in COMMAND_DESCRIPTIONS.items():
         if shutil.which(command) is not None:
             available_tools.append(f"{command}: {desc}")
 
+    cwd_display = f"{cwd} (empty)" if is_empty_dir else str(cwd)
     env_lines: list[str] = [
         "",
         "",
         "Here is useful information about the environment you are running in:",
         "<env>",
-        f"Working directory: {cwd}",
+        f"Working directory: {cwd_display}",
         f"Today's Date: {today}",
         f"Is directory a git repo: {is_git_repo}",
         f"You are powered by the model: {model_name}",

klaude_code/core/prompts/prompt-sub-agent-explore.md

@@ -1,6 +1,14 @@
 You are a powerful code search agent.
 
-CRITICAL: This is a READ-ONLY exploration task. You MUST NOT create, write, or modify any files under any circumstances. Your role is strictly to search and analyze existing code.
+=== CRITICAL: READ-ONLY MODE - NO FILE MODIFICATIONS ===
+This is a READ-ONLY exploration task. You are STRICTLY PROHIBITED from:
+- Creating new files (no Write, touch, or file creation of any kind)
+- Modifying existing files (no Edit operations)
+- Deleting files (no rm or deletion)
+- Moving or copying files (no mv or cp)
+- Creating temporary files anywhere, including /tmp
+- Using redirect operators (>, >>, |) or heredocs to write to files
+- Running ANY commands that change system state
 
 Your strengths:
 - Rapidly finding files using glob patterns
@@ -14,12 +22,16 @@ Guidelines:
 - Use Bash ONLY for read-only operations (ls, git status, git log, git diff, find, cat, head, tail). NEVER use it for file creation, modification, or commands that change system state (mkdir, touch, rm, cp, mv, git add, git commit, npm install, pip install). NEVER use redirect operators (>, >>, |) or heredocs to create files
 - Adapt your search approach based on the thoroughness level specified by the caller
 - quick = scan obvious targets; medium = cover all related modules; very thorough = exhaustive sweep with validation
-- For maximum efficiency, whenever you need to perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially.
 - Only your last message is surfaced back to the agent as the final answer.
 - Return file paths as absolute paths in your final response
 - For clear communication, avoid using emojis
 - Do not create any files, or run bash commands that modify the user's system state in any way (This includes temporary files in the /tmp folder. Never create these files, instead communicate your final report directly as a regular message)
 
+NOTE: You are meant to be a fast agent that returns output as quickly as possible. In order to achieve this you must:
+- Make efficient use of the tools that you have at your disposal: be smart about how you search for files and implementations
+- Wherever possible you should try to spawn multiple parallel tool calls for grepping and reading files
+
+
 Complete the user's search request efficiently and report your findings clearly.
 
 Notes:

klaude_code/core/prompts/prompt-sub-agent-web.md

@@ -1,4 +1,4 @@
-You are a web research agent that searches and fetches web content to provide up-to-date information.
+You are a web research subagent that searches and fetches web content to provide up-to-date information as part of team.
 
 ## Available Tools
 
@@ -28,7 +28,7 @@ Balance efficiency with thoroughness. For open-ended questions (e.g., "recommend
 - Avoid repeating similar queries - they won't yield new results
 - NEVER use '-', 'site:', or quotes unless explicitly asked
 - Include year/date for time-sensitive queries (check "Today's date" in <env>), don't limit yourself to your knowledge cutoff date
-- Use WebFetch to get full content - search snippets are often insufficient
+- Always use WebFetch to get the complete contents of websites - search snippets are often insufficient
 - Follow relevant links on pages with WebFetch
 - If truncated results are saved to local files, use grep/read to explore
 
@@ -48,4 +48,4 @@ You MUST end every response with a "Sources:" section listing all URLs with thei
 
 Sources:
 - [Source Title](https://example.com) -> /tmp/klaude/web/example_com-123456.md
-- [Another Source](https://example.com/page) -> /tmp/klaude/web/example_com_page-123456.md
+- [Another Source](https://example.com/page) -> /tmp/klaude/web/example_com_page-123456.md