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

lm_deluge/api_requests/openai.py

@@ -2,12 +2,17 @@ import json
 import os
 import traceback as tb
 from types import SimpleNamespace
+from typing import Sequence
 
 import aiohttp
 from aiohttp import ClientResponse
 
 from lm_deluge.request_context import RequestContext
 from lm_deluge.tool import MCPServer, Tool
+from lm_deluge.util.schema import (
+    prepare_output_schema,
+    transform_schema_for_openai,
+)
 from lm_deluge.warnings import maybe_warn
 
 from ..config import SamplingParams
@@ -56,8 +61,6 @@ async def _build_oa_chat_request(
     else:
         request_json["max_completion_tokens"] = sampling_params.max_new_tokens
     if model.reasoning_model:
-        request_json["temperature"] = 1.0
-        request_json["top_p"] = 1.0
         effort = sampling_params.reasoning_effort
         if effort in [None, "none"]:
             # Disable reasoning for Gemini models when no effort requested
@@ -67,11 +70,24 @@ async def _build_oa_chat_request(
                 effort = "minimal"
             else:
                 effort = "low"
-        if effort == "minimal" and "gpt-5" not in model.id:
-            print(
-                "WARNING: 'minimal' reasoning effort only allowed for gpt-5. setting to 'low'."
-            )
+        # GPT-5.1 models don't support 'minimal', they support 'none' instead
+        if effort == "minimal" and "gpt-5.1" in model.id:
+            maybe_warn("WARN_MINIMAL_TO_NONE", model_name=context.model_name)
+            effort = "none"
+        elif effort == "minimal" and "gpt-5" not in model.id:
+            maybe_warn("WARN_MINIMAL_TO_LOW", model_name=context.model_name)
             effort = "low"
+        # xhigh only supported for specific models (gpt-5.2, gpt-5.1-codex-max)
+        if effort == "xhigh" and not model.supports_xhigh:
+            maybe_warn("WARN_XHIGH_TO_HIGH", model_name=context.model_name)
+            effort = "high"
+        # GPT-5.2 and gpt-5.1-codex-max don't support temperature/top_p when reasoning is enabled
+        if model.supports_xhigh and effort != "none":
+            del request_json["temperature"]
+            del request_json["top_p"]
+        else:
+            request_json["temperature"] = 1.0
+            request_json["top_p"] = 1.0
         request_json["reasoning_effort"] = effort
     else:
         if sampling_params.reasoning_effort:
@@ -81,17 +97,48 @@ async def _build_oa_chat_request(
         request_json["logprobs"] = True
         if sampling_params.top_logprobs is not None:
             request_json["top_logprobs"] = sampling_params.top_logprobs
-    if sampling_params.json_mode and model.supports_json:
+
+    # Handle structured outputs (output_schema takes precedence over json_mode)
+    if context.output_schema:
+        if model.supports_json:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply OpenAI-specific transformations (currently passthrough with copy)
+            transformed_schema = transform_schema_for_openai(base_schema)
+
+            request_json["response_format"] = {
+                "type": "json_schema",
+                "json_schema": {
+                    "name": "response",
+                    "schema": transformed_schema,
+                    "strict": True,
+                },
+            }
+        else:
+            print(
+                f"WARNING: Model {model.name} does not support structured outputs. Ignoring output_schema."
+            )
+    elif sampling_params.json_mode and model.supports_json:
         request_json["response_format"] = {"type": "json_object"}
+
     if tools:
         request_tools = []
         for tool in tools:
             if isinstance(tool, Tool):
-                request_tools.append(tool.dump_for("openai-completions"))
+                request_tools.append(
+                    tool.dump_for(
+                        "openai-completions", strict=sampling_params.strict_tools
+                    )
+                )
             elif isinstance(tool, MCPServer):
                 as_tools = await tool.to_tools()
                 request_tools.extend(
-                    [t.dump_for("openai-completions") for t in as_tools]
+                    [
+                        t.dump_for(
+                            "openai-completions", strict=sampling_params.strict_tools
+                        )
+                        for t in as_tools
+                    ]
                 )
         request_json["tools"] = request_tools
     return request_json
@@ -271,23 +318,60 @@ async def _build_oa_responses_request(
         request_json["max_output_tokens"] = sampling_params.max_new_tokens
 
     if model.reasoning_model:
-        if sampling_params.reasoning_effort in [None, "none"]:
+        effort = sampling_params.reasoning_effort
+        if effort in [None, "none"]:
             # gemini models can switch reasoning off
             if "gemini" in model.id:
-                sampling_params.reasoning_effort = "none"
+                effort = "none"
             else:
-                sampling_params.reasoning_effort = "low"
-        request_json["temperature"] = 1.0
-        request_json["top_p"] = 1.0
+                effort = "low"
+        # GPT-5.1 models don't support 'minimal', they support 'none' instead
+        if effort == "minimal" and "gpt-5.1" in model.id:
+            maybe_warn("WARN_MINIMAL_TO_NONE", model_name=context.model_name)
+            effort = "none"
+        elif effort == "minimal" and "gpt-5" not in model.id:
+            maybe_warn("WARN_MINIMAL_TO_LOW", model_name=context.model_name)
+            effort = "low"
+        # xhigh only supported for specific models (gpt-5.2, gpt-5.1-codex-max)
+        if effort == "xhigh" and not model.supports_xhigh:
+            maybe_warn("WARN_XHIGH_TO_HIGH", model_name=context.model_name)
+            effort = "high"
+        # GPT-5.2 and gpt-5.1-codex-max don't support temperature/top_p when reasoning is enabled
+        if model.supports_xhigh and effort != "none":
+            del request_json["temperature"]
+            del request_json["top_p"]
+        else:
+            request_json["temperature"] = 1.0
+            request_json["top_p"] = 1.0
         request_json["reasoning"] = {
-            "effort": sampling_params.reasoning_effort,
+            "effort": effort,
             "summary": "auto",
         }
     else:
         if sampling_params.reasoning_effort:
             maybe_warn("WARN_REASONING_UNSUPPORTED", model_name=context.model_name)
 
-    if sampling_params.json_mode and model.supports_json:
+    # Handle structured outputs (output_schema takes precedence over json_mode)
+    if context.output_schema:
+        if model.supports_json:
+            base_schema = prepare_output_schema(context.output_schema)
+
+            # Apply OpenAI-specific transformations (currently passthrough with copy)
+            transformed_schema = transform_schema_for_openai(base_schema)
+
+            request_json["text"] = {
+                "format": {
+                    "type": "json_schema",
+                    "name": "response",
+                    "schema": transformed_schema,
+                    "strict": True,
+                }
+            }
+        else:
+            print(
+                f"WARNING: Model {model.name} does not support structured outputs. Ignoring output_schema."
+            )
+    elif sampling_params.json_mode and model.supports_json:
         request_json["text"] = {"format": {"type": "json_object"}}
 
     # Handle tools
@@ -295,11 +379,13 @@ async def _build_oa_responses_request(
     # Add regular function tools
     for tool in tools or []:
         if isinstance(tool, Tool):
-            request_tools.append(tool.dump_for("openai-responses"))
+            request_tools.append(
+                tool.dump_for("openai-responses", strict=sampling_params.strict_tools)
+            )
         elif isinstance(tool, dict):
             # if computer use, make sure model supports it
             if tool["type"] == "computer_use_preview":
-                if model.name != "openai-computer-use-preview":
+                if model.name != "computer-use-preview":
                     raise ValueError(f"model {model.id} does not support computer use")
                 # have to use truncation
                 request_json["truncation"] = "auto"
@@ -307,7 +393,14 @@ async def _build_oa_responses_request(
         elif isinstance(tool, MCPServer):
             if context.force_local_mcp:
                 as_tools = await tool.to_tools()
-                request_tools.extend([t.dump_for("openai-responses") for t in as_tools])
+                request_tools.extend(
+                    [
+                        t.dump_for(
+                            "openai-responses", strict=sampling_params.strict_tools
+                        )
+                        for t in as_tools
+                    ]
+                )
             else:
                 request_tools.append(tool.for_openai_responses())
 
@@ -381,7 +474,7 @@ class OpenAIResponsesRequest(APIRequestBase):
                         output = data.get("output", [])
                         if not output:
                             is_error = True
-                            error_message = "No output in response"
+                            error_message = f"No output in response. Status: {data.get('status')}, error: {data.get('error')}, incomplete details: {data.get('incomplete_details')}"
                         else:
                             # Process each output item
                             for item in output:
@@ -536,7 +629,7 @@ async def stream_chat(
     model_name: str,  # must correspond to registry
     prompt: Conversation,
     sampling_params: SamplingParams = SamplingParams(),
-    tools: list | None = None,
+    tools: Sequence[Tool | dict | MCPServer] | None = None,
     cache: CachePattern | None = None,
     extra_headers: dict[str, str] | None = None,
 ):