lm-deluge 0.0.67__py3-none-any.whl → 0.0.90__py3-none-any.whl

lm_deluge/prompt.py

@@ -23,16 +23,95 @@ CachePattern = Literal[
 # 1. Low-level content blocks – either text or an image                       #
 ###############################################################################
 Role = Literal["system", "user", "assistant", "tool"]
+SignatureProvider = Literal["anthropic", "gemini"]
+
+
+@dataclass(slots=True)
+class ThoughtSignature:
+    value: str
+    provider: SignatureProvider | None = None
+
+    def for_provider(self, provider: SignatureProvider) -> str | None:
+        if self.provider is None or self.provider == provider:
+            return self.value
+        return None
+
+
+ThoughtSignatureLike: TypeAlias = ThoughtSignature | str
+
+
+def _normalize_signature(
+    signature: ThoughtSignatureLike | None,
+    *,
+    provider: SignatureProvider | None = None,
+) -> ThoughtSignature | None:
+    if signature is None:
+        return None
+    if isinstance(signature, ThoughtSignature):
+        if provider is not None and signature.provider is None:
+            return ThoughtSignature(signature.value, provider)
+        return signature
+    return ThoughtSignature(signature, provider)
+
+
+def _signature_for_provider(
+    signature: ThoughtSignatureLike | None, provider: SignatureProvider
+) -> str | None:
+    if signature is None:
+        return None
+    if isinstance(signature, ThoughtSignature):
+        return signature.for_provider(provider)
+    return signature
+
+
+def _signature_value(signature: ThoughtSignatureLike | None) -> str | None:
+    if signature is None:
+        return None
+    if isinstance(signature, ThoughtSignature):
+        return signature.value
+    return signature
+
+
+def _serialize_signature(signature: ThoughtSignatureLike | None) -> str | dict | None:
+    if signature is None:
+        return None
+    if isinstance(signature, ThoughtSignature):
+        if signature.provider is None:
+            return signature.value
+        return {"value": signature.value, "provider": signature.provider}
+    return signature
+
+
+def _deserialize_signature(payload: str | dict | None) -> ThoughtSignature | None:
+    if payload is None:
+        return None
+    if isinstance(payload, dict):
+        value = payload.get("value")
+        provider = payload.get("provider")
+        if isinstance(value, str):
+            if provider in ("anthropic", "gemini"):
+                return ThoughtSignature(value, provider)
+            return ThoughtSignature(value)
+        return None
+    if isinstance(payload, str):
+        return ThoughtSignature(payload)
+    return None
 
 
 @dataclass(slots=True)
 class Text:
     text: str
     type: str = field(init=False, default="text")
+    # for gemini 3 - thought signatures to maintain reasoning context
+    thought_signature: ThoughtSignatureLike | None = None
+
+    def __post_init__(self) -> None:
+        self.thought_signature = _normalize_signature(self.thought_signature)
 
     @property
     def fingerprint(self) -> str:
-        return xxhash.xxh64(self.text.encode()).hexdigest()
+        signature = _signature_value(self.thought_signature) or ""
+        return xxhash.xxh64(f"{self.text}:{signature}".encode()).hexdigest()
 
     # ── provider-specific emission ────────────────────────────────────────────
     def oa_chat(self) -> dict | str:  # OpenAI Chat Completions
@@ -45,7 +124,11 @@ class Text:
         return {"type": "text", "text": self.text}
 
     def gemini(self) -> dict:
-        return {"text": self.text}
+        result = {"text": self.text}
+        signature = _signature_for_provider(self.thought_signature, "gemini")
+        if signature is not None:
+            result["thoughtSignature"] = signature
+        return result
 
     def mistral(self) -> dict:
         return {"type": "text", "text": self.text}
@@ -61,6 +144,11 @@ class ToolCall:
     built_in: bool = False
     built_in_type: str | None = None
     extra_body: dict | None = None
+    # for gemini 3 - thought signatures to maintain reasoning context
+    thought_signature: ThoughtSignatureLike | None = None
+
+    def __post_init__(self) -> None:
+        self.thought_signature = _normalize_signature(self.thought_signature)
 
     @property
     def fingerprint(self) -> str:
@@ -93,7 +181,11 @@ class ToolCall:
         }
 
     def gemini(self) -> dict:
-        return {"functionCall": {"name": self.name, "args": self.arguments}}
+        result = {"functionCall": {"name": self.name, "args": self.arguments}}
+        signature = _signature_for_provider(self.thought_signature, "gemini")
+        if signature is not None:
+            result["thoughtSignature"] = signature  # type: ignore
+        return result
 
     def mistral(self) -> dict:
         return {
@@ -198,6 +290,8 @@ class ToolResult:
                 "call_id": self.tool_call_id,
             }
             if self.built_in_type == "computer_call":
+                # OpenAI expects "computer_call_output" for the result type
+                result["type"] = "computer_call_output"
                 result["output"] = output_data.get("output", {})
                 if "acknowledged_safety_checks" in output_data:
                     result["acknowledged_safety_checks"] = output_data[
@@ -230,15 +324,41 @@ class ToolResult:
             raise ValueError("unsupported self.result type")
 
     def gemini(self) -> dict:
-        if not isinstance(self.result, str):
-            raise ValueError("can't handle content blocks for gemini yet")
-        return {
-            "functionResponse": {
-                "name": self.tool_call_id,  # Gemini uses name field for ID
-                "response": {"result": self.result},
-            }
+        # Build the function response
+        func_response: dict = {
+            "name": self.tool_call_id,  # Gemini uses name field for ID
         }
 
+        # Handle different result types
+        if isinstance(self.result, str):
+            func_response["response"] = {"result": self.result}
+        elif isinstance(self.result, dict):
+            # Check for Gemini computer use format with inline screenshot
+            if self.built_in_type == "gemini_computer_use":
+                # Gemini CU expects response dict with optional inline_data parts
+                func_response["response"] = self.result.get("response", {})
+                # Include inline data (screenshot) if present
+                if "inline_data" in self.result:
+                    func_response["parts"] = [
+                        {
+                            "inlineData": {
+                                "mimeType": self.result["inline_data"].get(
+                                    "mime_type", "image/png"
+                                ),
+                                "data": self.result["inline_data"]["data"],
+                            }
+                        }
+                    ]
+            else:
+                func_response["response"] = self.result
+        elif isinstance(self.result, list):
+            # Handle content blocks (images, etc.) - not yet implemented
+            raise ValueError("can't handle content blocks for gemini yet")
+        else:
+            func_response["response"] = {"result": str(self.result)}
+
+        return {"functionResponse": func_response}
+
     def mistral(self) -> dict:
         return {
             "type": "tool_result",
@@ -253,6 +373,12 @@ class Thinking:
     type: str = field(init=False, default="thinking")
     # for openai - to keep conversation chain
     raw_payload: dict | None = None
+    # for gemini 3 - thought signatures to maintain reasoning context
+    thought_signature: ThoughtSignatureLike | None = None
+    summary: str | None = None  # to differentiate summary text from actual content
+
+    def __post_init__(self) -> None:
+        self.thought_signature = _normalize_signature(self.thought_signature)
 
     @property
     def fingerprint(self) -> str:
@@ -267,10 +393,20 @@ class Thinking:
         return {"type": "reasoning", "content": self.content}
 
     def anthropic(self) -> dict:  # Anthropic Messages
-        return {"type": "thinking", "thinking": self.content}
+        if self.raw_payload:
+            return dict(self.raw_payload)
+        result = {"type": "thinking", "thinking": self.content}
+        signature = _signature_for_provider(self.thought_signature, "anthropic")
+        if signature is not None:
+            result["signature"] = signature
+        return result
 
     def gemini(self) -> dict:
-        return {"text": f"[Thinking: {self.content}]"}
+        result = {"text": f"[Thinking: {self.content}]"}
+        signature = _signature_for_provider(self.thought_signature, "gemini")
+        if signature is not None:
+            result["thoughtSignature"] = signature
+        return result
 
     def mistral(self) -> dict:
         return {"type": "text", "text": f"[Thinking: {self.content}]"}
@@ -341,10 +477,15 @@ class Message:
     #         return {"type": "file", "tag": f"<File ({size} bytes)>"}
     #     return repr(value)
 
-    def to_log(self) -> dict:
+    def to_log(self, *, preserve_media: bool = False) -> dict:
         """
         Return a JSON-serialisable dict that fully captures the message.
+
+        Args:
+            preserve_media: If True, store full base64-encoded bytes for images and files.
+                           If False (default), replace with placeholder tags.
         """
+        import base64
 
         def _json_safe(value):
             if isinstance(value, (str, int, float, bool)) or value is None:
@@ -366,22 +507,52 @@ class Message:
         content_blocks: list[dict] = []
         for p in self.parts:
             if isinstance(p, Text):
-                content_blocks.append({"type": "text", "text": p.text})
-            elif isinstance(p, Image):  # Image – redact the bytes, keep a hint
-                w, h = p.size
-                content_blocks.append({"type": "image", "tag": f"<Image ({w}×{h})>"})
-            elif isinstance(p, File):  # File – redact the bytes, keep a hint
-                size = p.size
-                content_blocks.append({"type": "file", "tag": f"<File ({size} bytes)>"})
+                text_block: dict = {"type": "text", "text": p.text}
+                signature = _serialize_signature(p.thought_signature)
+                if signature is not None:
+                    text_block["thought_signature"] = signature
+                content_blocks.append(text_block)
+            elif isinstance(p, Image):
+                if preserve_media:
+                    content_blocks.append(
+                        {
+                            "type": "image",
+                            "data": base64.b64encode(p._bytes()).decode("ascii"),
+                            "media_type": p.media_type,
+                            "detail": p.detail,
+                        }
+                    )
+                else:
+                    w, h = p.size
+                    content_blocks.append(
+                        {"type": "image", "tag": f"<Image ({w}×{h})>"}
+                    )
+            elif isinstance(p, File):
+                if preserve_media:
+                    content_blocks.append(
+                        {
+                            "type": "file",
+                            "data": base64.b64encode(p._bytes()).decode("ascii"),
+                            "media_type": p.media_type,
+                            "filename": p.filename,
+                        }
+                    )
+                else:
+                    size = p.size
+                    content_blocks.append(
+                        {"type": "file", "tag": f"<File ({size} bytes)>"}
+                    )
             elif isinstance(p, ToolCall):
-                content_blocks.append(
-                    {
-                        "type": "tool_call",
-                        "id": p.id,
-                        "name": p.name,
-                        "arguments": _json_safe(p.arguments),
-                    }
-                )
+                tool_call_block = {
+                    "type": "tool_call",
+                    "id": p.id,
+                    "name": p.name,
+                    "arguments": _json_safe(p.arguments),
+                }
+                signature = _serialize_signature(p.thought_signature)
+                if signature is not None:
+                    tool_call_block["thought_signature"] = signature
+                content_blocks.append(tool_call_block)
             elif isinstance(p, ToolResult):
                 content_blocks.append(
                     {
@@ -391,38 +562,82 @@ class Message:
                     }
                 )
             elif isinstance(p, Thinking):
-                content_blocks.append({"type": "thinking", "content": p.content})
+                thinking_block: dict = {"type": "thinking", "content": p.content}
+                signature = _serialize_signature(p.thought_signature)
+                if signature is not None:
+                    thinking_block["thought_signature"] = signature
+                content_blocks.append(thinking_block)
 
         return {"role": self.role, "content": content_blocks}
 
     @classmethod
     def from_log(cls, data: dict) -> "Message":
         """Re-hydrate a Message previously produced by `to_log()`."""
-        # DEBUG: Track when from_log is called
-        # print(f"DEBUG: Message.from_log called for {data['role']} message with {len(data['content'])} content blocks")
+        import base64
+
         role: Role = data["role"]
         parts: list[Part] = []
 
         for p in data["content"]:
             if p["type"] == "text":
-                parts.append(Text(p["text"]))
+                parts.append(
+                    Text(
+                        p["text"],
+                        thought_signature=_deserialize_signature(
+                            p.get("thought_signature")
+                        ),
+                    )
+                )
             elif p["type"] == "image":
-                # We only stored a placeholder tag; rehydrate as inert text to avoid byte access.
-                # print(f"DEBUG: Message.from_log creating Text placeholder for image: {p['tag']}")
-                parts.append(Text(p["tag"]))
+                if "data" in p:
+                    # Full image data was preserved
+                    parts.append(
+                        Image(
+                            data=base64.b64decode(p["data"]),
+                            media_type=p.get("media_type"),
+                            detail=p.get("detail", "auto"),
+                        )
+                    )
+                else:
+                    # Placeholder tag only
+                    parts.append(Text(p["tag"]))
             elif p["type"] == "file":
-                # We only stored a placeholder tag; rehydrate as inert text to avoid byte access.
-                parts.append(Text(p["tag"]))
+                if "data" in p:
+                    # Full file data was preserved
+                    parts.append(
+                        File(
+                            data=base64.b64decode(p["data"]),
+                            media_type=p.get("media_type"),
+                            filename=p.get("filename"),
+                        )
+                    )
+                else:
+                    # Placeholder tag only
+                    parts.append(Text(p["tag"]))
             elif p["type"] == "tool_call":
                 parts.append(
-                    ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                    ToolCall(
+                        id=p["id"],
+                        name=p["name"],
+                        arguments=p["arguments"],
+                        thought_signature=_deserialize_signature(
+                            p.get("thought_signature")
+                        ),
+                    )
                 )
             elif p["type"] == "tool_result":
                 parts.append(
                     ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
                 )
             elif p["type"] == "thinking":
-                parts.append(Thinking(content=p["content"]))
+                parts.append(
+                    Thinking(
+                        content=p["content"],
+                        thought_signature=_deserialize_signature(
+                            p.get("thought_signature")
+                        ),
+                    )
+                )
             else:
                 raise ValueError(f"Unknown part type {p['type']!r}")
 
@@ -753,7 +968,15 @@ class Message:
         # Anthropic: system message is *not* in the list
         if self.role == "system":
             raise ValueError("Anthropic keeps system outside message list")
-        content = [p.anthropic() for p in self.parts]
+        content: list[dict] = []
+        for part in self.parts:
+            if isinstance(part, Thinking) and part.raw_payload is None:
+                signature = _signature_for_provider(part.thought_signature, "anthropic")
+                if signature is None:
+                    continue
+            content.append(part.anthropic())
+        if not content:
+            content = [{"type": "text", "text": ""}]
         # Shortcut: single text becomes a bare string
         if len(content) == 1 and content[0].get("type") == "text":
             content = content[0]["text"]
@@ -848,14 +1071,16 @@ class Conversation:
             if content is None:
                 return parts
             if isinstance(content, str):
-                parts.append(Text(content))
+                if content.strip():
+                    parts.append(Text(content))
                 return parts
 
             for block in content:
                 block_type = block.get("type")
                 if block_type in text_types:
                     text_value = block.get("text") or block.get(block_type) or ""
-                    parts.append(Text(text_value))
+                    if text_value.strip():
+                        parts.append(Text(text_value))
                 elif block_type in image_types:
                     parts.append(_to_image_from_url(block))
                 elif block_type in file_types:
@@ -1001,7 +1226,8 @@ class Conversation:
                             )
                         )
 
-            conversation_messages.append(Message(mapped_role, parts))
+            if parts:
+                conversation_messages.append(Message(mapped_role, parts))
 
         return cls(conversation_messages)
 
@@ -1079,7 +1305,9 @@ class Conversation:
             return result_parts
 
         def _anthropic_content_to_parts(
-            role: Role, content: str | list[dict] | None
+            role: Role,
+            content: str | list[dict] | None,
+            signature_state: dict[str, ThoughtSignature | None] | None = None,
         ) -> list[Part]:
             parts: list[Part] = []
             if content is None:
@@ -1108,15 +1336,38 @@ class Conversation:
                         raise ValueError("Anthropic tool_use block missing id")
                     name = block.get("name") or "tool"
                     arguments = block.get("input") or {}
+                    tool_call = ToolCall(
+                        id=tool_id,
+                        name=name,
+                        arguments=arguments
+                        if isinstance(arguments, dict)
+                        else {"value": arguments},
+                    )
+                    if signature_state is not None:
+                        pending_signature = signature_state.get("pending")
+                        if pending_signature:
+                            tool_call.thought_signature = pending_signature
+                            signature_state["pending"] = None
+                    parts.append(tool_call)
+                elif block_type == "redacted_thinking":
                     parts.append(
-                        ToolCall(
-                            id=tool_id,
-                            name=name,
-                            arguments=arguments
-                            if isinstance(arguments, dict)
-                            else {"value": arguments},
+                        Thinking(content=block.get("data", ""), raw_payload=block)
+                    )
+                elif block_type == "thinking":
+                    thinking_content = block.get("thinking", "")
+                    signature = _normalize_signature(
+                        block.get("signature"),
+                        provider="anthropic",
+                    )
+                    parts.append(
+                        Thinking(
+                            content=thinking_content,
+                            raw_payload=block,
+                            thought_signature=signature,
                         )
                     )
+                    if signature_state is not None and signature is not None:
+                        signature_state["pending"] = signature
                 elif block_type == "tool_result":
                     tool_use_id = block.get("tool_use_id")
                     if tool_use_id is None:
@@ -1126,9 +1377,6 @@ class Conversation:
                     result = _anthropic_tool_result_content(block.get("content"))
                     tool_result = ToolResult(tool_call_id=tool_use_id, result=result)
                     parts.append(tool_result)
-                elif block_type == "thinking":
-                    thinking_content = block.get("thinking", "")
-                    parts.append(Thinking(content=thinking_content, raw_payload=block))
                 else:
                     parts.append(Text(json.dumps(block)))
             return parts
@@ -1158,6 +1406,9 @@ class Conversation:
             content = message.get("content")
             if isinstance(content, list):
                 buffer_parts: list[Part] = []
+                signature_state: None | dict[str, ThoughtSignature | None] = (
+                    {"pending": None} if base_role == "assistant" else None
+                )
                 for block in content:
                     block_type = block.get("type")
                     if block_type == "tool_result":
@@ -1179,7 +1430,11 @@ class Conversation:
                             )
                         )
                     else:
-                        block_parts = _anthropic_content_to_parts(base_role, [block])
+                        block_parts = _anthropic_content_to_parts(
+                            base_role,
+                            [block],
+                            signature_state=signature_state,
+                        )
                         buffer_parts.extend(block_parts)
 
                 if buffer_parts:
@@ -1192,14 +1447,24 @@ class Conversation:
 
     @classmethod
     def from_unknown(
-        cls, messages: list[dict], *, system: str | list[dict] | None = None
+        cls, messages: list[dict] | dict, *, system: str | list[dict] | None = None
     ) -> tuple["Conversation", str]:
         """Attempt to convert provider-formatted messages without knowing the provider.
 
         Returns the parsed conversation together with the provider label that succeeded
-        ("openai" or "anthropic").
+        ("openai", "anthropic", or "log").
         """
 
+        # Check if input is in log format (output from to_log())
+        if isinstance(messages, dict) and "messages" in messages:
+            return cls.from_log(messages), "log"
+
+        # Ensure messages is a list for provider detection
+        if not isinstance(messages, list):
+            raise ValueError(
+                "messages must be a list of dicts or a dict with 'messages' key"
+            )
+
         def _detect_provider() -> str:
             has_openai_markers = False
             has_anthropic_markers = False
@@ -1330,14 +1595,14 @@ class Conversation:
                 # For assistant messages, extract computer calls as separate items
                 text_parts = []
                 for p in m.parts:
-                    if isinstance(p, ToolCall) and p.name.startswith("_computer_"):
+                    if isinstance(p, ToolCall) and p.built_in_type == "computer_call":
                         # Computer calls become separate items in the input array
-                        action_type = p.name.replace("_computer_", "")
+                        # p.arguments already contains the full action dict with "type"
                         input_items.append(
                             {
                                 "type": "computer_call",
                                 "call_id": p.id,
-                                "action": {"type": action_type, **p.arguments},
+                                "action": p.arguments,
                             }
                         )
                     elif isinstance(p, Text):
@@ -1511,36 +1776,68 @@ class Conversation:
         hasher.update(json.dumps([m.fingerprint for m in self.messages]).encode())
         return hasher.hexdigest()
 
-    def to_log(self) -> dict:
+    def to_log(self, *, preserve_media: bool = False) -> dict:
         """
         Return a JSON-serialisable dict that fully captures the conversation.
+
+        Args:
+            preserve_media: If True, store full base64-encoded bytes for images and files.
+                           If False (default), replace with placeholder tags.
         """
+        import base64
+
         serialized: list[dict] = []
 
         for msg in self.messages:
             content_blocks: list[dict] = []
             for p in msg.parts:
                 if isinstance(p, Text):
-                    content_blocks.append({"type": "text", "text": p.text})
-                elif isinstance(p, Image):  # Image – redact the bytes, keep a hint
-                    w, h = p.size
-                    content_blocks.append(
-                        {"type": "image", "tag": f"<Image ({w}×{h})>"}
-                    )
-                elif isinstance(p, File):  # File – redact the bytes, keep a hint
-                    size = p.size
-                    content_blocks.append(
-                        {"type": "file", "tag": f"<File ({size} bytes)>"}
-                    )
+                    text_block: dict = {"type": "text", "text": p.text}
+                    signature = _serialize_signature(p.thought_signature)
+                    if signature is not None:
+                        text_block["thought_signature"] = signature
+                    content_blocks.append(text_block)
+                elif isinstance(p, Image):
+                    if preserve_media:
+                        content_blocks.append(
+                            {
+                                "type": "image",
+                                "data": base64.b64encode(p._bytes()).decode("ascii"),
+                                "media_type": p.media_type,
+                                "detail": p.detail,
+                            }
+                        )
+                    else:
+                        w, h = p.size
+                        content_blocks.append(
+                            {"type": "image", "tag": f"<Image ({w}×{h})>"}
+                        )
+                elif isinstance(p, File):
+                    if preserve_media:
+                        content_blocks.append(
+                            {
+                                "type": "file",
+                                "data": base64.b64encode(p._bytes()).decode("ascii"),
+                                "media_type": p.media_type,
+                                "filename": p.filename,
+                            }
+                        )
+                    else:
+                        size = p.size
+                        content_blocks.append(
+                            {"type": "file", "tag": f"<File ({size} bytes)>"}
+                        )
                 elif isinstance(p, ToolCall):
