klaude-code 2.0.1__py3-none-any.whl → 2.1.0__py3-none-any.whl

klaude_code/core/tool/todo/update_plan_tool.py

@@ -6,8 +6,8 @@ from pathlib import Path
 
 from pydantic import BaseModel, field_validator
 
+from klaude_code.core.tool.context import ToolContext
 from klaude_code.core.tool.tool_abc import ToolABC, load_desc
-from klaude_code.core.tool.tool_context import get_current_todo_context
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, message, model, tools
 
@@ -79,15 +79,13 @@ class UpdatePlanTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> message.ToolResultMessage:
+    async def call(cls, arguments: str, context: ToolContext) -> message.ToolResultMessage:
         try:
             args = UpdatePlanArguments.model_validate_json(arguments)
         except ValueError as exc:
             return message.ToolResultMessage(status="error", output_text=f"Invalid arguments: {exc}")
 
-        todo_context = get_current_todo_context()
-        if todo_context is None:
-            return message.ToolResultMessage(status="error", output_text="No active session found")
+        todo_context = context.todo_context
 
         new_todos = [model.TodoItem(content=item.step, status=item.status) for item in args.plan]
         old_todos = todo_context.get_todos()

klaude_code/core/tool/tool_abc.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass
 from enum import Enum
 from pathlib import Path
 
+from klaude_code.core.tool.context import ToolContext
 from klaude_code.protocol import llm_param, message
 
 
@@ -27,7 +28,7 @@ class ToolABC(ABC):
 
     @classmethod
     @abstractmethod
-    async def call(cls, arguments: str) -> message.ToolResultMessage:
+    async def call(cls, arguments: str, context: ToolContext) -> message.ToolResultMessage:
         raise NotImplementedError
 
 

klaude_code/core/tool/tool_registry.py

@@ -3,8 +3,8 @@ from typing import TypeVar
 
 from klaude_code.core.tool.sub_agent_tool import SubAgentTool
 from klaude_code.core.tool.tool_abc import ToolABC
-from klaude_code.protocol import llm_param, tools
-from klaude_code.protocol.sub_agent import get_sub_agent_profile, iter_sub_agent_profiles, sub_agent_tool_names
+from klaude_code.protocol import llm_param
+from klaude_code.protocol.sub_agent import iter_sub_agent_profiles
 
 _REGISTRY: dict[str, type[ToolABC]] = {}
 
@@ -45,34 +45,3 @@ def get_tool_schemas(tool_names: list[str]) -> list[llm_param.ToolSchema]:
 def get_registry() -> dict[str, type[ToolABC]]:
     """Get the global tool registry."""
     return _REGISTRY
-
-
-def load_agent_tools(
-    model_name: str, sub_agent_type: tools.SubAgentType | None = None, *, vanilla: bool = False
-) -> list[llm_param.ToolSchema]:
-    """Get tools for an agent based on model and agent type.
-
-    Args:
-        model_name: The model name.
-        sub_agent_type: If None, returns main agent tools. Otherwise returns sub-agent tools.
-        vanilla: If True, returns minimal vanilla tools (ignores sub_agent_type).
-    """
-    if vanilla:
-        return get_tool_schemas([tools.BASH, tools.EDIT, tools.WRITE, tools.READ])
-
-    if sub_agent_type is not None:
-        profile = get_sub_agent_profile(sub_agent_type)
-        return get_tool_schemas(list(profile.tool_set))
-
-    # Main agent tools
-    if "gpt-5" in model_name:
-        tool_names = [tools.BASH, tools.READ, tools.APPLY_PATCH, tools.MOVE, tools.UPDATE_PLAN]
-    elif "gemini-3" in model_name:
-        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.MOVE]
-    else:
-        tool_names = [tools.BASH, tools.READ, tools.EDIT, tools.WRITE, tools.MOVE, tools.TODO_WRITE]
-
-    tool_names.extend(sub_agent_tool_names(enabled_only=True, model_name=model_name))
-    tool_names.extend([tools.SKILL, tools.MERMAID])
-    # tool_names.extend([tools.MEMORY])
-    return get_tool_schemas(tool_names)

klaude_code/core/tool/tool_runner.py

@@ -3,9 +3,9 @@ from collections.abc import AsyncGenerator, Callable, Iterable, Sequence
 from dataclasses import dataclass
 
 from klaude_code.const import CANCEL_OUTPUT
