lm-deluge 0.0.56__py3-none-any.whl → 0.0.69__py3-none-any.whl

lm_deluge/models/together.py

@@ -20,8 +20,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 3.0,
         "output_cost": 7.0,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
     },
     "deepseek-v3-together": {
         "id": "deepseek-v3-together",
@@ -32,8 +30,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 1.25,
         "output_cost": 1.25,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
     },
     "qwen-3-235b-together": {
         "id": "qwen-3-235b-together",
@@ -44,8 +40,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 0.2,
         "output_cost": 0.6,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
     },
     "qwen-2.5-vl-together": {
         "id": "qwen-2.5-vl-together",
@@ -56,8 +50,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 1.95,
         "output_cost": 8.0,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
     },
     "llama-4-maverick-together": {
         "id": "llama-4-maverick-together",
@@ -68,8 +60,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 0.27,
         "output_cost": 0.85,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
     },
     "llama-4-scout-together": {
         "id": "llama-4-scout-together",
@@ -80,8 +70,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 0.18,
         "output_cost": 0.59,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
     },
     "gpt-oss-120b-together": {
         "id": "gpt-oss-120b-together",
@@ -92,8 +80,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 0.18,
         "output_cost": 0.59,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
         "reasoning_model": True,
     },
     "gpt-oss-20b-together": {
@@ -105,8 +91,6 @@ TOGETHER_MODELS = {
         "api_spec": "openai",
         "input_cost": 0.18,
         "output_cost": 0.59,
-        "requests_per_minute": None,
-        "tokens_per_minute": None,
         "reasoning_model": True,
     },
 }

lm_deluge/prompt.py

@@ -2,13 +2,14 @@ import io
 import json
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Literal, Sequence
+from typing import Literal, Sequence, TypeAlias
 
 import tiktoken
 import xxhash
 
 from lm_deluge.file import File
 from lm_deluge.image import Image, MediaType
