klaude-code 2.6.0__py3-none-any.whl → 2.8.0__py3-none-any.whl

klaude_code/llm/antigravity/input.py

@@ -0,0 +1,261 @@
+"""Message conversion utilities for Antigravity Cloud Code Assist API."""
+
+import json
+from base64 import b64decode
+from binascii import Error as BinasciiError
+from typing import Any, TypedDict
+
+from klaude_code.const import EMPTY_TOOL_OUTPUT_MESSAGE
+from klaude_code.llm.image import assistant_image_to_data_url, parse_data_url
+from klaude_code.llm.input_common import (
+    DeveloperAttachment,
+    attach_developer_messages,
+    merge_reminder_text,
+    split_thinking_parts,
+)
+from klaude_code.protocol import llm_param, message
+
+
+class InlineData(TypedDict, total=False):
+    mimeType: str
+    data: str
+
+
+class FunctionCall(TypedDict, total=False):
+    id: str
+    name: str
+    args: dict[str, Any]
+
+
+class FunctionResponse(TypedDict, total=False):
+    id: str
+    name: str
+    response: dict[str, Any]
+    parts: list[dict[str, Any]]
+
+
+class Part(TypedDict, total=False):
+    text: str
+    thought: bool
+    thoughtSignature: str
+    inlineData: InlineData
+    functionCall: FunctionCall
+    functionResponse: FunctionResponse
+
+
+class Content(TypedDict):
+    role: str
+    parts: list[Part]
+
+
+class FunctionDeclaration(TypedDict, total=False):
+    name: str
+    description: str
+    parameters: dict[str, Any]
+
+
+class Tool(TypedDict):
+    functionDeclarations: list[FunctionDeclaration]
+
+
+def _data_url_to_inline_data(url: str) -> InlineData:
+    """Convert data URL to inline_data dict."""
+    media_type, _, decoded = parse_data_url(url)
+    import base64
+
+    return InlineData(mimeType=media_type, data=base64.b64encode(decoded).decode("ascii"))
+
+
+def _image_part_to_part(image: message.ImageURLPart) -> Part:
+    """Convert ImageURLPart to Part dict."""
+    url = image.url
+    if url.startswith("data:"):
+        return Part(inlineData=_data_url_to_inline_data(url))
+    # For non-data URLs, best-effort using inline_data format
+    return Part(text=f"[Image: {url}]")
+
+
+def _user_message_to_content(msg: message.UserMessage, attachment: DeveloperAttachment) -> Content:
+    """Convert UserMessage to Content dict."""
+    parts: list[Part] = []
+    for part in msg.parts:
+        if isinstance(part, message.TextPart):
+            parts.append(Part(text=part.text))
+        elif isinstance(part, message.ImageURLPart):
+            parts.append(_image_part_to_part(part))
+    if attachment.text:
+        parts.append(Part(text=attachment.text))
+    for image in attachment.images:
+        parts.append(_image_part_to_part(image))
+    if not parts:
+        parts.append(Part(text=""))
+    return Content(role="user", parts=parts)
+
+
+def _tool_messages_to_contents(
+    msgs: list[tuple[message.ToolResultMessage, DeveloperAttachment]], model_name: str | None
+) -> list[Content]:
+    """Convert tool result messages to Content dicts."""
+    supports_multimodal_function_response = bool(model_name and "gemini-3" in model_name.lower())
+
+    response_parts: list[Part] = []
+    extra_image_contents: list[Content] = []
+
+    for msg, attachment in msgs:
+        merged_text = merge_reminder_text(
+            msg.output_text or EMPTY_TOOL_OUTPUT_MESSAGE,
+            attachment.text,
+        )
+        has_text = merged_text.strip() != ""
+
+        images = [part for part in msg.parts if isinstance(part, message.ImageURLPart)] + attachment.images
+        image_parts: list[Part] = []
+        function_response_parts: list[dict[str, Any]] = []
+
+        for image in images:
+            try:
+                image_parts.append(_image_part_to_part(image))
+                if image.url.startswith("data:"):
+                    inline_data = _data_url_to_inline_data(image.url)
+                    function_response_parts.append({"inlineData": inline_data})
+            except ValueError:
+                continue
+
+        has_images = len(image_parts) > 0
+        response_value = merged_text if has_text else "(see attached image)" if has_images else ""
+        response_payload = {"error": response_value} if msg.status != "success" else {"output": response_value}
+
+        function_response = FunctionResponse(
+            id=msg.call_id,
+            name=msg.tool_name,
+            response=response_payload,
+        )
+        if has_images and supports_multimodal_function_response:
+            function_response["parts"] = function_response_parts
+
+        response_parts.append(Part(functionResponse=function_response))
+
+        if has_images and not supports_multimodal_function_response:
+            extra_image_contents.append(Content(role="user", parts=[Part(text="Tool result image:"), *image_parts]))
+
+    contents: list[Content] = []
+    if response_parts:
+        contents.append(Content(role="user", parts=response_parts))
+    contents.extend(extra_image_contents)
+    return contents
+
+
+def _decode_thought_signature(sig: str | None) -> str | None:
+    """Validate base64 thought signature."""
+    if not sig:
+        return None
+    try:
+        b64decode(sig)
+        return sig
+    except (BinasciiError, ValueError):
+        return None
+
+
+def _assistant_message_to_content(msg: message.AssistantMessage, model_name: str | None) -> Content | None:
+    """Convert AssistantMessage to Content dict."""
+    parts: list[Part] = []
+    native_thinking_parts, degraded_thinking_texts = split_thinking_parts(msg, model_name)
+    native_thinking_ids = {id(part) for part in native_thinking_parts}
+
+    for part in msg.parts:
+        if isinstance(part, message.ThinkingTextPart):
+            if id(part) not in native_thinking_ids:
+                continue
+            parts.append(Part(text=part.text, thought=True))
+
+        elif isinstance(part, message.ThinkingSignaturePart):
+            if id(part) not in native_thinking_ids:
+                continue
+            if not part.signature or part.format != "google":
+                continue
+            # Attach signature to the previous part
+            if parts:
+                sig = _decode_thought_signature(part.signature)
+                if sig:
+                    parts[-1]["thoughtSignature"] = sig
+
+        elif isinstance(part, message.TextPart):
+            # Skip empty text blocks
+            if not part.text or part.text.strip() == "":
+                continue
+            parts.append(Part(text=part.text))
+
+        elif isinstance(part, message.ToolCallPart):
+            args: dict[str, Any]
+            if part.arguments_json:
+                try:
+                    args = json.loads(part.arguments_json)
+                except json.JSONDecodeError:
+                    args = {"_raw": part.arguments_json}
+            else:
+                args = {}
+            parts.append(Part(functionCall=FunctionCall(id=part.call_id, name=part.tool_name, args=args)))
+
+        elif isinstance(part, message.ImageFilePart):
+            try:
+                data_url = assistant_image_to_data_url(part)
+                parts.append(_image_part_to_part(message.ImageURLPart(url=data_url)))
+            except (ValueError, FileNotFoundError):
+                pass
+
+    if degraded_thinking_texts:
+        parts.insert(0, Part(text="<thinking>\n" + "\n".join(degraded_thinking_texts) + "\n</thinking>"))
+
+    if not parts:
+        return None
+    return Content(role="model", parts=parts)
+
+
+def convert_history_to_contents(
+    history: list[message.Message],
+    model_name: str | None,
+) -> list[Content]:
+    """Convert message history to Cloud Code Assist Content format."""
+    contents: list[Content] = []
+    pending_tool_messages: list[tuple[message.ToolResultMessage, DeveloperAttachment]] = []
+
+    def flush_tool_messages() -> None:
+        nonlocal pending_tool_messages
+        if pending_tool_messages:
+            contents.extend(_tool_messages_to_contents(pending_tool_messages, model_name=model_name))
+            pending_tool_messages = []
+
+    for msg, attachment in attach_developer_messages(history):
+        match msg:
+            case message.ToolResultMessage():
+                pending_tool_messages.append((msg, attachment))
+            case message.UserMessage():
+                flush_tool_messages()
+                contents.append(_user_message_to_content(msg, attachment))
+            case message.AssistantMessage():
+                flush_tool_messages()
+                content = _assistant_message_to_content(msg, model_name=model_name)
+                if content is not None:
+                    contents.append(content)
+            case message.SystemMessage():
+                continue
+            case _:
+                continue
+
+    flush_tool_messages()
+    return contents
+
+
+def convert_tool_schema(tools: list[llm_param.ToolSchema] | None) -> list[Tool] | None:
+    """Convert tool schemas to Cloud Code Assist Tool format."""
+    if tools is None or len(tools) == 0:
+        return None
+    declarations = [
+        FunctionDeclaration(
+            name=tool.name,
+            description=tool.description,
+            parameters=dict(tool.parameters) if tool.parameters else {},
+        )
+        for tool in tools
+    ]
+    return [Tool(functionDeclarations=declarations)]

