lm-deluge 0.0.66__tar.gz → 0.0.68__tar.gz

{lm_deluge-0.0.66/src/lm_deluge.egg-info → lm_deluge-0.0.68}/PKG-INFO

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

{lm_deluge-0.0.66 → lm_deluge-0.0.68}/pyproject.toml

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

{lm_deluge-0.0.66 → lm_deluge-0.0.68}/src/lm_deluge/api_requests/openai.py

@@ -350,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:
@@ -362,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 and data["usage"] is not None:
-                            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.66 → lm_deluge-0.0.68}/src/lm_deluge/client.py

@@ -702,7 +702,7 @@ class _LLMClient(BaseModel):
 
     async def start(
         self,
-        prompt: str | Conversation,
+        prompt: Prompt,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
         cache: CachePattern | None = None,
@@ -780,12 +780,12 @@ class _LLMClient(BaseModel):
 
     async def stream(
         self,
-        prompt: str | Conversation,
+        prompt: Prompt,
         tools: list[Tool | dict | MCPServer] | None = None,
     ):
         model, sampling_params = self._select_model()
-        if isinstance(prompt, str):
-            prompt = Conversation.user(prompt)
+        prompt = prompts_to_conversations([prompt])[0]
+        assert isinstance(prompt, Conversation)
         async for item in stream_chat(
             model, prompt, sampling_params, tools, None, self.extra_headers
         ):
@@ -799,7 +799,7 @@ class _LLMClient(BaseModel):
 
     async def run_agent_loop(
         self,
-        conversation: str | Conversation,
+        conversation: Prompt,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
         max_rounds: int = 5,
@@ -812,8 +812,9 @@ class _LLMClient(BaseModel):
         instances or built‑in tool dictionaries.
         """
 
-        if isinstance(conversation, str):
-            conversation = Conversation.user(conversation)
+        if not isinstance(conversation, Conversation):
+            conversation = prompts_to_conversations([conversation])[0]
+            assert isinstance(conversation, Conversation)
 
         # Expand MCPServer objects to their constituent tools for tool execution
         expanded_tools: list[Tool] = []
@@ -870,7 +871,7 @@ class _LLMClient(BaseModel):
 
     def run_agent_loop_sync(
         self,
-        conversation: str | Conversation,
+        conversation: Prompt,
         *,
         tools: list[Tool | dict | MCPServer] | None = None,
         max_rounds: int = 5,

{lm_deluge-0.0.66 → lm_deluge-0.0.68/src/lm_deluge.egg-info}/PKG-INFO

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