synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

examples/warming_up_to_rl/task_app/synth_envs_hosted/inference/openai_client.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 import httpx
 
@@ -11,22 +12,24 @@ logger = logging.getLogger(__name__)
 
 class OpenAIClient:
     """Async HTTP client for OpenAI-compatible inference servers (vLLM)."""
-    
+
     def __init__(
         self,
         base_url: str,
-        api_key: Optional[str] = None,
+        api_key: str | None = None,
         timeout_s: float = 120.0,
     ) -> None:
         self.base_url = base_url.rstrip("/")
         self.api_key = api_key
         self.timeout_s = timeout_s
         self.headers = {}
-        
+
         if api_key:
             self.headers["Authorization"] = f"Bearer {api_key}"
 
-    def _fix_model_parameters(self, request: Dict[str, Any], target_url: Optional[str] = None) -> Dict[str, Any]:
+    def _fix_model_parameters(
+        self, request: dict[str, Any], target_url: str | None = None
+    ) -> dict[str, Any]:
         """
         Fix parameter compatibility for newer OpenAI models.
 
@@ -75,7 +78,9 @@ class OpenAIClient:
                 if "max_tokens" in fixed_request:
                     if "max_completion_tokens" not in fixed_request:
                         fixed_request["max_completion_tokens"] = fixed_request.pop("max_tokens")
-                        logger.info(f"Converted max_tokens to max_completion_tokens for model {model}")
+                        logger.info(
+                            f"Converted max_tokens to max_completion_tokens for model {model}"
+                        )
                     else:
                         fixed_request.pop("max_tokens")
                         logger.info(f"Removed conflicting max_tokens parameter for model {model}")
@@ -87,9 +92,25 @@ class OpenAIClient:
                 try:
                     tools = fixed_request.get("tools")
                     if isinstance(tools, list) and tools:
+                        # Choose the first provided function name from tools schema (e.g., run_command)
+                        func_name = None
+                        for t in tools:
+                            try:
+                                cand = None
+                                if isinstance(t, dict):
+                                    f = t.get("function")
+                                    if isinstance(f, dict):
+                                        cand = f.get("name")
+                                if isinstance(cand, str) and cand:
+                                    func_name = cand
+                                    break
+                            except Exception:
+                                continue
+                        if not func_name:
+                            func_name = "run_command"
                         fixed_request["tool_choice"] = {
                             "type": "function",
-                            "function": {"name": "interact_many"},
+                            "function": {"name": func_name},
                         }
                         fixed_request["parallel_tool_calls"] = False
                 except Exception:
@@ -99,11 +120,11 @@ class OpenAIClient:
 
     async def generate(
         self,
-        request: Dict[str, Any],
-        base_url: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-        extra_headers: Optional[Dict[str, str]] = None,
-    ) -> Dict[str, Any]:
+        request: dict[str, Any],
+        base_url: str | None = None,
+        timeout_s: float | None = None,
+        extra_headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
         """
         Send a chat completion request to the inference server.
 
@@ -131,21 +152,20 @@ class OpenAIClient:
         logger.info(f"Inference POST target: {url}")
         if extra_headers:
             logger.info(f"Extra headers: {extra_headers}")
-        try:
-            keys_preview = sorted(list(processed_request.keys()))
+        with contextlib.suppress(Exception):
+            keys_preview = sorted(processed_request.keys())
             logger.info(f"Request keys: {keys_preview}")
-        except Exception:
-            pass
 
         # Final hard-guard for OpenAI: ensure unsupported field is not present
         try:
-            if "openai" in url.lower():
-                if "stop_after_tool_calls" in processed_request:
-                    processed_request.pop("stop_after_tool_calls", None)
-                    logger.info("Removed stop_after_tool_calls for OpenAI request")
+            if "openai" in url.lower() and "stop_after_tool_calls" in processed_request:
+                processed_request.pop("stop_after_tool_calls", None)
+                logger.info("Removed stop_after_tool_calls for OpenAI request")
             # Groq-specific requirement: when using JSON mode, one of the messages must contain the word 'json'
             low_url = url.lower()
-            if ("groq.com" in low_url or "/openai" in low_url) and isinstance(processed_request, dict):
+            if ("groq.com" in low_url or "/openai" in low_url) and isinstance(
+                processed_request, dict
+            ):
                 rf = processed_request.get("response_format")
                 rf_type = None
                 if isinstance(rf, dict):
@@ -164,7 +184,9 @@ class OpenAIClient:
                                     # Join any text segments
                                     parts = []
                                     for seg in content:
-                                        if isinstance(seg, dict) and isinstance(seg.get("text"), str):
+                                        if isinstance(seg, dict) and isinstance(
+                                            seg.get("text"), str
+                                        ):
                                             parts.append(seg["text"])
                                     text = "\n".join(parts)
                                 if isinstance(text, str) and ("json" in text.lower()):
@@ -174,13 +196,17 @@ class OpenAIClient:
                                 continue
                     if not has_json_word:
                         try:
-                            instruction = "Respond in strict JSON only. Output a single valid JSON object."
+                            instruction = (
+                                "Respond in strict JSON only. Output a single valid JSON object."
+                            )
                             if not isinstance(msgs, list):
                                 msgs = []
                             # Prepend a system message to satisfy Groq requirement without changing user intent
                             prepend = {"role": "system", "content": instruction}
                             processed_request["messages"] = [prepend] + list(msgs)
-                            logger.info("Injected JSON-mode system instruction for Groq response_format compliance")
+                            logger.info(
+                                "Injected JSON-mode system instruction for Groq response_format compliance"
+                            )
                         except Exception:
                             pass
         except Exception:
@@ -194,7 +220,7 @@ class OpenAIClient:
                     headers=headers,
                 )
                 response.raise_for_status()
-                
+
                 # Rich response diagnostics
                 content_type = response.headers.get("content-type")
                 body_text = response.text
@@ -203,12 +229,14 @@ class OpenAIClient:
                 )
                 if body_text:
                     preview_len = min(800, len(body_text))
-                    logger.info(f"Inference response preview ({preview_len} bytes): {body_text[:preview_len]}")
+                    logger.info(
+                        f"Inference response preview ({preview_len} bytes): {body_text[:preview_len]}"
+                    )
 
                 result = response.json()
                 logger.info(f"Inference response parsed_type={type(result).__name__}")
                 return result
-                
+
             except httpx.TimeoutException:
                 logger.error(f"Request to {url} timed out after {timeout}s")
                 raise
@@ -217,12 +245,14 @@ class OpenAIClient:
                 text = e.response.text if e.response is not None else str(e)
                 # Log full body for debugging remote failures
                 try:
-                    logger.error({
-                        "openai_http_error": True,
-                        "status": status,
-                        "url": url,
-                        "body": text,
-                    })
+                    logger.error(
+                        {
+                            "openai_http_error": True,
+                            "status": status,
+                            "url": url,
+                            "body": text,
+                        }
+                    )
                 except Exception:
                     logger.error(f"HTTP error from {url}: {status} - {text}")
                 # For 4xx/5xx, print full sanitized request to aid debugging (especially Groq 400s)
@@ -230,13 +260,15 @@ class OpenAIClient:
                     redacted_headers = dict(headers)
                     if "Authorization" in redacted_headers:
                         redacted_headers["Authorization"] = "***REDACTED***"
-                    logger.error({
-                        "request_debug": True,
-                        "status": status,
-                        "target": url,
-                        "headers": redacted_headers,
-                        "payload": processed_request,
-                    })
+                    logger.error(
+                        {
+                            "request_debug": True,
+                            "status": status,
+                            "target": url,
+                            "headers": redacted_headers,
+                            "payload": processed_request,
+                        }
+                    )
                 except Exception:
                     pass
                 # Special case: token budget exceeded (OpenAI-compatible error schema)
@@ -266,27 +298,42 @@ class OpenAIClient:
                                         processed_request.pop(k, None)
                                     # Force structured tool choice
                                     if processed_request.get("tool_choice") == "required":
-                                        func_name = "interact_many"
+                                        func_name = "run_command"
                                         try:
                                             tools_arr = processed_request.get("tools") or []
                                             if isinstance(tools_arr, list) and tools_arr:
-                                                f = tools_arr[0].get("function") if isinstance(tools_arr[0], dict) else None
-                                                cand = (f or {}).get("name") if isinstance(f, dict) else None
+                                                f = (
+                                                    tools_arr[0].get("function")
+                                                    if isinstance(tools_arr[0], dict)
+                                                    else None
+                                                )
+                                                cand = (
+                                                    (f or {}).get("name")
+                                                    if isinstance(f, dict)
+                                                    else None
+                                                )
                                                 if isinstance(cand, str) and cand:
                                                     func_name = cand
                                         except Exception:
                                             pass
-                                        processed_request["tool_choice"] = {"type": "function", "function": {"name": func_name}}
+                                        processed_request["tool_choice"] = {
+                                            "type": "function",
+                                            "function": {"name": func_name},
+                                        }
                                         processed_request["parallel_tool_calls"] = False
-                                    logger.warning({
-                                        "token_budget_recovery": True,
-                                        "messages_tokens": messages_tokens,
-                                        "model_limit": model_limit,
-                                        "retry_max_tokens": new_max,
-                                    })
+                                    logger.warning(
+                                        {
+                                            "token_budget_recovery": True,
+                                            "messages_tokens": messages_tokens,
+                                            "model_limit": model_limit,
+                                            "retry_max_tokens": new_max,
+                                        }
+                                    )
                                     # Retry once with reduced budget
                                     async with httpx.AsyncClient(timeout=timeout) as client2:
-                                        r2 = await client2.post(url, json=processed_request, headers=headers)
+                                        r2 = await client2.post(
+                                            url, json=processed_request, headers=headers
+                                        )
                                         r2.raise_for_status()
                                         return r2.json()
                             except Exception:
@@ -302,14 +349,17 @@ class OpenAIClient:
                             err = e.response.json()
                         except Exception:
                             err = {"error": "unprocessable", "detail": (text or "")[:200]}
-                        logger.warning({
-                            "inference_422_recovered": True,
-                            "detail": err,
-                        })
+                        logger.warning(
+                            {
+                                "inference_422_recovered": True,
+                                "detail": err,
+                            }
+                        )
                     except Exception:
                         pass
                     # Return a minimal OpenAI-compatible response with no tool_calls/content
                     import time as _t
+
                     return {
                         "id": f"cmpl-{int(_t.time())}",
                         "object": "chat.completion",
@@ -328,25 +378,25 @@ class OpenAIClient:
             except Exception as e:
                 logger.error(f"Unexpected error calling {url}: {e}")
                 raise
-    
+
     async def check_health(
         self,
-        base_url: Optional[str] = None,
-        timeout_s: Optional[float] = None,
-    ) -> Dict[str, Any]:
+        base_url: str | None = None,
+        timeout_s: float | None = None,
+    ) -> dict[str, Any]:
         """
         Check if the inference service is healthy.
-        
+
         Args:
             base_url: Override base URL for this request
             timeout_s: Override timeout for this request
-        
+
         Returns:
             Health status dict with 'status' field
         """
         url = (base_url or self.base_url).rstrip("/") + "/health"
         timeout = timeout_s or 10.0
-        
+
         try:
             async with httpx.AsyncClient(timeout=timeout) as client:
                 response = await client.get(url, headers=self.headers)
@@ -364,19 +414,19 @@ class OpenAIClient:
             return {"status": "unhealthy", "error": str(e)}
         except Exception as e:
             return {"status": "unhealthy", "error": str(e)}
-    
+
     async def generate_with_retries(
         self,
-        request: Dict[str, Any],
-        base_url: Optional[str] = None,
-        timeout_s: Optional[float] = None,
+        request: dict[str, Any],
+        base_url: str | None = None,
+        timeout_s: float | None = None,
         max_retries: int = 4,
         backoff_factor: float = 2.0,
-        extra_headers: Optional[Dict[str, str]] = None,
-    ) -> Dict[str, Any]:
+        extra_headers: dict[str, str] | None = None,
+    ) -> dict[str, Any]:
         """
         Generate with exponential backoff retries for transient errors.
-        
+
         Args:
             request: OpenAI-compatible chat completion request
             base_url: Override base URL
@@ -384,13 +434,13 @@ class OpenAIClient:
             max_retries: Maximum number of retry attempts
             backoff_factor: Exponential backoff multiplier
             extra_headers: Additional headers to include (e.g., X-Policy-Name)
-        
+
         Returns:
             OpenAI-compatible chat completion response
         """
         last_error = None
         wait_time = 1.0
-        
+
         for attempt in range(max_retries + 1):
             try:
                 # Apply parameter fixes to the request
@@ -417,7 +467,9 @@ class OpenAIClient:
                             retry_after = response_data.get("retry_after", 1)
                             # Use the suggested retry_after time instead of exponential backoff for overload
                             wait_time = max(wait_time, float(retry_after))
-                            logger.warning(f"Inference service overloaded (400). {response_data} Retrying after {wait_time}s...")
+                            logger.warning(
+                                f"Inference service overloaded (400). {response_data} Retrying after {wait_time}s..."
+                            )
                         else:
                             # This is a different type of 400 error, don't retry
                             try:
@@ -428,13 +480,15 @@ class OpenAIClient:
                                         redacted_headers["Authorization"] = "***REDACTED***"
                                 except Exception:
                                     redacted_headers = {}
-                                logger.error({
-                                    "non_overload_400": True,
-                                    "target": (base_url or self.base_url),
-                                    "payload": processed_request,
-                                    "headers": redacted_headers,
-                                    "body": e.response.text if e.response is not None else None,
-                                })
+                                logger.error(
+                                    {
+                                        "non_overload_400": True,
+                                        "target": (base_url or self.base_url),
+                                        "payload": processed_request,
+                                        "headers": redacted_headers,
+                                        "body": e.response.text if e.response is not None else None,
+                                    }
+                                )
                             except Exception:
                                 pass
                             raise RuntimeError(
@@ -442,14 +496,14 @@ class OpenAIClient:
                             ) from e
                     except Exception:
                         # If we can't parse the response, don't retry 400 errors
-                        try:
-                            logger.error({
-                                "non_overload_400_unparsed": True,
-                                "target": (base_url or self.base_url),
-                                "payload": processed_request,
-                            })
-                        except Exception:
-                            pass
+                        with contextlib.suppress(Exception):
+                            logger.error(
+                                {
+                                    "non_overload_400_unparsed": True,
+                                    "target": (base_url or self.base_url),
+                                    "payload": processed_request,
+                                }
+                            )
                         raise RuntimeError(
                             f"Inference 400 response (unparsed): {e.response.text if e.response is not None else 'Bad Request'}"
                         ) from e
@@ -472,7 +526,7 @@ class OpenAIClient:
                     )
             except httpx.TimeoutException as e:
                 last_error = e
-            
+
             if attempt < max_retries:
                 logger.warning(
                     f"Inference request failed (attempt {attempt + 1}/{max_retries + 1}), "
@@ -480,21 +534,21 @@ class OpenAIClient:
                 )
                 await asyncio.sleep(wait_time)
                 wait_time *= backoff_factor
-        
+
         raise last_error
 
 
 def create_inference_client(
     task_app: Any,
-    api_key: Optional[str] = None,
+    api_key: str | None = None,
 ) -> OpenAIClient:
     """
     Create an inference client using TaskApp configuration.
-    
+
     Args:
         task_app: TaskApp instance with vllm_base_url
         api_key: Optional API key for authentication
-    
+
     Returns:
         Configured OpenAIClient instance
     """
@@ -502,10 +556,62 @@ def create_inference_client(
     if api_key is None:
         try:
             import os as _os  # local import to avoid module-level side effects
+
             api_key = _os.getenv("OPENAI_API_KEY") or getattr(task_app, "openai_api_key", None)
         except Exception:
             api_key = None
 
+    import json as _json
+    import os as _os
+    import time as _time
+
+    if _os.getenv("SYNTH_FAKE_INFERENCE", "").strip():
+
+        class _DummyClient:
+            async def generate_with_retries(
+                self,
+                request: dict[str, Any],
+                base_url: str | None = None,
+                max_retries: int = 0,
+                backoff_factor: float = 1.0,
+                extra_headers: dict[str, str] | None = None,
+            ) -> dict[str, Any]:
+                tool_call = {
+                    "id": "call_dummy",
+                    "type": "function",
+                    "function": {
+                        "name": "interact_many",
+                        "arguments": _json.dumps({"actions": ["move_right"]}),
+                    },
+                }
+                return {
+                    "id": f"cmpl-{int(_time.time())}",
+                    "object": "chat.completion",
+                    "created": int(_time.time()),
+                    "model": request.get("model") or "dummy-model",
+                    "choices": [
+                        {
+                            "index": 0,
+                            "message": {
+                                "role": "assistant",
+                                "content": "",
+                                "tool_calls": [tool_call],
+                            },
+                            "finish_reason": "tool_calls",
+                        }
+                    ],
+                    "usage": {"prompt_tokens": 10, "completion_tokens": 5, "total_tokens": 15},
+                }
+
+            async def check_health(
+                self,
+                base_url: str | None = None,
+                timeout_s: float | None = None,
+            ) -> dict[str, Any]:
+                return {"status": "ok", "dummy": True}
+
+        return _DummyClient()
+
     return OpenAIClient(
         base_url=task_app.vllm_base_url,
         api_key=api_key,

examples/warming_up_to_rl/task_app/synth_envs_hosted/main.py

@@ -12,7 +12,6 @@ For Modal deployment:
 from __future__ import annotations
 
 import os
-from typing import Optional
 
 import modal
 
@@ -26,7 +25,6 @@ except ImportError:
 
 from synth_envs_hosted.hosted_app import create_app
 
-
 # Local development mode
 if __name__ == "__main__":
     import uvicorn