klaude_code/llm/registry.py

@@ -21,6 +21,7 @@ _PROTOCOL_MODULES: dict[llm_param.LLMClientProtocol, str] = {
     llm_param.LLMClientProtocol.OPENROUTER: "klaude_code.llm.openrouter",
     llm_param.LLMClientProtocol.RESPONSES: "klaude_code.llm.responses",
     llm_param.LLMClientProtocol.GOOGLE: "klaude_code.llm.google",
+    llm_param.LLMClientProtocol.ANTIGRAVITY: "klaude_code.llm.antigravity",
 }
 
 

klaude_code/protocol/commands.py

@@ -20,7 +20,6 @@ class CommandName(str, Enum):
     COMPACT = "compact"
     REFRESH_TERMINAL = "refresh-terminal"
     CLEAR = "clear"
-    TERMINAL_SETUP = "terminal-setup"
     EXPORT = "export"
     EXPORT_ONLINE = "export-online"
     STATUS = "status"

klaude_code/protocol/events.py

@@ -14,6 +14,8 @@ __all__ = [
     "AssistantTextEndEvent",
     "AssistantTextStartEvent",
     "CommandOutputEvent",
+    "CompactionEndEvent",
+    "CompactionStartEvent",
     "DeveloperMessageEvent",
     "EndEvent",
     "ErrorEvent",
@@ -83,6 +85,20 @@ class TaskStartEvent(Event):
     model_id: str | None = None
 
 
+class CompactionStartEvent(Event):
+    reason: Literal["threshold", "overflow", "manual"]
+
+
+class CompactionEndEvent(Event):
+    reason: Literal["threshold", "overflow", "manual"]
+    aborted: bool = False
+    will_retry: bool = False
+    tokens_before: int | None = None
+    kept_from_index: int | None = None
+    summary: str | None = None
+    kept_items_brief: list[message.KeptItemBrief] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
+
+
 class TaskFinishEvent(Event):
     task_result: str
     has_structured_output: bool = False
@@ -185,6 +201,8 @@ type ReplayEventUnion = (
     | InterruptEvent
     | DeveloperMessageEvent
     | ErrorEvent
+    | CompactionStartEvent
+    | CompactionEndEvent
 )
 
 

klaude_code/protocol/llm_param.py

@@ -16,6 +16,7 @@ class LLMClientProtocol(Enum):
     BEDROCK = "bedrock"
     CODEX_OAUTH = "codex_oauth"
     GOOGLE = "google"
+    ANTIGRAVITY = "antigravity"
 
 
 class ToolSchema(BaseModel):

klaude_code/protocol/message.py

@@ -63,6 +63,28 @@ class StreamErrorItem(BaseModel):
     created_at: datetime = Field(default_factory=datetime.now)
 
 
+class CompactionDetails(BaseModel):
+    read_files: list[str] = Field(default_factory=list)
+    modified_files: list[str] = Field(default_factory=list)
+
+
+class KeptItemBrief(BaseModel):
+    """Brief info about a kept (non-compacted) message item."""
+
+    item_type: str  # "User", "Assistant", "Read", "Edit", "Bash", etc.
+    count: int = 1
+    preview: str = ""  # Short preview text
+
+
+class CompactionEntry(BaseModel):
+    summary: str
+    first_kept_index: int
+    tokens_before: int | None = None
+    details: CompactionDetails | None = None
+    kept_items_brief: list[KeptItemBrief] = Field(default_factory=list)  # pyright: ignore[reportUnknownVariableType]
+    created_at: datetime = Field(default_factory=datetime.now)
+
+
 # Part types
 
 
@@ -173,7 +195,7 @@ class ToolResultMessage(MessageBase):
 
 Message = SystemMessage | DeveloperMessage | UserMessage | AssistantMessage | ToolResultMessage
 
-HistoryEvent = Message | StreamErrorItem | TaskMetadataItem
+HistoryEvent = Message | StreamErrorItem | TaskMetadataItem | CompactionEntry
 
 StreamItem = AssistantTextDelta | AssistantImageDelta | ThinkingTextDelta | ToolCallStartDelta
 

klaude_code/protocol/op.py

@@ -8,7 +8,7 @@ that the executor uses to handle different types of requests.
 from __future__ import annotations
 
 from enum import Enum
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 from uuid import uuid4
 
 from pydantic import BaseModel, Field
@@ -24,6 +24,7 @@ class OperationType(Enum):
     """Enumeration of supported operation types."""
 
     RUN_AGENT = "run_agent"
+    COMPACT_SESSION = "compact_session"
     CHANGE_MODEL = "change_model"
     CHANGE_SUB_AGENT_MODEL = "change_sub_agent_model"
     CHANGE_THINKING = "change_thinking"
@@ -57,6 +58,19 @@ class RunAgentOperation(Operation):
         await handler.handle_run_agent(self)
 
 
+class CompactSessionOperation(Operation):
+    """Operation for compacting a session's conversation history."""
+
+    type: OperationType = OperationType.COMPACT_SESSION
+    session_id: str
+    reason: Literal["threshold", "overflow", "manual"]
+    focus: str | None = None
+    will_retry: bool = False
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_compact_session(self)
+
+
 class ChangeModelOperation(Operation):
     """Operation for changing the model used by the active agent session."""
 

klaude_code/protocol/op_handler.py

@@ -14,6 +14,7 @@ if TYPE_CHECKING:
         ChangeSubAgentModelOperation,
         ChangeThinkingOperation,
         ClearSessionOperation,
+        CompactSessionOperation,
         ExportSessionOperation,
         InitAgentOperation,
         InterruptOperation,
@@ -29,6 +30,10 @@ class OperationHandler(Protocol):
         """Handle a run agent operation."""
         ...
 
+    async def handle_compact_session(self, operation: CompactSessionOperation) -> None:
+        """Handle a compact session operation."""
+        ...
+
     async def handle_change_model(self, operation: ChangeModelOperation) -> None:
         """Handle a change model operation."""
         ...

klaude_code/session/session.py

@@ -228,6 +228,30 @@ class Session(BaseModel):
         )
         self._store.append_and_flush(session_id=self.id, items=items, meta=meta)
 