+from klaude_code.core.tool.context import ToolContext
 from klaude_code.core.tool.report_back_tool import ReportBackTool
 from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy
-from klaude_code.core.tool.tool_context import current_sub_agent_session_id_recorder
 from klaude_code.core.tool.truncation import truncate_tool_output
 from klaude_code.protocol import message, model, tools
 
@@ -18,19 +18,24 @@ class ToolCallRequest:
     arguments_json: str
 
 
-async def run_tool(tool_call: ToolCallRequest, registry: dict[str, type[ToolABC]]) -> message.ToolResultMessage:
+async def run_tool(
+    tool_call: ToolCallRequest,
+    registry: dict[str, type[ToolABC]],
+    context: ToolContext,
+) -> message.ToolResultMessage:
     """Execute a tool call and return the result.
 
     Args:
         tool_call: The tool call to execute.
         registry: The tool registry mapping tool names to tool classes.
+        context: The explicit tool execution context.
 
     Returns:
         The result of the tool execution.
     """
     # Special handling for report_back tool (not registered in global registry)
     if tool_call.tool_name == tools.REPORT_BACK:
-        tool_result = await ReportBackTool.call(tool_call.arguments_json)
+        tool_result = await ReportBackTool.call(tool_call.arguments_json, context)
         tool_result.call_id = tool_call.call_id
         tool_result.tool_name = tool_call.tool_name
         return tool_result
@@ -43,7 +48,7 @@ async def run_tool(tool_call: ToolCallRequest, registry: dict[str, type[ToolABC]
             tool_name=tool_call.tool_name,
         )
     try:
-        tool_result = await registry[tool_call.tool_name].call(tool_call.arguments_json)
+        tool_result = await registry[tool_call.tool_name].call(tool_call.arguments_json, context)
         tool_result.call_id = tool_call.call_id
         tool_result.tool_name = tool_call.tool_name
         if tool_result.output_text:
@@ -109,9 +114,11 @@ class ToolExecutor:
     def __init__(
         self,
         *,
+        context: ToolContext,
         registry: dict[str, type[ToolABC]],
         append_history: Callable[[Sequence[message.HistoryEvent]], None],
     ) -> None:
+        self._context = context
         self._registry = registry
         self._append_history = append_history
 
@@ -268,15 +275,11 @@ class ToolExecutor:
 
     async def _run_single_tool_call(self, tool_call: ToolCallRequest) -> list[ToolExecutorEvent]:
         def _record_sub_agent_session_id(session_id: str) -> None:
-            # Keep the first recorded id if multiple writes happen.
             if tool_call.call_id not in self._sub_agent_session_ids:
                 self._sub_agent_session_ids[tool_call.call_id] = session_id
 
-        recorder_token = current_sub_agent_session_id_recorder.set(_record_sub_agent_session_id)
-        try:
-            tool_result: message.ToolResultMessage = await run_tool(tool_call, self._registry)
-        finally:
-            current_sub_agent_session_id_recorder.reset(recorder_token)
+        call_context = self._context.with_record_sub_agent_session_id(_record_sub_agent_session_id)
+        tool_result: message.ToolResultMessage = await run_tool(tool_call, self._registry, call_context)
 
         self._append_history([tool_result])
 

klaude_code/core/tool/web/mermaid_tool.py

@@ -8,6 +8,7 @@ from pathlib import Path
 from pydantic import BaseModel, Field
 
 from klaude_code.const import MERMAID_LIVE_PREFIX
+from klaude_code.core.tool.context import ToolContext
 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, message, model, tools
@@ -40,7 +41,8 @@ class MermaidTool(ToolABC):
         )
 
     @classmethod
-    async def call(cls, arguments: str) -> message.ToolResultMessage:
+    async def call(cls, arguments: str, context: ToolContext) -> message.ToolResultMessage:
+        del context
         try:
             args = cls.MermaidArguments.model_validate_json(arguments)
         except Exception as exc:  # pragma: no cover - defensive

klaude_code/core/tool/web/web_fetch_tool.py

@@ -16,6 +16,7 @@ from klaude_code.const import (
     WEB_FETCH_DEFAULT_TIMEOUT_SEC,
     WEB_FETCH_USER_AGENT,
 )
