klaude-code 1.2.6__py3-none-any.whl → 1.8.0__py3-none-any.whl

klaude_code/protocol/llm_param.py

@@ -12,6 +12,9 @@ class LLMClientProtocol(Enum):
     RESPONSES = "responses"
     OPENROUTER = "openrouter"
     ANTHROPIC = "anthropic"
+    BEDROCK = "bedrock"
+    CODEX = "codex"
+    GOOGLE = "google"
 
 
 class ToolSchema(BaseModel):
@@ -27,7 +30,7 @@ class Thinking(BaseModel):
     """
 
     # OpenAI Reasoning Style
-    reasoning_effort: Literal["high", "medium", "low", "minimal", "none"] | None = None
+    reasoning_effort: Literal["high", "medium", "low", "minimal", "none", "xhigh"] | None = None
     reasoning_summary: Literal["auto", "concise", "detailed"] | None = None
 
     # Claude/Gemini Thinking Style
@@ -36,12 +39,13 @@ class Thinking(BaseModel):
 
 
 class Cost(BaseModel):
-    """Cost configuration per million tokens (USD)."""
+    """Cost configuration per million tokens."""
 
     input: float  # Input token price per million tokens
     output: float  # Output token price per million tokens
     cache_read: float = 0.0  # Cache read price per million tokens
     cache_write: float = 0.0  # Cache write price per million tokens (ignored in calculation for now)
+    currency: Literal["USD", "CNY"] = "USD"  # Currency for cost display
 
 
 class OpenRouterProviderRouting(BaseModel):
@@ -89,8 +93,15 @@ class LLMConfigProviderParameter(BaseModel):
     protocol: LLMClientProtocol
     base_url: str | None = None
     api_key: str | None = None
+    # Azure OpenAI
     is_azure: bool = False
     azure_api_version: str | None = None
+    # AWS Bedrock configuration
+    aws_access_key: str | None = None
+    aws_secret_key: str | None = None
+    aws_region: str | None = None
+    aws_session_token: str | None = None
+    aws_profile: str | None = None
 
 
 class LLMConfigModelParameter(BaseModel):
@@ -136,12 +147,4 @@ class LLMCallParameter(LLMConfigModelParameter):
     input: list[ConversationItem]
     system: str | None = None
     tools: list[ToolSchema] | None = None
-
-    stream: Literal[True] = True  # Always True
-
-    # OpenAI Responses
-    include: list[str] | None = None
-    store: bool = True
-    previous_response_id: str | None = None
-
     session_id: str | None = None

klaude_code/protocol/model.py

@@ -1,9 +1,10 @@
 from datetime import datetime
 from enum import Enum
-from typing import Literal
+from typing import Annotated, Any, Literal
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field, computed_field
 
+from klaude_code import const
 from klaude_code.protocol.commands import CommandName
 from klaude_code.protocol.tools import SubAgentType
 
@@ -12,26 +13,73 @@ TodoStatusType = Literal["pending", "in_progress", "completed"]
 
 
 class Usage(BaseModel):
+    # Token Usage (primary state)
     input_tokens: int = 0
     cached_tokens: int = 0
     reasoning_tokens: int = 0
     output_tokens: int = 0
-    total_tokens: int = 0
-    context_usage_percent: float | None = None
+
+    # Context window tracking
+    context_size: int | None = None  # Peak total_tokens seen (for context usage display)
+    context_limit: int | None = None  # Model's context limit
+    max_tokens: int | None = None  # Max output tokens for this request
+
     throughput_tps: float | None = None
     first_token_latency_ms: float | None = None
 
-    # Cost in USD (calculated from token counts and cost config)
+    # Cost (calculated from token counts and cost config)
     input_cost: float | None = None  # Cost for non-cached input tokens
     output_cost: float | None = None  # Cost for output tokens (including reasoning)
     cache_read_cost: float | None = None  # Cost for cached tokens
-    total_cost: float | None = None  # Total cost (input + output + cache_read)
+    currency: str = "USD"  # Currency for cost display (USD or CNY)
+
+    @computed_field
+    @property
+    def total_tokens(self) -> int:
+        """Total tokens computed from input + output tokens."""
+        return self.input_tokens + self.output_tokens
+
+    @computed_field
+    @property
+    def total_cost(self) -> float | None:
+        """Total cost computed from input + output + cache_read costs."""
+        costs = [self.input_cost, self.output_cost, self.cache_read_cost]
+        non_none = [c for c in costs if c is not None]
+        return sum(non_none) if non_none else None
+
+    @computed_field
+    @property
+    def context_usage_percent(self) -> float | None:
+        """Context usage percentage computed from context_token / (context_limit - max_tokens)."""
+        if self.context_limit is None or self.context_limit <= 0:
+            return None
+        if self.context_size is None:
+            return None
+        effective_limit = self.context_limit - (self.max_tokens or const.DEFAULT_MAX_TOKENS)
+        if effective_limit <= 0:
+            return None
+        return (self.context_size / effective_limit) * 100
 
 
 class TodoItem(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
     content: str
     status: TodoStatusType
-    activeForm: str = ""
+    active_form: str = Field(default="", alias="activeForm")
+
+
+class FileStatus(BaseModel):
+    """Tracks file state including modification time and content hash.
+
+    Notes:
+    - `mtime` is a cheap heuristic and may miss changes on some filesystems.
+    - `content_sha256` provides an explicit content-based change detector.
+    """
+
+    mtime: float
+    content_sha256: str | None = None
+    is_memory: bool = False
 
 
 class TodoUIExtra(BaseModel):
@@ -39,43 +87,104 @@ class TodoUIExtra(BaseModel):
     new_completed: list[str]
 
 
-class ToolResultUIExtraType(str, Enum):
-    DIFF_TEXT = "diff_text"
-    TODO_LIST = "todo_list"
-    SESSION_ID = "session_id"
-    MERMAID_LINK = "mermaid_link"
-    TRUNCATION = "truncation"
-    SESSION_STATUS = "session_status"
-
-
 class ToolSideEffect(str, Enum):
     TODO_CHANGE = "todo_change"
 
 
+# Discriminated union types for ToolResultUIExtra
+class DiffSpan(BaseModel):
+    op: Literal["equal", "insert", "delete"]
+    text: str
+
+
+class DiffLine(BaseModel):
+    kind: Literal["ctx", "add", "remove", "gap"]
+    new_line_no: int | None = None
+    spans: list[DiffSpan]
+
+
+class DiffFileDiff(BaseModel):
+    file_path: str
+    lines: list[DiffLine]
+    stats_add: int = 0
+    stats_remove: int = 0
+
+
+class DiffUIExtra(BaseModel):
+    type: Literal["diff"] = "diff"
+    files: list[DiffFileDiff]
+
+
+class TodoListUIExtra(BaseModel):
+    type: Literal["todo_list"] = "todo_list"
+    todo_list: TodoUIExtra
+
+
+class SessionIdUIExtra(BaseModel):
+    type: Literal["session_id"] = "session_id"
+    session_id: str
+
+
 class MermaidLinkUIExtra(BaseModel):
+    type: Literal["mermaid_link"] = "mermaid_link"
+    code: str = ""
     link: str
     line_count: int
 
 
 class TruncationUIExtra(BaseModel):
+    type: Literal["truncation"] = "truncation"
     saved_file_path: str
     original_length: int
     truncated_length: int
 
 
+class MarkdownDocUIExtra(BaseModel):
+    type: Literal["markdown_doc"] = "markdown_doc"
+    file_path: str
+    content: str
+
+
 class SessionStatusUIExtra(BaseModel):
+    type: Literal["session_status"] = "session_status"
     usage: "Usage"
     task_count: int
+    by_model: list["TaskMetadata"] = []
+
+
+MultiUIExtraItem = (
+    DiffUIExtra
+    | TodoListUIExtra
+    | SessionIdUIExtra
+    | MermaidLinkUIExtra
+    | TruncationUIExtra
+    | MarkdownDocUIExtra
+    | SessionStatusUIExtra
+)
+
 
+class MultiUIExtra(BaseModel):
+    """A container UIExtra that can render multiple UI blocks for a single tool result.
+
+    This is primarily used by tools like apply_patch which can perform multiple
+    operations in one invocation.
+    """
+
+    type: Literal["multi"] = "multi"
+    items: list[MultiUIExtraItem]
 
-class ToolResultUIExtra(BaseModel):
-    type: ToolResultUIExtraType
-    diff_text: str | None = None
-    todo_list: TodoUIExtra | None = None
-    session_id: str | None = None
-    mermaid_link: MermaidLinkUIExtra | None = None
-    truncation: TruncationUIExtra | None = None
-    session_status: SessionStatusUIExtra | None = None
+
+ToolResultUIExtra = Annotated[
+    DiffUIExtra
+    | TodoListUIExtra
+    | SessionIdUIExtra
+    | MermaidLinkUIExtra
+    | TruncationUIExtra
+    | MarkdownDocUIExtra
+    | SessionStatusUIExtra
+    | MultiUIExtra,
+    Field(discriminator="type"),
+]
 
 
 class AtPatternParseResult(BaseModel):
@@ -85,6 +194,7 @@ class AtPatternParseResult(BaseModel):
     tool_args: str
     operation: Literal["Read", "List"]
     images: list["ImageURLPart"] | None = None
+    mentioned_in: str | None = None  # Parent file that referenced this file
 
 
 class CommandOutput(BaseModel):
@@ -97,6 +207,7 @@ class SubAgentState(BaseModel):
     sub_agent_type: SubAgentType
     sub_agent_desc: str
     sub_agent_prompt: str
+    output_schema: dict[str, Any] | None = None
 
 
 """
