lm-deluge 0.0.78__py3-none-any.whl → 0.0.80__py3-none-any.whl

lm_deluge/api_requests/anthropic.py

@@ -16,6 +16,7 @@ from lm_deluge.util.schema import (
     prepare_output_schema,
     transform_schema_for_anthropic,
 )
+from lm_deluge.warnings import maybe_warn
 
 from ..models import APIModel
 from .base import APIRequestBase, APIResponse
@@ -62,20 +63,45 @@ def _build_anthropic_request(
         "max_tokens": sampling_params.max_new_tokens,
     }
 
+    if model.id == "claude-4.5-opus" and sampling_params.global_effort:
+        request_json["effort"] = sampling_params.global_effort
+        _add_beta(base_headers, "effort-2025-11-24")
+
     # handle thinking
-    if model.reasoning_model and sampling_params.reasoning_effort:
-        # translate reasoning effort of low, medium, high to budget tokens
-        budget = {"minimal": 256, "low": 1024, "medium": 4096, "high": 16384}.get(
-            sampling_params.reasoning_effort
-        )
-        request_json["thinking"] = {
-            "type": "enabled",
-            "budget_tokens": budget,
-        }
-        if "top_p" in request_json:
-            request_json["top_p"] = max(request_json["top_p"], 0.95)
-        request_json["temperature"] = 1.0
-        request_json["max_tokens"] += budget
+    if model.reasoning_model:
+        if (
+            sampling_params.thinking_budget is not None
+            and sampling_params.reasoning_effort is not None
+        ):
+            maybe_warn("WARN_THINKING_BUDGET_AND_REASONING_EFFORT")
+
+        if sampling_params.thinking_budget is not None:
+            budget = sampling_params.thinking_budget
+        elif sampling_params.reasoning_effort is not None:
+            # translate reasoning effort of low, medium, high to budget tokens
+            budget = {
+                "none": 0,
+                "minimal": 256,
+                "low": 1024,
+                "medium": 4096,
+                "high": 16384,
+            }.get(sampling_params.reasoning_effort)
+            assert isinstance(budget, int)
+        else:
+            budget = 0
+
+        if budget > 0:
+            request_json["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": budget,
+            }
+            if "top_p" in request_json:
+                request_json["top_p"] = max(request_json["top_p"], 0.95)
+            request_json["temperature"] = 1.0
+            request_json["max_tokens"] += budget
+        else:
+            request_json["thinking"] = {"type": "disabled"}
+
     else:
         request_json["thinking"] = {"type": "disabled"}
         if sampling_params.reasoning_effort:
@@ -83,10 +109,11 @@ def _build_anthropic_request(
     if system_message is not None:
         request_json["system"] = system_message
 
-    # handle temp + top_p for opus 4.1/sonnet 4.5
+    # handle temp + top_p for opus 4.1/sonnet 4.5.
+    # TODO: make clearer / more user-friendly so there can be NotGiven
+    # and user can control which one they want to use
     if "4-1" in model.name or "4-5" in model.name:
-        if "temperature" in request_json and "top_p" in request_json:
-            request_json.pop("top_p")
+        request_json.pop("top_p")
 
     # Handle structured outputs (output_format)
     if context.output_schema:

lm_deluge/api_requests/gemini.py

@@ -1,6 +1,5 @@
 import json
 import os
-from typing import Any
 
 from aiohttp import ClientResponse
 
@@ -23,6 +22,21 @@ async def _build_gemini_request(
 ) -> dict:
     system_message, messages = prompt.to_gemini()
 
+    # For Gemini 3, inject dummy signatures when missing for function calls
+    is_gemini_3 = "gemini-3" in model.name.lower()
+    if is_gemini_3:
+        dummy_sig = "context_engineering_is_the_way_to_go"
+        for msg in messages:
+            if "parts" in msg:
+                for part in msg["parts"]:
+                    # For function calls, inject dummy signature if missing
+                    if "functionCall" in part and "thoughtSignature" not in part:
+                        part["thoughtSignature"] = dummy_sig
+                        maybe_warn(
+                            "WARN_GEMINI3_MISSING_SIGNATURE",
+                            part_type="function call",
+                        )
+
     request_json = {
         "contents": messages,
         "generationConfig": {
@@ -37,20 +51,61 @@ async def _build_gemini_request(
         request_json["systemInstruction"] = {"parts": [{"text": system_message}]}
 
     # Handle reasoning models (thinking)
-    if model.reasoning_model:
-        thinking_config: dict[str, Any] | None = None
-        effort = sampling_params.reasoning_effort
-        if effort is None or effort == "none":
-            budget = 128 if "2.5-pro" in model.id else 0
-            # Explicitly disable thoughts when no effort is requested
-            thinking_config = {"includeThoughts": False, "thinkingBudget": budget}
+    is_gemini_3 = "gemini-3" in model.name.lower()
+    if is_gemini_3:
+        # gemini3 MUST think
+        if not sampling_params.reasoning_effort:
+            maybe_warn("WARN_GEMINI3_NO_REASONING")
+            effort = "low"
         else:
-            thinking_config = {"includeThoughts": True}
-            if effort in {"minimal", "low", "medium", "high"} and "flash" in model.id:
-                budget = {"minimal": 256, "low": 1024, "medium": 4096, "high": 16384}[
-                    effort
-                ]
-                thinking_config["thinkingBudget"] = budget
+            level_map = {
+                "none": "low",
+                "minimal": "low",
+                "low": "low",
+                "medium": "high",  # change when supported
+                "high": "high",
+            }
+            effort = level_map[sampling_params.reasoning_effort]
+        thinking_config = {"thinkingLevel": effort}
+        request_json["generationConfig"]["thinkingConfig"] = thinking_config
+
+    elif model.reasoning_model:
+        if (
+            sampling_params.thinking_budget is not None
+            and sampling_params.reasoning_effort is not None
+        ):
+            maybe_warn("WARN_THINKING_BUDGET_AND_REASONING_EFFORT")
+
+        if (
+            sampling_params.thinking_budget is not None
+            and sampling_params.thinking_budget > 0
+        ):
+            thinking_config = {
+                "includeThoughts": True,
+                "thinkingBudget": sampling_params.thinking_budget,
+            }
+        elif sampling_params.thinking_budget == -1:
+            # dynamic thinking
+            thinking_config = {"includeThoughts": True, "thinkingBudget": -1}
+        elif sampling_params.reasoning_effort not in [None, "none"]:
+            level_map = {
+                "minimal": 256,
+                "low": 1024,
+                "medium": 4096,
+                "high": 16384,
+            }
+            assert sampling_params.reasoning_effort in level_map
+            budget = level_map[sampling_params.reasoning_effort]
+            if "flash-lite" in model.id:
+                budget = max(budget, 512)
+            thinking_config = {"includeThoughts": True, "thinkingBudget": budget}
+        elif "2.5-pro" in model.id:
+            # 2.5 pro must think.
+            thinking_config = {"includeThoughts": True, "thinkingBudget": 128}
+        else:
+            # no thoughts head empty
+            thinking_config = {"includeThoughts": False, "thinkingBudget": 0}
+
         request_json["generationConfig"]["thinkingConfig"] = thinking_config
 
     else:
@@ -66,6 +121,21 @@ async def _build_gemini_request(
     if sampling_params.json_mode and model.supports_json:
         request_json["generationConfig"]["responseMimeType"] = "application/json"
 
+    # Handle media_resolution for Gemini 3 (requires v1alpha)
+    if sampling_params.media_resolution is not None:
+        is_gemini_3 = "gemini-3" in model.name.lower()
+        if is_gemini_3:
+            # Add global media resolution to generationConfig
+            request_json["generationConfig"]["mediaResolution"] = {
+                "level": sampling_params.media_resolution
+            }
+        else:
+            # Warn if trying to use media_resolution on non-Gemini-3 models
+            maybe_warn(
+                "WARN_MEDIA_RESOLUTION_UNSUPPORTED",
+                model_name=model.name,
+            )
+
     return request_json
 
 
@@ -137,10 +207,19 @@ class GeminiRequest(APIRequestBase):
                         candidate = data["candidates"][0]
                         if "content" in candidate and "parts" in candidate["content"]:
                             for part in candidate["content"]["parts"]:
+                                # Extract thought signature if present
+                                thought_sig = part.get("thoughtSignature")
+
                                 if "text" in part:
                                     parts.append(Text(part["text"]))
                                 elif "thought" in part:
-                                    parts.append(Thinking(part["thought"]))
+                                    # Thought with optional signature
+                                    parts.append(
+                                        Thinking(
+                                            content=part["thought"],
+                                            thought_signature=thought_sig,
+                                        )
+                                    )
                                 elif "functionCall" in part:
                                     func_call = part["functionCall"]
                                     # Generate a unique ID since Gemini doesn't provide one
@@ -152,6 +231,7 @@ class GeminiRequest(APIRequestBase):
                                             id=tool_id,
                                             name=func_call["name"],
                                             arguments=func_call.get("args", {}),
+                                            thought_signature=thought_sig,
                                         )
                                     )
 

lm_deluge/client.py

@@ -79,7 +79,7 @@ class _LLMClient(BaseModel):
     background: bool = False
     # sampling params - if provided, and sampling_params is not,
     # these override the defaults
-    temperature: float = 0.75
+    temperature: float = 1.0
     top_p: float = 1.0
     json_mode: bool = False
     max_new_tokens: int = 512
@@ -262,6 +262,7 @@ class _LLMClient(BaseModel):
             self.max_tokens_per_minute = max_tokens_per_minute
         if max_concurrent_requests:
             self.max_concurrent_requests = max_concurrent_requests
+        return self
 
     def _get_tracker(self) -> StatusTracker:
         if self._tracker is None:
@@ -336,7 +337,7 @@ class _LLMClient(BaseModel):
         if "sampling_params" not in data or len(data.get("sampling_params", [])) == 0:
             data["sampling_params"] = [
                 SamplingParams(
-                    temperature=data.get("temperature", 0.75),
+                    temperature=data.get("temperature", 1.0),
                     top_p=data.get("top_p", 1.0),
                     json_mode=data.get("json_mode", False),
                     max_new_tokens=data.get("max_new_tokens", 512),
@@ -1066,7 +1067,7 @@ def LLMClient(
     extra_headers: dict[str, str] | None = None,
     use_responses_api: bool = False,
     background: bool = False,
-    temperature: float = 0.75,
+    temperature: float = 1.0,
     top_p: float = 1.0,
     json_mode: bool = False,
     max_new_tokens: int = 512,
@@ -1095,7 +1096,7 @@ def LLMClient(
     extra_headers: dict[str, str] | None = None,
     use_responses_api: bool = False,
     background: bool = False,
-    temperature: float = 0.75,
+    temperature: float = 1.0,
     top_p: float = 1.0,
     json_mode: bool = False,
     max_new_tokens: int = 512,
@@ -1123,7 +1124,7 @@ def LLMClient(
     extra_headers: dict[str, str] | None = None,
     use_responses_api: bool = False,
     background: bool = False,
-    temperature: float = 0.75,
+    temperature: float = 1.0,
     top_p: float = 1.0,
     json_mode: bool = False,
     max_new_tokens: int = 512,

lm_deluge/config.py

@@ -4,14 +4,23 @@ from pydantic import BaseModel
 
 
 class SamplingParams(BaseModel):
-    temperature: float = 0.0
+    temperature: float = 1.0  # more typical for new models
     top_p: float = 1.0
     json_mode: bool = False
     max_new_tokens: int = 2_048
+    global_effort: Literal["low", "medium", "high"] = "high"  # for opus-4.5
     reasoning_effort: Literal["low", "medium", "high", "minimal", "none", None] = None
+    thinking_budget: int | None = None
     logprobs: bool = False
     top_logprobs: int | None = None
     strict_tools: bool = True
+    # Gemini 3 only - controls multimodal vision processing fidelity
+    media_resolution: (
+        Literal[
+            "media_resolution_low", "media_resolution_medium", "media_resolution_high"
+        ]
+        | None
+    ) = None
 
     def to_vllm(self):
         try:

lm_deluge/llm_tools/sandbox.py

@@ -0,0 +1,523 @@
+import secrets
+
+from lm_deluge.tool import Tool
+
+
+class ModalSandbox:
+    def __init__(self, app_name: str | None = None, *, block_network: bool = False):
+        import modal
+
+        app_name = app_name or secrets.token_urlsafe(32)
+        app = modal.App.lookup(app_name, create_if_missing=True)
+        self.app = app
+        self.block_network = block_network
+        self.sb = modal.Sandbox.create(app=app, block_network=block_network)
+        self.last_process = None
+        self._destroyed = False
+
+    def __enter__(self):
+        """Synchronous context manager entry (use async with for async support)."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Synchronous context manager exit - cleanup sandbox."""
+        if not self._destroyed:
+            self._destroy()
+        return False
+
+    def __del__(self):
+        """Cleanup sandbox when garbage collected (backup cleanup)."""
+        if not self._destroyed:
+            try:
+                self._destroy()
+            except Exception:
+                # Ignore errors during cleanup in __del__
+                pass
+
+    @staticmethod
+    async def _safe_read(process, max_lines: int = 25, max_chars: int = 2500):
+        result = await process.stdout.read.aio()
+
+        if len(result) > max_chars:
+            result = result[-max_chars:]
+
+        lines = result.splitlines()
+        lines = lines[-max_lines:]
+
+        return "\n".join(lines)
+
+    async def _exec(
+        self, cmd: list[str], timeout: int = 5, check: bool = False
+    ) -> str | None:
+        process = await self.sb.exec.aio(*cmd, timeout=timeout)
+        self.last_process = process
+        if check:
+            return await self._safe_read(process)
+
+    async def _read(self, limit: int = 25):
+        if not self.last_process:
+            return None
+        return await self._safe_read(self.last_process)
+
+    def _get_credentials(self):
+        if self.block_network:
+            return None
+        creds = self.sb.create_connect_token(user_metadata={"user_id": "foo"})
+
+        return creds  # f"URL: {creds.url}; Token: {creds.token}"
+
+    def _destroy(self):
+        """Destroy the sandbox and mark as destroyed."""
+        if not self._destroyed:
+            self.sb.terminate()
+            self._destroyed = True
+
+    def get_tools(self):
+        bash_tool = Tool(
+            name="bash",
+            description=(
+                "Execute a bash command in the sandbox environment. "
+                "Provide the command as a list of strings (e.g., ['ls', '-la']). "
+                "Optionally set a timeout in seconds and check=True to immediately read the output."
+            ),
+            run=self._exec,
+            parameters={
+                "cmd": {
+                    "type": "array",
+                    "description": "The command to execute as a list of strings (e.g., ['python', 'script.py'])",
+                    "items": {"type": "string"},
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in seconds for the command execution (default: 5)",
+                },
+                "check": {
+                    "type": "boolean",
+                    "description": "If true, immediately read and return the last line of stdout (default: false)",
+                },
+            },
+            required=["cmd"],
+        )
+
+        stdout_tool = Tool(
+            name="read_stdout",
+            description=(
+                "Read the most recent stdout output from the bash shell. "
+                "ONLY returns stdout from the most recent command, "
+                "cannot be used to get output from previous commands. "
+                "Returns the last `limit` lines of stdout (default: 25 lines)."
+            ),
+            run=self._read,
+            parameters={
+                "limit": {
+                    "type": "integer",
+                    "description": "Maximum number of recent lines to return (default: 25)",
+                }
+            },
+            required=[],
+        )
+
+        tunnel_tool = Tool(
+            name="tunnel",
+            description=(
+                "Opens a tunnel on port 8080 and returns a URL and token to connect to it. "
+                "Useful for exposing a local server or application to the user. "
+                "Only works when network is enabled (block_network=False)."
+            ),
+            run=self._get_credentials,
+            parameters={},
+            required=[],
+        )
+
+        return [bash_tool, stdout_tool, tunnel_tool]
+
+
+class DaytonaSandbox:
+    def __init__(
+        self,
+        api_key: str | None = None,
+        api_url: str | None = None,
+        target: str | None = None,
+        sandbox_id: str | None = None,
+        language: str = "python",
+        auto_start: bool = True,
+    ):
+        """
+        Initialize a Daytona sandbox.
+
+        Args:
+            api_key: Daytona API key (if None, will look for DAYTONA_API_KEY env var)
+            api_url: Daytona API URL (if None, will look for DAYTONA_API_URL env var)
+            target: Daytona target (if None, will look for DAYTONA_TARGET env var)
+            sandbox_id: ID of existing sandbox to connect to (if None, creates a new one)
+            language: Programming language for the sandbox (default: python)
+            auto_start: Whether to automatically start the sandbox if stopped
+        """
+        import os
+
+        self.api_key = api_key or os.getenv("DAYTONA_API_KEY")
+        self.api_url = api_url or os.getenv("DAYTONA_API_URL")
+        self.target = target or os.getenv("DAYTONA_TARGET")
+        self.sandbox_id = sandbox_id
+        self.language = language
+        self.auto_start = auto_start
+        self.sandbox = None
+        self.client = None
+        self._initialized = False
+        self._destroyed = False
+
+    async def __aenter__(self):
+        """Async context manager entry - initialize sandbox."""
+        await self._ensure_initialized()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit - cleanup sandbox."""
+        if not self._destroyed:
+            await self._destroy()
+        return False
+
+    def __del__(self):
+        """Cleanup sandbox when garbage collected (backup cleanup).
+
+        Note: This attempts sync cleanup which may not work perfectly for async resources.
+        Prefer using 'async with' for guaranteed cleanup.
+        """
+        if not self._destroyed and self.sandbox:
+            import warnings
+
+            warnings.warn(
+                "DaytonaSandbox was not properly cleaned up. "
+                "Use 'async with DaytonaSandbox(...) as sandbox:' for automatic cleanup.",
+                ResourceWarning,
+                stacklevel=2,
+            )
+
+    async def _ensure_initialized(self):
+        """Lazy initialization of sandbox"""
+        if self._initialized:
+            return
+
+        from daytona_sdk import (  # type: ignore
+            AsyncDaytona,
+            CreateSandboxBaseParams,
+            DaytonaConfig,
+        )
+
+        # Initialize client with config
+        if self.api_key or self.api_url or self.target:
+            config = DaytonaConfig(
+                api_key=self.api_key, api_url=self.api_url, target=self.target
+            )
+            self.client = AsyncDaytona(config)
+        else:
+            # Use environment variables
+            self.client = AsyncDaytona()
+
+        if self.sandbox_id:
+            # Connect to existing sandbox - use find_one with id label
+            sandboxes = await self.client.list(labels={"id": self.sandbox_id})
+            if not sandboxes or not sandboxes.items:
+                raise ValueError(f"Sandbox with ID {self.sandbox_id} not found")
+            self.sandbox = sandboxes.items[0]
+        else:
+            # Create new sandbox with default configuration
+            params = CreateSandboxBaseParams(language=self.language)  # type: ignore
+            self.sandbox = await self.client.create(params)  # type: ignore
+            self.sandbox_id = self.sandbox.id
+
+        # Start sandbox if needed
+        if self.auto_start and self.sandbox.state != "started":
+            await self.sandbox.start()
+
+        self._initialized = True
+
+    async def _exec(
+        self,
+        command: str,
+        timeout: int = 30,
+        cwd: str | None = None,
+        env: dict | None = None,
+    ) -> str:
+        """
+        Execute a shell command in the sandbox.
+
+        Args:
+            command: Shell command to execute
+            timeout: Timeout in seconds (None for no timeout)
+            cwd: Working directory for the command
+            env: Environment variables for the command
+
+        Returns:
+            Command output and exit code information
+        """
+        await self._ensure_initialized()
+
+        # Execute command using the process interface
+        # API: exec(command, cwd=".", env=None, timeout=None) -> ExecutionResponse
+        assert self.sandbox, "no sandbox"
+        result = await self.sandbox.process.exec(
+            command=command, cwd=cwd or ".", env=env, timeout=timeout
+        )
+
+        # ExecutionResponse has .result (output) and .exit_code
+        output = result.result or ""
+
+        # Include exit code if non-zero
+        if result.exit_code != 0:
+            output = f"[Exit code: {result.exit_code}]\n{output}"
+
+        # Limit output to last 5000 characters to avoid overwhelming the LLM
+        if len(output) > 5000:
+            output = "...[truncated]...\n" + output[-5000:]
+
+        return output or "(no output)"
+
+    async def _read_file(self, path: str, max_size: int = 50000) -> str:
+        """
+        Read a file from the sandbox.
+
+        Args:
+            path: Path to the file in the sandbox
+            max_size: Maximum file size in bytes to read
+
+        Returns:
+            File contents as string
+        """
+        await self._ensure_initialized()
+
+        # API: download_file(remote_path, timeout=1800) -> bytes
+        assert self.sandbox, "no sandbox"
+        content_bytes = await self.sandbox.fs.download_file(path)
+        content = content_bytes.decode("utf-8", errors="replace")
+
+        if len(content) > max_size:
+            return f"File too large ({len(content)} bytes). First {max_size} bytes:\n{content[:max_size]}"
+
+        return content
+
+    async def _write_file(self, path: str, content: str) -> str:
+        """
+        Write content to a file in the sandbox.
+
+        Args:
+            path: Path to the file in the sandbox
+            content: Content to write
+
+        Returns:
+            Success message
+        """
+        await self._ensure_initialized()
+        assert self.sandbox, "no sandbox"
+
+        # API: upload_file(file: bytes, remote_path: str, timeout=1800) -> None
+        content_bytes = content.encode("utf-8")
+        await self.sandbox.fs.upload_file(content_bytes, path)
+        return f"Successfully wrote {len(content)} bytes to {path}"
+
+    async def _list_files(self, path: str = ".", pattern: str | None = None) -> str:
+        """
+        List files in a directory.
+
+        Args:
+            path: Directory path to list
+            pattern: Optional glob pattern to filter files
+
+        Returns:
+            Formatted list of files
+        """
+        await self._ensure_initialized()
+        assert self.sandbox, "no sandbox"
+
+        if pattern:
+            # API: find_files(path, pattern) -> List[Match]
+            matches = await self.sandbox.fs.find_files(path=path, pattern=pattern)
+            if not matches:
+                return f"No files matching '{pattern}' found in {path}"
+
+            # Format the matches
+            files = [match.file for match in matches]
+            return "\n".join(files)
+        else:
+            # API: list_files(path) -> List[FileInfo]
+            file_infos = await self.sandbox.fs.list_files(path=path)
+
+            if not file_infos:
+                return f"No files found in {path}"
+
+            # Format the output with file info
+            lines = []
+            for info in file_infos:
+                # FileInfo has .name, .size, .mode, .is_dir, etc
+                if info.is_dir:
+                    lines.append(f"{info.name}/")
+                else:
+                    lines.append(f"{info.name} ({info.size} bytes)")
+            return "\n".join(lines)
+
+    async def _get_preview_link(self, port: int = 8080) -> str:
+        """
+        Get a preview link for exposing a port.
+
+        Args:
+            port: Port number to expose
+
+        Returns:
+            Preview URL and token information
+        """
+        await self._ensure_initialized()
+        assert self.sandbox, "no sandbox"
+        preview = await self.sandbox.get_preview_link(port)
+
+        result = f"URL: {preview.url}"
+        if hasattr(preview, "token") and preview.token:
+            result += f"\nToken: {preview.token}"
+
+        return result
+
+    async def _get_working_dir(self) -> str:
+        """Get the current working directory in the sandbox."""
+        await self._ensure_initialized()
+        assert self.sandbox, "no sandbox"
+        return await self.sandbox.get_work_dir()
+
+    async def _destroy(self):
+        """Delete the sandbox and clean up resources."""
+        if self.sandbox and not self._destroyed:
+            await self.sandbox.delete()
+            self._destroyed = True
+            self._initialized = False
+            self.sandbox = None
+
+    def get_tools(self):
+        """Return list of tools for LLM use."""
+        bash_tool = Tool(
+            name="bash",
+            description=(
+                "Execute a bash command in the Daytona sandbox environment. "
+                "The command runs in a persistent Linux environment. "
+                "Provide the command as a string (e.g., 'ls -la' or 'python script.py'). "
+                "Output is truncated to the last 5000 characters if longer. "
+                "Exit codes are included in output if non-zero."
+            ),
+            run=self._exec,
+            parameters={
+                "command": {
+                    "type": "string",
+                    "description": "The shell command to execute (e.g., 'ls -la', 'python script.py')",
+                },
+                "timeout": {
+                    "type": "integer",
+                    "description": "Timeout in seconds for the command execution (default: 30)",
+                },
+                "cwd": {
+                    "type": "string",
+                    "description": "Working directory for the command (default: current directory)",
+                },
+                "env": {
+                    "type": "object",
+                    "description": "Environment variables for the command (optional)",
+                },
+            },
+            required=["command"],
+        )
+
+        read_file_tool = Tool(
+            name="read_file",
+            description=(
+                "Read the contents of a file from the sandbox filesystem. "
+                "Provide the absolute or relative path to the file. "
+                "Files larger than 50KB are truncated."
+            ),
+            run=self._read_file,
+            parameters={
+                "path": {
+                    "type": "string",
+                    "description": "Path to the file to read (e.g., '/home/user/script.py')",
+                },
+                "max_size": {
+                    "type": "integer",
+                    "description": "Maximum file size in bytes to read (default: 50000)",
+                },
+            },
+            required=["path"],
+        )
+
+        write_file_tool = Tool(
+            name="write_file",
+            description=(
+                "Write content to a file in the sandbox filesystem. "
+                "Creates the file if it doesn't exist, overwrites if it does. "
+                "Parent directories must exist."
+            ),
+            run=self._write_file,
+            parameters={
+                "path": {
+                    "type": "string",
+                    "description": "Path where to write the file (e.g., '/home/user/script.py')",
+                },
+                "content": {
+                    "type": "string",
+                    "description": "Content to write to the file",
+                },
+            },
+            required=["path", "content"],
+        )
+
+        list_files_tool = Tool(
+            name="list_files",
+            description=(
+                "List files and directories in the sandbox filesystem. "
+                "Useful for exploring the sandbox environment and finding files. "
+                "Optionally filter by glob pattern (e.g., '*.py', '**/*.txt')."
+            ),
+            run=self._list_files,
+            parameters={
+                "path": {
+                    "type": "string",
+                    "description": "Directory path to list (default: current directory)",
+                },
+                "pattern": {
+                    "type": "string",
+                    "description": "Glob pattern to filter files (e.g., '*.py', '**/*.txt')",
+                },
+            },
+            required=[],
+        )
+
+        preview_tool = Tool(
+            name="get_preview_link",
+            description=(
+                "Get a public URL to access a port in the sandbox. "
+                "Useful for exposing web servers or applications running in the sandbox. "
+                "Returns a URL and authentication token if needed."
+            ),
+            run=self._get_preview_link,
+            parameters={
+                "port": {
+                    "type": "integer",
+                    "description": "Port number to expose (default: 8080)",
+                },
+            },
+            required=[],
+        )
+
+        workdir_tool = Tool(
+            name="get_working_directory",
+            description=(
+                "Get the current working directory path in the sandbox. "
+                "Useful for understanding the sandbox environment layout."
+            ),
+            run=self._get_working_dir,
+            parameters={},
+            required=[],
+        )
+
+        return [
+            bash_tool,
+            read_file_tool,
+            write_file_tool,
+            list_files_tool,
+            preview_tool,
+            workdir_tool,
+        ]

lm_deluge/models/anthropic.py

@@ -10,6 +10,19 @@ ANTHROPIC_MODELS = {
     #                                                                   ░███
     #                                                                   █████
     #
+    "claude-4.5-opus": {
+        "id": "claude-4.5-opus",
+        "name": "claude-opus-4-5-20251101",
+        "api_base": "https://api.anthropic.com/v1",
+        "api_key_env_var": "ANTHROPIC_API_KEY",
+        "supports_json": False,
+        "api_spec": "anthropic",
+        "input_cost": 5.0,
+        "cached_input_cost": 0.50,
+        "cache_write_cost": 6.25,
+        "output_cost": 25.0,
+        "reasoning_model": True,
+    },
     "claude-4.5-haiku": {
         "id": "claude-4.5-haiku",
         "name": "claude-haiku-4-5-20251001",
@@ -21,6 +34,7 @@ ANTHROPIC_MODELS = {
         "cached_input_cost": 0.10,
         "cache_write_cost": 1.25,
         "output_cost": 3.0,
+        "reasoning_model": True,
     },
     "claude-4.5-sonnet": {
         "id": "claude-4.5-sonnet",
@@ -33,6 +47,7 @@ ANTHROPIC_MODELS = {
         "cached_input_cost": 0.30,
         "cache_write_cost": 3.75,
         "output_cost": 15.0,
+        "reasoning_model": True,
     },
     "claude-4.1-opus": {
         "id": "claude-4.1-opus",

lm_deluge/models/google.py

@@ -138,4 +138,19 @@ GOOGLE_MODELS = {
         "output_cost": 0.4,
         "reasoning_model": True,
     },
+    # Gemini 3 models - advanced reasoning with thought signatures
+    "gemini-3-pro-preview": {
+        "id": "gemini-3-pro-preview",
+        "name": "gemini-3-pro-preview",
+        "api_base": "https://generativelanguage.googleapis.com/v1alpha",
+        "api_key_env_var": "GEMINI_API_KEY",
+        "supports_json": True,
+        "supports_logprobs": False,
+        "api_spec": "gemini",
+        "input_cost": 2.0,  # <200k tokens
+        "cached_input_cost": 0.5,  # estimated
+        "output_cost": 12.0,  # <200k tokens
+        # Note: >200k tokens pricing is $4/$18 per million
+        "reasoning_model": True,
+    },
 }

lm_deluge/models/openrouter.py

@@ -61,4 +61,14 @@ OPENROUTER_MODELS = {
         "cache_write_cost": 0.6,
         "output_cost": 2.20,
     },
+    "olmo-3-32b-think-openrouter": {
+        "id": "olmo-3-32b-think-openrouter",
+        "name": "allenai/olmo-3-32b-think",
+        "api_base": "https://openrouter.ai/api/v1",
+        "api_key_env_var": "OPENROUTER_API_KEY",
+        "supports_json": True,
+        "api_spec": "openai",
+        "input_cost": 0.2,
+        "output_cost": 35,
+    },
 }

lm_deluge/prompt.py

@@ -61,6 +61,8 @@ class ToolCall:
     built_in: bool = False
     built_in_type: str | None = None
     extra_body: dict | None = None
+    # for gemini 3 - thought signatures to maintain reasoning context
+    thought_signature: str | None = None
 
     @property
     def fingerprint(self) -> str:
@@ -93,7 +95,10 @@ class ToolCall:
         }
 
     def gemini(self) -> dict:
-        return {"functionCall": {"name": self.name, "args": self.arguments}}
+        result = {"functionCall": {"name": self.name, "args": self.arguments}}
+        if self.thought_signature is not None:
+            result["thoughtSignature"] = self.thought_signature  # type: ignore
+        return result
 
     def mistral(self) -> dict:
         return {
@@ -253,6 +258,8 @@ class Thinking:
     type: str = field(init=False, default="thinking")
     # for openai - to keep conversation chain
     raw_payload: dict | None = None
+    # for gemini 3 - thought signatures to maintain reasoning context
+    thought_signature: str | None = None
 
     @property
     def fingerprint(self) -> str:
@@ -270,7 +277,10 @@ class Thinking:
         return {"type": "thinking", "thinking": self.content}
 
     def gemini(self) -> dict:
-        return {"text": f"[Thinking: {self.content}]"}
+        result = {"text": f"[Thinking: {self.content}]"}
+        if self.thought_signature is not None:
+            result["thoughtSignature"] = self.thought_signature
+        return result
 
     def mistral(self) -> dict:
         return {"type": "text", "text": f"[Thinking: {self.content}]"}
@@ -374,14 +384,15 @@ class Message:
                 size = p.size
                 content_blocks.append({"type": "file", "tag": f"<File ({size} bytes)>"})
             elif isinstance(p, ToolCall):
-                content_blocks.append(
-                    {
-                        "type": "tool_call",
-                        "id": p.id,
-                        "name": p.name,
-                        "arguments": _json_safe(p.arguments),
-                    }
-                )
+                tool_call_block = {
+                    "type": "tool_call",
+                    "id": p.id,
+                    "name": p.name,
+                    "arguments": _json_safe(p.arguments),
+                }
+                if p.thought_signature is not None:
+                    tool_call_block["thought_signature"] = p.thought_signature
+                content_blocks.append(tool_call_block)
             elif isinstance(p, ToolResult):
                 content_blocks.append(
                     {
@@ -391,7 +402,10 @@ class Message:
                     }
                 )
             elif isinstance(p, Thinking):
-                content_blocks.append({"type": "thinking", "content": p.content})
+                thinking_block = {"type": "thinking", "content": p.content}
+                if p.thought_signature is not None:
+                    thinking_block["thought_signature"] = p.thought_signature
+                content_blocks.append(thinking_block)
 
         return {"role": self.role, "content": content_blocks}
 
@@ -415,14 +429,24 @@ class Message:
                 parts.append(Text(p["tag"]))
             elif p["type"] == "tool_call":
                 parts.append(
-                    ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                    ToolCall(
+                        id=p["id"],
+                        name=p["name"],
+                        arguments=p["arguments"],
+                        thought_signature=p.get("thought_signature"),
+                    )
                 )
             elif p["type"] == "tool_result":
                 parts.append(
                     ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
                 )
             elif p["type"] == "thinking":
-                parts.append(Thinking(content=p["content"]))
+                parts.append(
+                    Thinking(
+                        content=p["content"],
+                        thought_signature=p.get("thought_signature"),
+                    )
+                )
             else:
                 raise ValueError(f"Unknown part type {p['type']!r}")
 
@@ -1546,14 +1570,15 @@ class Conversation:
                         {"type": "file", "tag": f"<File ({size} bytes)>"}
                     )
                 elif isinstance(p, ToolCall):
-                    content_blocks.append(
-                        {
-                            "type": "tool_call",
-                            "id": p.id,
-                            "name": p.name,
-                            "arguments": p.arguments,
-                        }
-                    )
+                    tool_call_block = {
+                        "type": "tool_call",
+                        "id": p.id,
+                        "name": p.name,
+                        "arguments": p.arguments,
+                    }
+                    if p.thought_signature is not None:
+                        tool_call_block["thought_signature"] = p.thought_signature
+                    content_blocks.append(tool_call_block)
                 elif isinstance(p, ToolResult):
                     content_blocks.append(
                         {
@@ -1565,7 +1590,10 @@ class Conversation:
                         }
                     )
                 elif isinstance(p, Thinking):
-                    content_blocks.append({"type": "thinking", "content": p.content})
+                    thinking_block = {"type": "thinking", "content": p.content}
+                    if p.thought_signature is not None:
+                        thinking_block["thought_signature"] = p.thought_signature
+                    content_blocks.append(thinking_block)
             serialized.append({"role": msg.role, "content": content_blocks})
 
         return {"messages": serialized}
@@ -1590,14 +1618,24 @@ class Conversation:
                     parts.append(Text(p["tag"]))
                 elif p["type"] == "tool_call":
                     parts.append(
-                        ToolCall(id=p["id"], name=p["name"], arguments=p["arguments"])
+                        ToolCall(
+                            id=p["id"],
+                            name=p["name"],
+                            arguments=p["arguments"],
+                            thought_signature=p.get("thought_signature"),
+                        )
                     )
                 elif p["type"] == "tool_result":
                     parts.append(
                         ToolResult(tool_call_id=p["tool_call_id"], result=p["result"])
                     )
                 elif p["type"] == "thinking":
-                    parts.append(Thinking(content=p["content"]))
+                    parts.append(
+                        Thinking(
+                            content=p["content"],
+                            thought_signature=p.get("thought_signature"),
+                        )
+                    )
                 else:
                     raise ValueError(f"Unknown part type {p['type']!r}")
 

lm_deluge/warnings.py

@@ -9,6 +9,10 @@ WARNINGS: dict[str, str] = {
     "WARN_LOGPROBS_UNSUPPORTED": "Ignoring logprobs param for non-logprobs model: {model_name}",
     "WARN_MINIMAL_TO_LOW": "'minimal' reasoning effort only allowed for gpt-5 models. Setting to 'low' for {model_name}.",
     "WARN_MINIMAL_TO_NONE": "GPT-5.1 models don't support 'minimal' reasoning effort. Converting to 'none' for {model_name}.",
+    "WARN_MEDIA_RESOLUTION_UNSUPPORTED": "media_resolution parameter is only supported for Gemini 3 models, ignoring for {model_name}.",
+    "WARN_GEMINI3_MISSING_SIGNATURE": "Gemini 3 thought signature missing in {part_type}, injecting dummy signature 'context_engineering_is_the_way_to_go' to avoid API error.",
+    "WARN_GEMINI3_NO_REASONING": "Gemini 3 requires reasoning (thinkingConfig). Setting thinkingConfig to low.",
+    "WARN_THINKING_BUDGET_AND_REASONING_EFFORT": "`reasoning_effort` and `thinking_budget` both provided. `thinking_budget` will take priority.",
 }
 
 

{lm_deluge-0.0.78.dist-info → lm_deluge-0.0.80.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lm_deluge
-Version: 0.0.78
+Version: 0.0.80
 Summary: Python utility for using LLM API models.
 Author-email: Benjamin Anderson <ben@trytaylor.ai>
 Requires-Python: >=3.10
@@ -52,7 +52,7 @@ Dynamic: license-file
 pip install lm-deluge
 ```
 
-The package relies on environment variables for API keys. Typical variables include `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `COHERE_API_KEY`, `META_API_KEY`, and `GOOGLE_API_KEY`. `LLMClient` will automatically load the `.env` file when imported; we recommend using that to set the environment variables. For Bedrock, you'll need to set `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`.
+The package relies on environment variables for API keys. Typical variables include `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `COHERE_API_KEY`, `META_API_KEY`, and `GEMINI_API_KEY`. `LLMClient` will automatically load the `.env` file when imported; we recommend using that to set the environment variables. For Bedrock, you'll need to set `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY`.
 
 ## Quickstart
 
@@ -61,9 +61,9 @@ The package relies on environment variables for API keys. Typical variables incl
 ```python
 from lm_deluge import LLMClient
 
-client = LLMClient("gpt-4o-mini")
+client = LLMClient("gpt-4.1-mini")
 resps = client.process_prompts_sync(["Hello, world!"])
-print(resp[0].completion)
+print(resps[0].completion)
 ```
 
 ## Spraying Across Models
@@ -74,13 +74,13 @@ To distribute your requests across models, just provide a list of more than one
 from lm_deluge import LLMClient
 
 client = LLMClient(
-    ["gpt-4o-mini", "claude-3-haiku"],
+    ["gpt-4.1-mini", "claude-4.5-haiku"],
     max_requests_per_minute=10_000
 )
 resps = client.process_prompts_sync(
     ["Hello, ChatGPT!", "Hello, Claude!"]
 )
-print(resp[0].completion)
+print(resps[0].completion)
 ```
 
 ## Configuration
@@ -181,7 +181,7 @@ def get_weather(city: str) -> str:
     return f"The weather in {city} is sunny and 72°F"
 
 tool = Tool.from_function(get_weather)
-client = LLMClient("claude-3-haiku")
+client = LLMClient("claude-4.5-haiku")
 resps = client.process_prompts_sync(
     ["What's the weather in Paris?"],
     tools=[tool]
@@ -255,7 +255,7 @@ conv = (
 )
 
 # Use prompt caching to cache system message and tools
-client = LLMClient("claude-3-5-sonnet")
+client = LLMClient("claude-4.5-sonnet")
 resps = client.process_prompts_sync(
     [conv],
     cache="system_and_tools"  # Cache system message and any tools

{lm_deluge-0.0.78.dist-info → lm_deluge-0.0.80.dist-info}/RECORD

@@ -2,27 +2,27 @@ lm_deluge/__init__.py,sha256=zF5lAitfgJ8A28IXJ5BE9OUCqGOqSnGOWn3ZIlizNyY,822
 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=RoxIeuM-LjaKl9fPXfs7rf2NyOuUNBLbTjVPkcIRfYA,44776
-lm_deluge/config.py,sha256=d7lS6i5-J23nM-UPjJ_gFcsmfgI8aPVwqw_IGGb1x3I,975
+lm_deluge/client.py,sha256=VqCuFXM_ylO4v-lev85HMPFRHeU69tZo70favz-I2Uk,44791
+lm_deluge/config.py,sha256=C-_rVwAFL5sivLfKSkaa2ANMqqxKbyDCW86KfQB_Lck,1357
 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=-u4kxSzwoxDt_2fLh5LaiqETnu0Jg_VDL7TWAAYHGNw,21762
-lm_deluge/prompt.py,sha256=_6xkMuEKJEizRNbjQ5gbZesoE_vtwQe2wJHdm-E6vP0,64002
+lm_deluge/prompt.py,sha256=JRjLckFQ14r5wfWcYCjFOTGADTz4klwMthctx0GwrtU,65808
 lm_deluge/request_context.py,sha256=eM_cCXZsrVb5FF3VQl6u1dZeZrWv00wW42Cr_Fjs5oA,2752
 lm_deluge/rerank.py,sha256=-NBAJdHz9OB-SWWJnHzkFmeVO4wR6lFV7Vw-SxG7aVo,11457
 lm_deluge/tool.py,sha256=ipgNy4OpfH3CA9OPQq5zfn1xO8H08GMvDynB8ZPQ5mA,30617
 lm_deluge/tracker.py,sha256=aeS9GUJpgOSQRVXAnGDvlMO8qYpSxpTNLYj2hrMg0m8,14757
 lm_deluge/usage.py,sha256=xz9tAw2hqaJvv9aAVhnQ6N1Arn7fS8Shb28VwCW26wI,5136
-lm_deluge/warnings.py,sha256=xXXYXEfaaSVr__16BKOEEWLdfZi1L-2ylzTrXTRyO18,1748
+lm_deluge/warnings.py,sha256=12RseSa9mYAFkbY783FQTP0x9RapRBErIQt4o7hzVnM,2321
 lm_deluge/api_requests/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-lm_deluge/api_requests/anthropic.py,sha256=OvkciXTHyrG1cFyC1vv6nYyCFTqtMgt1r15Q-pbHiUQ,10411
+lm_deluge/api_requests/anthropic.py,sha256=ytNeADgGeflmlm5gVQ0cJ5bgchJ_EZvKJIIt7Imxf2A,11338
 lm_deluge/api_requests/base.py,sha256=mXEM85mcU_5LD-ugELpCl28tv-tpHKcaxerTIVLQZVo,10436
 lm_deluge/api_requests/bedrock.py,sha256=mY1xTvgfCLyqLlfFFmu_baKgkVq1Df1_MJXeN_G1jWQ,15597
 lm_deluge/api_requests/chat_reasoning.py,sha256=sJvstvKFqsSBUjYcwxzGt2_FH4cEp3Z6gKcBPyPjGwk,236
 lm_deluge/api_requests/common.py,sha256=BZ3vRO5TB669_UsNKugkkuFSzoLHOYJIKt4nV4sf4vc,422
-lm_deluge/api_requests/gemini.py,sha256=4uD7fQl0yWyAvYkPNi3oO1InBnvYfo5_QR6k-va-2GI,7838
+lm_deluge/api_requests/gemini.py,sha256=FjYKisAjD6rW2fA6WyXnnRn3oqJBXMod1_8HtGWIyEU,11099
 lm_deluge/api_requests/mistral.py,sha256=8JZP2CDf1XZfaPcTk0WS4q-VfYYj58ptpoH8LD3MQG4,4528
 lm_deluge/api_requests/openai.py,sha256=E0oakhcb2T5Swfn6ATMjRZKuLyRrx4Zj5SREo1JILfc,28841
 lm_deluge/api_requests/response.py,sha256=vG194gAH5p7ulpNy4qy5Pryfb1p3ZV21-YGoj__ru3E,7436
@@ -43,18 +43,19 @@ lm_deluge/llm_tools/extract.py,sha256=p61JW8yv5gQxPp4P8Hkm90ERgfD_Ek5IABzjIIlX-M
 lm_deluge/llm_tools/filesystem.py,sha256=Uy0lQ2Ecx5Cvqv0Sr3r_PEw8gBGZ21VAov5dg2knKfk,27942
 lm_deluge/llm_tools/locate.py,sha256=lYNbKTmy9dTvj0lEQkOQ7yrxyqsgYzjD0C_byJKI_4w,6271
 lm_deluge/llm_tools/ocr.py,sha256=7fDlvs6uUOvbxMasvGGNJx5Fj6biM6z3lijKZaGN26k,23
+lm_deluge/llm_tools/sandbox.py,sha256=7bc4r0ApY4WfdzNrfKfO4Omoz9rR1rr86qp-OwtqlyY,18399
 lm_deluge/llm_tools/score.py,sha256=9oGA3-k2U5buHQXkXaEI9M4Wb5yysNhTLsPbGeghAlQ,2580
 lm_deluge/llm_tools/subagents.py,sha256=srJ7On7YR0Y8WuNvf5TJl_7IUfEtG3zlxZeLgmn_-NI,8484
 lm_deluge/llm_tools/todos.py,sha256=doKJZWLZlh4J_k6HkdwonWHfZTZaxEI9_XHAoNFnfQo,14906
 lm_deluge/llm_tools/translate.py,sha256=iXyYvQZ8bC44FWhBk4qpdqjKM1WFF7Shq-H2PxhPgg4,1452
 lm_deluge/models/__init__.py,sha256=54H24K_eADbfdEH9aNORrNEXvDLZCQ4TEekeLiWljSE,4619
-lm_deluge/models/anthropic.py,sha256=sFkS-g0OWgRnVoFMKxWkSUt0qy2LVrcO5KtbYAG26iY,6283
+lm_deluge/models/anthropic.py,sha256=X92EYIapos-8LXnIYiypPJcFhI0tqmXja_w8e9H4CF8,6781
 lm_deluge/models/bedrock.py,sha256=g1PbfceSRH2lWST3ja0mUlF3oTq4e4T-si6RMe7qXgg,4888
 lm_deluge/models/cerebras.py,sha256=u2FMXJF6xMr0euDRKLKMo_NVTOcvSrrEpehbHr8sSeE,2050
 lm_deluge/models/cohere.py,sha256=iXjYtM6jy_YL73Op8OfNsrMNopwae9y-Sw-4vF9cEBw,3406
 lm_deluge/models/deepseek.py,sha256=6_jDEprNNYis5I5MDQNloRes9h1P6pMYHXxOd2UZMgg,941
 lm_deluge/models/fireworks.py,sha256=yvt2Ggzye4aUqCqY74ta67Vu7FrQaLFjdFtN4P7D-dc,638
-lm_deluge/models/google.py,sha256=Hr2MolQoaeY85pKCGO7k7OH_1nQJdrwMgrJbfz5bI8w,5387
+lm_deluge/models/google.py,sha256=fARfBMHDwhPJ48SGcYg3sHQDQ0Mm0yPQ-9s6iVYne8M,6011
 lm_deluge/models/grok.py,sha256=TDzr8yfTaHbdJhwMA-Du6L-efaKFJhjTQViuVElCCHI,2566
 lm_deluge/models/groq.py,sha256=Mi5WE1xOBGoZlymD0UN6kzhH_NOmfJYU4N2l-TO0Z8Q,2552
 lm_deluge/models/kimi.py,sha256=1voigLdNO2CxpWv0KDpQPP3Wolx5WrqgAlYL9ObJFuQ,1117
@@ -62,7 +63,7 @@ lm_deluge/models/meta.py,sha256=BBgnscL1gMcIdPbRqrlDl_q9YAYGSrkw9JkAIabXtLs,1883
 lm_deluge/models/minimax.py,sha256=rwW9gNotAYfDVtMlqmSYegN6GoZM_9DSNNZU2yPOmaU,275
 lm_deluge/models/mistral.py,sha256=x67o5gckBGmPcIGdVbS26XZAYFKBYM4tsxEAahGp8bk,4323
 lm_deluge/models/openai.py,sha256=t6fcXo0YXgPQ6YiftZJP8gPw8FOBqoVapSavMVmtaOw,12411
-lm_deluge/models/openrouter.py,sha256=O-Po4tmHjAqFIVU96TUL0QnK01R4e2yDN7Z4sYJ-CuE,2120
+lm_deluge/models/openrouter.py,sha256=aT3AGBaZ0ShY2-ncGHbc8UEm00l78GqkXy9Pq67SITQ,2469
 lm_deluge/models/together.py,sha256=AjKhPsazqBgqyLwHkNQW07COM1n_oSrYQRp2BFVvn9o,4381
 lm_deluge/presets/cerebras.py,sha256=MDkqj15qQRrj8wxSCDNNe_Cs7h1WN1UjV6lTmSY1olQ,479
 lm_deluge/presets/meta.py,sha256=QrreLAVgYS6VIC_NQth1vgGAYuxY38jFQQZSe6ot7C8,364
@@ -73,8 +74,8 @@ lm_deluge/util/schema.py,sha256=q6uwhA4s1lM2dHT1Kwc46E7OY1VecMOtTEI0PTFn6tA,1320
 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.78.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
-lm_deluge-0.0.78.dist-info/METADATA,sha256=VaCsZgSsbc2yr0Wm8Q5Gw_9UKMRm-KkKkVQ7rS_p5-M,13697
-lm_deluge-0.0.78.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-lm_deluge-0.0.78.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
-lm_deluge-0.0.78.dist-info/RECORD,,
+lm_deluge-0.0.80.dist-info/licenses/LICENSE,sha256=uNNXGXPCw2TC7CUs7SEBkA-Mz6QBQFWUUEWDMgEs1dU,1058
+lm_deluge-0.0.80.dist-info/METADATA,sha256=LJ2nPTs9WzdiP3kU5KPKUdOy_SuuiHRJCz9PINHEvZk,13705
+lm_deluge-0.0.80.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+lm_deluge-0.0.80.dist-info/top_level.txt,sha256=hqU-TJX93yBwpgkDtYcXyLr3t7TLSCCZ_reytJjwBaE,10
+lm_deluge-0.0.80.dist-info/RECORD,,