lm-deluge 0.0.70__py3-none-any.whl → 0.0.72__py3-none-any.whl

lm_deluge/api_requests/base.py

@@ -90,9 +90,32 @@ class APIRequestBase(ABC):
         start -> poll -> result style of request.
         """
         assert self.context.status_tracker, "no status tracker"
-        start_time = time.time()
+        poll_interval = 5.0
+        attempt_start = time.monotonic()
+        deadline = attempt_start + self.context.request_timeout
+        response_id: str | None = None
+        last_status: str | None = None
+
         async with aiohttp.ClientSession() as session:
-            last_status: str | None = None
+
+            async def cancel_response(reason: str) -> None:
+                nonlocal response_id
+                if not response_id:
+                    return
+                cancel_url = f"{self.url}/{response_id}/cancel"
+                try:
+                    async with session.post(
+                        url=cancel_url,
+                        headers=self.request_header,
+                    ) as cancel_response:
+                        cancel_response.raise_for_status()
+                    print(f"Background req {response_id} cancelled: {reason}")
+                except (
+                    Exception
+                ) as cancel_err:  # pragma: no cover - best effort logging
+                    print(
+                        f"Failed to cancel background req {response_id}: {cancel_err}"
+                    )
 
             try:
                 self.context.status_tracker.total_requests += 1
@@ -109,14 +132,11 @@ class APIRequestBase(ABC):
                     last_status = data["status"]
 
                 while True:
-                    if time.time() - start_time > self.context.request_timeout:
-                        # cancel the response
-                        async with session.post(
-                            url=f"{self.url}/{response_id}/cancel",
-                            headers=self.request_header,
-                        ) as http_response:
-                            http_response.raise_for_status()
-
+                    now = time.monotonic()
+                    remaining = deadline - now
+                    if remaining <= 0:
+                        elapsed = now - attempt_start
+                        await cancel_response(f"timed out after {elapsed:.1f}s")
                         return APIResponse(
                             id=self.context.task_id,
                             model_internal=self.context.model_name,
@@ -128,8 +148,9 @@ class APIRequestBase(ABC):
                             content=None,
                             usage=None,
                         )
+
                     # poll for the response
-                    await asyncio.sleep(5.0)
+                    await asyncio.sleep(min(poll_interval, max(remaining, 0)))
                     async with session.get(
                         url=f"{self.url}/{response_id}",
                         headers=self.request_header,
@@ -146,6 +167,8 @@ class APIRequestBase(ABC):
                             return await self.handle_response(http_response)
 
             except Exception as e:
+                if response_id:
+                    await cancel_response(f"errored: {type(e).__name__}")
                 raise_if_modal_exception(e)
                 tb = traceback.format_exc()
                 print(tb)

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/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.dist-info → lm_deluge-0.0.72.dist-info}/METADATA

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

{lm_deluge-0.0.70.dist-info → lm_deluge-0.0.72.dist-info}/RECORD

@@ -8,8 +8,8 @@ lm_deluge/embed.py,sha256=CO-TOlC5kOTAM8lcnicoG4u4K664vCBwHF1vHa-nAGg,13382
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
 lm_deluge/file.py,sha256=PTmlJQ-IaYcYUFun9V0bJ1NPVP84edJrR0hvCMWFylY,19697
 lm_deluge/image.py,sha256=5AMXmn2x47yXeYNfMSMAOWcnlrOxxOel-4L8QCJwU70,8928
-lm_deluge/mock_openai.py,sha256=dYZDBKgTepQ-yd5zPRYBgMRXO6TeLqiM1fDQe622Ono,22110
-lm_deluge/prompt.py,sha256=Bgszws8-3GPefiVRa-Mht4tfyfoqD_hV5MX1nrbkJn0,63465
+lm_deluge/mock_openai.py,sha256=-u4kxSzwoxDt_2fLh5LaiqETnu0Jg_VDL7TWAAYHGNw,21762
+lm_deluge/prompt.py,sha256=b93ZZHlK9luujgilcnSkwoPCD-U6r1wLWXxWJ4D4ZIE,63578
 lm_deluge/request_context.py,sha256=cBayMFWupWhde2OjRugW3JH-Gin-WFGc6DK2Mb4Prdc,2576
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
 lm_deluge/tool.py,sha256=Kp2O5lDq_WVo_ASxjLQSHzVRbaxZkS6J0JIIskBjux0,28909
@@ -18,7 +18,7 @@ lm_deluge/usage.py,sha256=xz9tAw2hqaJvv9aAVhnQ6N1Arn7fS8Shb28VwCW26wI,5136
 lm_deluge/warnings.py,sha256=nlDJMCw30VhDEFxqLO2-bfXH_Tv5qmlglzUSbokCSw8,1498
 lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
 lm_deluge/api_requests/anthropic.py,sha256=QGq3G5jJIGcoM2HdRt73GgkvZs4GOViyjYexWex05Vk,8927
-lm_deluge/api_requests/base.py,sha256=GCcydwBRx4_xAuYLvasXlyj-TgqvKAVhVvxRfJkvPbY,9471
+lm_deluge/api_requests/base.py,sha256=mXEM85mcU_5LD-ugELpCl28tv-tpHKcaxerTIVLQZVo,10436
 lm_deluge/api_requests/bedrock.py,sha256=Uppne03GcIEk1tVYzoGu7GXK2Sg94a_xvFTLDRN_phY,15412
 lm_deluge/api_requests/chat_reasoning.py,sha256=sJvstvKFqsSBUjYcwxzGt2_FH4cEp3Z6gKcBPyPjGwk,236
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
@@ -69,8 +69,8 @@ lm_deluge/util/logprobs.py,sha256=UkBZakOxWluaLqHrjARu7xnJ0uCHVfLGHJdnYlEcutk,11
 lm_deluge/util/spatial.py,sha256=BsF_UKhE-x0xBirc-bV1xSKZRTUhsOBdGqsMKme20C8,4099
 lm_deluge/util/validation.py,sha256=hz5dDb3ebvZrZhnaWxOxbNSVMI6nmaOODBkk0htAUhs,1575
 lm_deluge/util/xml.py,sha256=Ft4zajoYBJR3HHCt2oHwGfymGLdvp_gegVmJ-Wqk4Ck,10547
-lm_deluge-0.0.70.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.70.dist-info/METADATA,sha256=URQWK2LB1itY_viE7mv0ijJOfUolZMDRzvK-Pdzmn_o,13514
-lm_deluge-0.0.70.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.70.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.70.dist-info/RECORD,,
+lm_deluge-0.0.72.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.72.dist-info/METADATA,sha256=Ffg1w5rphPj_MScOCYhA1cQmSKsc2XjBqJefXiZOtDk,13514
+lm_deluge-0.0.72.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.72.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.72.dist-info/RECORD,,