+    def get_llm_history(self) -> list[message.HistoryEvent]:
+        """Return the LLM-facing history view with compaction summary injected."""
+        history = self.conversation_history
+        last_compaction: message.CompactionEntry | None = None
+        for item in reversed(history):
+            if isinstance(item, message.CompactionEntry):
+                last_compaction = item
+                break
+        if last_compaction is None:
+            return [it for it in history if not isinstance(it, message.CompactionEntry)]
+
+        summary_message = message.UserMessage(parts=[message.TextPart(text=last_compaction.summary)])
+        kept = [it for it in history[last_compaction.first_kept_index :] if not isinstance(it, message.CompactionEntry)]
+
+        # Guard against old/bad persisted compaction boundaries that start with tool results.
+        # Tool results must not appear without their corresponding assistant tool call.
+        if kept and isinstance(kept[0], message.ToolResultMessage):
+            first_non_tool = 0
+            while first_non_tool < len(kept) and isinstance(kept[first_non_tool], message.ToolResultMessage):
+                first_non_tool += 1
+            kept = kept[first_non_tool:]
+
+        return [summary_message, *kept]
+
     def fork(self, *, new_id: str | None = None, until_index: int | None = None) -> Session:
         """Create a new session as a fork of the current session.
 
@@ -399,6 +423,18 @@ class Session(BaseModel):
                     yield events.DeveloperMessageEvent(session_id=self.id, item=dm)
                 case message.StreamErrorItem() as se:
                     yield events.ErrorEvent(error_message=se.error, can_retry=False, session_id=self.id)
+                case message.CompactionEntry() as ce:
+                    yield events.CompactionStartEvent(session_id=self.id, reason="threshold")
+                    yield events.CompactionEndEvent(
+                        session_id=self.id,
+                        reason="threshold",
+                        aborted=False,
+                        will_retry=False,
+                        tokens_before=ce.tokens_before,
+                        kept_from_index=ce.first_kept_index,
+                        summary=ce.summary,
+                        kept_items_brief=ce.kept_items_brief,
+                    )
                 case message.SystemMessage():
                     pass
             prev_item = it

klaude_code/skill/assets/create-plan/SKILL.md

@@ -49,12 +49,12 @@ Throughout the entire workflow, operate in read-only mode. Do not write or updat
 - Out:
 
 ## Action items
-[ ] <Step 1>
-[ ] <Step 2>
-[ ] <Step 3>
-[ ] <Step 4>
-[ ] <Step 5>
-[ ] <Step 6>
+- [ ] <Step 1>
+- [ ] <Step 2>
+- [ ] <Step 3>
+- [ ] <Step 4>
+- [ ] <Step 5>
+- [ ] <Step 6>
 
 ## Open questions
 - <Question 1>

klaude_code/skill/loader.py

@@ -209,22 +209,21 @@ class SkillLoader:
         """Get list of all loaded skill names"""
         return list(self.loaded_skills.keys())
 
-    def get_skills_xml(self) -> str:
-        """Generate Level 1 metadata in XML format for tool description
+    def get_skills_yaml(self) -> str:
+        """Generate skill metadata in YAML format for system prompt.
 
         Returns:
-            XML string with all skill metadata
+            YAML string with all skill metadata
         """
