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

{lm_deluge-0.0.69/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.69
+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.69 → lm_deluge-0.0.71}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["setuptools", "wheel"]
 
 [project]
 name = "lm_deluge"
-version = "0.0.69"
+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.69 → lm_deluge-0.0.71}/src/lm_deluge/__init__.py

@@ -4,7 +4,13 @@ from .prompt import Conversation, Message
 from .tool import Tool, ToolParams
 
 try:
-    from .mock_openai import MockAsyncOpenAI  # noqa
+    from .mock_openai import (  # noqa
+        APIError,
+        APITimeoutError,
+        BadRequestError,
+        MockAsyncOpenAI,
+        RateLimitError,
+    )
 
     _has_openai = True
 except ImportError:
@@ -24,4 +30,12 @@ __all__ = [
 ]
 
 if _has_openai:
-    __all__.append("MockAsyncOpenAI")
+    __all__.extend(
+        [
+            "MockAsyncOpenAI",
+            "APIError",
+            "APITimeoutError",
+            "BadRequestError",
+            "RateLimitError",
+        ]
+    )

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

@@ -25,20 +25,30 @@ import uuid
 from typing import Any, AsyncIterator, Literal, Union, overload
 
 try:
+    from openai import (
+        APIError,
+        APITimeoutError,
+        BadRequestError,
+        RateLimitError,
+    )
+    from openai.types import Completion
     from openai.types.chat import (
         ChatCompletion,
         ChatCompletionChunk,
         ChatCompletionMessage,
         ChatCompletionMessageToolCall,
     )
-    from openai.types.chat.chat_completion import Choice as CompletionChoice
+    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,
     )
     from openai.types.chat.chat_completion_message_tool_call import Function
+    from openai.types.completion_choice import CompletionChoice as TextCompletionChoice
     from openai.types.completion_usage import CompletionUsage
 except ImportError:
     raise ImportError(
@@ -46,56 +56,70 @@ except ImportError:
         "Install it with: pip install lm-deluge[openai]"
     )
 
-from lm_deluge.client import LLMClient
-from lm_deluge.prompt import Conversation, Message, Part, Text, ToolCall, ToolResult
+# Re-export exceptions for compatibility
+__all__ = [
+    "MockAsyncOpenAI",
+    "APIError",
+    "APITimeoutError",
+    "BadRequestError",
+    "RateLimitError",
+]
 
+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,
-                    )
-                )
 
-        # 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 ""))
+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", {})
 
-        conv_messages.append(Message(role=role, parts=parts))
+            # Extract properties and required from the parameters schema
+            properties = params_schema.get("properties", {})
+            required = params_schema.get("required", [])
 
-    return Conversation(messages=conv_messages)
+            lm_tool = Tool(
+                name=func["name"],
+                description=func.get("description"),
+                parameters=properties if properties else None,
+                required=required,
+            )
+            lm_tools.append(lm_tool)
+
+    return lm_tools
+
+
+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(
@@ -114,7 +138,7 @@ def _response_to_chat_completion(
             role="assistant",
             content=response.error_message or "Error occurred",
         )
-        choice = CompletionChoice(
+        choice = ChatCompletionChoice(
             index=0,
             message=message,
             finish_reason="stop",  # or could use "error" but that's not standard
@@ -164,7 +188,7 @@ def _response_to_chat_completion(
     )
 
     # Create choice
-    choice = CompletionChoice(
+    choice = ChatCompletionChoice(
         index=0,
         message=message,
         finish_reason=response.finish_reason or "stop",
@@ -329,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)
@@ -360,29 +384,121 @@ 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)
 
 
+class MockTextCompletions:
+    """Mock text completions resource for legacy completions API."""
+
+    def __init__(self, parent: "MockAsyncOpenAI"):
+        self._parent = parent
+
+    async def create(
+        self,
+        *,
+        model: str,
+        prompt: str | list[str],
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        top_p: float | None = None,
+        seed: int | None = None,
+        n: int | None = None,
+        stop: str | list[str] | None = None,
+        **kwargs: Any,
+    ) -> Completion:
+        """
+        Create a text completion using lm-deluge's LLMClient.
+
+        Args:
+            model: Model identifier
+            prompt: Text prompt or list of prompts
+            temperature: Sampling temperature
+            max_tokens: Max tokens to generate
+            top_p: Nucleus sampling parameter
+            seed: Random seed
+            n: Number of completions (currently ignored, always returns 1)
+            stop: Stop sequences
+            **kwargs: Other parameters
+
+        Returns:
+            Completion object
+        """
+        # Get or create client for this model
+        client: _LLMClient = self._parent._get_or_create_client(model)
+
+        # Handle single prompt
+        if isinstance(prompt, list):
+            # For now, just use the first prompt
+            prompt = prompt[0] if prompt else ""
+
+        # Convert prompt to Conversation
+        conversation = Conversation([Message(role="user", parts=[Text(prompt)])])
+
+        # Build sampling params
+        sampling_kwargs = {}
+        if temperature is not None:
+            sampling_kwargs["temperature"] = temperature
+        if max_tokens is not None:
+            sampling_kwargs["max_new_tokens"] = max_tokens
+        if top_p is not None:
+            sampling_kwargs["top_p"] = top_p
+        if seed is not None:
+            sampling_kwargs["seed"] = seed
+
+        # Create client with merged params if needed
+        if sampling_kwargs:
+            merged_params = {**self._parent._default_sampling_params, **sampling_kwargs}
+            client = self._parent._create_client_with_params(model, merged_params)
+
+        # Execute request
+        response = await client.start(conversation, cache=self._parent.cache_pattern)  # type: ignore
+
+        # Convert to Completion format
+        completion_text = None
+        if response.content:
+            text_parts = [p.text for p in response.content.parts if isinstance(p, Text)]
+            if text_parts:
+                completion_text = "".join(text_parts)
+
+        # Create choice
+        choice = TextCompletionChoice(
+            index=0,
+            text=completion_text or "",
+            finish_reason=response.finish_reason or "stop",  # type: ignore
+        )
+
+        # Create usage
+        usage = None
+        if response.usage:
+            usage = CompletionUsage(
+                prompt_tokens=response.usage.input_tokens,
+                completion_tokens=response.usage.output_tokens,
+                total_tokens=response.usage.input_tokens + response.usage.output_tokens,
+            )
+
+        return Completion(
+            id=f"cmpl-{uuid.uuid4().hex[:24]}",
+            choices=[choice],
+            created=int(time.time()),
+            model=model,
+            object="text_completion",
+            usage=usage,
+        )
+
+
 class MockChat:
     """Mock chat resource that provides access to completions."""
 
@@ -414,23 +530,52 @@ class MockAsyncOpenAI:
 
     Args:
         model: Default model to use (can be overridden in create())
+        api_key: API key (optional, for compatibility)
+        organization: Organization ID (optional, for compatibility)
+        project: Project ID (optional, for compatibility)
+        base_url: Base URL (defaults to OpenAI's URL for compatibility)
+        timeout: Request timeout (optional, for compatibility)
+        max_retries: Max retries (defaults to 2 for compatibility)
+        default_headers: Default headers (optional, for compatibility)
         temperature: Default temperature
         max_completion_tokens: Default max completion tokens
         top_p: Default top_p
+        seed: Default seed for deterministic sampling
         **kwargs: Additional parameters passed to LLMClient
     """
 
     def __init__(
         self,
         *,
-        model: str,
+        model: str | None = None,
+        api_key: str | None = None,
+        organization: str | None = None,
+        project: str | None = None,
+        base_url: str | None = None,
+        timeout: float | None = None,
+        max_retries: int | None = None,
+        default_headers: dict[str, str] | None = None,
+        http_client: Any | None = None,
         temperature: float | None = None,
         max_completion_tokens: int | None = None,
         top_p: float | None = None,
         seed: int | None = None,
+        cache_pattern: CachePattern | None = None,
         **kwargs: Any,
     ):
-        self._default_model = model
+        # OpenAI-compatible attributes
+        self.api_key = api_key
+        self.organization = organization
+        self.project = project
+        self.base_url = base_url or "https://api.openai.com/v1"
+        self.timeout = timeout
+        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"
         self._default_sampling_params = {}
 
         if temperature is not None:
@@ -449,10 +594,11 @@ class MockAsyncOpenAI:
         self._clients: dict[str, Any] = {}
 
         # Create the default client
-        self._clients[model] = self._create_client(model)
+        self._clients[self._default_model] = self._create_client(self._default_model)
 
         # Create nested resources
         self._chat = MockChat(self)
+        self._completions = MockTextCompletions(self)
 
     def _create_client(self, model: str) -> Any:
         """Create a new LLMClient for the given model."""
@@ -480,3 +626,18 @@ class MockAsyncOpenAI:
     def chat(self) -> MockChat:
         """Access the chat resource."""
         return self._chat
+
+    @property
+    def completions(self) -> MockTextCompletions:
+        """Access the text completions resource."""
+        return self._completions
+
+    async def close(self) -> None:
+        """
+        Close the client and clean up resources.
+
+        This is provided for compatibility with AsyncOpenAI's close() method.
+        Currently a no-op as LLMClient instances don't need explicit cleanup.
+        """
+        # No cleanup needed for LLMClient instances
+        pass

{lm_deluge-0.0.69 → 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.69 → 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.69
+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.69 → lm_deluge-0.0.71}/tests/test_mock_openai.py

@@ -34,7 +34,21 @@ async def test_client_structure():
     assert hasattr(client.chat.completions, "create")
     assert callable(client.chat.completions.create)
 
+    # Verify OpenAI-compatible attributes exist
+    assert hasattr(client, "base_url")
+    assert hasattr(client, "api_key")
+    assert hasattr(client, "organization")
+    assert hasattr(client, "project")
+    assert hasattr(client, "timeout")
+    assert hasattr(client, "max_retries")
+    assert hasattr(client, "default_headers")
+
+    # Verify default values
+    assert client.base_url == "https://api.openai.com/v1"
+    assert client.max_retries == 2
+
     print("   Client structure verified - has chat.completions.create")
+    print("   OpenAI-compatible attributes verified (base_url, api_key, etc.)")
 
 
 async def test_basic_completion():
@@ -308,6 +322,212 @@ async def test_json_mode():
         print(f"   ⚠️  Response was not valid JSON: {content}")
 
 
+async def test_text_completions():
+    """Test text completions API (legacy API)."""
+    print("\n✓ Testing text completions...")
+
+    # Skip if no API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("   ⚠️  Skipping: OPENAI_API_KEY not set")
+        return
+
+    client = MockAsyncOpenAI(model="gpt-4o-mini")
+    response = await client.completions.create(
+        model="gpt-4o-mini",
+        prompt="Say hello in one word:",
+        temperature=0.0,
+        max_tokens=10,
+    )
+
+    assert isinstance(response, __import__("openai").types.Completion)
+    assert response.object == "text_completion"
+    assert len(response.choices) == 1
+    assert response.choices[0].text is not None
+    print(f"   Text completion: {response.choices[0].text}")
+
+
+async def test_close_method():
+    """Test that close() method exists and works."""
+    print("\n✓ Testing close() method...")
+
+    client = MockAsyncOpenAI(model="gpt-4o-mini")
+    # Should not raise an error
+    await client.close()
+    print("   close() method works")
+
+
+async def test_subclassing():
+    """Test that MockAsyncOpenAI can be subclassed."""
+    print("\n✓ Testing subclassing...")
+
+    class CustomClient(MockAsyncOpenAI):
+        def __init__(self, **kwargs):
+            super().__init__(**kwargs)
+            self.custom_attr = "custom"
+
+    client = CustomClient(model="gpt-4o-mini", api_key="test-key")
+    assert client.custom_attr == "custom"
+    assert client.api_key == "test-key"
+    assert hasattr(client, "chat")
+    print("   Subclassing works correctly")
+
+
+async def test_http_client_parameter():
+    """Test that http_client parameter is accepted."""
+    print("\n✓ Testing http_client parameter...")
+
+    # Mock http client
+    class MockHttpClient:
+        pass
+
+    http_client = MockHttpClient()
+    client = MockAsyncOpenAI(model="gpt-4o-mini", http_client=http_client)
+    assert client.http_client is http_client
+    print("   http_client parameter works")
+
+
+async def test_exception_imports():
+    """Test that OpenAI exceptions are available."""
+    print("\n✓ Testing exception imports...")
+
+    from lm_deluge.mock_openai import (
+        APIError,
+        APITimeoutError,
+        BadRequestError,
+        RateLimitError,
+    )
+
+    # Verify they are the right types
+    assert APIError is not None
+    assert APITimeoutError is not None
+    assert BadRequestError is not None
+    assert RateLimitError is not None
+    print("   All exception types imported successfully")
+
+
+async def test_verifiers_like_initialization():
+    """Test initialization pattern used by Verifiers library."""
+    print("\n✓ Testing Verifiers-like initialization...")
+
+    # Simulate Verifiers initialization pattern
+    client = MockAsyncOpenAI(
+        base_url="https://api.openai.com/v1",
+        api_key="test-key",
+        max_retries=3,
+        http_client=None,
+    )
+
+    # Verify attributes
+    assert str(client.base_url) == "https://api.openai.com/v1"
+    assert client.api_key == "test-key"
+    assert client.max_retries == 3
+
+    print(f"   base_url: {client.base_url}")
+    print(f"   api_key: {client.api_key}")
+    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)
@@ -315,7 +535,16 @@ async def run_all_tests():
     print("=" * 60)
 
     tests = [
-        test_client_structure,  # No API key needed
+        # No API key needed
+        test_client_structure,
+        test_close_method,
+        test_subclassing,
+        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,
         test_tool_calling,
@@ -324,6 +553,7 @@ async def run_all_tests():
         test_multi_turn_conversation,
         test_with_different_provider,
         test_json_mode,
+        test_text_completions,
     ]
 
     failed = []