+from klaude_code.core.tool.context import ToolContext
 from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy, ToolMetadata, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, message, tools
@@ -213,7 +214,7 @@ class WebFetchTool(ToolABC):
         url: str
 
     @classmethod
-    async def call(cls, arguments: str) -> message.ToolResultMessage:
+    async def call(cls, arguments: str, context: ToolContext) -> message.ToolResultMessage:
         try:
             args = WebFetchTool.WebFetchArguments.model_validate_json(arguments)
         except ValueError as e:
@@ -221,10 +222,11 @@ class WebFetchTool(ToolABC):
                 status="error",
                 output_text=f"Invalid arguments: {e}",
             )
-        return await cls.call_with_args(args)
+        return await cls.call_with_args(args, context)
 
     @classmethod
-    async def call_with_args(cls, args: WebFetchArguments) -> message.ToolResultMessage:
+    async def call_with_args(cls, args: WebFetchArguments, context: ToolContext) -> message.ToolResultMessage:
+        del context
         url = args.url
 
         # Basic URL validation

klaude_code/core/tool/web/web_search_tool.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from pydantic import BaseModel
 
 from klaude_code.const import WEB_SEARCH_DEFAULT_MAX_RESULTS, WEB_SEARCH_MAX_RESULTS_LIMIT
+from klaude_code.core.tool.context import ToolContext
 from klaude_code.core.tool.tool_abc import ToolABC, ToolConcurrencyPolicy, ToolMetadata, load_desc
 from klaude_code.core.tool.tool_registry import register
 from klaude_code.protocol import llm_param, message, tools
@@ -91,7 +92,7 @@ class WebSearchTool(ToolABC):
         max_results: int = WEB_SEARCH_DEFAULT_MAX_RESULTS
 
     @classmethod
-    async def call(cls, arguments: str) -> message.ToolResultMessage:
+    async def call(cls, arguments: str, context: ToolContext) -> message.ToolResultMessage:
         try:
             args = WebSearchTool.WebSearchArguments.model_validate_json(arguments)
         except ValueError as e:
@@ -99,10 +100,11 @@ class WebSearchTool(ToolABC):
                 status="error",
                 output_text=f"Invalid arguments: {e}",
             )
-        return await cls.call_with_args(args)
+        return await cls.call_with_args(args, context)
 
     @classmethod
-    async def call_with_args(cls, args: WebSearchArguments) -> message.ToolResultMessage:
+    async def call_with_args(cls, args: WebSearchArguments, context: ToolContext) -> message.ToolResultMessage:
+        del context
         query = args.query.strip()
         if not query:
             return message.ToolResultMessage(

klaude_code/core/turn.py

@@ -5,8 +5,8 @@ from dataclasses import dataclass, field
 from typing import TYPE_CHECKING
 
 from klaude_code.const import INTERRUPT_MARKER, SUPPORTED_IMAGE_SIZES
-from klaude_code.core.tool import ToolABC, tool_context
-from klaude_code.core.tool.tool_context import current_sub_agent_resume_claims
+from klaude_code.core.tool import ToolABC
+from klaude_code.core.tool.context import SubAgentResumeClaims, ToolContext
 
 if TYPE_CHECKING:
     from klaude_code.core.task import SessionContext
@@ -20,8 +20,8 @@ from klaude_code.core.tool.tool_runner import (
     ToolExecutorEvent,
 )
 from klaude_code.llm import LLMClientABC
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import events, llm_param, message, model, tools
-from klaude_code.trace import DebugType, log_debug
 
 
 class TurnError(Exception):
@@ -206,6 +206,8 @@ class TurnExecutor:
 
         ctx = self._context
         session_ctx = ctx.session_ctx
+        thinking_active = False
+        assistant_text_active = False
         message_types = (
             message.SystemMessage,
             message.DeveloperMessage,
@@ -247,12 +249,30 @@ class TurnExecutor:
             )
             match delta:
                 case message.ThinkingTextDelta() as delta:
+                    if not thinking_active:
+                        thinking_active = True
+                        yield events.ThinkingStartEvent(
+                            response_id=delta.response_id,
+                            session_id=session_ctx.session_id,
+                        )
                     yield events.ThinkingDeltaEvent(
                         content=delta.content,
                         response_id=delta.response_id,
                         session_id=session_ctx.session_id,
                     )
                 case message.AssistantTextDelta() as delta:
+                    if thinking_active:
+                        thinking_active = False
+                        yield events.ThinkingEndEvent(
+                            response_id=delta.response_id,
+                            session_id=session_ctx.session_id,
+                        )
+                    if not assistant_text_active:
+                        assistant_text_active = True
+                        yield events.AssistantTextStartEvent(
+                            response_id=delta.response_id,
+                            session_id=session_ctx.session_id,
+                        )
                     if delta.response_id:
                         self._assistant_response_id = delta.response_id
                     self._assistant_delta_buffer.append(delta.content)
@@ -262,6 +282,12 @@ class TurnExecutor:
                         session_id=session_ctx.session_id,
                     )
                 case message.AssistantImageDelta() as delta:
+                    if thinking_active:
+                        thinking_active = False
+                        yield events.ThinkingEndEvent(
+                            response_id=delta.response_id,
+                            session_id=session_ctx.session_id,
+                        )
                     yield events.AssistantImageDeltaEvent(
                         file_path=delta.file_path,
                         response_id=delta.response_id,
@@ -270,6 +296,18 @@ class TurnExecutor:
                 case message.AssistantMessage() as msg:
                     if msg.response_id is None and self._assistant_response_id:
                         msg.response_id = self._assistant_response_id
+                    if thinking_active:
+                        thinking_active = False
+                        yield events.ThinkingEndEvent(
+                            response_id=msg.response_id,
+                            session_id=session_ctx.session_id,
+                        )
+                    if assistant_text_active:
+                        assistant_text_active = False
+                        yield events.AssistantTextEndEvent(
+                            response_id=msg.response_id,
+                            session_id=session_ctx.session_id,
+                        )
                     turn_result.assistant_message = msg
                     for part in msg.parts:
                         if isinstance(part, message.ToolCallPart):
@@ -281,11 +319,16 @@ class TurnExecutor:
                                     arguments_json=part.arguments_json,
                                 )
                             )
-                    yield events.AssistantMessageEvent(
-                        content=message.join_text_parts(msg.parts),
-                        response_id=msg.response_id,
-                        session_id=session_ctx.session_id,
-                    )
+                    if msg.stop_reason != "aborted":
+                        thinking_text = "".join(
+                            part.text for part in msg.parts if isinstance(part, message.ThinkingTextPart)
+                        )
+                        yield events.ResponseCompleteEvent(
+                            content=message.join_text_parts(msg.parts),
+                            response_id=msg.response_id,
+                            session_id=session_ctx.session_id,
+                            thinking_text=thinking_text or None,
+                        )
                     if msg.stop_reason == "aborted":
                         yield events.InterruptEvent(session_id=session_ctx.session_id)
                     if msg.usage:
@@ -296,9 +339,9 @@ class TurnExecutor:
                             metadata.model_name = ctx.llm_client.model_name
                         if metadata.provider is None:
                             metadata.provider = ctx.llm_client.get_llm_config().provider_name or None
-                        yield events.ResponseMetadataEvent(
+                        yield events.UsageEvent(
                             session_id=session_ctx.session_id,
-                            metadata=metadata,
+                            usage=metadata,
                         )
                 case message.StreamErrorItem() as msg:
                     turn_result.stream_error = msg
@@ -309,12 +352,23 @@ class TurnExecutor:
                         debug_type=DebugType.RESPONSE,
                     )
                 case message.ToolCallStartItem() as msg:
-                    yield events.TurnToolCallStartEvent(
+                    if thinking_active:
+                        thinking_active = False
+                        yield events.ThinkingEndEvent(
+                            response_id=msg.response_id,
+                            session_id=session_ctx.session_id,
+                        )
+                    if assistant_text_active:
+                        assistant_text_active = False
+                        yield events.AssistantTextEndEvent(
+                            response_id=msg.response_id,
+                            session_id=session_ctx.session_id,
+                        )
+                    yield events.ToolCallStartEvent(
                         session_id=session_ctx.session_id,
                         response_id=msg.response_id,
                         tool_call_id=msg.call_id,
                         tool_name=msg.name,
-                        arguments="",
                     )
                 case _:
                     continue
@@ -332,20 +386,26 @@ class TurnExecutor:
 
         ctx = self._context
         session_ctx = ctx.session_ctx
-        with tool_context(session_ctx.file_tracker, session_ctx.todo_context):
-            resume_claims_token = current_sub_agent_resume_claims.set(set())
-            executor = ToolExecutor(
-                registry=ctx.tool_registry,
-                append_history=session_ctx.append_history,
-            )
-            self._tool_executor = executor
-            try:
-                async for exec_event in executor.run_tools(tool_calls):
-                    for ui_event in build_events_from_tool_executor_event(session_ctx.session_id, exec_event):
-                        yield ui_event
-            finally:
-                self._tool_executor = None
-                current_sub_agent_resume_claims.reset(resume_claims_token)
+        tool_context = ToolContext(
+            file_tracker=session_ctx.file_tracker,
+            todo_context=session_ctx.todo_context,
+            session_id=session_ctx.session_id,
+            run_subtask=session_ctx.run_subtask,
+            sub_agent_resume_claims=SubAgentResumeClaims(),
+        )
+
+        executor = ToolExecutor(
+            context=tool_context,
+            registry=ctx.tool_registry,
+            append_history=session_ctx.append_history,
+        )
+        self._tool_executor = executor
+        try:
+            async for exec_event in executor.run_tools(tool_calls):
+                for ui_event in build_events_from_tool_executor_event(session_ctx.session_id, exec_event):
+                    yield ui_event
+        finally:
+            self._tool_executor = None
 
     def _persist_partial_assistant_on_cancel(self) -> None:
         """Persist streamed assistant text when a turn is interrupted.

klaude_code/llm/anthropic/client.py

@@ -34,8 +34,8 @@ from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message, model
-from klaude_code.trace import DebugType, log_debug
 
 
 def _map_anthropic_stop_reason(reason: str) -> model.StopReason | None:

klaude_code/llm/bedrock/client.py

@@ -14,8 +14,8 @@ from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message
-from klaude_code.trace import DebugType, log_debug
 
 
 @register(llm_param.LLMClientProtocol.BEDROCK)

klaude_code/llm/claude/client.py

@@ -22,8 +22,8 @@ from klaude_code.llm.client import LLMClientABC
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message
-from klaude_code.trace import DebugType, log_debug
 
 _CLAUDE_OAUTH_REQUIRED_BETAS: tuple[str, ...] = (
     ANTHROPIC_BETA_OAUTH,

klaude_code/llm/codex/client.py

@@ -25,8 +25,8 @@ from klaude_code.llm.registry import register
 from klaude_code.llm.responses.client import parse_responses_stream
 from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message
-from klaude_code.trace import DebugType, log_debug
 
 
 def build_payload(param: llm_param.LLMCallParameter) -> ResponseCreateParamsStreaming:

klaude_code/llm/google/client.py

@@ -26,8 +26,8 @@ from klaude_code.llm.google.input import convert_history_to_contents, convert_to
 from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message, model
-from klaude_code.trace import DebugType, log_debug
 
 
 def _build_config(param: llm_param.LLMCallParameter) -> GenerateContentConfig:

klaude_code/llm/openai_compatible/client.py

@@ -13,8 +13,8 @@ from klaude_code.llm.openai_compatible.input import convert_history_to_input, co
 from klaude_code.llm.openai_compatible.stream import DefaultReasoningHandler, parse_chat_completions_stream
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message
-from klaude_code.trace import DebugType, log_debug
 
 
 def build_payload(param: llm_param.LLMCallParameter) -> tuple[CompletionCreateParamsStreaming, dict[str, object]]:

klaude_code/llm/openai_compatible/tool_call_accumulator.py

@@ -4,8 +4,8 @@ from abc import ABC, abstractmethod
 from openai.types.chat.chat_completion_chunk import ChoiceDeltaToolCall
 from pydantic import BaseModel, Field
 
+from klaude_code.log import log_debug
 from klaude_code.protocol import message
-from klaude_code.trace.log import log_debug
 
 
 def normalize_tool_name(name: str) -> str:

klaude_code/llm/openrouter/client.py

@@ -22,8 +22,8 @@ from klaude_code.llm.openrouter.input import convert_history_to_input, is_claude
 from klaude_code.llm.openrouter.reasoning import ReasoningStreamHandler
 from klaude_code.llm.registry import register
 from klaude_code.llm.usage import MetadataTracker
+from klaude_code.log import DebugType, is_debug_enabled, log_debug
 from klaude_code.protocol import llm_param, message
-from klaude_code.trace import DebugType, is_debug_enabled, log_debug
 
 
 def build_payload(

klaude_code/llm/openrouter/reasoning.py

@@ -1,8 +1,8 @@
 from pydantic import BaseModel
 
 from klaude_code.llm.openai_compatible.stream import ReasoningDeltaResult, ReasoningHandlerABC
+from klaude_code.log import log
 from klaude_code.protocol import message
-from klaude_code.trace import log
 
 
 class ReasoningDetail(BaseModel):

klaude_code/llm/responses/client.py

@@ -14,8 +14,8 @@ from klaude_code.llm.input_common import apply_config_defaults
 from klaude_code.llm.registry import register
 from klaude_code.llm.responses.input import convert_history_to_input, convert_tool_schema
 from klaude_code.llm.usage import MetadataTracker, error_stream_items
+from klaude_code.log import DebugType, log_debug
 from klaude_code.protocol import llm_param, message, model
-from klaude_code.trace import DebugType, log_debug
 
 if TYPE_CHECKING:
     from openai import AsyncStream

klaude_code/protocol/events/__init__.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from klaude_code.protocol.events.base import Event, ResponseEvent
+from klaude_code.protocol.events.chat import DeveloperMessageEvent, TodoChangeEvent, UserMessageEvent
+from klaude_code.protocol.events.lifecycle import TaskFinishEvent, TaskStartEvent, TurnEndEvent, TurnStartEvent
+from klaude_code.protocol.events.metadata import TaskMetadataEvent, UsageEvent
+from klaude_code.protocol.events.streaming import (
+    AssistantImageDeltaEvent,
+    AssistantTextDeltaEvent,
+    AssistantTextEndEvent,
+    AssistantTextStartEvent,
+    ResponseCompleteEvent,
+    ThinkingDeltaEvent,
+    ThinkingEndEvent,
+    ThinkingStartEvent,
+    ToolCallStartEvent,
+)
+from klaude_code.protocol.events.system import (
+    EndEvent,
+    ErrorEvent,
+    InterruptEvent,
+    ReplayEventUnion,
+    ReplayHistoryEvent,
+    WelcomeEvent,
+)
+from klaude_code.protocol.events.tools import ToolCallEvent, ToolResultEvent
+
+__all__ = [
+    "AssistantImageDeltaEvent",
+    "AssistantTextDeltaEvent",
+    "AssistantTextEndEvent",
+    "AssistantTextStartEvent",
+    "DeveloperMessageEvent",
+    "EndEvent",
+    "ErrorEvent",
+    "Event",
+    "InterruptEvent",
+    "ReplayEventUnion",
+    "ReplayHistoryEvent",
+    "ResponseCompleteEvent",
+    "ResponseEvent",
+    "TaskFinishEvent",
+    "TaskMetadataEvent",
+    "TaskStartEvent",
+    "ThinkingDeltaEvent",
+    "ThinkingEndEvent",
+    "ThinkingStartEvent",
+    "TodoChangeEvent",
+    "ToolCallEvent",
+    "ToolCallStartEvent",
+    "ToolResultEvent",
+    "TurnEndEvent",
+    "TurnStartEvent",
+    "UsageEvent",
+    "UserMessageEvent",
+    "WelcomeEvent",
+]

klaude_code/protocol/events/base.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import time
+
+from pydantic import BaseModel, Field
+
+
+class Event(BaseModel):
+    """Base event."""
+
+    session_id: str
+    timestamp: float = Field(default_factory=time.time)
+
+
+class ResponseEvent(Event):
+    """Event associated with a single model response."""
+
+    response_id: str | None = None

klaude_code/protocol/events/chat.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from klaude_code.protocol import message, model
+
+from .base import Event
+
+
+class UserMessageEvent(Event):
+    content: str
+    images: list[message.ImageURLPart] | None = None
+
+
+class DeveloperMessageEvent(Event):
+    """DeveloperMessages are reminders in user messages or tool results."""
+
+    item: message.DeveloperMessage
+
+
+class TodoChangeEvent(Event):
+    todos: list[model.TodoItem]