-        xml_parts: list[str] = []
-        # Prefer showing higher-priority skills first (project > user > system).
+        yaml_parts: list[str] = []
         location_order = {"project": 0, "user": 1, "system": 2}
         for skill in sorted(self.loaded_skills.values(), key=lambda s: location_order.get(s.location, 3)):
-            xml_parts.append(
-                f"""<skill>
-<name>{skill.name}</name>
-<description>{skill.description}</description>
-<scope>{skill.location}</scope>
-<location>{skill.skill_path}</location>
-</skill>"""
+            # Escape description for YAML (handle multi-line and special chars)
+            desc = skill.description.replace("\n", " ").strip()
+            yaml_parts.append(
+                f"- name: {skill.name}\n"
+                f"  description: {desc}\n"
+                f"  scope: {skill.location}\n"
+                f"  location: {skill.skill_path}"
             )
-        return "\n".join(xml_parts)
+        return "\n".join(yaml_parts)

klaude_code/skill/manager.py

@@ -80,8 +80,8 @@ def format_available_skills_for_system_prompt() -> str:
 
     try:
         loader = _ensure_initialized()
-        skills_xml = loader.get_skills_xml().strip()
-        if not skills_xml:
+        skills_yaml = loader.get_skills_yaml().strip()
+        if not skills_yaml:
             return ""
 
         return f"""
@@ -102,7 +102,7 @@ Important:
 The list below is metadata only (name/description/location). The full instructions live in the referenced file.
 
 <available_skills>
-{skills_xml}
+{skills_yaml}
 </available_skills>"""
     except Exception:
         # Skills are an optional enhancement; do not fail prompt construction if discovery breaks.

klaude_code/tui/command/__init__.py

@@ -30,6 +30,7 @@ def ensure_commands_loaded() -> None:
 
     # Import and register commands in display order
     from .clear_cmd import ClearCommand
+    from .compact_cmd import CompactCommand
     from .copy_cmd import CopyCommand
     from .debug_cmd import DebugCommand
     from .export_cmd import ExportCommand
@@ -40,12 +41,12 @@ def ensure_commands_loaded() -> None:
     from .resume_cmd import ResumeCommand
     from .status_cmd import StatusCommand
     from .sub_agent_model_cmd import SubAgentModelCommand
-    from .terminal_setup_cmd import TerminalSetupCommand
     from .thinking_cmd import ThinkingCommand
 
     # Register in desired display order
     register(CopyCommand())
     register(ExportCommand())
+    register(CompactCommand())
     register(RefreshTerminalCommand())
     register(ModelCommand())
     register(SubAgentModelCommand())
@@ -55,7 +56,6 @@ def ensure_commands_loaded() -> None:
     register(StatusCommand())
     register(ResumeCommand())
     register(ExportOnlineCommand())
-    register(TerminalSetupCommand())
     register(DebugCommand())
     register(ClearCommand())
 
@@ -66,6 +66,7 @@ def ensure_commands_loaded() -> None:
 def __getattr__(name: str) -> object:
     _commands_map = {
         "ClearCommand": "clear_cmd",
+        "CompactCommand": "compact_cmd",
         "CopyCommand": "copy_cmd",
         "DebugCommand": "debug_cmd",
         "ExportCommand": "export_cmd",
@@ -76,7 +77,6 @@ def __getattr__(name: str) -> object:
         "ResumeCommand": "resume_cmd",
         "StatusCommand": "status_cmd",
         "SubAgentModelCommand": "sub_agent_model_cmd",
-        "TerminalSetupCommand": "terminal_setup_cmd",
         "ThinkingCommand": "thinking_cmd",
     }
     if name in _commands_map:
@@ -91,7 +91,7 @@ __all__ = [
     # Command classes are lazily loaded via __getattr__
     # "ClearCommand", "DiffCommand", "HelpCommand", "ModelCommand",
     # "ExportCommand", "RefreshTerminalCommand", "ReleaseNotesCommand",
-    # "StatusCommand", "TerminalSetupCommand",
+    # "StatusCommand",
     "CommandABC",
     "CommandResult",
     "dispatch_command",

klaude_code/tui/command/compact_cmd.py

@@ -0,0 +1,32 @@
+from klaude_code.protocol import commands, message, op
+from klaude_code.tui.command.command_abc import Agent, CommandABC, CommandResult
+
+
+class CompactCommand(CommandABC):
+    @property
+    def name(self) -> commands.CommandName:
+        return commands.CommandName.COMPACT
+
+    @property
+    def summary(self) -> str:
+        return "summarize older context to free up the model window"
+
+    @property
+    def support_addition_params(self) -> bool:
+        return True
+
+    @property
+    def placeholder(self) -> str:
+        return "optional focus for the summary"
+
+    async def run(self, agent: Agent, user_input: message.UserInputPayload) -> CommandResult:
+        focus = user_input.text.strip() if user_input.text else None
+        return CommandResult(
+            operations=[
+                op.CompactSessionOperation(
+                    session_id=agent.session.id,
+                    reason="manual",
+                    focus=focus or None,
+                )
+            ]
+        )

klaude_code/tui/command/copy_cmd.py

@@ -1,5 +1,5 @@
 from klaude_code.protocol import commands, events, message
-from klaude_code.tui.input.clipboard import copy_to_clipboard
+from klaude_code.tui.input.key_bindings import copy_to_clipboard
 
 from .command_abc import Agent, CommandABC, CommandResult