lm-deluge 0.0.65__tar.gz → 0.0.67__tar.gz

{lm_deluge-0.0.65/src/lm_deluge.egg-info → lm_deluge-0.0.67}/PKG-INFO

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

{lm_deluge-0.0.65 → lm_deluge-0.0.67}/pyproject.toml

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

{lm_deluge-0.0.65 → lm_deluge-0.0.67}/src/lm_deluge/api_requests/anthropic.py

@@ -90,6 +90,9 @@ def _build_anthropic_request(
         for tool in tools:
             if isinstance(tool, Tool):
                 tool_definitions.append(tool.dump_for("anthropic"))
+            elif isinstance(tool, dict) and "url" in tool:
+                _add_beta(base_headers, "mcp-client-2025-04-04")
+                mcp_servers.append(tool)
             elif isinstance(tool, dict):
                 tool_definitions.append(tool)
                 # add betas if needed

{lm_deluge-0.0.65 → lm_deluge-0.0.67}/src/lm_deluge/api_requests/openai.py

@@ -184,7 +184,8 @@ class OpenAIRequest(APIRequestBase):
 
                     content = Message("assistant", parts)
 
-                    usage = Usage.from_openai_usage(data["usage"])
+                    if "usage" in data and data["usage"] is not None:
+                        usage = Usage.from_openai_usage(data["usage"])
                     if (
                         self.context.sampling_params.logprobs
                         and "logprobs" in data["choices"][0]
@@ -349,7 +350,8 @@ class OpenAIResponsesRequest(APIRequestBase):
         assert self.context.status_tracker
 
         if status_code == 500:
-            print("Internal Server Error: ", http_response.text())
+            res_text = await http_response.text()
+            print("Internal Server Error: ", res_text)
 
         if status_code >= 200 and status_code < 300:
             try:
@@ -361,126 +363,138 @@ class OpenAIResponsesRequest(APIRequestBase):
                 )
             if not is_error:
                 assert data is not None, "data is None"
-                try:
-                    # Parse Responses API format
-                    parts = []
 
-                    # Get the output array from the response
-                    output = data.get("output", [])
-                    if not output:
-                        is_error = True
-                        error_message = "No output in response"
-                    else:
-                        # Process each output item
-                        for item in output:
-                            if item.get("type") == "message":
-                                message_content = item.get("content", [])
-                                for content_item in message_content:
-                                    if content_item.get("type") == "output_text":
-                                        parts.append(Text(content_item["text"]))
-                                    elif content_item.get("type") == "refusal":
-                                        parts.append(Text(content_item["refusal"]))
-                            elif item.get("type") == "reasoning":
-                                summary = item["summary"]
-                                if not summary:
-                                    continue
-                                if isinstance(summary, list) and len(summary) > 0:
-                                    summary = summary[0]
-                                assert isinstance(summary, dict), "summary isn't a dict"
-                                parts.append(Thinking(summary["text"]))
-                            elif item.get("type") == "function_call":
-                                parts.append(
-                                    ToolCall(
-                                        id=item["call_id"],
-                                        name=item["name"],
-                                        arguments=json.loads(item["arguments"]),
+                # Check if response is incomplete
+                if data.get("status") == "incomplete":
+                    is_error = True
+                    incomplete_reason = data.get("incomplete_details", {}).get(
+                        "reason", "unknown"
+                    )
+                    error_message = f"Response incomplete: {incomplete_reason}"
+
+                if not is_error:
+                    try:
+                        # Parse Responses API format
+                        parts = []
+
+                        # Get the output array from the response
+                        output = data.get("output", [])
+                        if not output:
+                            is_error = True
+                            error_message = "No output in response"
+                        else:
+                            # Process each output item
+                            for item in output:
+                                if item.get("type") == "message":
+                                    message_content = item.get("content", [])
+                                    for content_item in message_content:
+                                        if content_item.get("type") == "output_text":
+                                            parts.append(Text(content_item["text"]))
+                                        elif content_item.get("type") == "refusal":
+                                            parts.append(Text(content_item["refusal"]))
+                                elif item.get("type") == "reasoning":
+                                    summary = item["summary"]
+                                    if not summary:
+                                        continue
+                                    if isinstance(summary, list) and len(summary) > 0:
+                                        summary = summary[0]
+                                    assert isinstance(
+                                        summary, dict
+                                    ), "summary isn't a dict"
+                                    parts.append(Thinking(summary["text"]))
+                                elif item.get("type") == "function_call":
+                                    parts.append(
+                                        ToolCall(
+                                            id=item["call_id"],
+                                            name=item["name"],
+                                            arguments=json.loads(item["arguments"]),
+                                        )
                                     )
-                                )
-                            elif item.get("type") == "mcp_call":
-                                parts.append(
-                                    ToolCall(
-                                        id=item["id"],
-                                        name=item["name"],
-                                        arguments=json.loads(item["arguments"]),
-                                        built_in=True,
-                                        built_in_type="mcp_call",
-                                        extra_body={
-                                            "server_label": item["server_label"],
-                                            "error": item.get("error"),
-                                            "output": item.get("output"),
-                                        },
+                                elif item.get("type") == "mcp_call":
+                                    parts.append(
+                                        ToolCall(
+                                            id=item["id"],
+                                            name=item["name"],
+                                            arguments=json.loads(item["arguments"]),
+                                            built_in=True,
+                                            built_in_type="mcp_call",
+                                            extra_body={
+                                                "server_label": item["server_label"],
+                                                "error": item.get("error"),
+                                                "output": item.get("output"),
+                                            },
+                                        )
                                     )
-                                )
 
-                            elif item.get("type") == "computer_call":
-                                parts.append(
-                                    ToolCall(
-                                        id=item["call_id"],
-                                        name="computer_call",
-                                        arguments=item.get("action"),
-                                        built_in=True,
-                                        built_in_type="computer_call",
+                                elif item.get("type") == "computer_call":
+                                    parts.append(
+                                        ToolCall(
+                                            id=item["call_id"],
+                                            name="computer_call",
+                                            arguments=item.get("action"),
+                                            built_in=True,
+                                            built_in_type="computer_call",
+                                        )
                                     )
-                                )
 
-                            elif item.get("type") == "web_search_call":
-                                parts.append(
-                                    ToolCall(
-                                        id=item["id"],
-                                        name="web_search_call",
-                                        arguments={},
-                                        built_in=True,
-                                        built_in_type="web_search_call",
-                                        extra_body={"status": item["status"]},
+                                elif item.get("type") == "web_search_call":
+                                    parts.append(
+                                        ToolCall(
+                                            id=item["id"],
+                                            name="web_search_call",
+                                            arguments={},
+                                            built_in=True,
+                                            built_in_type="web_search_call",
+                                            extra_body={"status": item["status"]},
+                                        )
                                     )
-                                )
 
-                            elif item.get("type") == "file_search_call":
-                                parts.append(
-                                    ToolCall(
-                                        id=item["id"],
-                                        name="file_search_call",
-                                        arguments={"queries": item["queries"]},
-                                        built_in=True,
-                                        built_in_type="file_search_call",
-                                        extra_body={
-                                            "status": item["status"],
-                                            "results": item["results"],
-                                        },
+                                elif item.get("type") == "file_search_call":
+                                    parts.append(
+                                        ToolCall(
+                                            id=item["id"],
+                                            name="file_search_call",
+                                            arguments={"queries": item["queries"]},
+                                            built_in=True,
+                                            built_in_type="file_search_call",
+                                            extra_body={
+                                                "status": item["status"],
+                                                "results": item["results"],
+                                            },
+                                        )
                                     )
-                                )
-                            elif item.get("type") == "image_generation_call":
-                                parts.append(
-                                    ToolCall(
-                                        id=item["id"],
-                                        name="image_generation_call",
-                                        arguments={},
-                                        built_in=True,
-                                        built_in_type="image_generation_call",
-                                        extra_body={
-                                            "status": item["status"],
-                                            "result": item["result"],
-                                        },
+                                elif item.get("type") == "image_generation_call":
+                                    parts.append(
+                                        ToolCall(
+                                            id=item["id"],
+                                            name="image_generation_call",
+                                            arguments={},
+                                            built_in=True,
+                                            built_in_type="image_generation_call",
+                                            extra_body={
+                                                "status": item["status"],
+                                                "result": item["result"],
+                                            },
+                                        )
                                     )
-                                )
 
-                        # Handle reasoning if present
-                        if "reasoning" in data and data["reasoning"].get("summary"):
-                            thinking = data["reasoning"]["summary"]
-                            parts.append(Thinking(thinking))
+                            # Handle reasoning if present
+                            if "reasoning" in data and data["reasoning"].get("summary"):
+                                thinking = data["reasoning"]["summary"]
+                                parts.append(Thinking(thinking))
 
-                        content = Message("assistant", parts)
+                            content = Message("assistant", parts)
 
-                        # Extract usage information
-                        if "usage" in data:
-                            usage = Usage.from_openai_usage(data["usage"])
+                            # Extract usage information
+                            if "usage" in data and data["usage"] is not None:
+                                usage = Usage.from_openai_usage(data["usage"])
 
-                except Exception as e:
-                    is_error = True
-                    error_message = f"Error parsing {self.model.name} responses API response: {str(e)}"
-                    print("got data:", data)
-                    traceback = tb.format_exc()
-                    print(f"Error details:\n{traceback}")
+                    except Exception as e:
+                        is_error = True
+                        error_message = f"Error parsing {self.model.name} responses API response: {str(e)}"
+                        print("got data:", data)
+                        traceback = tb.format_exc()
+                        print(f"Error details:\n{traceback}")
 
         elif mimetype and "json" in mimetype.lower():
             print("is_error True, json response")

{lm_deluge-0.0.65 → lm_deluge-0.0.67}/src/lm_deluge/prompt.py

@@ -329,6 +329,18 @@ class Message:
         """Get all thinking parts with proper typing."""
         return [part for part in self.parts if part.type == "thinking"]  # type: ignore
 
+    # @staticmethod
+    # def dump_part(part: Part):
+    #     if isinstance(value, Text):
+    #         return {"type": "text", "text": value.text}
+    #     if isinstance(value, Image):
+    #         w, h = value.size
+    #         return {"type": "image", "tag": f"<Image ({w}×{h})>"}
+    #     if isinstance(value, File):
+    #         size = value.size
+    #         return {"type": "file", "tag": f"<File ({size} bytes)>"}
+    #     return repr(value)
+
     def to_log(self) -> dict:
         """
         Return a JSON-serialisable dict that fully captures the message.

{lm_deluge-0.0.65 → lm_deluge-0.0.67/src/lm_deluge.egg-info}/PKG-INFO

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