-                    content_blocks.append(
-                        {
-                            "type": "tool_call",
-                            "id": p.id,
-                            "name": p.name,
-                            "arguments": p.arguments,
-                        }
-                    )
+                    tool_call_block = {
+                        "type": "tool_call",
+                        "id": p.id,
+                        "name": p.name,
+                        "arguments": p.arguments,
+                    }
+                    signature = _serialize_signature(p.thought_signature)
+                    if signature is not None:
+                        tool_call_block["thought_signature"] = signature
+                    content_blocks.append(tool_call_block)
                 elif isinstance(p, ToolResult):
                     content_blocks.append(
                         {
@@ -1552,14 +1849,125 @@ class Conversation:
                         }
                     )
                 elif isinstance(p, Thinking):
-                    content_blocks.append({"type": "thinking", "content": p.content})
+                    thinking_block: dict = {"type": "thinking", "content": p.content}
+                    signature = _serialize_signature(p.thought_signature)
+                    if signature is not None:
+                        thinking_block["thought_signature"] = signature
+                    content_blocks.append(thinking_block)
             serialized.append({"role": msg.role, "content": content_blocks})
 
         return {"messages": serialized}
 
+    def print(self, max_text_length: int = 500, indent: int = 2) -> None:
+        """Pretty-print the conversation to stdout.
+
+        Args:
+            max_text_length: Truncate text content longer than this (default 500 chars)
+            indent: JSON indentation for tool calls/results (default 2)
+        """
+        ROLE_COLORS = {
+            "system": "\033[95m",  # magenta
+            "user": "\033[94m",  # blue
+            "assistant": "\033[92m",  # green
+            "tool": "\033[93m",  # yellow
+        }
+        RESET = "\033[0m"
+        DIM = "\033[2m"
+        BOLD = "\033[1m"
+
+        def truncate(text: str, max_len: int) -> str:
+            if len(text) <= max_len:
+                return text
+            return (
+                text[:max_len] + f"{DIM}... [{len(text) - max_len} more chars]{RESET}"
+            )
+
+        def format_json(obj: dict | list, ind: int) -> str:
+            return json.dumps(obj, indent=ind, ensure_ascii=False)
+
+        print(f"\n{BOLD}{'=' * 60}{RESET}")
+        print(f"{BOLD}Conversation ({len(self.messages)} messages){RESET}")
+        print(f"{BOLD}{'=' * 60}{RESET}\n")
+
+        for i, msg in enumerate(self.messages):
+            role_color = ROLE_COLORS.get(msg.role, "")
+            print(f"{role_color}{BOLD}[{msg.role.upper()}]{RESET}")
+
+            for part in msg.parts:
+                if isinstance(part, Text):
+                    text = truncate(part.text, max_text_length)
+                    # Indent multiline text
+                    lines = text.split("\n")
+                    if len(lines) > 1:
+                        print("  " + "\n  ".join(lines))
+                    else:
+                        print(f"  {text}")
+
+                elif isinstance(part, Image):
+                    w, h = part.size
+                    print(f"  {DIM}<Image ({w}x{h})>{RESET}")
+
+                elif isinstance(part, File):
+                    size = part.size
+                    filename = getattr(part, "filename", None)
+                    if filename:
+                        print(f"  {DIM}<File: {filename} ({size} bytes)>{RESET}")
+                    else:
+                        print(f"  {DIM}<File ({size} bytes)>{RESET}")
+
+                elif isinstance(part, ToolCall):
+                    print(
+                        f"  {DIM}Tool Call:{RESET} {BOLD}{part.name}{RESET} (id: {part.id})"
+                    )
+                    if part.arguments:
+                        args_json = format_json(part.arguments, indent)
+                        # Indent the JSON
+                        indented = "\n".join(
+                            "    " + line for line in args_json.split("\n")
+                        )
+                        print(indented)
+
+                elif isinstance(part, ToolResult):
+                    print(f"  {DIM}Tool Result:{RESET} (call_id: {part.tool_call_id})")
+                    if isinstance(part.result, str):
+                        result_text = truncate(part.result, max_text_length)
+                        lines = result_text.split("\n")
+                        for line in lines:
+                            print(f"    {line}")
+                    elif isinstance(part.result, dict):
+                        result_json = format_json(part.result, indent)
+                        indented = "\n".join(
+                            "    " + line for line in result_json.split("\n")
+                        )
+                        print(indented)
+                    elif isinstance(part.result, list):
+                        print(f"    {DIM}<{len(part.result)} content blocks>{RESET}")
+                        for block in part.result:
+                            if isinstance(block, Text):
+                                block_text = truncate(block.text, max_text_length // 2)
+                                print(f"      [text] {block_text}")
+                            elif isinstance(block, Image):
+                                bw, bh = block.size
+                                print(f"      {DIM}<Image ({bw}x{bh})>{RESET}")
+
+                elif isinstance(part, Thinking):
+                    print(f"  {DIM}Thinking:{RESET}")
+                    thought = truncate(part.content, max_text_length)
+                    lines = thought.split("\n")
+                    for line in lines:
+                        print(f"    {DIM}{line}{RESET}")
+
+            # Separator between messages
+            if i < len(self.messages) - 1:
+                print(f"\n{'-' * 40}\n")
+
+        print(f"\n{BOLD}{'=' * 60}{RESET}\n")
+
     @classmethod
     def from_log(cls, payload: dict) -> "Conversation":
         """Re-hydrate a Conversation previously produced by `to_log()`."""
+        import base64
+
         msgs: list[Message] = []
 
         for m in payload.get("messages", []):
@@ -1568,23 +1976,64 @@ class Conversation:
 
             for p in m["content"]:
                 if p["type"] == "text":
-                    parts.append(Text(p["text"]))
+                    parts.append(
+                        Text(
+                            p["text"],
+                            thought_signature=_deserialize_signature(
+                                p.get("thought_signature")
+                            ),
+                        )
+                    )
                 elif p["type"] == "image":
-                    # We only stored a placeholder tag; rehydrate as inert text to avoid byte access.
-                    parts.append(Text(p["tag"]))
+                    if "data" in p:
+                        # Full image data was preserved
+                        parts.append(
+                            Image(
+                                data=base64.b64decode(p["data"]),
+                                media_type=p.get("media_type"),
+                                detail=p.get("detail", "auto"),
+                            )
+                        )
+                    else:
+                        # Placeholder tag only
+                        parts.append(Text(p["tag"]))
                 elif p["type"] == "file":
-                    # We only stored a placeholder tag; rehydrate as inert text to avoid byte access.
-                    parts.append(Text(p["tag"]))
+                    if "data" in p:
+                        # Full file data was preserved
+                        parts.append(
+                            File(
+                                data=base64.b64decode(p["data"]),
+                                media_type=p.get("media_type"),
+                                filename=p.get("filename"),
+                            )
+                        )
+                    else:
+                        # Placeholder tag only
+                        parts.append(Text(p["tag"]))
                 elif p["type"] == "tool_call":
                     parts.append(
-                        ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                        ToolCall(
+                            id=p["id"],
+                            name=p["name"],
+                            arguments=p["arguments"],
+                            thought_signature=_deserialize_signature(
+                                p.get("thought_signature")
+                            ),
+                        )
                     )
                 elif p["type"] == "tool_result":
                     parts.append(
                         ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
                     )
                 elif p["type"] == "thinking":
-                    parts.append(Thinking(content=p["content"]))
+                    parts.append(
+                        Thinking(
+                            content=p["content"],
+                            thought_signature=_deserialize_signature(
+                                p.get("thought_signature")
+                            ),
+                        )
+                    )
                 else:
                     raise ValueError(f"Unknown part type {p['type']!r}")
 
@@ -1596,7 +2045,7 @@ class Conversation:
 Prompt: TypeAlias = str | list[dict] | Message | Conversation
 
 
-def prompts_to_conversations(prompts: Sequence[Prompt]) -> Sequence[Prompt]:
+def prompts_to_conversations(prompts: Sequence[Prompt]) -> Sequence[Conversation]:
     converted = []
     for prompt in prompts:
         if isinstance(prompt, Conversation):