@@ -121,7 +232,7 @@ A conversation history input contains:
 - [DeveloperMessageItem]
 
 When adding a new item, please also modify the following:
-- session.py#_TypeMap
+- session/codec.py (ConversationItem registry derived from ConversationItem union)
 """
 
 
@@ -150,11 +261,13 @@ class DeveloperMessageItem(BaseModel):
 
     # Special fields for reminders UI
     memory_paths: list[str] | None = None
+    memory_mentioned: dict[str, list[str]] | None = None  # memory_path -> list of @ patterns mentioned in it
     external_file_changes: list[str] | None = None
     todo_use: bool | None = None
     at_files: list[AtPatternParseResult] | None = None
     command_output: CommandOutput | None = None
     user_image_count: int | None = None
+    skill_name: str | None = None  # Skill name activated via $skill syntax
 
 
 class ImageURLPart(BaseModel):
@@ -239,6 +352,7 @@ class ToolResultItem(BaseModel):
     ui_extra: ToolResultUIExtra | None = None  # Extra data for UI display, e.g. diff render
     images: list[ImageURLPart] | None = None
     side_effects: list[ToolSideEffect] | None = None
+    task_metadata: "TaskMetadata | None" = None  # Sub-agent task metadata for propagation to main agent
     created_at: datetime = Field(default_factory=datetime.now)
 
 
@@ -248,19 +362,101 @@ class AssistantMessageDelta(BaseModel):
     created_at: datetime = Field(default_factory=datetime.now)
 
 
+class ReasoningTextDelta(BaseModel):
+    response_id: str | None = None
+    content: str
+    created_at: datetime = Field(default_factory=datetime.now)
+
+
 class StreamErrorItem(BaseModel):
     error: str
     created_at: datetime = Field(default_factory=datetime.now)
 
 
 class ResponseMetadataItem(BaseModel):
+    """Metadata for a single LLM response (turn-level)."""
+
     response_id: str | None = None
     usage: Usage | None = None
     model_name: str = ""
     provider: str | None = None  # OpenRouter's provider name
     task_duration_s: float | None = None
-    status: str | None = None
-    error_reason: str | None = None
+    created_at: datetime = Field(default_factory=datetime.now)
+
+
+class TaskMetadata(BaseModel):
+    """Base metadata for a task execution (used by both main and sub-agents)."""
+
+    usage: Usage | None = None
+    model_name: str = ""
+    provider: str | None = None
+    task_duration_s: float | None = None
+    turn_count: int = 0
+
+    @staticmethod
+    def merge_usage(dst: Usage, src: Usage) -> None:
+        """Merge src usage into dst usage (in-place).
+
+        Accumulates token counts and cost components. Does not handle
+        special fields like throughput_tps, first_token_latency_ms,
+        context_size, or context_limit - those require custom logic.
+        """
+        dst.input_tokens += src.input_tokens
+        dst.cached_tokens += src.cached_tokens
+        dst.reasoning_tokens += src.reasoning_tokens
+        dst.output_tokens += src.output_tokens
+
+        if src.input_cost is not None:
+            dst.input_cost = (dst.input_cost or 0.0) + src.input_cost
+        if src.output_cost is not None:
+            dst.output_cost = (dst.output_cost or 0.0) + src.output_cost
+        if src.cache_read_cost is not None:
+            dst.cache_read_cost = (dst.cache_read_cost or 0.0) + src.cache_read_cost
+
+    @staticmethod
+    def aggregate_by_model(metadata_list: list["TaskMetadata"]) -> list["TaskMetadata"]:
+        """Aggregate multiple TaskMetadata by (model_name, provider).
+
+        Returns a list sorted by total_cost descending.
+
+        Note: total_tokens and total_cost are now computed fields,
+        so we only accumulate the primary state fields here.
+        """
+        aggregated: dict[tuple[str, str | None], TaskMetadata] = {}
+
+        for meta in metadata_list:
+            if not meta.usage:
+                continue
+
+            key = (meta.model_name, meta.provider)
+            usage = meta.usage
+
+            if key not in aggregated:
+                aggregated[key] = TaskMetadata(
+                    model_name=meta.model_name,
+                    provider=meta.provider,
+                    usage=Usage(currency=usage.currency),
+                )
+
+            agg = aggregated[key]
+            if agg.usage is None:
+                continue
+
+            TaskMetadata.merge_usage(agg.usage, usage)
+
+        # Sort by total_cost descending
+        return sorted(
+            aggregated.values(),
+            key=lambda m: m.usage.total_cost if m.usage and m.usage.total_cost else 0.0,
+            reverse=True,
+        )
+
+
+class TaskMetadataItem(BaseModel):
+    """Aggregated metadata for a complete task, stored in conversation history."""
+
+    main_agent: TaskMetadata = Field(default_factory=TaskMetadata)  # Main agent metadata
+    sub_agent_task_metadata: list[TaskMetadata] = Field(default_factory=lambda: list[TaskMetadata]())
     created_at: datetime = Field(default_factory=datetime.now)
 
 
@@ -276,10 +472,17 @@ MessageItem = (
 )
 
 
-StreamItem = AssistantMessageDelta
+StreamItem = AssistantMessageDelta | ReasoningTextDelta
 
 ConversationItem = (
-    StartItem | InterruptItem | StreamErrorItem | StreamItem | MessageItem | ResponseMetadataItem | ToolCallStartItem
+    StartItem
+    | InterruptItem
+    | StreamErrorItem
+    | StreamItem
+    | MessageItem
+    | ResponseMetadataItem
+    | TaskMetadataItem
+    | ToolCallStartItem
 )
 
 

klaude_code/protocol/op.py

@@ -13,6 +13,7 @@ from uuid import uuid4
 
 from pydantic import BaseModel, Field
 
+from klaude_code.protocol.llm_param import Thinking
 from klaude_code.protocol.model import UserInputPayload
 
 if TYPE_CHECKING:
@@ -23,6 +24,12 @@ class OperationType(Enum):
     """Enumeration of supported operation types."""
 
     USER_INPUT = "user_input"
+    RUN_AGENT = "run_agent"
+    CHANGE_MODEL = "change_model"
+    CHANGE_THINKING = "change_thinking"
+    CLEAR_SESSION = "clear_session"
+    RESUME_SESSION = "resume_session"
+    EXPORT_SESSION = "export_session"
     INTERRUPT = "interrupt"
     INIT_AGENT = "init_agent"
     END = "end"
@@ -51,6 +58,84 @@ 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
+    save_as_default: bool = False
+    # When True, the executor must not auto-trigger an interactive thinking selector.
+    # This is required for in-prompt model switching where the terminal is already
+    # controlled by a prompt_toolkit PromptSession.
+    defer_thinking_selection: bool = False
+    # When False, do not emit WelcomeEvent (which renders a banner/panel).
+    # This is useful for in-prompt model switching where extra output is noisy.
+    emit_welcome_event: bool = True
+
+    # When False, do not emit the "Switched to: ..." developer message.
+    # This is useful for in-prompt model switching where extra output is noisy.
+    emit_switch_message: bool = True
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_change_model(self)
+
+
+class ChangeThinkingOperation(Operation):
+    """Operation for changing the thinking/reasoning configuration."""
+
+    type: OperationType = OperationType.CHANGE_THINKING
+    session_id: str
+    thinking: Thinking | None = None
+    emit_welcome_event: bool = True
+    emit_switch_message: bool = True
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_change_thinking(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 ResumeSessionOperation(Operation):
+    """Operation for resuming a different session."""
+
+    type: OperationType = OperationType.RESUME_SESSION
+    target_session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_resume_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."""
 
