klaude-code 2.7.0__py3-none-any.whl → 2.8.1__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

@@ -27,6 +27,7 @@ class CommandName(str, Enum):
     FORK_SESSION = "fork-session"
     RESUME = "resume"
     COPY = "copy"
+    CONTINUE = "continue"
 
     def __str__(self) -> str:
         return self.value

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,8 @@ class OperationType(Enum):
     """Enumeration of supported operation types."""
 
     RUN_AGENT = "run_agent"
+    CONTINUE_AGENT = "continue_agent"
+    COMPACT_SESSION = "compact_session"
     CHANGE_MODEL = "change_model"
     CHANGE_SUB_AGENT_MODEL = "change_sub_agent_model"
     CHANGE_THINKING = "change_thinking"
@@ -57,6 +59,32 @@ class RunAgentOperation(Operation):
         await handler.handle_run_agent(self)
 
 
+class ContinueAgentOperation(Operation):
+    """Operation for continuing an agent task without adding a new user message.
+
+    Used for recovery after interruptions (network errors, API failures, etc.).
+    """
+
+    type: OperationType = OperationType.CONTINUE_AGENT
+    session_id: str
+
+    async def execute(self, handler: OperationHandler) -> None:
+        await handler.handle_continue_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,8 @@ if TYPE_CHECKING:
         ChangeSubAgentModelOperation,
         ChangeThinkingOperation,
         ClearSessionOperation,
+        CompactSessionOperation,
+        ContinueAgentOperation,
         ExportSessionOperation,
         InitAgentOperation,
         InterruptOperation,
@@ -29,6 +31,14 @@ class OperationHandler(Protocol):
         """Handle a run agent operation."""
         ...
 
+    async def handle_continue_agent(self, operation: ContinueAgentOperation) -> None:
+        """Handle a continue agent operation (resume without adding user message)."""
+        ...
+
+    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."""
         ...