synth-ai 0.2.9.dev4__py3-none-any.whl → 0.2.9.dev7__py3-none-any.whl

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/environment.py

@@ -90,6 +90,7 @@ class CrafterEnvironmentWrapper:
                 logger.warning("Unknown Crafter action: %s - ignoring", action_str)
                 return None  # Signal to skip this action
             return CRAFTER_ACTIONS[action_str]
+
         for tc in tool_calls:
             if isinstance(tc, EnvToolCall):
                 # Expand interact_many; otherwise coerce non-interact tools into interact(action=tool)
@@ -103,12 +104,12 @@ class CrafterEnvironmentWrapper:
                             )
                 elif tc.tool != "interact":
                     candidate_action = tc.args.get("action") if isinstance(tc.args, dict) else None
-                    resolved_action = candidate_action if candidate_action in allowed_actions else tc.tool
+                    resolved_action = (
+                        candidate_action if candidate_action in allowed_actions else tc.tool
+                    )
                     action_int = _action_to_int(resolved_action)
                     if action_int is not None:  # Skip invalid actions
-                        normalized.append(
-                            EnvToolCall(tool="interact", args={"action": action_int})
-                        )
+                        normalized.append(EnvToolCall(tool="interact", args={"action": action_int}))
                 else:
                     normalized.append(tc)
             else:
@@ -120,13 +121,14 @@ class CrafterEnvironmentWrapper:
                 args = tc.get("arguments") or tc.get("args") or {}
                 if isinstance(args, str):
                     import json as _json
+
                     try:
                         args = _json.loads(args)
                     except Exception:
                         args = {}
                 # Expand interact_many into multiple interacts
                 if tool_name == "interact_many":
-                    for action in (args.get("actions") or []):
+                    for action in args.get("actions") or []:
                         action_int = _action_to_int(action)
                         if action_int is not None:  # Skip invalid actions
                             normalized.append(
@@ -135,11 +137,17 @@ class CrafterEnvironmentWrapper:
                 else:
                     # For any non-interact tool, resolve to an interact action.
                     # Support a packed list of actions under 'actions' for convenience.
-                    if isinstance(args, dict) and isinstance(args.get("actions"), list) and args.get("actions"):
+                    if (
+                        isinstance(args, dict)
+                        and isinstance(args.get("actions"), list)
+                        and args.get("actions")
+                    ):
                         for action in args.get("actions"):
                             action_int = _action_to_int(action)
                             if action_int is not None:
-                                normalized.append(EnvToolCall(tool="interact", args={"action": action_int}))
+                                normalized.append(
+                                    EnvToolCall(tool="interact", args={"action": action_int})
+                                )
                     else:
                         candidate_action = None
                         if isinstance(args, dict) and "action" in args:
@@ -148,13 +156,18 @@ class CrafterEnvironmentWrapper:
                         action_int: Optional[int]
                         if isinstance(candidate_action, int):
                             action_int = _action_to_int(candidate_action)
-                        elif isinstance(candidate_action, str) and candidate_action in allowed_actions:
+                        elif (
+                            isinstance(candidate_action, str)
+                            and candidate_action in allowed_actions
+                        ):
                             action_int = _action_to_int(candidate_action)
                         else:
                             # Fallback: interpret the tool name itself as the action label
                             action_int = _action_to_int(tool_name)
                         if action_int is not None:
-                            normalized.append(EnvToolCall(tool="interact", args={"action": action_int}))
+                            normalized.append(
+                                EnvToolCall(tool="interact", args={"action": action_int})
+                            )
 
         # Ensure we have at least one valid action; default to noop if none provided
         if not normalized:
@@ -173,7 +186,9 @@ class CrafterEnvironmentWrapper:
                 "semantic_map": pub_before.semantic_map,
             }
             actions_printable = [
-                (tc.args.get("action") if isinstance(tc.args, dict) else None) if isinstance(tc, EnvToolCall) else None
+                (tc.args.get("action") if isinstance(tc.args, dict) else None)
+                if isinstance(tc, EnvToolCall)
+                else None
                 for tc in normalized
             ]
             logger.info(
@@ -185,7 +200,11 @@ class CrafterEnvironmentWrapper:
                 [k for k, v in before_state["achievements_status"].items() if v],
                 actions_printable,
             )
-            logger.info("Surroundings BEFORE (seed=%s):\n%s", str(self.seed), _format_semantic_map_view(before_state))
+            logger.info(
+                "Surroundings BEFORE (seed=%s):\n%s",
+                str(self.seed),
+                _format_semantic_map_view(before_state),
+            )
         except Exception as _:
             # Logging should not interfere with stepping; fail-fast elsewhere
             pass
@@ -253,8 +272,14 @@ class CrafterEnvironmentWrapper:
                     inv_changes = ", ".join(changed_items) if changed_items else "none"
 
                     # Achievements gained/lost
-                    ach_b = {k for k, v in (before_state.get("achievements_status", {}) or {}).items() if v}
-                    ach_a = {k for k, v in (after_dict.get("achievements_status", {}) or {}).items() if v}
+                    ach_b = {
+                        k
+                        for k, v in (before_state.get("achievements_status", {}) or {}).items()
+                        if v
+                    }
+                    ach_a = {
+                        k for k, v in (after_dict.get("achievements_status", {}) or {}).items() if v
+                    }
                     ach_added = sorted(list(ach_a - ach_b))
                     ach_added_latest = ach_added
                     ach_removed = sorted(list(ach_b - ach_a))
@@ -272,12 +297,19 @@ class CrafterEnvironmentWrapper:
                     if reward is None and ach_added_latest:
                         try:
                             reward = float(len(ach_added_latest))
-                            logger.info("Reward shaping applied: +%s (achievements added)", len(ach_added_latest))
+                            logger.info(
+                                "Reward shaping applied: +%s (achievements added)",
+                                len(ach_added_latest),
+                            )
                         except Exception:
                             pass
                 except Exception:
                     pass
-            logger.info("Surroundings AFTER (seed=%s):\n%s", str(self.seed), _format_semantic_map_view(after_dict))
+            logger.info(
+                "Surroundings AFTER (seed=%s):\n%s",
+                str(self.seed),
+                _format_semantic_map_view(after_dict),
+            )
         except Exception as _:
             pass
         result: Dict[str, Any] = {
@@ -340,6 +372,7 @@ class CrafterEnvironmentWrapper:
             # Build reverse action map for readability
             int_to_action = {v: k for k, v in CRAFTER_ACTIONS.items()}
             from collections import Counter
+
             action_ids = []
             for tc in normalized:
                 if isinstance(tc, EnvToolCall) and isinstance(tc.args, dict):
@@ -380,7 +413,7 @@ class CrafterEnvironmentWrapper:
         return {
             "observation": convert_numpy_to_python(observation),
             "info": convert_numpy_to_python(info) if info else None,
-            "step_idx": self.step_idx
+            "step_idx": self.step_idx,
         }
 
     async def terminate(self) -> Dict[str, Any]:
@@ -390,7 +423,7 @@ class CrafterEnvironmentWrapper:
         return {
             "observation": convert_numpy_to_python(observation),
             "info": convert_numpy_to_python(info) if info else None,
-            "step_idx": self.step_idx
+            "step_idx": self.step_idx,
         }
 
     def state_dict(self) -> Dict[str, Any]:

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/policy.py

@@ -5,17 +5,18 @@ from abc import ABC, abstractmethod
 from .react_agent import CrafterReActAgent
 from .tools import TOOLS_SCHEMA
 
+
 # Define Policy base class here to avoid circular import
 class Policy(ABC):
     """Base class for environment-specific policies."""
-    
+
     @abstractmethod
     def prepare_inference_request(
         self, observation: Dict[str, Any], history: List[Dict[str, Any]] = None
     ) -> Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]:
         """Prepare an inference request."""
         pass
-    
+
     @abstractmethod
     def parse_model_response(
         self, response: str, observation: Dict[str, Any]
@@ -23,6 +24,7 @@ class Policy(ABC):
         """Parse model response into tool calls."""
         pass
 
+
 # (imports moved to top of file to satisfy linter)
 
 
@@ -161,7 +163,7 @@ class CrafterPolicy(Policy):
         # First check if we got actual tool calls
         choices = response.get("choices", [])
         tool_calls: List[Dict[str, Any]] = []
-        
+
         for choice in choices:
             msg = choice.get("message", {})
             if "tool_calls" in msg and msg["tool_calls"] is not None:
@@ -185,7 +187,7 @@ class CrafterPolicy(Policy):
                                 "arguments": tc["arguments"],
                             }
                         )
-        
+
         # If we got tool calls, return them
         if tool_calls:
             # Normalize common degenerate pattern ["move_right", "do"] when nothing is nearby.
@@ -197,6 +199,7 @@ class CrafterPolicy(Policy):
                     if isinstance(args, str):
                         try:
                             import json
+
                             args = json.loads(args)
                         except (json.JSONDecodeError, ValueError):
                             args = {}
@@ -208,11 +211,13 @@ class CrafterPolicy(Policy):
                     # Simple heuristic: avoid repeating same pair; avoid 'do' with no context
                     if len(actions) == 2 and actions[0] == "move_right" and actions[1] == "do":
                         actions = ["move_right"]
-                    normalized.append({"tool_name": "interact_many", "arguments": {"actions": actions or []}})
+                    normalized.append(
+                        {"tool_name": "interact_many", "arguments": {"actions": actions or []}}
+                    )
                 else:
                     normalized.append(tc)
             return normalized
-            
+
         # Otherwise, parse plain text content for actions
         text = ""
         for choice in choices:
@@ -221,15 +226,16 @@ class CrafterPolicy(Policy):
             if content:
                 text = content
                 break
-        
+
         if text:
             # Try to parse actions from the text
             from .shared import parse_actions
+
             actions = parse_actions(text)
             if actions:
                 # Wrap actions in interact_many tool call
                 return [{"tool_name": "interact_many", "arguments": {"actions": actions}}]
-        
+
         # No actions found
         return []
 
@@ -264,7 +270,11 @@ class CrafterPolicy(Policy):
                 prev_tool_calls = metadata["prev_tool_calls"]
             if "prev_env_result" in metadata:
                 prev_env_result = metadata["prev_env_result"]
-            if prev_assistant_text is not None or prev_tool_calls is not None or prev_env_result is not None:
+            if (
+                prev_assistant_text is not None
+                or prev_tool_calls is not None
+                or prev_env_result is not None
+            ):
                 self._append_assistant_turn(prev_assistant_text, prev_tool_calls, prev_env_result)
 
         # Append current observation as the next user message (internal history only)
@@ -274,8 +284,12 @@ class CrafterPolicy(Policy):
         # (formatted surroundings/inventory) with the previous 3 tool calls as context.
         # Most recent first.
         lines: List[str] = []
-        def _format_tool_call_line_for_context(tool_name: str, arguments: Any, max_chars: int = 500) -> str:
+
+        def _format_tool_call_line_for_context(
+            tool_name: str, arguments: Any, max_chars: int = 500
+        ) -> str:
             import json as _json
+
             # Render arguments compactly, then clip to max_chars
             if isinstance(arguments, (dict, list)):
                 try:
@@ -289,6 +303,7 @@ class CrafterPolicy(Policy):
             if isinstance(rendered, str) and len(rendered) > max_chars:
                 rendered = rendered[:max_chars]
             return f"- {tool_name}: {rendered}"
+
         # Prefer pulling from trajectory_history (accumulates over turns)
         for record in reversed(self.trajectory_history):
             if len(lines) >= 3:
@@ -316,7 +331,9 @@ class CrafterPolicy(Policy):
                 args = call.get("arguments")
                 lines.append(_format_tool_call_line_for_context(name, args))
 
-        context_text = "Previous tool calls (most recent first):\n" + ("\n".join(lines) if lines else "- none")
+        context_text = "Previous tool calls (most recent first):\n" + (
+            "\n".join(lines) if lines else "- none"
+        )
 
         # Combine observation with context so the model always sees surroundings/inventory
         combined_text = f"{observation_text}\n\n{context_text}"
@@ -326,7 +343,7 @@ class CrafterPolicy(Policy):
             history=[],  # no prior user/assistant history
             turn=self.turn_index,
         )
-        #print("Debugging only:; ", payload)
+        # print("Debugging only:; ", payload)
         meta_out = {
             "inference_url": self.inference_url,
             "inference_request": payload,
@@ -372,7 +389,7 @@ class CrafterPolicy(Policy):
 
     async def terminate(self) -> None:
         return None
-    
+
     def prepare_inference_request(
         self, observation: Dict[str, Any], history: List[Dict[str, Any]] = None
     ) -> Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]:
@@ -382,9 +399,7 @@ class CrafterPolicy(Policy):
 
         # Build messages (observation_text already formatted; no raw matrices)
         messages = CrafterReActAgent.build_messages(
-            observation=observation_text,
-            history=history,
-            turn=self.turn_index
+            observation=observation_text, history=history, turn=self.turn_index
         )
 
         # Return messages and tools schema
@@ -402,7 +417,6 @@ class CrafterPolicy(Policy):
         if not isinstance(obs_data, dict):
             return f"Observation: {str(observation)}"
 
-
         # Use the shared format_observation function with step information
         step_idx = observation.get("step_idx", 0)
         max_steps = 100  # Default max steps, could be made configurable
@@ -416,25 +430,25 @@ class CrafterPolicy(Policy):
                 obs_data["health"] = info["health"]
 
         return format_observation(obs_data, step_count=step_idx, max_steps=max_steps)
-    
+
     def parse_model_response(
         self, response: str, observation: Dict[str, Any]
     ) -> List[Dict[str, Any]]:
         """Parse model response into tool calls (implementing abstract method).
-        
+
         Note: Despite the type hint, vLLM actually returns a dict response,
         not a string. We handle both cases.
         """
         # Handle dict response from vLLM (the actual case)
         if isinstance(response, dict):
             return self.parse_response_to_tool_calls(response, self.use_tools)
-        
+
         # Handle string response (fallback case for raw text)
         if isinstance(response, str):
             actions = CrafterReActAgent.parse_actions_from_response(response)
             if actions:
                 return [{"tool_name": "interact_many", "arguments": {"actions": actions}}]
-        
+
         # Default empty response
         return []
 

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/react_agent.py

@@ -51,7 +51,7 @@ class CrafterReActAgent:
             "place_stone, place_table, place_furnace, place_plant, make_wood_pickaxe, make_stone_pickaxe, "
             "make_iron_pickaxe, make_wood_sword, make_stone_sword, make_iron_sword\n"
         )
-    
+
     @staticmethod
     def get_system_prompt_with_tools() -> str:
         """System prompt for tool-based interaction (e.g., Qwen3 models)."""
@@ -80,9 +80,13 @@ class CrafterReActAgent:
         )
 
     @staticmethod
-    def build_messages(observation: str, history: Optional[List[Dict[str, str]]] = None, turn: Optional[int] = None) -> List[Dict[str, str]]:
+    def build_messages(
+        observation: str, history: Optional[List[Dict[str, str]]] = None, turn: Optional[int] = None
+    ) -> List[Dict[str, str]]:
         """Construct OpenAI-style messages list for vLLM generation."""
-        msgs: List[Dict[str, str]] = [{"role": "system", "content": CrafterReActAgent.get_system_prompt()}]
+        msgs: List[Dict[str, str]] = [
+            {"role": "system", "content": CrafterReActAgent.get_system_prompt()}
+        ]
         if history:
             msgs.extend(history)
         msgs.append({"role": "user", "content": observation})
@@ -93,4 +97,4 @@ class CrafterReActAgent:
         return parse_actions(response_text)
 
 
-__all__ = ["CrafterReActAgent"]
+__all__ = ["CrafterReActAgent"]

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/shared.py

@@ -71,7 +71,7 @@ def validate_action(action: str) -> bool:
 
 def parse_actions(action_text: str) -> List[str]:
     """Extract actions from response text.
-    
+
     Tries multiple parsing strategies:
     1. <action>...</action> tags (original format)
     2. [action]...[/action] or [action]... format
@@ -80,43 +80,43 @@ def parse_actions(action_text: str) -> List[str]:
     5. Newline-separated actions
     """
     import json
-    
+
     # First try the original <action> tag format
     matches = re.findall(r"<action>(.*?)</action>", action_text, re.IGNORECASE)
     if matches:
         return [m.strip() for m in matches if validate_action(m.strip())]
-    
+
     # Try [action] format
     matches = re.findall(r"\[action\](.*?)(?:\[/action\]|\n|$)", action_text, re.IGNORECASE)
     if matches:
         return [m.strip() for m in matches if validate_action(m.strip())]
-    
+
     # If no tags found, try to parse plain text
     text = action_text.strip()
-    
+
     # Check if the entire text is a valid action
     if validate_action(text):
         return [text]
-    
+
     # Try splitting by newlines and checking each line
-    lines = text.split('\n')
+    lines = text.split("\n")
     actions = []
     for line in lines:
         line = line.strip()
-        
+
         # Remove various prefixes
-        for prefix in ['ACTION:', 'Action:', 'action:', 'ACTION', '-', '*', '•', '**ACTION:**']:
+        for prefix in ["ACTION:", "Action:", "action:", "ACTION", "-", "*", "•", "**ACTION:**"]:
             if line.startswith(prefix):
-                line = line[len(prefix):].strip()
+                line = line[len(prefix) :].strip()
                 break
-        
+
         # Also handle numbered lists
-        if re.match(r'^\d+\.\s*', line):
-            line = re.sub(r'^\d+\.\s*', '', line)
-        
+        if re.match(r"^\d+\.\s*", line):
+            line = re.sub(r"^\d+\.\s*", "", line)
+
         # Split by common separators to handle multiple actions on one line
-        parts = re.split(r'[,;]|\s+and\s+|\s+then\s+', line)
-        
+        parts = re.split(r"[,;]|\s+and\s+|\s+then\s+", line)
+
         for part in parts:
             part = part.strip()
             # Remove quotes if present
@@ -124,23 +124,23 @@ def parse_actions(action_text: str) -> List[str]:
                 part = part[1:-1]
             if part.startswith("'") and part.endswith("'"):
                 part = part[1:-1]
-                
+
             # Check if it's a valid action
             if part and validate_action(part):
                 actions.append(part)
-    
+
     return actions
 
 
 def format_observation(obs_data: Dict[str, Any], step_count: int = 0, max_steps: int = 100) -> str:
     """Format a Crafter observation dictionary into a human-readable string.
-    
+
     This is critical for preventing massive token counts when observations
     contain large numpy arrays or deeply nested structures.
     """
     if not obs_data:
         return ""
-    
+
     # Extract key information
     health = obs_data.get("health") or obs_data.get("inventory", {}).get("health", 0)
     inventory_dict = obs_data.get("inventory", {})
@@ -160,18 +160,18 @@ def format_observation(obs_data: Dict[str, Any], step_count: int = 0, max_steps:
     max_steps_from_obs = obs_data.get("max_steps_episode") or obs_data.get("max_steps")
     if isinstance(max_steps_from_obs, (int, float)) and max_steps_from_obs > 0:
         max_steps = int(max_steps_from_obs)
-    
+
     # Format inventory (skip health as it's shown separately)
     inv_items = [f"{k}:{v}" for k, v in inventory_dict.items() if v > 0 and k != "health"]
     inventory_str = ", ".join(inv_items) if inv_items else "empty"
-    
+
     # Format achievements
     achieved_list = [k for k, v in achievements.items() if v]
     achievements_str = ", ".join(achieved_list) if achieved_list else "none"
-    
+
     # Format semantic map view (simplified version)
     map_view = _format_semantic_map_view(obs_data, VIEW_SIZE)
-    
+
     return (
         f"=== CRAFTER GAME STATE ===\n"
         f"Step: {step_count}/{max_steps}\n"
@@ -184,6 +184,7 @@ def format_observation(obs_data: Dict[str, Any], step_count: int = 0, max_steps:
         f"Choose your next actions.\n"
     )
 
+
 def _try_build_dynamic_mapping():
     """Attempt to build id->name mapping from a real Crafter env.
 
@@ -232,7 +233,7 @@ def _try_build_dynamic_mapping():
 # Build dynamic mapping if possible; otherwise fall back to a basic map
 _ID_TO_NAME = _try_build_dynamic_mapping()
 _FALLBACK_ID_TO_NAME = {
-    0: "none",      # None from materials
+    0: "none",  # None from materials
     1: "water",
     2: "grass",
     3: "stone",
@@ -299,4 +300,6 @@ def _format_semantic_map_view(obs_data: Dict[str, Any], view_size: int = VIEW_SI
 
     transposed = list(zip(*matrix))
     grid_rows: List[str] = [" ".join(row) for row in transposed]
-    return "\nLocal Map View (" + str(view_size) + "x" + str(view_size) + "):\n" + "\n".join(grid_rows)
+    return (
+        "\nLocal Map View (" + str(view_size) + "x" + str(view_size) + "):\n" + "\n".join(grid_rows)
+    )

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/tools.py

@@ -44,4 +44,4 @@ TOOLS_SCHEMA = [
             },
         },
     }
-]
+]

examples/warming_up_to_rl/task_app/synth_envs_hosted/hosted_app.py

@@ -22,9 +22,7 @@ class TaskApp:
         self.service_base_url = service_base_url or os.getenv(
             "SERVICE_BASE_URL", "http://localhost:8000"
         )
-        self.vllm_base_url = vllm_base_url or os.getenv(
-            "VLLM_BASE_URL", "http://localhost:8001"
-        )
+        self.vllm_base_url = vllm_base_url or os.getenv("VLLM_BASE_URL", "http://localhost:8001")
         self.default_model = default_model or os.getenv("DEFAULT_MODEL")
 
 
@@ -69,9 +67,7 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
         @app.middleware("http")
         async def validate_environment(request, call_next):
             # Check if this is an environment-related request
-            if request.url.path.startswith("/env/") or request.url.path.startswith(
-                "/rollout"
-            ):
+            if request.url.path.startswith("/env/") or request.url.path.startswith("/rollout"):
                 # Extract environment name from request body for POST requests
                 if request.method == "POST":
                     # We need to read the body to check env_name
@@ -83,9 +79,7 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
                         env_name = data.get("env_name", "").lower()
 
                         # Check if environment is allowed
-                        if env_name and env_name not in [
-                            e.lower() for e in allowed_environments
-                        ]:
+                        if env_name and env_name not in [e.lower() for e in allowed_environments]:
                             from fastapi import HTTPException
 
                             raise HTTPException(
@@ -111,6 +105,7 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
     # Policy routes are optional; skip if optional envs are missing in this build
     try:
         from .policy_routes import router as policy_router
+
         app.include_router(policy_router, prefix="/policy", tags=["policy"])
     except Exception as _e:
         # Log lightweight message; policy endpoints will be unavailable
@@ -157,6 +152,7 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
 
         # Check if any environment API keys are configured
         from synth_ai.task.auth import allowed_environment_api_keys
+
         allowed_keys = allowed_environment_api_keys()
         if not allowed_keys:
             # Server-side misconfiguration; rollout would fail with 503
@@ -167,22 +163,28 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
                     "detail": "Auth not configured: missing ENVIRONMENT_API_KEY in task service environment",
                 },
             )
-        
+
         # Authorize using all header variants without typed Header params (avoid 422s)
         from synth_ai.task.auth import is_api_key_header_authorized
+
         authorized = is_api_key_header_authorized(request)
         if not authorized:
             # Soft-pass 200 with authorized=False to avoid failing CLI preflight
             primary_key = list(allowed_keys)[0] if allowed_keys else None
-            prefix = (primary_key[: max(1, len(primary_key) // 2)] if primary_key else None)
+            prefix = primary_key[: max(1, len(primary_key) // 2)] if primary_key else None
             content = {"status": "healthy", "authorized": False}
             if prefix:
                 content["expected_api_key_prefix"] = prefix
             return JSONResponse(status_code=200, content=content)
-        return {"status": "healthy", "authorized": True, "service": {"base_url": task_app.service_base_url}}
+        return {
+            "status": "healthy",
+            "authorized": True,
+            "service": {"base_url": task_app.service_base_url},
+        }
 
     # Log and surface 422 validation errors with header presence
     from fastapi.exceptions import RequestValidationError
+
     @app.exception_handler(RequestValidationError)
     async def _on_validation_error(request: Request, exc: RequestValidationError):
         try:
@@ -197,6 +199,8 @@ def create_app(allowed_environments: list[str] = None) -> FastAPI:
             print("[422] validation", snapshot, flush=True)
         except Exception:
             pass
-        return JSONResponse(status_code=422, content={"status": "invalid", "detail": exc.errors()[:5]})
+        return JSONResponse(
+            status_code=422, content={"status": "invalid", "detail": exc.errors()[:5]}
+        )
 
     return app

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

@@ -2,4 +2,4 @@
 
 from .openai_client import OpenAIClient, create_inference_client
 
-__all__ = ["OpenAIClient", "create_inference_client"]
+__all__ = ["OpenAIClient", "create_inference_client"]