+from lm_deluge.warnings import deprecated
 
 CachePattern = Literal[
     "tools_only",
@@ -144,8 +145,8 @@ class ToolResult:
     def oa_chat(
         self,
     ) -> dict:  # OpenAI Chat Completions - tool results are separate messages
-        print("serializing toolresult with oa_chat...")
-        print("typeof self.result:", type(self.result))
+        # print("serializing toolresult with oa_chat...")
+        # print("typeof self.result:", type(self.result))
         if isinstance(self.result, str):
             return {
                 "role": "tool",
@@ -174,8 +175,7 @@ class ToolResult:
             raise ValueError("result type not supported")
 
     def oa_resp(self) -> dict:  # OpenAI Responses
-        print("serializing toolresult with oa_chat...")
-        print("typeof self.result:", type(self.result))
+        # print("typeof self.result:", type(self.result))
         # if normal (not built-in just return the regular output
         if not self.built_in:
             result = (
@@ -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.
@@ -416,12 +428,17 @@ class Message:
 
         return cls(role, parts)
 
-    def add_text(self, content: str) -> "Message":
+    def with_text(self, content: str) -> "Message":
         """Append a text block and return self for chaining."""
         self.parts.append(Text(content))
         return self
 
-    def add_image(
+    @deprecated("with_text")
+    def add_text(self, content: str) -> "Message":
+        """Append a text block and return self for chaining."""
+        return self.with_text(content)
+
+    def with_image(
         self,
         data: bytes | str | Path | io.BytesIO | Image,
         *,
@@ -447,9 +464,50 @@ class Message:
         self.parts.append(img)
         return self
 
+    @deprecated("with_image")
+    def add_image(
+        self,
+        data: bytes | str | Path | io.BytesIO | Image,
+        *,
+        media_type: MediaType | None = None,
+        detail: Literal["low", "high", "auto"] = "auto",
+        max_size: int | None = None,
+    ) -> "Message":
+        """
+        Append an image block and return self for chaining.
+
+        If max_size is provided, the image will be resized so that its longer
+        dimension equals max_size, but only if the longer dimension is currently
+        larger than max_size.
+        """
+        return self.with_image(
+            data=data, media_type=media_type, detail=detail, max_size=max_size
+        )
+
+    def with_file(
+        self,
+        data: bytes | str | Path | io.BytesIO | File,
+        *,
+        media_type: str | None = None,
+        filename: str | None = None,
+        # remote: bool = False,
+        # provider: Literal["openai", "anthropic", "google"] | None = None,
+    ) -> "Message":
+        """
+        Append a file block and return self for chaining.
+        """
+        if not isinstance(data, File):
+            file = File(data, media_type=media_type, filename=filename)
+        else:
+            file = data
+
+        self.parts.append(file)
+        return self
+
+    @deprecated("with_file")
     def add_file(
         self,
-        data: bytes | str | Path | io.BytesIO,
+        data: bytes | str | Path | io.BytesIO | File,
         *,
         media_type: str | None = None,
         filename: str | None = None,
@@ -457,27 +515,66 @@ class Message:
         """
         Append a file block and return self for chaining.
         """
-        file = File(data, media_type=media_type, filename=filename)
+        return self.with_file(data, media_type=media_type, filename=filename)
+
+    async def with_remote_file(
+        self,
+        data: bytes | str | Path | io.BytesIO | File,
+        *,
+        media_type: str | None = None,
+        filename: str | None = None,
+        provider: Literal["openai", "anthropic", "google"] = "openai",
+    ):
+        if not isinstance(data, File):
+            file = File(data, media_type=media_type, filename=filename)
+        else:
+            file = data
+
+        if not file.is_remote:
+            file = await file.as_remote(provider=provider)
+        else:
+            if file.remote_provider != provider:
+                raise ValueError(
+                    f"File is already remote with provider {file.remote_provider}, cannot change provider"
+                )
+
         self.parts.append(file)
         return self
 
-    def add_tool_call(self, id: str, name: str, arguments: dict) -> "Message":
+    def with_tool_call(self, id: str, name: str, arguments: dict) -> "Message":
         """Append a tool call block and return self for chaining."""
         self.parts.append(ToolCall(id=id, name=name, arguments=arguments))
         return self
 
-    def add_tool_result(
+    @deprecated("with_tool_call")
+    def add_tool_call(self, id: str, name: str, arguments: dict) -> "Message":
+        """Append a tool call block and return self for chaining."""
+        return self.with_tool_call(id, name, arguments)
+
+    def with_tool_result(
         self, tool_call_id: str, result: str | list[ToolResultPart]
     ) -> "Message":
         """Append a tool result block and return self for chaining."""
         self.parts.append(ToolResult(tool_call_id=tool_call_id, result=result))
         return self
 
-    def add_thinking(self, content: str) -> "Message":
+    @deprecated("with_tool_result")
+    def add_tool_result(
+        self, tool_call_id: str, result: str | list[ToolResultPart]
+    ) -> "Message":
+        """Append a tool result block and return self for chaining."""
+        return self.with_tool_result(tool_call_id, result)
+
+    def with_thinking(self, content: str) -> "Message":
         """Append a thinking block and return self for chaining."""
         self.parts.append(Thinking(content=content))
         return self
 
+    @deprecated("with_thinking")
+    def add_thinking(self, content: str) -> "Message":
+        """Append a thinking block and return self for chaining."""
+        return self.with_thinking(content)
+
     # -------- convenient constructors --------
     @classmethod
     def user(
@@ -489,25 +586,25 @@ class Message:
     ) -> "Message":
         res = cls("user", [])
         if text is not None:
-            res.add_text(text)
+            res.with_text(text)
         if image is not None:
-            res.add_image(image)
+            res.with_image(image)
         if file is not None:
-            res.add_file(file)
+            res.with_file(file)
         return res
 
     @classmethod
     def system(cls, text: str | None = None) -> "Message":
         res = cls("system", [])
         if text is not None:
-            res.add_text(text)
+            res.with_text(text)
         return res
 
     @classmethod
     def ai(cls, text: str | None = None) -> "Message":
         res = cls("assistant", [])
         if text is not None:
-            res.add_text(text)
+            res.with_text(text)
         return res
 
     # ──── provider-specific constructors ───
@@ -699,9 +796,9 @@ class Conversation:
     ) -> "Conversation":
         msg = Message.user(text)
         if image is not None:
-            msg.add_image(image)
+            msg.with_image(image)
         if file is not None:
-            msg.add_file(file)
+            msg.with_file(file)
         return cls([msg])
 
     @classmethod
@@ -1189,11 +1286,11 @@ class Conversation:
         """
         if self.messages and self.messages[-1].role == "tool":
             # Append to existing tool message (parallel tool calls)
-            self.messages[-1].add_tool_result(tool_call_id, result)
+            self.messages[-1].with_tool_result(tool_call_id, result)
         else:
             # Create new tool message
             tool_msg = Message("tool", [])
-            tool_msg.add_tool_result(tool_call_id, result)
+            tool_msg.with_tool_result(tool_call_id, result)
             self.messages.append(tool_msg)
         return self
 
@@ -1212,11 +1309,11 @@ class Conversation:
                 for i, tool_result in enumerate(m.tool_results):
                     images = tool_result.get_images()
                     if len(images) > 0:
-                        user_msg.add_text(
+                        user_msg.with_text(
                             f"[Images for Tool Call {tool_result.tool_call_id}]"
                         )
                         for img in images:
-                            user_msg.add_image(img)
+                            user_msg.with_image(img)
 
             else:
                 result.append(m.oa_chat())
@@ -1496,9 +1593,21 @@ class Conversation:
         return cls(msgs)
 
 
-def prompts_to_conversations(prompts: Sequence[str | list[dict] | Conversation]):
-    if any(isinstance(x, list) for x in prompts):
-        raise ValueError("can't convert list[dict] to conversation yet")
-    return [  # type: ignore
-        Conversation.user(p) if isinstance(p, str) else p for p in prompts
-    ]
+Prompt: TypeAlias = str | list[dict] | Message | Conversation
+
+
+def prompts_to_conversations(prompts: Sequence[Prompt]) -> Sequence[Prompt]:
+    converted = []
+    for prompt in prompts:
+        if isinstance(prompt, Conversation):
+            converted.append(prompt)
+        elif isinstance(prompt, Message):
+            converted.append(Conversation([prompt]))
+        elif isinstance(prompt, str):
+            converted.append(Conversation.user(prompt))
+        elif isinstance(prompt, list):
+            conv, provider = Conversation.from_unknown(prompt)
+            converted.append(conv)
+        else:
+            raise ValueError(f"Unknown prompt type {type(prompt)}")
+    return converted

lm_deluge/request_context.py

@@ -26,28 +26,22 @@ class RequestContext:
 
     # Infrastructure
     status_tracker: StatusTracker | None = None
-    results_arr: list[Any] | None = (
-        None  # list["APIRequestBase"] but avoiding circular import
-    )
+    # avoiding circular import
+    results_arr: list[Any] | None = None  # list["APIRequestBase"]
     callback: Callable | None = None
 
     # Optional features
     tools: list | None = None
     cache: CachePattern | None = None
     use_responses_api: bool = False
+    background: bool = False
+    service_tier: str | None = None
     extra_headers: dict[str, str] | None = None
+    extra_body: dict[str, Any] | None = None
     force_local_mcp: bool = False
 
     # Computed properties
     cache_key: str = field(init=False)
-    # num_tokens: int = field(init=False)
-
-    # def __post_init__(self):
-    #     # Compute cache key from prompt fingerprint
-    #     # self.cache_key = self.prompt.fingerprint
-
-    #     # Compute token count
-    #     self.num_tokens =
 
     @cached_property
     def num_tokens(self):
@@ -74,6 +68,10 @@ class RequestContext:
             "tools": self.tools,
             "cache": self.cache,
             "use_responses_api": self.use_responses_api,
+            "background": self.background,
+            "service_tier": self.service_tier,
+            "extra_headers": self.extra_headers,
+            "extra_body": self.extra_body,
             "force_local_mcp": self.force_local_mcp,
         }