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

klaude_code/protocol/op.py

@@ -23,6 +23,10 @@ class OperationType(Enum):
     """Enumeration of supported operation types."""
 
     USER_INPUT = "user_input"
+    RUN_AGENT = "run_agent"
+    CHANGE_MODEL = "change_model"
+    CLEAR_SESSION = "clear_session"
+    EXPORT_SESSION = "export_session"
     INTERRUPT = "interrupt"
     INIT_AGENT = "init_agent"
     END = "end"
@@ -51,6 +55,49 @@ class UserInputOperation(Operation):
         await handler.handle_user_input(self)
 
 
+class RunAgentOperation(Operation):
+    """Operation for launching an agent task for a given session."""
+
+    type: OperationType = OperationType.RUN_AGENT
+    session_id: str
+    input: UserInputPayload
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_run_agent(self)
+
+
+class ChangeModelOperation(Operation):
+    """Operation for changing the model used by the active agent session."""
+
+    type: OperationType = OperationType.CHANGE_MODEL
+    session_id: str
+    model_name: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_change_model(self)
+
+
+class ClearSessionOperation(Operation):
+    """Operation for clearing the active session and starting a new one."""
+
+    type: OperationType = OperationType.CLEAR_SESSION
+    session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_clear_session(self)
+
+
+class ExportSessionOperation(Operation):
+    """Operation for exporting a session transcript to HTML."""
+
+    type: OperationType = OperationType.EXPORT_SESSION
+    session_id: str
+    output_path: str | None = None
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_export_session(self)
+
+
 class InterruptOperation(Operation):
     """Operation for interrupting currently running tasks."""
 

klaude_code/protocol/op_handler.py

@@ -9,7 +9,15 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Protocol
 
 if TYPE_CHECKING:
-    from klaude_code.protocol.op import InitAgentOperation, InterruptOperation, UserInputOperation
+    from klaude_code.protocol.op import (
+        ChangeModelOperation,
+        ClearSessionOperation,
+        ExportSessionOperation,
+        InitAgentOperation,
+        InterruptOperation,
+        RunAgentOperation,
+        UserInputOperation,
+    )
 
 
 class OperationHandler(Protocol):
@@ -19,6 +27,22 @@ class OperationHandler(Protocol):
         """Handle a user input operation."""
         ...
 
+    async def handle_run_agent(self, operation: RunAgentOperation) -> None:
+        """Handle a run agent operation."""
+        ...
+
+    async def handle_change_model(self, operation: ChangeModelOperation) -> None:
+        """Handle a change model operation."""
+        ...
+
+    async def handle_clear_session(self, operation: ClearSessionOperation) -> None:
+        """Handle a clear session operation."""
+        ...
+
+    async def handle_export_session(self, operation: ExportSessionOperation) -> None:
+        """Handle an export session operation."""
+        ...
+
     async def handle_interrupt(self, operation: InterruptOperation) -> None:
         """Handle an interrupt operation."""
         ...

klaude_code/protocol/sub_agent/web.py

