lm-deluge 0.0.60__tar.gz → 0.0.62__tar.gz

{lm_deluge-0.0.60/src/lm_deluge.egg-info → lm_deluge-0.0.62}/PKG-INFO

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

{lm_deluge-0.0.60 → lm_deluge-0.0.62}/pyproject.toml

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

{lm_deluge-0.0.60 → lm_deluge-0.0.62}/src/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-0.0.60 → lm_deluge-0.0.62}/src/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
@@ -143,23 +150,15 @@ class _LLMClient(BaseModel):
     def _normalize_model_names(
         self, models: list[str]
     ) -> tuple[list[str], list[Literal["low", "medium", "high"] | None]]:
-        reasoning_effort_suffixes: dict[str, Literal["low", "medium", "high"]] = {
-            "-low": "low",
-            "-medium": "medium",
-            "-high": "high",
-        }
         normalized: list[str] = []
         efforts: list[Literal["low", "medium", "high"] | None] = []
 
         for name in models:
-            base_name = name
-            effort: Literal["low", "medium", "high"] | None = None
-            for suffix, candidate in reasoning_effort_suffixes.items():
-                if name.endswith(suffix) and len(name) > len(suffix):
-                    base_name = name[: -len(suffix)]
-                    effort = candidate
-                    break
-            normalized.append(base_name)
+            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
@@ -254,31 +253,63 @@ 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":
-        # Parse reasoning effort from model name suffixes (e.g., "gpt-5-high")
-        # Only applies when a single model string is provided
-        if isinstance(data.get("model_names"), str):
-            model_name = data["model_names"]
-            reasoning_effort_suffixes = {
-                "-low": "low",
-                "-medium": "medium",
-                "-high": "high",
-            }
-
-            for suffix, effort in reasoning_effort_suffixes.items():
-                if model_name.endswith(suffix):
-                    # Extract base model name by removing suffix
-                    base_model = model_name[: -len(suffix)]
-                    data["model_names"] = base_model
-
-                    # Set reasoning_effort if not already explicitly set
-                    if data.get("reasoning_effort") is None:
-                        data["reasoning_effort"] = effort
-                    break
-
-            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"]]
@@ -298,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):