lm-deluge 0.0.47__tar.gz → 0.0.49__tar.gz

{lm_deluge-0.0.47/src/lm_deluge.egg-info → lm_deluge-0.0.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.47
+Version: 0.0.49
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10

{lm_deluge-0.0.47 → lm_deluge-0.0.49}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.47"
+version = "0.0.49"
 authors = [{ name = "Benjamin Anderson", email = "ben@trytaylor.ai" }]
 description = "Python utility for using LLM API models."
 readme = "README.md"

{lm_deluge-0.0.47 → lm_deluge-0.0.49}/src/lm_deluge/api_requests/anthropic.py

@@ -28,10 +28,6 @@ def _add_beta(headers: dict, beta: str):
 def _build_anthropic_request(
     model: APIModel,
     context: RequestContext,
-    # prompt: Conversation,
-    # tools: list[Tool | dict | MCPServer] | None,
-    # sampling_params: SamplingParams,
-    # cache_pattern: CachePattern | None = None,
 ):
     prompt = context.prompt
     cache_pattern = context.cache

{lm_deluge-0.0.47 → lm_deluge-0.0.49}/src/lm_deluge/cache.py

@@ -78,9 +78,18 @@ class LevelDBCache:
         Get an API response from the cache.
         """
         key = f"{self.cache_key}:{prompt.fingerprint}"
+        # print(f"DEBUG: Cache.get() looking for key: {key}")
         data = self.db.get(key.encode())
         if data is not None:
-            return decode_api_response(data)
+            # print(f"DEBUG: Cache.get() FOUND data, calling decode_api_response")
+            try:
+                result = decode_api_response(data)
+                # print(f"DEBUG: Cache.get() decode_api_response returned: {type(result)}")
+                return result
+            except Exception:
+                # print(f"DEBUG: Cache.get() ERROR in decode_api_response: {e}")
+                return None
+        # print(f"DEBUG: Cache.get() NO data found, returning None")
         return None
 
     def put(self, prompt: Conversation, response: APIResponse):

{lm_deluge-0.0.47 → lm_deluge-0.0.49}/src/lm_deluge/client.py

@@ -250,12 +250,17 @@ class _LLMClient(BaseModel):
             return response
 
         if self.cache:
+            # print(f"DEBUG: Checking cache for prompt with {len(context.prompt.messages)} messages")
             cached = self.cache.get(context.prompt)
             if cached:
+                # print(f"DEBUG: Cache HIT! Returning cached response")
                 cached.local_cache_hit = True
                 if context.status_tracker:
                     context.status_tracker.task_succeeded(context.task_id)
                 return _maybe_postprocess(cached)
+            else:
+                # print(f"DEBUG: Cache MISS")
+                pass
 
         # Execute single request
         assert context.status_tracker
@@ -267,6 +272,7 @@ class _LLMClient(BaseModel):
             context.status_tracker.task_succeeded(context.task_id)
             # Cache successful responses immediately
             if self.cache and response.completion:
+                # print(f"DEBUG: Caching successful response")
                 self.cache.put(context.prompt, response)
             # Call callback if provided
             context.maybe_callback(response, context.status_tracker)

{lm_deluge-0.0.47 → lm_deluge-0.0.49}/src/lm_deluge/image.py

@@ -23,6 +23,16 @@ class Image:
     _fingerprint_cache: str | None = field(init=False, default=None)
     _size_cache: tuple[int, int] | None = field(init=False, default=None)
 
+    # def __post_init__(self):
+    # DEBUG: Track image data at creation
+    # data_type = type(self.data)
+    # data_preview = (
+    #     str(self.data)[:100]
+    #     if isinstance(self.data, str)
+    #     else f"[{data_type.__name__}]"
+    # )
+    # print(f"DEBUG: Image.__post_init__: id={id(self)}, data={data_type}, preview={data_preview}")
+
     def __repr__(self):
         return f"Image(data=[{type(self.data)}], media_type={self.media_type}, detail={self.detail})"
 
@@ -58,6 +68,15 @@ class Image:
 
     # helpers -----------------------------------------------------------------
     def _bytes(self) -> bytes:
+        # DEBUG: Track when _bytes is called and what data we have
+        # data_type = type(self.data)
+        # data_preview = (
+        #     str(self.data)[:100]
+        #     if isinstance(self.data, str)
+        #     else f"[{data_type.__name__}]"
+        # )
+        # print(f"DEBUG: Image._bytes called: id={id(self)}, data={data_type}, preview={data_preview}")
+
         if isinstance(self.data, bytes):
             return self.data
         elif isinstance(self.data, io.BytesIO):
@@ -82,6 +101,7 @@ class Image:
                 content = "[raw bytes]"
             else:
                 content = f"[raw {type(self.data)}]"
+            # print(f"DEBUG: Image._bytes ERROR PATH: type={type(self.data)}, content={content}")
             raise ValueError(
                 f"unreadable image format. type: {type(self.data)}. content: {content}"
             )
@@ -164,6 +184,7 @@ class Image:
     @property
     def fingerprint(self) -> str:
         # return base64 of a very small version of the image
+        # print(f"DEBUG: Image.fingerprint called, data type: {type(self.data)}")
         if self._fingerprint_cache is None:
             small_image = self._resize_longer(max_size=48)  # longer side = 48px
             self._fingerprint_cache = base64.b64encode(small_image).decode("utf-8")

{lm_deluge-0.0.47 → lm_deluge-0.0.49}/src/lm_deluge/prompt.py

@@ -333,6 +333,7 @@ class Message:
         """
         Return a JSON-serialisable dict that fully captures the message.
         """
+
         def _json_safe(value):
             if isinstance(value, (str, int, float, bool)) or value is None:
                 return value
@@ -385,6 +386,8 @@ class Message:
     @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")
         role: Role = data["role"]
         parts: list[Part] = []
 
@@ -392,11 +395,12 @@ class Message:
             if p["type"] == "text":
                 parts.append(Text(p["text"]))
             elif p["type"] == "image":
-                # We only stored a placeholder tag, so keep that placeholder.
-                parts.append(Image(p["tag"], detail="low"))
+                # 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"]))
             elif p["type"] == "file":
-                # We only stored a placeholder tag, so keep that placeholder.
-                parts.append(File(p["tag"]))
+                # We only stored a placeholder tag; rehydrate as inert text to avoid byte access.
+                parts.append(Text(p["tag"]))
             elif p["type"] == "tool_call":
                 parts.append(
                     ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
@@ -562,6 +566,51 @@ class Message:
     @classmethod
     def from_anthropic(cls, msg: dict):
         pass
+        # role = (
+        #     "system"
+        #     if msg["role"] in ["developer", "system"]
+        #     else ("user" if msg["role"] == "user" else "assistant")
+        # )
+        # parts: list[Part] = []
+        # content = msg["content"]
+        # if isinstance(content, str):
+        #     parts = [Text(content)]
+        # else:
+        #     part_list = []
+        #     for item in content:
+        #         if item["type"] == "text":
+        #             part_list.append(Text(item["text"]))
+        #         elif item["type"] == "image_url":
+        #             part_list.append(Image(data=item["image_url"]["url"]))
+        #         elif item["type"] == "file":
+        #             file_data = item["file"]
+        #             if "file_id" in file_data:
+        #                 # Handle file ID reference (not implemented yet)
+        #                 part_list.append(File(data=file_data["file_id"]))
+        #             elif "file_data" in file_data:
+        #                 # Handle base64 file data
+        #                 part_list.append(
+        #                     File(
+        #                         data=file_data["file_data"],
+        #                         filename=file_data.get("filename"),
+        #                     )
+        #                 )
+        #     parts = part_list
+
+        # # Handle tool calls (assistant messages)
+        # if "tool_calls" in msg:
+        #     part_list = list(parts) if parts else []
+        #     for tool_call in msg["tool_calls"]:
+        #         part_list.append(
+        #             ToolCall(
+        #                 id=tool_call["id"],
+        #                 name=tool_call["function"]["name"],
+        #                 arguments=json.loads(tool_call["function"]["arguments"]),
+        #             )
+        #         )
+        #     parts = part_list
+
+        # return cls(role, parts)
 
     # ───── provider-specific emission ─────
     def oa_chat(self) -> dict:
@@ -571,11 +620,6 @@ class Message:
             if len(tool_results) == 1:
                 tool_result = tool_results[0]
                 return tool_result.oa_chat()
-                # {
-                #     "role": "tool",
-                #     "tool_call_id": tool_result.tool_call_id,
-                #     "content": tool_result.result,
-                # }
             else:
                 raise ValueError(
                     f"Tool role messages must contain exactly one ToolResult part for OpenAI, got {len(tool_results)}"
@@ -661,14 +705,469 @@ class Conversation:
         return cls([msg])
 
     @classmethod
-    def from_openai(cls, messages: list[dict]):
+    def from_openai_chat(cls, messages: list[dict]):
         """Compatibility with openai-formatted messages"""
-        pass
+
+        def _to_image_from_url(block: dict) -> Image:
+            payload = block.get("image_url") or block.get("input_image") or {}
+            url = payload.get("url") or payload.get("file_id")
+            detail = payload.get("detail", "auto")
+            media_type = payload.get("media_type")
+            if url is None:
+                raise ValueError("image content missing url")
+            return Image(data=url, media_type=media_type, detail=detail)
+
+        def _to_file(block: dict) -> File:
+            payload = block.get("file") or block.get("input_file") or {}
+            file_id = payload.get("file_id") or block.get("file_id")
+            filename = payload.get("filename")
+            file_data = payload.get("file_data")
+            if file_id is not None:
+                return File(data=b"", filename=filename, file_id=file_id)
+            if file_data is not None:
+                return File(data=file_data, filename=filename)
+            raise ValueError("file content missing file data or id")
+
+        def _to_audio_file(block: dict) -> File:
+            payload = block.get("audio") or block.get("input_audio") or {}
+            file_id = payload.get("file_id")
+            audio_format = payload.get("format", "wav")
+            media_type = f"audio/{audio_format}"
+            data = payload.get("data")
+            if file_id is not None:
+                return File(data=b"", media_type=media_type, file_id=file_id)
+            if data is not None:
+                data_url = f"data:{media_type};base64,{data}"
+                return File(data=data_url, media_type=media_type)
+            raise ValueError("audio block missing data or file id")
+
+        text_types = {"text", "input_text", "output_text", "refusal"}
+        image_types = {"image_url", "input_image", "image"}
+        file_types = {"file", "input_file"}
+        audio_types = {"audio", "input_audio"}
+
+        def _convert_content_blocks(content: str | list[dict] | None) -> list[Part]:
+            parts: list[Part] = []
+            if content is None:
+                return parts
+            if isinstance(content, str):
+                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))
+                elif block_type in image_types:
+                    parts.append(_to_image_from_url(block))
+                elif block_type in file_types:
+                    parts.append(_to_file(block))
+                elif block_type in audio_types:
+                    parts.append(_to_audio_file(block))
+                elif block_type == "tool_result":
+                    # Rare: assistant echoing tool results – convert to text
+                    result = block.get("content")
+                    if isinstance(result, str):
+                        parts.append(Text(result))
+                    else:
+                        parts.append(Text(json.dumps(result)))
+                elif block_type == "image_file":
+                    payload = block.get("image_file", {})
+                    file_id = payload.get("file_id")
+                    placeholder = {"type": "image_file", "file_id": file_id}
+                    parts.append(Text(json.dumps(placeholder)))
+                else:
+                    parts.append(Text(json.dumps(block)))
+            return parts
+
+        def _convert_tool_arguments(raw: str | dict | None) -> dict:
+            if isinstance(raw, dict):
+                return raw
+            if raw is None:
+                return {}
+            try:
+                return json.loads(raw)
+            except json.JSONDecodeError:
+                return {"__raw__": raw}
+
+        def _convert_tool_result_content(
+            content: str | list[dict] | None,
+        ) -> str | list[ToolResultPart]:
+            if content is None:
+                return ""
+            if isinstance(content, str):
+                return content
+            result_parts: list[ToolResultPart] = []
+            for block in content:
+                block_type = block.get("type")
+                if block_type in {"text", "input_text", "output_text", "refusal"}:
+                    text_value = block.get("text") or block.get(block_type) or ""
+                    result_parts.append(Text(text_value))
+                elif block_type in image_types:
+                    result_parts.append(_to_image_from_url(block))
+                else:
+                    result_parts.append(Text(json.dumps(block)))
+            return result_parts
+
+        conversation_messages: list[Message] = []
+
+        for idx, raw_message in enumerate(messages):
+            role = raw_message.get("role")
+            if role is None:
+                raise ValueError("OpenAI message missing role")
+
+            role_lower = role.lower()
+            if role_lower in {"system", "developer"}:
+                parts = _convert_content_blocks(raw_message.get("content"))
+                conversation_messages.append(Message("system", parts))
+                continue
+
+            if role_lower == "tool" or role_lower == "function":
+                tool_call_id = (
+                    raw_message.get("tool_call_id")
+                    or raw_message.get("id")
+                    or raw_message.get("name")
+                    or f"tool_call_{idx}"
+                )
+                tool_result = ToolResult(
+                    tool_call_id=tool_call_id,
+                    result=_convert_tool_result_content(raw_message.get("content")),
+                )
+                conversation_messages.append(Message("tool", [tool_result]))
+                continue
+
+            mapped_role: Role
+            if role_lower == "user":
+                mapped_role = "user"
+            elif role_lower == "assistant":
+                mapped_role = "assistant"
+            else:
+                raise ValueError(f"Unsupported OpenAI message role: {role}")
+
+            parts = _convert_content_blocks(raw_message.get("content"))
+
+            tool_calls = raw_message.get("tool_calls")
+            if not tool_calls and raw_message.get("function_call") is not None:
+                tool_calls = [
+                    {
+                        "id": raw_message.get("id"),
+                        "type": "function",
+                        "function": raw_message["function_call"],
+                    }
+                ]
+
+            if tool_calls:
+                for call_index, call in enumerate(tool_calls):
+                    call_type = call.get("type", "function")
+                    call_id = (
+                        call.get("id")
+                        or call.get("tool_call_id")
+                        or call.get("call_id")
+                        or f"tool_call_{idx}_{call_index}"
+                    )
+
+                    if call_type == "function":
+                        function_payload = call.get("function", {})
+                        name = (
+                            function_payload.get("name")
+                            or call.get("name")
+                            or "function"
+                        )
+                        arguments = _convert_tool_arguments(
+                            function_payload.get("arguments")
+                        )
+                        parts.append(
+                            ToolCall(
+                                id=call_id,
+                                name=name,
+                                arguments=arguments,
+                            )
+                        )
+                    else:
+                        payload = call.get(call_type, {})
+                        if not isinstance(payload, dict):
+                            payload = {"value": payload}
+                        arguments = payload.get("arguments")
+                        if arguments is None:
+                            arguments = payload
+                        parts.append(
+                            ToolCall(
+                                id=call_id,
+                                name=call_type,
+                                arguments=arguments
+                                if isinstance(arguments, dict)
+                                else {"value": arguments},
+                                built_in=True,
+                                built_in_type=call_type,
+                                extra_body=payload,
+                            )
+                        )
+
+            conversation_messages.append(Message(mapped_role, parts))
+
+        return cls(conversation_messages)
 
     @classmethod
-    def from_anthropic(cls, messages: list[dict], system: str | None = None):
+    def from_anthropic(
+        cls, messages: list[dict], system: str | list[dict] | None = None
+    ):
         """Compatibility with anthropic-formatted messages"""
-        pass
+
+        def _anthropic_text_part(text_value: str | None) -> Text:
+            return Text(text_value or "")
+
+        def _anthropic_image(block: dict) -> Image:
+            source = block.get("source", {})
+            source_type = source.get("type")
+            if source_type == "base64":
+                media_type = source.get("media_type", "image/png")
+                data = source.get("data", "")
+                return Image(
+                    data=f"data:{media_type};base64,{data}",
+                    media_type=media_type,
+                )
+            if source_type == "url":
+                media_type = source.get("media_type")
+                url = source.get("url")
+                if url is None:
+                    raise ValueError("Anthropic image source missing url")
+                return Image(data=url, media_type=media_type)
+            if source_type == "file":
+                file_id = source.get("file_id")
+                if file_id is None:
+                    raise ValueError("Anthropic image file source missing file_id")
+                raise ValueError(
+                    "Anthropic image file references require external fetch"
+                )
+            raise ValueError(f"Unsupported Anthropic image source: {source_type}")
+
+        def _anthropic_file(block: dict) -> File:
+            source = block.get("source", {})
+            source_type = source.get("type")
+            if source_type == "file":
+                file_id = source.get("file_id")
+                if file_id is None:
+                    raise ValueError("Anthropic file source missing file_id")
+                return File(data=b"", file_id=file_id)
+            if source_type == "base64":
+                media_type = source.get("media_type")
+                data = source.get("data", "")
+                return File(
+                    data=f"data:{media_type};base64,{data}",
+                    media_type=media_type,
+                    filename=block.get("name"),
+                )
+            raise ValueError(f"Unsupported Anthropic file source: {source_type}")
+
+        def _anthropic_tool_result_content(
+            content: str | list[dict] | None,
+        ) -> str | list[ToolResultPart]:
+            if content is None:
+                return ""
+            if isinstance(content, str):
+                return content
+            result_parts: list[ToolResultPart] = []
+            for part in content:
+                part_type = part.get("type")
+                if part_type == "text":
+                    result_parts.append(_anthropic_text_part(part.get("text")))
+                elif part_type == "image":
+                    try:
+                        result_parts.append(_anthropic_image(part))
+                    except ValueError:
+                        result_parts.append(Text(json.dumps(part)))
+                else:
+                    result_parts.append(Text(json.dumps(part)))
+            return result_parts
+
+        def _anthropic_content_to_parts(
+            role: Role, content: str | list[dict] | None
+        ) -> list[Part]:
+            parts: list[Part] = []
+            if content is None:
+                return parts
+            if isinstance(content, str):
+                parts.append(_anthropic_text_part(content))
+                return parts
+
+            for block in content:
+                block_type = block.get("type")
+                if block_type == "text":
+                    parts.append(_anthropic_text_part(block.get("text")))
+                elif block_type == "image":
+                    try:
+                        parts.append(_anthropic_image(block))
+                    except ValueError:
+                        parts.append(Text(json.dumps(block)))
+                elif block_type == "document":
+                    try:
+                        parts.append(_anthropic_file(block))
+                    except ValueError:
+                        parts.append(Text(json.dumps(block)))
+                elif block_type == "tool_use":
+                    tool_id = block.get("id")
+                    if tool_id is None:
+                        raise ValueError("Anthropic tool_use block missing id")
+                    name = block.get("name") or "tool"
+                    arguments = block.get("input") or {}
+                    parts.append(
+                        ToolCall(
+                            id=tool_id,
+                            name=name,
+                            arguments=arguments
+                            if isinstance(arguments, dict)
+                            else {"value": arguments},
+                        )
+                    )
+                elif block_type == "tool_result":
+                    tool_use_id = block.get("tool_use_id")
+                    if tool_use_id is None:
+                        raise ValueError(
+                            "Anthropic tool_result block missing tool_use_id"
+                        )
+                    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
+
+        conversation_messages: list[Message] = []
+
+        if system is not None:
+            if isinstance(system, str):
+                conversation_messages.append(Message("system", [Text(system)]))
+            elif isinstance(system, list):
+                system_parts = _anthropic_content_to_parts("system", system)
+                conversation_messages.append(Message("system", system_parts))
+            else:
+                raise ValueError(
+                    "Anthropic system prompt must be string or list of blocks"
+                )
+
+        for message in messages:
+            role = message.get("role")
+            if role is None:
+                raise ValueError("Anthropic message missing role")
+
+            if role not in {"user", "assistant"}:
+                raise ValueError(f"Unsupported Anthropic role: {role}")
+
+            base_role: Role = role  # type: ignore[assignment]
+            content = message.get("content")
+            if isinstance(content, list):
+                buffer_parts: list[Part] = []
+                for block in content:
+                    block_type = block.get("type")
+                    if block_type == "tool_result":
+                        if buffer_parts:
+                            conversation_messages.append(
+                                Message(base_role, buffer_parts)
+                            )
+                            buffer_parts = []
+                        tool_use_id = block.get("tool_use_id")
+                        if tool_use_id is None:
+                            raise ValueError(
+                                "Anthropic tool_result block missing tool_use_id"
+                            )
+                        result = _anthropic_tool_result_content(block.get("content"))
+                        conversation_messages.append(
+                            Message(
+                                "tool",
+                                [ToolResult(tool_call_id=tool_use_id, result=result)],
+                            )
+                        )
+                    else:
+                        block_parts = _anthropic_content_to_parts(base_role, [block])
+                        buffer_parts.extend(block_parts)
+
+                if buffer_parts:
+                    conversation_messages.append(Message(base_role, buffer_parts))
+            else:
+                parts = _anthropic_content_to_parts(base_role, content)
+                conversation_messages.append(Message(base_role, parts))
+
+        return cls(conversation_messages)
+
+    @classmethod
+    def from_unknown(
+        cls, messages: list[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").
+        """
+
+        def _detect_provider() -> str:
+            has_openai_markers = False
+            has_anthropic_markers = False
+
+            for msg in messages:
+                role = msg.get("role")
+                if role == "tool":
+                    has_openai_markers = True
+
+                if role == "system":
+                    has_openai_markers = True
+
+                if (
+                    "tool_calls" in msg
+                    or "function_call" in msg
+                    or "tool_call_id" in msg
+                ):
+                    has_openai_markers = True
+
+                content = msg.get("content")
+                if isinstance(content, list):
+                    for block in content:
+                        if not isinstance(block, dict):
+                            continue
+                        block_type = block.get("type")
+                        if block_type in {
+                            "tool_use",
+                            "tool_result",
+                            "thinking",
+                            "assistant_response",
+                            "redacted",
+                        }:
+                            has_anthropic_markers = True
+                        if block_type == "tool_result" and block.get("tool_use_id"):
+                            has_anthropic_markers = True
+                        if block_type == "tool_use":
+                            has_anthropic_markers = True
+
+            if has_openai_markers and not has_anthropic_markers:
+                return "openai"
+            if has_anthropic_markers and not has_openai_markers:
+                return "anthropic"
+            if has_openai_markers:
+                return "openai"
+            if has_anthropic_markers:
+                return "anthropic"
+            # As a fallback, default to OpenAI which is the most permissive
+            return "openai"
+
+        provider = _detect_provider()
+        if provider == "openai":
+            try:
+                return cls.from_openai_chat(messages), "openai"
+            except Exception:
+                try:
+                    return cls.from_anthropic(messages, system=system), "anthropic"
+                except Exception as anthropic_error:
+                    raise ValueError(
+                        "Unable to parse messages as OpenAI or Anthropic"
+                    ) from anthropic_error
+        else:
+            try:
+                return cls.from_anthropic(messages, system=system), "anthropic"
+            except Exception:
+                return cls.from_openai_chat(messages), "openai"
 
     # fluent additions
     def with_message(self, msg: Message) -> "Conversation":
@@ -974,12 +1473,11 @@ class Conversation:
                 if p["type"] == "text":
                     parts.append(Text(p["text"]))
                 elif p["type"] == "image":
-                    # We only stored a placeholder tag, so keep that placeholder.
-                    # You could raise instead if real image bytes are required.
-                    parts.append(Image(p["tag"], detail="low"))
+                    # We only stored a placeholder tag; rehydrate as inert text to avoid byte access.
+                    parts.append(Text(p["tag"]))
                 elif p["type"] == "file":
-                    # We only stored a placeholder tag, so keep that placeholder.
-                    parts.append(File(p["tag"]))
+                    # We only stored a placeholder tag; rehydrate as inert text to avoid byte access.
+                    parts.append(Text(p["tag"]))
                 elif p["type"] == "tool_call":
                     parts.append(
                         ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])

{lm_deluge-0.0.47 → lm_deluge-0.0.49/src/lm_deluge.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.47
+Version: 0.0.49
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10