lm-deluge 0.0.88__py3-none-any.whl → 0.0.90__py3-none-any.whl

lm_deluge/__init__.py

@@ -3,19 +3,6 @@ from .file import File
 from .prompt import Conversation, Message
 from .tool import Tool
 
-try:
-    from .mock_openai import (  # noqa
-        APIError,
-        APITimeoutError,
-        BadRequestError,
-        MockAsyncOpenAI,
-        RateLimitError,
-    )
-
-    _has_openai = True
-except ImportError:
-    _has_openai = False
-
 # dotenv.load_dotenv() - don't do this, fucks with other packages
 
 __all__ = [
@@ -27,14 +14,3 @@ __all__ = [
     "Tool",
     "File",
 ]
-
-if _has_openai:
-    __all__.extend(
-        [
-            "MockAsyncOpenAI",
-            "APIError",
-            "APITimeoutError",
-            "BadRequestError",
-            "RateLimitError",
-        ]
-    )

lm_deluge/api_requests/anthropic.py

@@ -6,6 +6,7 @@ from aiohttp import ClientResponse
 from lm_deluge.prompt import (
     Message,
     Text,
+    ThoughtSignature,
     Thinking,
     ToolCall,
 )
@@ -250,8 +251,28 @@ class AnthropicRequest(APIRequestBase):
                     if item["type"] == "text":
                         parts.append(Text(item["text"]))
                     elif item["type"] == "thinking":
-                        thinking = item["thinking"]
-                        parts.append(Thinking(item["thinking"]))
+                        thinking_content = item.get("thinking", "")
+                        thinking = thinking_content
+                        signature = item.get("signature")
+                        parts.append(
+                            Thinking(
+                                thinking_content,
+                                raw_payload=item,
+                                thought_signature=ThoughtSignature(
+                                    signature,
+                                    provider="anthropic",
+                                )
+                                if signature is not None
+                                else None,
+                            )
+                        )
+                    elif item["type"] == "redacted_thinking":
+                        parts.append(
+                            Thinking(
+                                item.get("data", ""),
+                                raw_payload=item,
+                            )
+                        )
                     elif item["type"] == "tool_use":
                         parts.append(
                             ToolCall(
@@ -265,9 +286,8 @@ class AnthropicRequest(APIRequestBase):
                 usage = Usage.from_anthropic_usage(data["usage"])
             except Exception as e:
                 is_error = True
-                error_message = (
-                    f"Error calling .json() on response w/ status {status_code}: {e}"
-                )
+                response_text = await http_response.text()
+                error_message = f"Error calling .json() on response w/ status {status_code}: {e}. Response: {response_text[:500]}"
         elif mimetype and "json" in mimetype.lower():
             is_error = True  # expected status is 200, otherwise it's an error
             data = await http_response.json()

lm_deluge/api_requests/base.py

@@ -1,4 +1,6 @@
 import asyncio
+import json
+import os
 import time
 import traceback
 from abc import ABC, abstractmethod
@@ -73,6 +75,24 @@ class APIRequestBase(ABC):
 
         # Start with base headers, then overlay filtered extra headers (extra takes precedence)
         merged = dict(base_headers)
+        if "anthropic-beta" in merged and "anthropic-beta" in filtered_extra:
+            combined = []
+            seen = set()
+            for (
+                raw
+            ) in f"{merged['anthropic-beta']},{filtered_extra['anthropic-beta']}".split(
+                ","
+            ):
+                token = raw.strip()
+                if token and token not in seen:
+                    seen.add(token)
+                    combined.append(token)
+            merged["anthropic-beta"] = ",".join(combined)
+            filtered_extra = {
+                key: value
+                for key, value in filtered_extra.items()
+                if key != "anthropic-beta"
+            }
         merged.update(filtered_extra)
 
         # Filter out None values from final merged headers
@@ -189,6 +209,23 @@ class APIRequestBase(ABC):
         await self.build_request()
         assert self.context.status_tracker
 
+        if os.getenv("DELUGE_PROXY_LOG_PROVIDER_REQUESTS", "").strip().lower() in {
+            "1",
+            "true",
+            "yes",
+            "on",
+        }:
+            print("DELUGE_PROXY_PROVIDER_REQUEST")
+            print(f"URL: {self.url}")
+            print("Headers:")
+            print(self.request_header)
+            if self.request_json is not None:
+                print("JSON:")
+                try:
+                    print(json.dumps(self.request_json, indent=2))
+                except Exception:
+                    print(self.request_json)
+
         if (
             self.context.background
             and self.context.use_responses_api

lm_deluge/api_requests/bedrock.py

@@ -16,6 +16,7 @@ except ImportError:
 from lm_deluge.prompt import (
     Message,
     Text,
+    ThoughtSignature,
     Thinking,
     ToolCall,
 )
@@ -363,8 +364,28 @@ class BedrockRequest(APIRequestBase):
                         if item["type"] == "text":
                             parts.append(Text(item["text"]))
                         elif item["type"] == "thinking":
-                            thinking = item["thinking"]
-                            parts.append(Thinking(item["thinking"]))
+                            thinking_content = item.get("thinking", "")
+                            thinking = thinking_content
+                            signature = item.get("signature")
+                            parts.append(
+                                Thinking(
+                                    thinking_content,
+                                    raw_payload=item,
+                                    thought_signature=ThoughtSignature(
+                                        signature,
+                                        provider="anthropic",
+                                    )
+                                    if signature is not None
+                                    else None,
+                                )
+                            )
+                        elif item["type"] == "redacted_thinking":
+                            parts.append(
+                                Thinking(
+                                    item.get("data", ""),
+                                    raw_payload=item,
+                                )
+                            )
                         elif item["type"] == "tool_use":
                             parts.append(
                                 ToolCall(

lm_deluge/api_requests/gemini.py

@@ -9,7 +9,7 @@ from lm_deluge.warnings import maybe_warn
 
 from ..config import SamplingParams
 from ..models import APIModel
-from ..prompt import Conversation, Message, Text, Thinking, ToolCall
+from ..prompt import Conversation, Message, Text, ThoughtSignature, Thinking, ToolCall
 from ..usage import Usage
 from .base import APIRequestBase, APIResponse
 
@@ -52,6 +52,7 @@ async def _build_gemini_request(
 
     # Handle reasoning models (thinking)
     is_gemini_3 = "gemini-3" in model.name.lower()
+    is_gemini_3_flash = "gemini-3-flash" in model.name.lower()
     if is_gemini_3:
         # gemini3 MUST think
         if not sampling_params.reasoning_effort:
@@ -62,13 +63,24 @@ async def _build_gemini_request(
             if effort_key == "xhigh":
                 maybe_warn("WARN_XHIGH_TO_HIGH", model_name=model.name)
                 effort_key = "high"
-            level_map = {
-                "none": "low",
-                "minimal": "low",
-                "low": "low",
-                "medium": "high",  # change when supported
-                "high": "high",
-            }
+            if is_gemini_3_flash:
+                # Flash supports minimal, low, medium, high
+                level_map = {
+                    "none": "low",
+                    "minimal": "minimal",
+                    "low": "low",
+                    "medium": "medium",
+                    "high": "high",
+                }
+            else:
+                # Pro only supports low, high
+                level_map = {
+                    "none": "low",
+                    "minimal": "low",
+                    "low": "low",
+                    "medium": "high",
+                    "high": "high",
+                }
             effort = level_map[effort_key]
         thinking_config = {"thinkingLevel": effort}
         request_json["generationConfig"]["thinkingConfig"] = thinking_config
@@ -248,10 +260,20 @@ class GeminiRequest(APIRequestBase):
                         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")
+                                raw_sig = part.get("thoughtSignature")
+                                thought_sig = (
+                                    ThoughtSignature(raw_sig, provider="gemini")
+                                    if raw_sig is not None
+                                    else None
+                                )
 
                                 if "text" in part:
-                                    parts.append(Text(part["text"]))
+                                    parts.append(
+                                        Text(
+                                            part["text"],
+                                            thought_signature=thought_sig,
+                                        )
+                                    )
                                 elif "thought" in part:
                                     # Thought with optional signature
                                     parts.append(
@@ -274,6 +296,10 @@ class GeminiRequest(APIRequestBase):
                                             thought_signature=thought_sig,
                                         )
                                     )
+                                elif thought_sig:
+                                    parts.append(
+                                        Text("", thought_signature=thought_sig)
+                                    )
 
                     content = Message("assistant", parts)
 

lm_deluge/api_requests/openai.py

@@ -22,6 +22,24 @@ from ..usage import Usage
 from .base import APIRequestBase, APIResponse
 
 
+def _message_contents_to_string(messages: list[dict]):
+    messages = messages.copy()
+
+    for msg in messages:
+        content = msg.get("content")
+        assert content
+        if isinstance(content, list):
+            new_content = ""
+            for part in content:
+                assert "text" in part, "Invalid text part: " + str(part)
+                new_content += part["text"]
+                new_content += "\n"
+
+            msg["content"] = new_content.strip()
+
+    return messages
+
+
 async def _build_oa_chat_request(
     model: APIModel,
     context: RequestContext,
@@ -55,6 +73,10 @@ async def _build_oa_chat_request(
                 request_json["service_tier"] = context.service_tier
         else:
             request_json["service_tier"] = context.service_tier
+    # if tinker, for now hack to mush into 1 string
+    if "tinker" in model.name:
+        request_json["messages"] = _message_contents_to_string(request_json["messages"])
+
     # set max_tokens or max_completion_tokens dep. on provider
     if "cohere" in model.api_base:
         request_json["max_tokens"] = sampling_params.max_new_tokens
@@ -217,7 +239,7 @@ class OpenAIRequest(APIRequestBase):
                         parts.append(Text(message["content"]))
 
                     # Add tool calls if present
-                    if "tool_calls" in message:
+                    if "tool_calls" in message and message["tool_calls"] is not None:
                         for tool_call in message["tool_calls"]:
                             parts.append(
                                 ToolCall(
@@ -238,9 +260,9 @@ class OpenAIRequest(APIRequestBase):
                         and "logprobs" in data["choices"][0]
                     ):
                         logprobs = data["choices"][0]["logprobs"]["content"]
-                except Exception:
+                except Exception as e:
                     is_error = True
-                    error_message = f"Error getting 'choices' and 'usage' from {self.model.name} response."
+                    error_message = f"Error getting 'choices' and 'usage' from {self.model.name} response: {data}. Error: {e}"
         elif mimetype and "json" in mimetype.lower():
             is_error = True  # expected status is 200, otherwise it's an error
             data = await http_response.json()
@@ -655,7 +677,12 @@ async def stream_chat(
         request_header.update(filtered_extra)
 
     context = SimpleNamespace(
-        prompt=prompt, tools=tools, sampling_params=sampling_params
+        prompt=prompt,
+        tools=tools,
+        sampling_params=sampling_params,
+        service_tier=None,
+        output_schema=None,
+        model_name=model_name,
     )
 
     request_json = await _build_oa_chat_request(model, context)  # type: ignore

lm_deluge/batches.py

@@ -141,31 +141,22 @@ async def submit_batch_oa(file_path: str):
         return batch_id
 
 
-async def _submit_anthropic_batch(file_path: str, headers: dict, model: str):
-    """Upload a JSONL file and create one Anthropic batch."""
+async def _submit_anthropic_batch(requests: list[dict], headers: dict, model: str):
+    """Submit batch requests to Anthropic's Message Batches API."""
 
     async with aiohttp.ClientSession() as session:
         url = f"{registry[model].api_base}/messages/batches"
-        data = aiohttp.FormData()
-        with open(file_path, "rb") as f:
-            data.add_field(
-                "file",
-                f,
-                filename=os.path.basename(file_path),
-                content_type="application/json",
-            )
-
-            async with session.post(url, data=data, headers=headers) as response:
-                if response.status != 200:
-                    text = await response.text()
-                    raise ValueError(f"Error creating batch: {text}")
+        payload = {"requests": requests}
 
-                batch_data = await response.json()
-                batch_id = batch_data["id"]
-                print(f"Anthropic batch job started successfully: id = {batch_id}")
+        async with session.post(url, json=payload, headers=headers) as response:
+            if response.status != 200:
+                text = await response.text()
+                raise ValueError(f"Error creating batch: {text}")
 
-        os.remove(file_path)
-        return batch_id
+            batch_data = await response.json()
+            batch_id = batch_data["id"]
+            print(f"Anthropic batch job started successfully: id = {batch_id}")
+            return batch_id
 
 
 async def create_batch_files_oa(
@@ -409,20 +400,10 @@ async def submit_batches_anthropic(
 
         if current_batch and (would_exceed_size or would_exceed_items):
             # Submit current batch
-            def write_batch_file():
-                with tempfile.NamedTemporaryFile(
-                    mode="w+", suffix=".jsonl", delete=False
-                ) as f:
-                    for batch_request in current_batch:
-                        json.dump(batch_request, f)
-                        f.write("\n")
-                    print("wrote", len(current_batch), "items")
-                    return f.name
-
-            file_path = await asyncio.to_thread(write_batch_file)
+            print("wrote", len(current_batch), "items")
             batch_tasks.append(
                 asyncio.create_task(
-                    _submit_anthropic_batch(file_path, request_headers, model)  # type: ignore
+                    _submit_anthropic_batch(current_batch, request_headers, model)  # type: ignore
                 )
             )
 
@@ -436,21 +417,10 @@ async def submit_batches_anthropic(
 
     # Submit final batch if it has items
     if current_batch:
-
-        def write_final_batch_file():
-            with tempfile.NamedTemporaryFile(
-                mode="w+", suffix=".jsonl", delete=False
-            ) as f:
-                for batch_request in current_batch:
-                    json.dump(batch_request, f)
-                    f.write("\n")
-                print("wrote", len(current_batch), "items")
-                return f.name
-
-        file_path = await asyncio.to_thread(write_final_batch_file)
+        print("wrote", len(current_batch), "items")
         batch_tasks.append(
             asyncio.create_task(
-                _submit_anthropic_batch(file_path, request_headers, model)  # type: ignore
+                _submit_anthropic_batch(current_batch, request_headers, model)  # type: ignore
             )
         )
 

lm_deluge/client.py

@@ -289,6 +289,28 @@ class _LLMClient(BaseModel):
     def models(self):
         return self.model_names  # why? idk
 
+    @staticmethod
+    def _preprocess_tinker_model(model_name: str) -> str:
+        if model_name.startswith("tinker://"):
+            model_id = model_name
+            if model_id not in registry:
+                register_model(
+                    id=model_name,
+                    name=model_name,
+                    api_base="https://tinker.thinkingmachines.dev/services/tinker-prod/oai/api/v1",
+                    api_key_env_var="TINKER_API_KEY",
+                    api_spec="openai",
+                    supports_json=True,
+                    supports_logprobs=False,
+                    supports_responses=False,
+                    input_cost=0,  # Unknown costs for arbitrary tinker models
+                    cached_input_cost=0,
+                    cache_write_cost=0,
+                    output_cost=0,
+                )
+
+        return model_name
+
     @staticmethod
     def _preprocess_openrouter_model(model_name: str) -> str:
         """Process openrouter: prefix and register model if needed."""
@@ -315,7 +337,8 @@ class _LLMClient(BaseModel):
                 )
 
             return model_id
-        return model_name
+        else:
+            return model_name
 
     @model_validator(mode="before")
     @classmethod
@@ -328,6 +351,9 @@ class _LLMClient(BaseModel):
             # First, handle OpenRouter prefix
             model_name = cls._preprocess_openrouter_model(model_names)
 
+            # next handle tinker prefix
+            model_name = cls._preprocess_tinker_model(model_name)
+
             # 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:

lm_deluge/models/__init__.py

@@ -23,6 +23,7 @@ from .mistral import MISTRAL_MODELS
 from .openai import OPENAI_MODELS
 from .openrouter import OPENROUTER_MODELS
 from .together import TOGETHER_MODELS
+from .zai import ZAI_MODELS
 
 
 @dataclass
@@ -134,6 +135,7 @@ def register_model(
 # Register all models from all providers
 for model_dict in [
     ANTHROPIC_MODELS,
+    ZAI_MODELS,
     ARCEE_MODELS,
     BEDROCK_MODELS,
     COHERE_MODELS,

lm_deluge/models/anthropic.py

@@ -112,18 +112,18 @@ ANTHROPIC_MODELS = {
         "cache_write_cost": 3.75,
         "output_cost": 15.0,
     },
-    "claude-3.5-sonnet": {
-        "id": "claude-3.5-sonnet",
-        "name": "claude-3-5-sonnet-20240620",
-        "api_base": "https://api.anthropic.com/v1",
-        "api_key_env_var": "ANTHROPIC_API_KEY",
-        "supports_json": False,
-        "api_spec": "anthropic",
-        "input_cost": 3.0,
-        "cached_input_cost": 0.30,
-        "cache_write_cost": 3.75,
-        "output_cost": 15.0,
-    },
+    # "claude-3.5-sonnet": {
+    #     "id": "claude-3.5-sonnet",
+    #     "name": "claude-3-5-sonnet-20240620",
+    #     "api_base": "https://api.anthropic.com/v1",
+    #     "api_key_env_var": "ANTHROPIC_API_KEY",
+    #     "supports_json": False,
+    #     "api_spec": "anthropic",
+    #     "input_cost": 3.0,
+    #     "cached_input_cost": 0.30,
+    #     "cache_write_cost": 3.75,
+    #     "output_cost": 15.0,
+    # },
     "claude-3-opus": {
         "id": "claude-3-opus",
         "name": "claude-3-opus-20240229",

lm_deluge/models/google.py

@@ -153,6 +153,19 @@ GOOGLE_MODELS = {
         # Note: >200k tokens pricing is $4/$18 per million
         "reasoning_model": True,
     },
+    "gemini-3-flash-preview": {
+        "id": "gemini-3-flash-preview",
+        "name": "gemini-3-flash-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": 0.5,
+        "cached_input_cost": 0.125,  # estimated
+        "output_cost": 3.0,
+        "reasoning_model": True,
+    },
     # Gemini 2.5 Computer Use model
     "gemini-2.5-computer-use": {
         "id": "gemini-2.5-computer-use",

lm_deluge/models/minimax.py

@@ -1,4 +1,12 @@
 MINIMAX_MODELS = {
+    "minimax-m2.1": {
+        "id": "minimax-m2.1",
+        "name": "MiniMax-M2.1",
+        "api_base": "https://api.minimax.io/anthropic/v1",
+        "api_key_env_var": "MINIMAX_API_KEY",
+        "supports_json": False,
+        "api_spec": "anthropic",
+    },
     "minimax-m2": {
         "id": "minimax-m2",
         "name": "MiniMax-M2",
@@ -6,5 +14,5 @@ MINIMAX_MODELS = {
         "api_key_env_var": "MINIMAX_API_KEY",
         "supports_json": False,
         "api_spec": "anthropic",
-    }
+    },
 }

lm_deluge/models/openrouter.py

@@ -83,6 +83,18 @@ OPENROUTER_MODELS = {
         "cache_write_cost": 0.04,
         "output_cost": 0.18,
     },
+    "gpt-oss-20b-free-openrouter": {
+        "id": "gpt-oss-20b-openrouter",
+        "name": "openai/gpt-oss-20b:free",
+        "api_base": "https://openrouter.ai/api/v1",
+        "api_key_env_var": "OPENROUTER_API_KEY",
+        "supports_json": True,
+        "api_spec": "openai",
+        "input_cost": 0.0,
+        "cached_input_cost": 0.0,
+        "cache_write_cost": 0.0,
+        "output_cost": 0.0,
+    },
     "gpt-oss-120b-openrouter": {
         "id": "gpt-oss-120b-openrouter",
         "name": "openai/gpt-oss-120b",
@@ -95,6 +107,18 @@ OPENROUTER_MODELS = {
         "cache_write_cost": 0.05,
         "output_cost": 0.45,
     },
+    "gpt-oss-120b-free-openrouter": {
+        "id": "gpt-oss-120b-free-openrouter",
+        "name": "openai/gpt-oss-120b:free",
+        "api_base": "https://openrouter.ai/api/v1",
+        "api_key_env_var": "OPENROUTER_API_KEY",
+        "supports_json": True,
+        "api_spec": "openai",
+        "input_cost": 0.00,
+        "cached_input_cost": 0.00,
+        "cache_write_cost": 0.00,
+        "output_cost": 0.0,
+    },
     "kimi-k2-openrouter": {
         "id": "kimi-k2-openrouter",
         "name": "moonshotai/kimi-k2-0905:exacto",
@@ -139,4 +163,28 @@ OPENROUTER_MODELS = {
         "input_cost": 0.045,
         "output_cost": 0.15,
     },
+    "glm-4.7-openrouter": {
+        "id": "glm-4.7-openrouter",
+        "name": "z-ai/glm-4.7",
+        "api_base": "https://openrouter.ai/api/v1",
+        "api_key_env_var": "OPENROUTER_API_KEY",
+        "supports_json": True,
+        "api_spec": "openai",
+        "input_cost": 0.6,
+        "cached_input_cost": 0.6,
+        "cache_write_cost": 0.6,
+        "output_cost": 2.20,
+    },
+    "minimax-m2.1-openrouter": {
+        "id": "minimax-m2.1-openrouter",
+        "name": "minimax/minimax-m2.1",
+        "api_base": "https://openrouter.ai/api/v1",
+        "api_key_env_var": "OPENROUTER_API_KEY",
+        "supports_json": True,
+        "api_spec": "openai",
+        "input_cost": 0.3,
+        "cached_input_cost": 0.3,
+        "cache_write_cost": 0.3,
+        "output_cost": 1.20,
+    },
 }