@@ -71,7 +71,7 @@ register_sub_agent(
         description=WEB_AGENT_DESCRIPTION,
         parameters=WEB_AGENT_PARAMETERS,
         prompt_file="prompts/prompt-sub-agent-web.md",
-        tool_set=(tools.BASH, tools.READ, tools.WEB_FETCH, tools.WEB_SEARCH),
+        tool_set=(tools.BASH, tools.READ, tools.WEB_FETCH, tools.WEB_SEARCH, tools.WRITE),
         prompt_builder=_web_agent_prompt_builder,
         active_form="Surfing",
         output_schema_arg="output_format",

klaude_code/session/codec.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import json
+from typing import Any, TypeGuard, cast, get_args
+
+from pydantic import BaseModel
+
+from klaude_code.protocol import model
+
+
+def _is_basemodel_subclass(tp: object) -> TypeGuard[type[BaseModel]]:
+    return isinstance(tp, type) and issubclass(tp, BaseModel)
+
+
+def _flatten_union(tp: object) -> list[object]:
+    args = list(get_args(tp))
+    if not args:
+        return [tp]
+    flattened: list[object] = []
+    for arg in args:
+        flattened.extend(_flatten_union(arg))
+    return flattened
+
+
+def _build_type_registry() -> dict[str, type[BaseModel]]:
+    registry: dict[str, type[BaseModel]] = {}
+    for tp in _flatten_union(model.ConversationItem):
+        if not _is_basemodel_subclass(tp):
+            continue
+        registry[tp.__name__] = tp
+    return registry
+
+
+_CONVERSATION_ITEM_TYPES: dict[str, type[BaseModel]] = _build_type_registry()
+
+
+def encode_conversation_item(item: model.ConversationItem) -> dict[str, Any]:
+    return {"type": item.__class__.__name__, "data": item.model_dump(mode="json")}
+
+
+def decode_conversation_item(obj: dict[str, Any]) -> model.ConversationItem | None:
+    t = obj.get("type")
+    data = obj.get("data", {})
+    if not isinstance(t, str) or not isinstance(data, dict):
+        return None
+    cls = _CONVERSATION_ITEM_TYPES.get(t)
+    if cls is None:
+        return None
+    try:
+        item = cls(**data)
+    except TypeError:
+        return None
+    # pyright: ignore[reportReturnType]
+    return item  # type: ignore[return-value]
+
+
+def encode_jsonl_line(item: model.ConversationItem) -> str:
+    return json.dumps(encode_conversation_item(item), ensure_ascii=False) + "\n"
+
+
+def decode_jsonl_line(line: str) -> model.ConversationItem | None:
+    line = line.strip()
+    if not line:
+        return None
+    try:
+        obj = json.loads(line)
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(obj, dict):
+        return None
+    return decode_conversation_item(cast(dict[str, Any], obj))

klaude_code/session/export.py

@@ -63,7 +63,7 @@ def get_default_export_path(session: Session) -> Path:
     """Get default export path for a session."""
     from klaude_code.session.session import Session as SessionClass
 
-    exports_dir = SessionClass._exports_dir()  # pyright: ignore[reportPrivateUsage]
+    exports_dir = SessionClass.exports_dir()
     timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
     first_msg = get_first_user_message(session.conversation_history)
     sanitized_msg = _sanitize_filename(first_msg)
@@ -267,20 +267,30 @@ def _render_assistant_message(index: int, content: str, timestamp: datetime) ->
     )
 
 
-def _try_render_todo_args(arguments: str) -> str | None:
+def _try_render_todo_args(arguments: str, tool_name: str) -> str | None:
     try:
         parsed = json.loads(arguments)
-        if not isinstance(parsed, dict) or "todos" not in parsed or not isinstance(parsed["todos"], list):
+        if not isinstance(parsed, dict):
             return None
 
-        todos = cast(list[dict[str, str]], parsed["todos"])
-        if not todos:
+        # Support both TodoWrite (todos/content) and update_plan (plan/step)
+        parsed_dict = cast(dict[str, Any], parsed)
+        if tool_name == "TodoWrite":
+            items = parsed_dict.get("todos")
+            content_key = "content"
+        elif tool_name == "update_plan":
+            items = parsed_dict.get("plan")
+            content_key = "step"
+        else:
+            return None
+
+        if not isinstance(items, list) or not items:
             return None
 
         items_html: list[str] = []
-        for todo in todos:
-            content = _escape_html(todo.get("content", ""))
-            status = todo.get("status", "pending")
+        for item in cast(list[dict[str, str]], items):
+            content = _escape_html(item.get(content_key, ""))
+            status = item.get("status", "pending")
             status_class = f"status-{status}"
 
             items_html.append(
@@ -447,8 +457,8 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
     is_todo_list = False
     ts_str = _format_msg_timestamp(tool_call.created_at)
 
-    if tool_call.name == "TodoWrite":
-        args_html = _try_render_todo_args(tool_call.arguments)
+    if tool_call.name in ("TodoWrite", "update_plan"):
+        args_html = _try_render_todo_args(tool_call.arguments, tool_call.name)
         if args_html:
             is_todo_list = True
 
@@ -506,7 +516,7 @@ def _format_tool_call(tool_call: model.ToolCallItem, result: model.ToolResultIte
         diff_text = _get_diff_text(result.ui_extra)
         mermaid_html = _get_mermaid_link_html(result.ui_extra, tool_call)
 
-        should_hide_text = tool_call.name == "TodoWrite" and result.status != "error"
+        should_hide_text = tool_call.name in ("TodoWrite", "update_plan") and result.status != "error"
 
         if tool_call.name == "Edit" and not diff_text and result.status != "error":
             try: