lm-deluge 0.0.70__tar.gz → 0.0.71__tar.gz

{lm_deluge-0.0.70/src/lm_deluge.egg-info → lm_deluge-0.0.71}/PKG-INFO

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

{lm_deluge-0.0.70 → lm_deluge-0.0.71}/pyproject.toml

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

{lm_deluge-0.0.70 → lm_deluge-0.0.71}/src/lm_deluge/mock_openai.py

@@ -41,6 +41,8 @@ try:
     from openai.types.chat.chat_completion import Choice as ChatCompletionChoice
     from openai.types.chat.chat_completion_chunk import (
         Choice as ChunkChoice,
+    )
+    from openai.types.chat.chat_completion_chunk import (
         ChoiceDelta,
         ChoiceDeltaToolCall,
         ChoiceDeltaToolCallFunction,
@@ -63,56 +65,61 @@ __all__ = [
     "RateLimitError",
 ]
 
-from lm_deluge.client import LLMClient
-from lm_deluge.prompt import Conversation, Message, Part, Text, ToolCall, ToolResult
+from lm_deluge.client import LLMClient, _LLMClient
+from lm_deluge.prompt import CachePattern, Conversation, Message, Text, ToolCall
+from lm_deluge.tool import Tool
 
 
-def _messages_to_conversation(messages: list[dict[str, Any]]) -> Conversation:
-    """Convert OpenAI messages format to lm-deluge Conversation."""
-    conv_messages = []
-
-    for msg in messages:
-        role = msg["role"]
-        content = msg.get("content")
-        tool_calls = msg.get("tool_calls")
-        tool_call_id = msg.get("tool_call_id")
-
-        parts: list[Part] = []
-
-        # Handle regular content
-        if content:
-            if isinstance(content, str):
-                parts.append(Text(content))
-            elif isinstance(content, list):
-                # Multi-part content (text, images, etc.)
-                for item in content:
-                    if item.get("type") == "text":
-                        parts.append(Text(item["text"]))
-                    # Could add image support here later
-
-        # Handle tool calls (from assistant)
-        if tool_calls:
-            for tc in tool_calls:
-                # Parse arguments from JSON string to dict
-                args_str = tc["function"]["arguments"]
-                args_dict = (
-                    json.loads(args_str) if isinstance(args_str, str) else args_str
-                )
-                parts.append(
-                    ToolCall(
-                        id=tc["id"],
-                        name=tc["function"]["name"],
-                        arguments=args_dict,
-                    )
-                )
+def _openai_tools_to_lm_deluge(tools: list[dict[str, Any]]) -> list[Tool]:
+    """
+    Convert OpenAI tool format to lm-deluge Tool objects.
+
+    OpenAI format:
+        {
+            "type": "function",
+            "function": {
+                "name": "get_weather",
+                "description": "Get weather",
+                "parameters": {
+                    "type": "object",
+                    "properties": {...},
+                    "required": [...]
+                }
+            }
+        }
+
+    lm-deluge format:
+        Tool(
+            name="get_weather",
+            description="Get weather",
+            parameters={...properties...},
+            required=[...]
+        )
+    """
+    lm_tools = []
+    for tool in tools:
+        if tool.get("type") == "function":
+            func = tool["function"]
+            params_schema = func.get("parameters", {})
+
+            # Extract properties and required from the parameters schema
+            properties = params_schema.get("properties", {})
+            required = params_schema.get("required", [])
+
+            lm_tool = Tool(
+                name=func["name"],
+                description=func.get("description"),
+                parameters=properties if properties else None,
+                required=required,
+            )
+            lm_tools.append(lm_tool)
 
-        # Handle tool results (from tool role)
-        if role == "tool" and tool_call_id:
-            parts.append(ToolResult(tool_call_id=tool_call_id, result=content or ""))
+    return lm_tools
 
-        conv_messages.append(Message(role=role, parts=parts))
 
-    return Conversation(messages=conv_messages)
+def _messages_to_conversation(messages: list[dict[str, Any]]) -> Conversation:
+    """Convert OpenAI messages format to lm-deluge Conversation."""
+    return Conversation.from_openai_chat(messages)
 
 
 def _response_to_chat_completion(
@@ -346,7 +353,7 @@ class MockCompletions:
             ChatCompletion (non-streaming) or AsyncIterator[ChatCompletionChunk] (streaming)
         """
         # Get or create client for this model
-        client = self._parent._get_or_create_client(model)
+        client: _LLMClient = self._parent._get_or_create_client(model)
 
         # Convert messages to Conversation
         conversation = _messages_to_conversation(messages)
@@ -377,26 +384,19 @@ class MockCompletions:
         # Convert tools if provided
         lm_tools = None
         if tools:
-            # For now, just pass through - lm-deluge will handle the format
-            lm_tools = tools
+            # Convert from OpenAI format to lm-deluge Tool objects
+            lm_tools = _openai_tools_to_lm_deluge(tools)
 
         # Execute request
         if stream:
-            # Streaming mode
-            request_id = f"chatcmpl-{uuid.uuid4().hex[:24]}"
-            # Note: client.stream() is an async generator, not a coroutine
-            # We can directly wrap it
-            stream_iter = client.stream(conversation, tools=lm_tools)
-            # Verify it's a generator, not a coroutine
-            if hasattr(stream_iter, "__anext__"):
-                return _AsyncStreamWrapper(stream_iter, model, request_id)
-            else:
-                # If it's a coroutine, we need to await it first
-                # But this shouldn't happen with the current implementation
-                raise TypeError(f"Expected async generator, got {type(stream_iter)}")
+            raise RuntimeError("streaming not supported")
         else:
             # Non-streaming mode
-            response = await client.start(conversation, tools=lm_tools)
+            response = await client.start(
+                conversation,
+                tools=lm_tools,  # type: ignore
+                cache=self._parent.cache_pattern,  # type: ignore
+            )
             return _response_to_chat_completion(response, model)
 
 
@@ -437,7 +437,7 @@ class MockTextCompletions:
             Completion object
         """
         # Get or create client for this model
-        client = self._parent._get_or_create_client(model)
+        client: _LLMClient = self._parent._get_or_create_client(model)
 
         # Handle single prompt
         if isinstance(prompt, list):
@@ -464,7 +464,7 @@ class MockTextCompletions:
             client = self._parent._create_client_with_params(model, merged_params)
 
         # Execute request
-        response = await client.start(conversation)
+        response = await client.start(conversation, cache=self._parent.cache_pattern)  # type: ignore
 
         # Convert to Completion format
         completion_text = None
@@ -477,7 +477,7 @@ class MockTextCompletions:
         choice = TextCompletionChoice(
             index=0,
             text=completion_text or "",
-            finish_reason=response.finish_reason or "stop",
+            finish_reason=response.finish_reason or "stop",  # type: ignore
         )
 
         # Create usage
@@ -560,6 +560,7 @@ class MockAsyncOpenAI:
         max_completion_tokens: int | None = None,
         top_p: float | None = None,
         seed: int | None = None,
+        cache_pattern: CachePattern | None = None,
         **kwargs: Any,
     ):
         # OpenAI-compatible attributes
@@ -571,6 +572,7 @@ class MockAsyncOpenAI:
         self.max_retries = max_retries or 2
         self.default_headers = default_headers
         self.http_client = http_client
+        self.cache_pattern = cache_pattern
 
         # Internal attributes
         self._default_model = model or "gpt-4o-mini"

{lm_deluge-0.0.70 → lm_deluge-0.0.71}/src/lm_deluge/prompt.py

@@ -848,14 +848,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 +1003,8 @@ class Conversation:
                             )
                         )
 
-            conversation_messages.append(Message(mapped_role, parts))
+            if parts:
+                conversation_messages.append(Message(mapped_role, parts))
 
         return cls(conversation_messages)
 

{lm_deluge-0.0.70 → lm_deluge-0.0.71/src/lm_deluge.egg-info}/PKG-INFO

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

{lm_deluge-0.0.70 → lm_deluge-0.0.71}/tests/test_mock_openai.py

@@ -427,6 +427,107 @@ async def test_verifiers_like_initialization():
     print("   Verifiers-like initialization works")
 
 
+async def test_tool_conversion():
+    """Test that OpenAI tools are converted to lm-deluge format."""
+    print("\n✓ Testing tool conversion...")
+
+    from lm_deluge.mock_openai import _openai_tools_to_lm_deluge
+
+    # OpenAI tool format
+    openai_tools = [
+        {
+            "type": "function",
+            "function": {
+                "name": "get_weather",
+                "description": "Get the weather for a location",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "location": {
+                            "type": "string",
+                            "description": "The city name",
+                        },
+                        "units": {
+                            "type": "string",
+                            "enum": ["celsius", "fahrenheit"],
+                        },
+                    },
+                    "required": ["location"],
+                },
+            },
+        }
+    ]
+
+    # Convert to lm-deluge format
+    lm_tools = _openai_tools_to_lm_deluge(openai_tools)
+
+    # Verify conversion
+    assert len(lm_tools) == 1
+    tool = lm_tools[0]
+    assert tool.name == "get_weather"
+    assert tool.description == "Get the weather for a location"
+    assert "location" in tool.parameters
+    assert "units" in tool.parameters
+    assert tool.required == ["location"]
+
+    print("   Tool conversion works correctly")
+    print(f"   Tool name: {tool.name}")
+    print(f"   Parameters: {list(tool.parameters.keys())}")
+
+
+async def test_tool_result_role_conversion():
+    """Test that tool result messages are converted from role='tool' to role='user'."""
+    print("\n✓ Testing tool result role conversion...")
+
+    from lm_deluge.mock_openai import _messages_to_conversation
+
+    # OpenAI format with tool call and result
+    openai_messages = [
+        {"role": "user", "content": "What's the weather?"},
+        {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [
+                {
+                    "id": "call_123",
+                    "type": "function",
+                    "function": {
+                        "name": "get_weather",
+                        "arguments": '{"location": "NYC"}',
+                    },
+                }
+            ],
+        },
+        {
+            "role": "tool",
+            "tool_call_id": "call_123",
+            "content": "The weather is sunny, 72°F",
+        },
+        {"role": "assistant", "content": "The weather in NYC is sunny and 72°F."},
+    ]
+
+    # Convert to lm-deluge format
+    conversation = _messages_to_conversation(openai_messages)
+
+    # Verify conversion
+    assert len(conversation.messages) == 4
+    assert conversation.messages[0].role == "user"
+    assert conversation.messages[1].role == "assistant"
+    # The tool result message should be converted to role="user" (not "tool")
+    assert (
+        conversation.messages[2].role == "user"
+    ), "Tool result should be in user message"
+    # Message should have ONLY the ToolResult part (not Text)
+    assert len(conversation.messages[2].parts) == 1
+    assert hasattr(conversation.messages[2].parts[0], "tool_call_id")
+    assert conversation.messages[2].parts[0].tool_call_id == "call_123"
+    assert conversation.messages[2].parts[0].result == "The weather is sunny, 72°F"
+    assert conversation.messages[3].role == "assistant"
+
+    print("   Tool result role conversion works correctly")
+    print("   OpenAI role='tool' → lm-deluge role='user' ✓")
+
+
 async def run_all_tests():
     """Run all tests."""
     print("=" * 60)
@@ -441,6 +542,8 @@ async def run_all_tests():
         test_http_client_parameter,
         test_exception_imports,
         test_verifiers_like_initialization,
+        test_tool_conversion,
+        test_tool_result_role_conversion,
         # API key needed
         test_basic_completion,
         test_streaming,