lm-deluge 0.0.59__py3-none-any.whl → 0.0.61__py3-none-any.whl

lm_deluge/api_requests/anthropic.py

@@ -42,6 +42,14 @@ def _build_anthropic_request(
         "content-type": "application/json",
     }
 
+    # Check if any messages contain uploaded files (file_id)
+    # If so, add the files-api beta header
+    for msg in prompt.messages:
+        for file in msg.files:
+            if file.is_remote and file.remote_provider == "anthropic":
+                _add_beta(base_headers, "files-api-2025-04-14")
+                break
+
     request_json = {
         "model": model.name,
         "messages": messages,

lm_deluge/api_requests/bedrock.py

@@ -1,10 +1,11 @@
 import asyncio
 import json
 import os
-import warnings
 
 from aiohttp import ClientResponse
 
+from lm_deluge.warnings import maybe_warn
+
 try:
     from requests_aws4auth import AWS4Auth
 except ImportError:
@@ -187,9 +188,7 @@ async def _build_openai_bedrock_request(
     # Note: GPT-OSS on Bedrock doesn't support response_format parameter
     # Even though the model supports JSON, we can't use the response_format parameter
     if sampling_params.json_mode and model.supports_json:
-        warnings.warn(
-            f"JSON mode requested for {model.name} but response_format parameter not supported on Bedrock"
-        )
+        maybe_warn("WARN_JSON_MODE_UNSUPPORTED", model_name=model.name)
 
     if tools:
         request_tools = []

lm_deluge/api_requests/gemini.py

@@ -1,11 +1,12 @@
 import json
 import os
-import warnings
 from typing import Any
+
 from aiohttp import ClientResponse
 
 from lm_deluge.request_context import RequestContext
 from lm_deluge.tool import Tool
+from lm_deluge.warnings import maybe_warn
 
 from ..config import SamplingParams
 from ..models import APIModel
@@ -54,9 +55,7 @@ async def _build_gemini_request(
 
     else:
         if sampling_params.reasoning_effort:
-            warnings.warn(
-                f"Ignoring reasoning_effort param for non-reasoning model: {model.name}"
-            )
+            maybe_warn("WARN_REASONING_UNSUPPORTED", model_name=model.name)
 
     # Add tools if provided
     if tools:
@@ -76,8 +75,10 @@ class GeminiRequest(APIRequestBase):
 
         # Warn if cache is specified for Gemini model
         if self.context.cache is not None:
-            warnings.warn(
-                f"Cache parameter '{self.context.cache}' is not supported for Gemini models, ignoring for {self.context.model_name}"
+            maybe_warn(
+                "WARN_CACHING_UNSUPPORTED",
+                model_name=self.context.model_name,
+                cache_param=self.context.cache,
             )
 
         self.model = APIModel.from_registry(self.context.model_name)

lm_deluge/api_requests/mistral.py

@@ -1,9 +1,10 @@
 import json
 import os
-import warnings
 
 from aiohttp import ClientResponse
 
+from lm_deluge.warnings import maybe_warn
+
 from ..models import APIModel
 from ..prompt import Message
 from ..request_context import RequestContext
@@ -17,8 +18,10 @@ class MistralRequest(APIRequestBase):
 
         # Warn if cache is specified for non-Anthropic model
         if self.context.cache is not None:
-            warnings.warn(
-                f"Cache parameter '{self.context.cache}' is only supported for Anthropic models, ignoring for {self.context.model_name}"
+            maybe_warn(
+                "WARN_CACHING_UNSUPPORTED",
+                model_name=self.context.model_name,
+                cache_param=self.context.cache,
             )
         self.model = APIModel.from_registry(self.context.model_name)
 
@@ -38,13 +41,9 @@ class MistralRequest(APIRequestBase):
             "max_tokens": self.context.sampling_params.max_new_tokens,
         }
         if self.context.sampling_params.reasoning_effort:
-            warnings.warn(
-                f"Ignoring reasoning_effort param for non-reasoning model: {self.context.model_name}"
-            )
+            maybe_warn("WARN_REASONING_UNSUPPORTED", model_name=self.context.model_name)
         if self.context.sampling_params.logprobs:
-            warnings.warn(
-                f"Ignoring logprobs param for non-logprobs model: {self.context.model_name}"
-            )
+            maybe_warn("WARN_LOGPROBS_UNSUPPORTED", model_name=self.context.model_name)
         if self.context.sampling_params.json_mode and self.model.supports_json:
             self.request_json["response_format"] = {"type": "json_object"}
 

lm_deluge/api_requests/openai.py

@@ -1,7 +1,6 @@
 import json
 import os
 import traceback as tb
-import warnings
 from types import SimpleNamespace
 
 import aiohttp
@@ -9,6 +8,7 @@ from aiohttp import ClientResponse
 
 from lm_deluge.request_context import RequestContext
 from lm_deluge.tool import MCPServer, Tool
+from lm_deluge.warnings import maybe_warn
 
 from ..config import SamplingParams
 from ..models import APIModel
@@ -75,9 +75,8 @@ async def _build_oa_chat_request(
         request_json["reasoning_effort"] = effort
     else:
         if sampling_params.reasoning_effort:
-            warnings.warn(
-                f"Ignoring reasoning_effort param for non-reasoning model: {model.name}"
-            )
+            maybe_warn("WARN_REASONING_UNSUPPORTED", model_name=context.model_name)
+
     if sampling_params.logprobs:
         request_json["logprobs"] = True
         if sampling_params.top_logprobs is not None:
@@ -105,8 +104,10 @@ class OpenAIRequest(APIRequestBase):
 
         # Warn if cache is specified for non-Anthropic model
         if self.context.cache is not None:
-            warnings.warn(
-                f"Cache parameter '{self.context.cache}' is only supported for Anthropic models, ignoring for {self.context.model_name}"
+            maybe_warn(
+                "WARN_CACHING_UNSUPPORTED",
+                model_name=self.context.model_name,
+                cache_param=self.context.cache,
             )
         self.model = APIModel.from_registry(self.context.model_name)
 
@@ -283,9 +284,7 @@ async def _build_oa_responses_request(
         }
     else:
         if sampling_params.reasoning_effort:
-            warnings.warn(
-                f"Ignoring reasoning_effort for non-reasoning model: {model.id}"
-            )
+            maybe_warn("WARN_REASONING_UNSUPPORTED", model_name=context.model_name)
 
     if sampling_params.json_mode and model.supports_json:
         request_json["text"] = {"format": {"type": "json_object"}}
@@ -322,8 +321,10 @@ class OpenAIResponsesRequest(APIRequestBase):
         super().__init__(context)
         # Warn if cache is specified for non-Anthropic model
         if self.context.cache is not None:
-            warnings.warn(
-                f"Cache parameter '{self.context.cache}' is only supported for Anthropic models, ignoring for {self.context.model_name}"
+            maybe_warn(
+                "WARN_CACHING_UNSUPPORTED",
+                model_name=self.context.model_name,
+                cache_param=self.context.cache,
             )
         self.model = APIModel.from_registry(self.context.model_name)
 
@@ -526,8 +527,10 @@ async def stream_chat(
     extra_headers: dict[str, str] | None = None,
 ):
     if cache is not None:
-        warnings.warn(
-            f"Cache parameter '{cache}' is only supported for Anthropic models, ignoring for {model_name}"
+        maybe_warn(
+            "WARN_CACHING_UNSUPPORTED",
+            model_name=model_name,
+            cache_param=cache,
         )
 
     model = APIModel.from_registry(model_name)

lm_deluge/client.py

@@ -3,6 +3,7 @@ from typing import (
     Any,
     AsyncGenerator,
     Callable,
+    ClassVar,
     Literal,
     Self,
     Sequence,
@@ -31,7 +32,7 @@ from lm_deluge.tool import MCPServer, Tool
 
 from .api_requests.base import APIResponse
 from .config import SamplingParams
-from .models import APIModel, registry
+from .models import APIModel, register_model, registry
 from .request_context import RequestContext
 from .tracker import StatusTracker
 
@@ -43,6 +44,12 @@ class _LLMClient(BaseModel):
     Keeps all validation, serialization, and existing functionality.
     """
 
+    _REASONING_SUFFIXES: ClassVar[dict[str, Literal["low", "medium", "high"]]] = {
+        "-low": "low",
+        "-medium": "medium",
+        "-high": "high",
+    }
+
     model_names: str | list[str] = ["gpt-4.1-mini"]
     name: str | None = None
     max_requests_per_minute: int = 1_000
@@ -117,13 +124,112 @@ class _LLMClient(BaseModel):
 
     # NEW! Builder methods
     def with_model(self, model: str):
-        self.model_names = [model]
+        self._update_models([model])
         return self
 
     def with_models(self, models: list[str]):
-        self.model_names = models
+        self._update_models(models)
         return self
 
+    def _update_models(self, models: list[str]) -> None:
+        normalized, per_model_efforts = self._normalize_model_names(models)
+        if self.reasoning_effort is None:
+            unique_efforts = {eff for eff in per_model_efforts if eff is not None}
+            if len(normalized) == 1 and per_model_efforts[0] is not None:
+                self.reasoning_effort = per_model_efforts[0]
+            elif (
+                len(unique_efforts) == 1
+                and len(unique_efforts) != 0
+                and None not in per_model_efforts
+            ):
+                self.reasoning_effort = next(iter(unique_efforts))  # type: ignore
+        self.model_names = normalized
+        self._align_sampling_params(per_model_efforts)
+        self._reset_model_weights()
+
+    def _normalize_model_names(
+        self, models: list[str]
+    ) -> tuple[list[str], list[Literal["low", "medium", "high"] | None]]:
+        normalized: list[str] = []
+        efforts: list[Literal["low", "medium", "high"] | None] = []
+
+        for name in models:
+            base_name = self._preprocess_openrouter_model(name)
+            trimmed_name, effort = self.__class__._strip_reasoning_suffix_if_registered(
+                base_name
+            )
+            normalized.append(trimmed_name)
+            efforts.append(effort)
+
+        return normalized, efforts
+
+    def _align_sampling_params(
+        self, per_model_efforts: list[Literal["low", "medium", "high"] | None]
+    ) -> None:
+        if len(per_model_efforts) < len(self.model_names):
+            per_model_efforts = per_model_efforts + [None] * (
+                len(self.model_names) - len(per_model_efforts)
+            )
+
+        if not self.model_names:
+            self.sampling_params = []
+            return
+
+        if not self.sampling_params:
+            self.sampling_params = []
+
+        if len(self.sampling_params) == 0:
+            for _ in self.model_names:
+                self.sampling_params.append(
+                    SamplingParams(
+                        temperature=self.temperature,
+                        top_p=self.top_p,
+                        json_mode=self.json_mode,
+                        max_new_tokens=self.max_new_tokens,
+                        reasoning_effort=self.reasoning_effort,
+                        logprobs=self.logprobs,
+                        top_logprobs=self.top_logprobs,
+                    )
+                )
+        elif len(self.sampling_params) == 1 and len(self.model_names) > 1:
+            base_param = self.sampling_params[0]
+            self.sampling_params = [
+                base_param.model_copy(deep=True) for _ in self.model_names
+            ]
+        elif len(self.sampling_params) != len(self.model_names):
+            base_param = self.sampling_params[0]
+            self.sampling_params = [
+                base_param.model_copy(deep=True) for _ in self.model_names
+            ]
+
+        if self.reasoning_effort is not None:
+            for sp in self.sampling_params:
+                sp.reasoning_effort = self.reasoning_effort
+        else:
+            for sp, effort in zip(self.sampling_params, per_model_efforts):
+                if effort is not None:
+                    sp.reasoning_effort = effort
+
+    def _reset_model_weights(self) -> None:
+        if not self.model_names:
+            self.model_weights = []
+            return
+
+        if isinstance(self.model_weights, list):
+            if len(self.model_weights) == len(self.model_names) and any(
+                self.model_weights
+            ):
+                total = sum(self.model_weights)
+                if total == 0:
+                    self.model_weights = [
+                        1 / len(self.model_names) for _ in self.model_names
+                    ]
+                else:
+                    self.model_weights = [w / total for w in self.model_weights]
+                return
+        # Fallback to uniform distribution
+        self.model_weights = [1 / len(self.model_names) for _ in self.model_names]
+
     def with_limits(
         self,
         max_requests_per_minute: int | None = None,
@@ -147,11 +253,64 @@ class _LLMClient(BaseModel):
     def models(self):
         return self.model_names  # why? idk
 
+    @staticmethod
+    def _preprocess_openrouter_model(model_name: str) -> str:
+        """Process openrouter: prefix and register model if needed."""
+        if model_name.startswith("openrouter:"):
+            slug = model_name.split(":", 1)[1]  # Everything after "openrouter:"
+            # Create a unique id by replacing slashes with hyphens
+            model_id = f"openrouter-{slug.replace('/', '-')}"
+
+            # Register the model if not already in registry
+            if model_id not in registry:
+                register_model(
+                    id=model_id,
+                    name=slug,  # The full slug sent to OpenRouter API (e.g., "openrouter/andromeda-alpha")
+                    api_base="https://openrouter.ai/api/v1",
+                    api_key_env_var="OPENROUTER_API_KEY",
+                    api_spec="openai",
+                    supports_json=True,
+                    supports_logprobs=False,
+                    supports_responses=False,
+                    input_cost=0,  # Unknown costs for generic models
+                    cached_input_cost=0,
+                    cache_write_cost=0,
+                    output_cost=0,
+                )
+
+            return model_id
+        return model_name
+
     @model_validator(mode="before")
     @classmethod
     def fix_lists(cls, data) -> "_LLMClient":
-        if isinstance(data.get("model_names"), str):
-            data["model_names"] = [data["model_names"]]
+        # Process model_names - handle both strings and lists
+        model_names = data.get("model_names")
+
+        if isinstance(model_names, str):
+            # Single model as string
+            # First, handle OpenRouter prefix
+            model_name = cls._preprocess_openrouter_model(model_names)
+
+            # Then handle reasoning effort suffix (e.g., "gpt-5-high")
+            model_name, effort = cls._strip_reasoning_suffix_if_registered(model_name)
+            if effort and data.get("reasoning_effort") is None:
+                data["reasoning_effort"] = effort
+
+            data["model_names"] = [model_name]
+
+        elif isinstance(model_names, list):
+            # List of models - process each one
+            processed_models = []
+            for model_name in model_names:
+                # Handle OpenRouter prefix for each model
+                processed_model = cls._preprocess_openrouter_model(model_name)
+                processed_model, _ = cls._strip_reasoning_suffix_if_registered(
+                    processed_model
+                )
+                processed_models.append(processed_model)
+            data["model_names"] = processed_models
+
         if not isinstance(data.get("sampling_params", []), list):
             data["sampling_params"] = [data["sampling_params"]]
         if "sampling_params" not in data or len(data.get("sampling_params", [])) == 0:
@@ -170,6 +329,18 @@ class _LLMClient(BaseModel):
             data["sampling_params"] = data["sampling_params"] * len(data["model_names"])
         return data
 
+    @classmethod
+    def _strip_reasoning_suffix_if_registered(
+        cls, model_name: str
+    ) -> tuple[str, Literal["low", "medium", "high"] | None]:
+        """Remove reasoning suffix only when the trimmed model already exists."""
+        for suffix, effort in cls._REASONING_SUFFIXES.items():
+            if model_name.endswith(suffix) and len(model_name) > len(suffix):
+                candidate = model_name[: -len(suffix)]
+                if candidate in registry:
+                    return candidate, effort
+        return model_name, None
+
     @model_validator(mode="after")
     def validate_client(self) -> Self:
         if isinstance(self.model_names, str):

lm_deluge/file.py

@@ -1,22 +1,35 @@
-from functools import cached_property
-import os
-import io
-import requests
 import base64
+import io
 import mimetypes
-import xxhash
+import os
 from dataclasses import dataclass, field
+from functools import cached_property
 from pathlib import Path
+from typing import Literal
+
+import requests
+import xxhash
 
 
 @dataclass
 class File:
     # raw bytes, pathlike, http url, base64 data url, or file_id
-    data: bytes | io.BytesIO | Path | str
+    data: bytes | io.BytesIO | Path | str | None
     media_type: str | None = None  # inferred if None
+    type: str = field(init=False, default="file")
+    is_remote: bool = False
+    remote_provider: Literal["openai", "anthropic", "google"] | None = None
     filename: str | None = None  # optional filename for uploads
     file_id: str | None = None  # for OpenAI file uploads or Anthropic file API
-    type: str = field(init=False, default="file")
+
+    def __post_init__(self):
+        if self.is_remote:
+            if self.remote_provider is None:
+                raise ValueError("remote_provider must be specified")
+            if self.file_id is None:
+                raise ValueError("file_id must be specified for remote files")
+        if self.file_id and not self.is_remote:
+            print("Warning: File ID specified by file not labeled as remote.")
 
     # helpers -----------------------------------------------------------------
     def _bytes(self) -> bytes:
@@ -75,17 +88,342 @@ class File:
     @cached_property
     def fingerprint(self) -> str:
         # Hash the file contents for fingerprinting
+        if self.is_remote:
+            # For remote files, use provider:file_id for interpretability
+            return f"{self.remote_provider}:{self.file_id}"
         file_bytes = self._bytes()
         return xxhash.xxh64(file_bytes).hexdigest()
 
     @cached_property
     def size(self) -> int:
         """Return file size in bytes."""
+        if self.is_remote:
+            # For remote files, we don't have the bytes available
+            return 0
         return len(self._bytes())
 
+    async def as_remote(
+        self, provider: Literal["openai", "anthropic", "google"]
+    ) -> "File":
+        """Upload file to provider's file API and return new File with file_id.
+
+        Args:
+            provider: The provider to upload to ("openai", "anthropic", or "google")
+
+        Returns:
+            A new File object with file_id set and is_remote=True
+
+        Raises:
+            ValueError: If provider is unsupported or API key is missing
+            RuntimeError: If upload fails
+        """
+        if self.is_remote:
+            # If already remote with same provider, return self
+            if self.remote_provider == provider:
+                return self
+            # Otherwise raise error about cross-provider incompatibility
+            raise ValueError(
+                f"File is already uploaded to {self.remote_provider}. "
+                f"Cannot re-upload to {provider}."
+            )
+
+        if provider == "openai":
+            return await self._upload_to_openai()
+        elif provider == "anthropic":
+            return await self._upload_to_anthropic()
+        elif provider == "google":
+            return await self._upload_to_google()
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+    async def _upload_to_openai(self) -> "File":
+        """Upload file to OpenAI's Files API."""
+        import aiohttp
+
+        api_key = os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable must be set")
+
+        url = "https://api.openai.com/v1/files"
+        headers = {"Authorization": f"Bearer {api_key}"}
+
+        # Get file bytes and metadata
+        file_bytes = self._bytes()
+        filename = self._filename()
+
+        # Create multipart form data
+        data = aiohttp.FormData()
+        data.add_field("purpose", "assistants")
+        data.add_field(
+            "file",
+            file_bytes,
+            filename=filename,
+            content_type=self._mime(),
+        )
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, headers=headers, data=data) as response:
+                    if response.status != 200:
+                        text = await response.text()
+                        raise RuntimeError(f"Failed to upload file to OpenAI: {text}")
+
+                    response_data = await response.json()
+                    file_id = response_data["id"]
+
+            # Return new File object with file_id
+            return File(
+                data=None,
+                media_type=self.media_type,
+                is_remote=True,
+                remote_provider="openai",
+                filename=filename,
+                file_id=file_id,
+            )
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Failed to upload file to OpenAI: {e}")
+
+    async def _upload_to_anthropic(self) -> "File":
+        """Upload file to Anthropic's Files API."""
+        import aiohttp
+
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY environment variable must be set")
+
+        url = "https://api.anthropic.com/v1/files"
+        headers = {
+            "x-api-key": api_key,
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "files-api-2025-04-14",
+        }
+
+        # Get file bytes and metadata
+        file_bytes = self._bytes()
+        filename = self._filename()
+
+        # Create multipart form data
+        data = aiohttp.FormData()
+        data.add_field(
+            "file",
+            file_bytes,
+            filename=filename,
+            content_type=self._mime(),
+        )
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, headers=headers, data=data) as response:
+                    if response.status != 200:
+                        text = await response.text()
+                        raise RuntimeError(
+                            f"Failed to upload file to Anthropic: {text}"
+                        )
+
+                    response_data = await response.json()
+                    file_id = response_data["id"]
+
+            # Return new File object with file_id
+            return File(
+                data=None,
+                media_type=self.media_type,
+                is_remote=True,
+                remote_provider="anthropic",
+                filename=filename,
+                file_id=file_id,
+            )
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Failed to upload file to Anthropic: {e}")
+
+    async def _upload_to_google(self) -> "File":
+        """Upload file to Google Gemini Files API."""
+        import json
+
+        import aiohttp
+
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("GEMINI_API_KEY environment variable must be set")
+
+        # Google uses a different URL structure with the API key as a parameter
+        url = f"https://generativelanguage.googleapis.com/upload/v1beta/files?key={api_key}"
+
+        # Get file bytes and metadata
+        file_bytes = self._bytes()
+        filename = self._filename()
+        mime_type = self._mime()
+
+        # Google expects a multipart request with metadata and file data
+        # Using the resumable upload protocol
+        headers = {
+            "X-Goog-Upload-Protocol": "multipart",
+        }
+
+        # Create multipart form data with metadata and file
+        data = aiohttp.FormData()
+
+        # Add metadata part as JSON
+        metadata = {"file": {"display_name": filename}}
+        data.add_field(
+            "metadata",
+            json.dumps(metadata),
+            content_type="application/json",
+        )
+
+        # Add file data part
+        data.add_field(
+            "file",
+            file_bytes,
+            filename=filename,
+            content_type=mime_type,
+        )
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, headers=headers, data=data) as response:
+                    if response.status not in [200, 201]:
+                        text = await response.text()
+                        raise RuntimeError(f"Failed to upload file to Google: {text}")
+
+                    response_data = await response.json()
+                    # Google returns a file object with a 'name' field like 'files/abc123'
+                    file_uri = response_data.get("file", {}).get(
+                        "uri"
+                    ) or response_data.get("name")
+                    if not file_uri:
+                        raise RuntimeError(
+                            f"No file URI in Google response: {response_data}"
+                        )
+
+            # Return new File object with file_id (using the file URI)
+            return File(
+                data=None,
+                media_type=self.media_type,
+                is_remote=True,
+                remote_provider="google",
+                filename=filename,
+                file_id=file_uri,
+            )
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Failed to upload file to Google: {e}")
+
+    async def delete(self) -> bool:
+        """Delete the uploaded file from the remote provider.
+
+        Returns:
+            True if deletion was successful, False otherwise
+
+        Raises:
+            ValueError: If file is not a remote file or provider is unsupported
+            RuntimeError: If deletion fails
+        """
+        if not self.is_remote:
+            raise ValueError(
+                "Cannot delete a non-remote file. Only remote files can be deleted."
+            )
+
+        if not self.file_id:
+            raise ValueError("Cannot delete file without file_id")
+
+        if self.remote_provider == "openai":
+            return await self._delete_from_openai()
+        elif self.remote_provider == "anthropic":
+            return await self._delete_from_anthropic()
+        elif self.remote_provider == "google":
+            return await self._delete_from_google()
+        else:
+            raise ValueError(f"Unsupported provider: {self.remote_provider}")
+
+    async def _delete_from_openai(self) -> bool:
+        """Delete file from OpenAI's Files API."""
+        import aiohttp
+
+        api_key = os.environ.get("OPENAI_API_KEY")
+        if not api_key:
+            raise ValueError("OPENAI_API_KEY environment variable must be set")
+
+        url = f"https://api.openai.com/v1/files/{self.file_id}"
+        headers = {"Authorization": f"Bearer {api_key}"}
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.delete(url, headers=headers) as response:
+                    if response.status == 200:
+                        return True
+                    else:
+                        text = await response.text()
+                        raise RuntimeError(f"Failed to delete file from OpenAI: {text}")
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Failed to delete file from OpenAI: {e}")
+
+    async def _delete_from_anthropic(self) -> bool:
+        """Delete file from Anthropic's Files API."""
+        import aiohttp
+
+        api_key = os.environ.get("ANTHROPIC_API_KEY")
+        if not api_key:
+            raise ValueError("ANTHROPIC_API_KEY environment variable must be set")
+
+        url = f"https://api.anthropic.com/v1/files/{self.file_id}"
+        headers = {
+            "x-api-key": api_key,
+            "anthropic-version": "2023-06-01",
+            "anthropic-beta": "files-api-2025-04-14",
+        }
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.delete(url, headers=headers) as response:
+                    if response.status == 200:
+                        return True
+                    else:
+                        text = await response.text()
+                        raise RuntimeError(
+                            f"Failed to delete file from Anthropic: {text}"
+                        )
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Failed to delete file from Anthropic: {e}")
+
+    async def _delete_from_google(self) -> bool:
+        """Delete file from Google Gemini Files API."""
+        import aiohttp
+
+        api_key = os.environ.get("GEMINI_API_KEY")
+        if not api_key:
+            raise ValueError("GEMINI_API_KEY environment variable must be set")
+
+        # Google file_id is the full URI like "https://generativelanguage.googleapis.com/v1beta/files/abc123"
+        # We need to extract just the file name part for the delete endpoint
+        assert self.file_id, "can't delete file with no file id"
+        if self.file_id.startswith("https://"):
+            # Extract the path after the domain
+            file_name = self.file_id.split("/v1beta/")[-1]
+        else:
+            file_name = self.file_id
+
+        url = f"https://generativelanguage.googleapis.com/v1beta/{file_name}?key={api_key}"
+
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.delete(url) as response:
+                    if response.status in [200, 204]:
+                        return True
+                    else:
+                        text = await response.text()
+                        raise RuntimeError(f"Failed to delete file from Google: {text}")
+        except aiohttp.ClientError as e:
+            raise RuntimeError(f"Failed to delete file from Google: {e}")
+
     # ── provider-specific emission ────────────────────────────────────────────
     def oa_chat(self) -> dict:
         """For OpenAI Chat Completions - file content as base64 or file_id."""
+        # Validate provider compatibility
+        if self.is_remote and self.remote_provider != "openai":
+            raise ValueError(
+                f"Cannot emit file uploaded to {self.remote_provider} as OpenAI format. "
+                f"File must be uploaded to OpenAI or provided as raw data."
+            )
+
         if self.file_id:
             return {
                 "type": "file",
@@ -104,6 +442,13 @@ class File:
 
     def oa_resp(self) -> dict:
         """For OpenAI Responses API - file content as base64 or file_id."""
+        # Validate provider compatibility
+        if self.is_remote and self.remote_provider != "openai":
+            raise ValueError(
+                f"Cannot emit file uploaded to {self.remote_provider} as OpenAI format. "
+                f"File must be uploaded to OpenAI or provided as raw data."
+            )
+
         if self.file_id:
             return {
                 "type": "input_file",
@@ -118,6 +463,13 @@ class File:
 
     def anthropic(self) -> dict:
         """For Anthropic Messages API - file content as base64 or file_id."""
+        # Validate provider compatibility
+        if self.is_remote and self.remote_provider != "anthropic":
+            raise ValueError(
+                f"Cannot emit file uploaded to {self.remote_provider} as Anthropic format. "
+                f"File must be uploaded to Anthropic or provided as raw data."
+            )
+
         if self.file_id:
             return {
                 "type": "document",
@@ -145,13 +497,30 @@ class File:
         return filename, content, media_type
 
     def gemini(self) -> dict:
-        """For Gemini API - files are provided as inline data."""
-        return {
-            "inlineData": {
-                "mimeType": self._mime(),
-                "data": self._base64(include_header=False),
+        """For Gemini API - files are provided as inline data or file URI."""
+        # Validate provider compatibility
+        if self.is_remote and self.remote_provider != "google":
+            raise ValueError(
+                f"Cannot emit file uploaded to {self.remote_provider} as Google format. "
+                f"File must be uploaded to Google or provided as raw data."
+            )
+
+        if self.file_id:
+            # Use file URI for uploaded files
+            return {
+                "fileData": {
+                    "mimeType": self._mime(),
+                    "fileUri": self.file_id,
+                }
+            }
+        else:
+            # Use inline data for non-uploaded files
+            return {
+                "inlineData": {
+                    "mimeType": self._mime(),
+                    "data": self._base64(include_header=False),
+                }
             }
-        }
 
     def mistral(self) -> dict:
         """For Mistral API - not yet supported."""

lm_deluge/models/openai.py

@@ -10,6 +10,20 @@ OPENAI_MODELS = {
     #                ░███
     #                █████
     #               ░░░░░
+    "gpt-5-codex": {
+        "id": "gpt-5-codex",
+        "name": "gpt-5-codex",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": False,
+        "supports_logprobs": True,
+        "supports_responses": True,
+        "api_spec": "openai",
+        "input_cost": 1.25,
+        "cached_input_cost": 0.125,
+        "output_cost": 10.0,
+        "reasoning_model": True,
+    },
     "gpt-5": {
         "id": "gpt-5",
         "name": "gpt-5",
@@ -79,6 +93,20 @@ OPENAI_MODELS = {
         "output_cost": 12.0,
         "reasoning_model": False,
     },
+    "codex-mini-latest": {
+        "id": "codex-mini-latest",
+        "name": "codex-mini-latest",
+        "api_base": "https://api.openai.com/v1",
+        "api_key_env_var": "OPENAI_API_KEY",
+        "supports_json": True,
+        "supports_logprobs": False,
+        "supports_responses": True,
+        "api_spec": "openai",
+        "input_cost": 1.5,
+        "cached_input_cost": 0.375,
+        "output_cost": 6.0,
+        "reasoning_model": True,
+    },
     "o3": {
         "id": "o3",
         "name": "o3-2025-04-16",

lm_deluge/prompt.py

@@ -9,6 +9,7 @@ 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",
@@ -415,12 +416,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,
         *,
@@ -446,7 +452,27 @@ class Message:
         self.parts.append(img)
         return self
 
-    def add_file(
+    @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,
         *,
@@ -460,11 +486,29 @@ class Message:
         self.parts.append(file)
         return self
 
-    def add_tool_call(self, id: str, name: str, arguments: dict) -> "Message":
+    @deprecated("with_file")
+    def add_file(
+        self,
+        data: bytes | str | Path | io.BytesIO,
+        *,
+        media_type: str | None = None,
+        filename: str | None = None,
+    ) -> "Message":
+        """
+        Append a file block and return self for chaining.
+        """
+        return self.with_file(data, media_type=media_type, filename=filename)
+
+    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
 
+    @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":
@@ -472,11 +516,23 @@ class Message:
         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(
@@ -488,25 +544,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 ───
@@ -698,9 +754,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
@@ -1211,11 +1267,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())

lm_deluge/warnings.py

@@ -0,0 +1,46 @@
+import functools
+import os
+import warnings
+
+WARNINGS: dict[str, str] = {
+    "WARN_JSON_MODE_UNSUPPORTED": "JSON mode requested for {model_name} but response_format parameter not supported.",
+    "WARN_REASONING_UNSUPPORTED": "Ignoring reasoning_effort param for non-reasoning model: {model_name}.",
+    "WARN_CACHING_UNSUPPORTED": "Cache parameter '{cache_param}' is not supported, ignoring for {model_name}.",
+    "WARN_LOGPROBS_UNSUPPORTED": "Ignoring logprobs param for non-logprobs model: {model_name}",
+}
+
+
+def maybe_warn(warning: str, **kwargs):
+    if os.getenv(warning):
+        pass
+    else:
+        warnings.warn(WARNINGS[warning].format(**kwargs))
+        os.environ[warning] = "1"
+
+
+def deprecated(replacement: str):
+    """Decorator to mark methods as deprecated and suggest replacement.
+
+    Only shows the warning once per method to avoid spam.
+
+    Args:
+        replacement: The name of the replacement method to suggest
+    """
+
+    def decorator(func):
+        warning_key = f"DEPRECATED_{func.__module__}_{func.__qualname__}"
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            if not os.getenv(warning_key):
+                warnings.warn(
+                    f"{func.__name__} is deprecated, use {replacement} instead",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
+                os.environ[warning_key] = "1"
+            return func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

{lm_deluge-0.0.59.dist-info → lm_deluge-0.0.61.dist-info}/METADATA

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

{lm_deluge-0.0.59.dist-info → lm_deluge-0.0.61.dist-info}/RECORD

@@ -2,26 +2,27 @@ lm_deluge/__init__.py,sha256=LKKIcqQoQyDpTck6fnB7iAs75BnfNNa3Bj5Nz7KU4Hk,376
 lm_deluge/batches.py,sha256=Km6QM5_7BlF2qEyo4WPlhkaZkpzrLqf50AaveHXQOoY,25127
 lm_deluge/cache.py,sha256=xO2AIYvP3tUpTMKQjwQQYfGRJSRi6e7sMlRhLjsS-u4,4873
 lm_deluge/cli.py,sha256=Ilww5gOw3J5v0NReq_Ra4hhxU4BCIJBl1oTGxJZKedc,12065
-lm_deluge/client.py,sha256=jDXGC032MmBfAFDHdWNm23gdDP9pCiNeU-wIi9RCG5g,33616
+lm_deluge/client.py,sha256=TKRN1KAMOgtQFLazh_iyj185GBHtP7r8KAU4lod-qfs,40693
 lm_deluge/config.py,sha256=H1tQyJDNHGFuwxqQNL5Z-CjWAC0luHSBA3iY_pxmACM,932
 lm_deluge/embed.py,sha256=CO-TOlC5kOTAM8lcnicoG4u4K664vCBwHF1vHa-nAGg,13382
 lm_deluge/errors.py,sha256=oHjt7YnxWbh-eXMScIzov4NvpJMo0-2r5J6Wh5DQ1tk,209
-lm_deluge/file.py,sha256=FGomcG8s2go_55Z2CChflHgmU-UqgFftgFY8c7f_G70,5631
+lm_deluge/file.py,sha256=PTmlJQ-IaYcYUFun9V0bJ1NPVP84edJrR0hvCMWFylY,19697
 lm_deluge/image.py,sha256=5AMXmn2x47yXeYNfMSMAOWcnlrOxxOel-4L8QCJwU70,8928
-lm_deluge/prompt.py,sha256=fm-wUkf5YMz1NXwFTlzjckwxoWW7cXhN2Z01zrQPO5E,60001
+lm_deluge/prompt.py,sha256=1hGLOIwdyGFokKv0dPiVpke3OPHD6vK5qO6q9E8H89Y,62020
 lm_deluge/request_context.py,sha256=cBayMFWupWhde2OjRugW3JH-Gin-WFGc6DK2Mb4Prdc,2576
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
 lm_deluge/tool.py,sha256=eZpzgkSIlGD7KdZQwzLF-UdyRJpRnNNXpceGJrNhRrE,26421
 lm_deluge/tracker.py,sha256=aeS9GUJpgOSQRVXAnGDvlMO8qYpSxpTNLYj2hrMg0m8,14757
 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=7tTb_NMPodDHrCzakrLd9LyXuLqeTQyAGU-FvMoV3gI,8437
+lm_deluge/api_requests/anthropic.py,sha256=i4coscYQcg3TKkTJPoIvVAP5rY4HQA7Dt4P-OYTgBNw,8762
 lm_deluge/api_requests/base.py,sha256=GCcydwBRx4_xAuYLvasXlyj-TgqvKAVhVvxRfJkvPbY,9471
-lm_deluge/api_requests/bedrock.py,sha256=GmVxXz3ERAeQ7e52Nlztt81O4H9eJOQeOnS6b65vjm4,15453
+lm_deluge/api_requests/bedrock.py,sha256=Uppne03GcIEk1tVYzoGu7GXK2Sg94a_xvFTLDRN_phY,15412
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
-lm_deluge/api_requests/gemini.py,sha256=COHqPWmeaq9fpg0YwOZqQTUbijKnXNF4cvMLnW9kLl8,7857
-lm_deluge/api_requests/mistral.py,sha256=S_LpOfCGbCVEROH_od3P-tYeNYTKFMamMTL-c_wFCBI,4597
-lm_deluge/api_requests/openai.py,sha256=_da5n2FECjzKFj0fD9BzSUm2E_E0tSgGAMBk9mHOBjc,24908
+lm_deluge/api_requests/gemini.py,sha256=4uD7fQl0yWyAvYkPNi3oO1InBnvYfo5_QR6k-va-2GI,7838
+lm_deluge/api_requests/mistral.py,sha256=8JZP2CDf1XZfaPcTk0WS4q-VfYYj58ptpoH8LD3MQG4,4528
+lm_deluge/api_requests/openai.py,sha256=qRBakHOOMYJWvKO0HeeE5C1Dv_dbokuizZin9Ca4k_k,24855
 lm_deluge/api_requests/response.py,sha256=vG194gAH5p7ulpNy4qy5Pryfb1p3ZV21-YGoj__ru3E,7436
 lm_deluge/api_requests/deprecated/bedrock.py,sha256=WrcIShCoO8JCUSlFOCHxg6KQCNTZfw3TpYTvSpYk4mA,11320
 lm_deluge/api_requests/deprecated/cohere.py,sha256=KgDScD6_bWhAzOY5BHZQKSA3kurt4KGENqC4wLsGmcU,5142
@@ -53,7 +54,7 @@ lm_deluge/models/grok.py,sha256=TDzr8yfTaHbdJhwMA-Du6L-efaKFJhjTQViuVElCCHI,2566
 lm_deluge/models/groq.py,sha256=Mi5WE1xOBGoZlymD0UN6kzhH_NOmfJYU4N2l-TO0Z8Q,2552
 lm_deluge/models/meta.py,sha256=BBgnscL1gMcIdPbRqrlDl_q9YAYGSrkw9JkAIabXtLs,1883
 lm_deluge/models/mistral.py,sha256=x67o5gckBGmPcIGdVbS26XZAYFKBYM4tsxEAahGp8bk,4323
-lm_deluge/models/openai.py,sha256=HC_oNLmKkmShkcfeUgyhesACtXGg__I2WiIIDrN-X84,10176
+lm_deluge/models/openai.py,sha256=6J4eAt6Iu5RopokyldUQzRlviFBXBqhLqpVP5tztzqI,11074
 lm_deluge/models/openrouter.py,sha256=O-Po4tmHjAqFIVU96TUL0QnK01R4e2yDN7Z4sYJ-CuE,2120
 lm_deluge/models/together.py,sha256=AjKhPsazqBgqyLwHkNQW07COM1n_oSrYQRp2BFVvn9o,4381
 lm_deluge/presets/cerebras.py,sha256=MDkqj15qQRrj8wxSCDNNe_Cs7h1WN1UjV6lTmSY1olQ,479
@@ -64,8 +65,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.59.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.59.dist-info/METADATA,sha256=WKLfnV3lKGr1gkfEEyDhbp4oGMsu30LRXs0zPLRsdsk,13443
-lm_deluge-0.0.59.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.59.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.59.dist-info/RECORD,,
+lm_deluge-0.0.61.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.61.dist-info/METADATA,sha256=TKr3MSJYw8Hx4Qx5dmldB5UiS1fqeiwcZRIolb6W4ug,13443
+lm_deluge-0.0.61.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.61.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.61.dist-info/RECORD,,