@@ -63,7 +148,11 @@ class InterruptOperation(Operation):
 
 
 class InitAgentOperation(Operation):
-    """Operation for initializing an agent and replaying history if any."""
+    """Operation for initializing an agent and replaying history if any.
+
+    If session_id is None, a new session is created with an auto-generated ID.
+    If session_id is provided, attempts to load existing session or creates new one.
+    """
 
     type: OperationType = OperationType.INIT_AGENT
     session_id: str | None = None

klaude_code/protocol/op_handler.py

@@ -9,7 +9,17 @@ 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,
+        ChangeThinkingOperation,
+        ClearSessionOperation,
+        ExportSessionOperation,
+        InitAgentOperation,
+        InterruptOperation,
+        ResumeSessionOperation,
+        RunAgentOperation,
+        UserInputOperation,
+    )
 
 
 class OperationHandler(Protocol):
@@ -19,6 +29,30 @@ 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_change_thinking(self, operation: ChangeThinkingOperation) -> None:
+        """Handle a change thinking operation."""
+        ...
+
+    async def handle_clear_session(self, operation: ClearSessionOperation) -> None:
+        """Handle a clear session operation."""
+        ...
+
+    async def handle_resume_session(self, operation: ResumeSessionOperation) -> None:
+        """Handle a resume 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."""
         ...