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

synth_ai/demos/demo_task_apps/math/modal_task_app.py

@@ -1,14 +1,13 @@
-from __future__ import annotations
-
 """Modal task app for Hendrycks MATH single-step RL environment."""
 
+from __future__ import annotations
+
 import os
+from collections.abc import Iterable
+from functools import lru_cache
 from pathlib import Path
 
 from modal import App, Image, Secret, asgi_app
-from functools import lru_cache
-from typing import Iterable
-
 from starlette.requests import Request
 
 try:  # Backward compatibility with older installed SDKs
@@ -99,8 +98,7 @@ app = App("hendrycks-math-task-app")
 @asgi_app()
 def fastapi_app():
     import httpx
-    from fastapi import Body, HTTPException, status
-    from fastapi import FastAPI
+    from fastapi import Body, FastAPI, HTTPException, status
     from fastapi.middleware.cors import CORSMiddleware
     from fastapi.responses import JSONResponse
 
@@ -388,7 +386,7 @@ def fastapi_app():
         try:
             hdr = request.headers
             snapshot = {
-                "path": str(getattr(request, "url").path),
+                "path": str(request.url.path),
                 "have_x_api_key": bool(hdr.get("x-api-key")),
                 "have_x_api_keys": bool(hdr.get("x-api-keys")),
                 "have_authorization": bool(hdr.get("authorization")),
@@ -412,32 +410,32 @@ def fastapi_app():
     env_key = (
         os.environ.get("ENVIRONMENT_API_KEY")
         or os.environ.get("DEV_ENVIRONMENT_API_KEY")
-        or os.environ.get("dev_environment_api_key")
+        or os.environ.get("DEV_ENVIRONMENT_API_KEY")
     )
     if not env_key:
         raise RuntimeError("ENVIRONMENT_API_KEY missing in task app environment")
 
-    OPENAI_REMOVE_FIELDS = (
+    openai_remove_fields = (
         "stop_after_tool_calls",
         "thinking_mode",
         "thinking_budget",
         "reasoning",
     )
-    OPENAI_REMOVE_SAMPLING_FIELDS = ("temperature", "top_p")
-    TOOL_CHOICE_FORCE = {"type": "function", "function": {"name": "submit_answer"}}
+    openai_remove_sampling_fields = ("temperature", "top_p")
+    tool_choice_force = {"type": "function", "function": {"name": "submit_answer"}}
 
     def _prepare_openai_payload(model: str | None, payload: dict[str, object]) -> dict[str, object]:
         sanitized = dict(payload)
-        for key in OPENAI_REMOVE_FIELDS:
+        for key in openai_remove_fields:
             sanitized.pop(key, None)
         if model and "gpt-5" in model:
             if "max_tokens" in sanitized and "max_completion_tokens" not in sanitized:
                 sanitized["max_completion_tokens"] = sanitized.pop("max_tokens")
             else:
                 sanitized.pop("max_tokens", None)
-            for field in OPENAI_REMOVE_SAMPLING_FIELDS:
+            for field in openai_remove_sampling_fields:
                 sanitized.pop(field, None)
-                sanitized["tool_choice"] = TOOL_CHOICE_FORCE
+                sanitized["tool_choice"] = tool_choice_force
                 sanitized["parallel_tool_calls"] = False
             return sanitized
 
@@ -470,8 +468,8 @@ def fastapi_app():
     # Minimal math rollout endpoint: alternates agent/env; calls inference_url chat/completions
     @api.post("/rollout")
     def rollout(request: dict[str, object] = Body(...)):
-        from typing import Any
         import json as _json
+        from typing import Any
 
         run_id = str(request.get("run_id"))
         data = request if isinstance(request, dict) else {}
@@ -563,7 +561,7 @@ def fastapi_app():
 
         user_prompt = (
             str(question)
-            if isinstance(question, (str, int, float)) and str(question).strip()
+            if isinstance(question, str | int | float) and str(question).strip()
             else "Solve the problem. Provide answer steps succinctly."
         )
         payload = {
@@ -597,7 +595,7 @@ def fastapi_app():
                     name = fn.get("name")
                     if isinstance(name, str):
                         tool_names.append(name)
-            print(f"[math] system: <none>", flush=True)
+            print("[math] system: <none>", flush=True)
             print(f"[math] user: {user_prompt}", flush=True)
             print(f"[math] tools: {tool_names}", flush=True)
         except Exception:

synth_ai/demos/demo_task_apps/math/task_app_entry.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from synth_ai.task.apps import ModalDeploymentConfig, TaskAppEntry, register_task_app
 from synth_ai.task.apps.math_single_step import build_config as base_build_config
 
-
 DEMO_MODAL_CONFIG = ModalDeploymentConfig(
     app_name="hendrycks-math-task-app",
     pip_packages=(

synth_ai/environments/examples/crafter_classic/environment.py

@@ -2,11 +2,16 @@
 
 from __future__ import annotations
 
+import base64
 import dataclasses
 import logging
 import time
+from io import BytesIO
 from typing import Any, Dict, List, Optional, Union
 
+import numpy as np
+from PIL import Image
+
 # Import tracing abstractions
 from synth_ai.tracing_v3.abstractions import (
     RuntimeEvent,
@@ -43,6 +48,51 @@ from synth_ai.environments.reproducibility.core import ReproducibleEnvironment
 from synth_ai.environments.stateful.core import StatefulEnvironment
 
 
+def _convert_numpy_to_python(obj: Any) -> Any:
+    if isinstance(obj, np.integer):
+        return int(obj)
+    if isinstance(obj, np.floating):
+        return float(obj)
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    if isinstance(obj, dict):
+        return {k: _convert_numpy_to_python(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_convert_numpy_to_python(item) for item in obj]
+    return obj
+
+
+def _encode_image_to_base64(image_array: Any) -> dict[str, Any] | None:
+    if not isinstance(image_array, np.ndarray):
+        return None
+    if image_array.ndim != 3 or image_array.shape[-1] not in (1, 3, 4):
+        return None
+    try:
+        array_uint8 = (
+            image_array.astype("uint8")
+            if image_array.dtype != np.uint8
+            else image_array  # pragma: no cover - fast path
+        )
+        mode = "L" if array_uint8.shape[-1] == 1 else "RGB"
+        if array_uint8.shape[-1] == 4:
+            mode = "RGBA"
+        img = Image.fromarray(array_uint8, mode=mode)
+        buffer = BytesIO()
+        img.save(buffer, format="PNG")
+        encoded = base64.b64encode(buffer.getvalue()).decode("ascii")
+        width = int(array_uint8.shape[1])
+        height = int(array_uint8.shape[0])
+        return {
+            "format": "png",
+            "width": width,
+            "height": height,
+            "data": encoded,
+            "data_url": f"data:image/png;base64,{encoded}",
+        }
+    except Exception:
+        return None
+
+
 # --- Tool Definition ---
 class CrafterActionInput(BaseModel):
     action: int = Field(..., description="Integer action for the Crafter environment.")
@@ -362,7 +412,8 @@ class CrafterClassicEnvironment(StatefulEnvironment, ReproducibleEnvironment[Cra
         state_before = {"private_state": priv, "public_state": pub}
 
         active_obs_cb = obs_cb or SynthCrafterObservationCallable()
-        observation = await active_obs_cb.get_observation(pub, priv)
+        raw_observation = await active_obs_cb.get_observation(pub, priv)
+        observation = self._prepare_observation(raw_observation)
         if extra_obs and isinstance(observation, dict):
             observation.update(extra_obs)
 
@@ -385,6 +436,30 @@ class CrafterClassicEnvironment(StatefulEnvironment, ReproducibleEnvironment[Cra
 
         return observation
 
+    def _prepare_observation(self, observation: Any) -> dict[str, Any]:
+        obs_dict: dict[str, Any]
+        image_payload: dict[str, Any] | None = None
+
+        if isinstance(observation, dict):
+            image_payload = _encode_image_to_base64(observation.get("observation_image"))
+            sanitized = dict(observation)
+            sanitized.pop("observation_image", None)
+            obs_dict = _convert_numpy_to_python(sanitized) or {}
+        else:
+            obs_dict = _convert_numpy_to_python(observation) or {}
+
+        if not isinstance(obs_dict, dict):
+            obs_dict = {"value": obs_dict}
+
+        if image_payload:
+            obs_dict["observation_image_base64"] = image_payload["data"]
+            obs_dict["observation_image_format"] = image_payload["format"]
+            obs_dict["observation_image_width"] = image_payload["width"]
+            obs_dict["observation_image_height"] = image_payload["height"]
+            obs_dict["observation_image_data_url"] = image_payload["data_url"]
+
+        return obs_dict
+
     # ────────────────────────────────────────────────────────────────────
     # ReproducibleEnvironment plumbing
     # ────────────────────────────────────────────────────────────────────

synth_ai/environments/reproducibility/tree.py

@@ -14,8 +14,10 @@ big “backend.production” code-base.
 from __future__ import annotations
 
 import gzip
+import hashlib
 import json
 import logging
+import os
 import pickle
 import sqlite3
 from collections.abc import Iterable
@@ -32,11 +34,6 @@ log = logging.getLogger(__name__)
 # --------------------------------------------------------------------------- #
 # lightweight metadata record                                                 #
 # --------------------------------------------------------------------------- #
-import hashlib
-import logging
-import os
-
-log = logging.getLogger(__name__)
 
 # Default directory for storing snapshots relative to some base path
 # This could be configured via environment variables or settings later.

synth_ai/environments/service/app.py

@@ -1,6 +1,17 @@
+import logging
 import os  # Added to ensure os is available before use
 import sys
 
+import synth_ai.environments.examples.crafter_classic.environment as cc
+import synth_ai.environments.examples.crafter_custom.environment as ccustom
+from fastapi import FastAPI
+from synth_ai.environments.service.core_routes import api_router
+from synth_ai.environments.service.external_registry import (
+    ExternalRegistryConfig,
+    load_external_environments,
+)
+from synth_ai.environments.service.registry import list_supported_env_types, register_environment
+
 # Ensure repository root is on PYTHONPATH for dev installs
 # Current file path: <repo>/synth_ai/environments/service/app.py
 # We want sys.path to include <repo>, NOT <repo>/synth_ai to avoid shadowing stdlib 'http'
@@ -16,15 +27,6 @@ if _repo_root not in sys.path:
     sys.path.insert(0, _repo_root)
 
 print(f"SYS.PATH IN APP.PY: {sys.path}")
-import logging
-
-from fastapi import FastAPI
-from synth_ai.environments.service.core_routes import api_router
-from synth_ai.environments.service.external_registry import (
-    ExternalRegistryConfig,
-    load_external_environments,
-)
-from synth_ai.environments.service.registry import list_supported_env_types, register_environment
 
 # Configure logging with more detail
 logging.basicConfig(
@@ -38,11 +40,8 @@ logger = logging.getLogger(__name__)
 logging.getLogger("uvicorn.access").setLevel(logging.INFO)
 
 # Register built-in environments at import time
-import synth_ai.environments.examples.crafter_classic.environment as cc
 
 register_environment("CrafterClassic", cc.CrafterClassicEnvironment)
-import synth_ai.environments.examples.crafter_custom.environment as ccustom
-
 register_environment("CrafterCustom", ccustom.CrafterCustomEnvironment)
 
 # Register Wordle example environment

synth_ai/environments/service/core_routes.py

@@ -97,15 +97,12 @@ def create_task_instance_for_environment(
             task.initial_engine_snapshot["seed"] = config["seed"]
 
         # For CrafterClassic, also handle difficulty
-        if env_name == "CrafterClassic" and config:
-            if "difficulty" in config:
-                task.initial_engine_snapshot["difficulty"] = config["difficulty"]
+        if env_name == "CrafterClassic" and config and "difficulty" in config:
+            task.initial_engine_snapshot["difficulty"] = config["difficulty"]
 
         # For MiniGrid, handle environment selection
-        if env_name == "MiniGrid" and config:
-            # Check if a specific environment is requested
-            if "env_name" in config:
-                task.initial_engine_snapshot["env_name"] = config["env_name"]
+        if env_name == "MiniGrid" and config and "env_name" in config:
+            task.initial_engine_snapshot["env_name"] = config["env_name"]
 
         return task
 

synth_ai/environments/stateful/engine.py

@@ -14,7 +14,7 @@ class StatefulEngine(Engine):
         pass
 
     @classmethod
-    async def deserialize(self, engine_snapshot: StatefulEngineSnapshot):
+    async def deserialize(cls, engine_snapshot: StatefulEngineSnapshot):
         pass
 
     async def _step_engine(self):

synth_ai/environments/tasks/core.py

@@ -4,6 +4,7 @@ from dataclasses import dataclass, field
 from typing import Any, Optional
 from uuid import UUID
 
+from synth_ai.environments.stateful.engine import StatefulEngineSnapshot
 from synth_ai.environments.v0_observability.history import SynthGlobalTrajectory
 
 

synth_ai/environments/tasks/filters.py

@@ -29,13 +29,12 @@ class RangeFilter(TaskInstanceMetadataFilter):
             # If the attribute doesn't exist on the metadata, it can't be in range.
             return False
 
-        if not isinstance(instance_value, (int, float)):
+        if not isinstance(instance_value, int | float):
             # If the attribute is not a number, it can't be in a numerical range.
             # Or, we could raise an error, depending on desired strictness.
             return False
 
-        if self.min_val is not None and instance_value < self.min_val:
-            return False
-        if self.max_val is not None and instance_value > self.max_val:
-            return False
-        return True
+        return not (
+            (self.min_val is not None and instance_value < self.min_val)
+            or (self.max_val is not None and instance_value > self.max_val)
+        )

synth_ai/environments/tasks/utils.py

@@ -54,11 +54,10 @@ class RangeFilter(TaskInstanceMetadataFilter):
 
     def __call__(self, instance: TaskInstance) -> bool:
         value = getattr(instance.metadata, self.key, None)
-        if self.min_value is not None and (value is None or value < self.min_value):
-            return False
-        if self.max_value is not None and (value is None or value > self.max_value):
-            return False
-        return True
+        return not (
+            (self.min_value is not None and (value is None or value < self.min_value))
+            or (self.max_value is not None and (value is None or value > self.max_value))
+        )
 
 
 def make_taskset(

synth_ai/handshake.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
+import contextlib
 import os
 import time
 import webbrowser
-from typing import Any, Dict, Tuple
+from typing import Any
 from urllib.parse import urljoin, urlsplit, urlunsplit
 
 import requests
@@ -43,7 +45,7 @@ def _split_origin(origin: str) -> tuple[str, str]:
     return bare, path
 
 
-def _ensure_verification_uri(data: Dict[str, Any], base_with_path: str) -> None:
+def _ensure_verification_uri(data: dict[str, Any], base_with_path: str) -> None:
     uri = data.get("verification_uri")
     if not isinstance(uri, str) or not uri:
         return
@@ -52,7 +54,7 @@ def _ensure_verification_uri(data: Dict[str, Any], base_with_path: str) -> None:
     data["verification_uri"] = urljoin(base_with_path.rstrip("/") + "/", uri.lstrip("/"))
 
 
-def start_handshake_session(origin: str | None = None) -> Tuple[str, str, int, int]:
+def start_handshake_session(origin: str | None = None) -> tuple[str, str, int, int]:
     base = (origin or _origin()).rstrip("/")
     api_origin, _ = _split_origin(base)
     url = urljoin(api_origin.rstrip("/") + "/", "api/sdk/handshake/init")
@@ -74,7 +76,7 @@ def start_handshake_session(origin: str | None = None) -> Tuple[str, str, int, i
 
 def poll_handshake_token(
     device_code: str, origin: str | None = None, *, timeout_s: int | None = None
-) -> Dict[str, Any]:
+) -> dict[str, Any]:
     base = (origin or _origin()).rstrip("/")
     api_origin, _ = _split_origin(base)
     url = urljoin(api_origin.rstrip("/") + "/", "api/sdk/handshake/token")
@@ -84,7 +86,7 @@ def poll_handshake_token(
             raise HandshakeError("handshake timed out")
         try:
             r = requests.post(url, json={"device_code": device_code}, timeout=10)
-        except Exception as e:
+        except Exception:
             time.sleep(2)
             continue
         if r.status_code == 200:
@@ -100,10 +102,8 @@ def poll_handshake_token(
         time.sleep(2)
 
 
-def run_handshake(origin: str | None = None) -> Dict[str, Any]:
+def run_handshake(origin: str | None = None) -> dict[str, Any]:
     device_code, verification_uri, expires_in, interval = start_handshake_session(origin)
-    try:
+    with contextlib.suppress(Exception):
         webbrowser.open(verification_uri)
-    except Exception:
-        pass
     return poll_handshake_token(device_code, origin, timeout_s=expires_in)

synth_ai/http.py

@@ -18,7 +18,7 @@ except Exception:
         _client_path = _here.parent / "http_client.py"
         _spec = _ilu.spec_from_file_location("http_client", str(_client_path))
         if not _spec or not _spec.loader:
-            raise ImportError("Could not load http_client module")
+            raise ImportError("Could not load http_client module") from None
         _mod = _ilu.module_from_spec(_spec)
         _spec.loader.exec_module(_mod)
         _sys.modules["synth_ai.http_client"] = _mod

synth_ai/http_client.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
 import asyncio
+import os
 from dataclasses import dataclass
-from typing import Any, Dict, Optional
+from typing import Any
 
 import aiohttp
 
@@ -27,11 +28,18 @@ class AsyncHttpClient:
         self._base_url = base_url.rstrip("/")
         self._api_key = api_key
         self._timeout = aiohttp.ClientTimeout(total=timeout)
-        self._session: Optional[aiohttp.ClientSession] = None
+        self._session: aiohttp.ClientSession | None = None
 
-    async def __aenter__(self) -> "AsyncHttpClient":
+    async def __aenter__(self) -> AsyncHttpClient:
         if self._session is None:
             headers = {"authorization": f"Bearer {self._api_key}"}
+            # Optional dev overrides for user/org context
+            user_id = os.getenv("SYNTH_USER_ID") or os.getenv("X_USER_ID") or os.getenv("USER_ID")
+            if user_id:
+                headers["X-User-ID"] = user_id
+            org_id = os.getenv("SYNTH_ORG_ID") or os.getenv("X_ORG_ID") or os.getenv("ORG_ID")
+            if org_id:
+                headers["X-Org-ID"] = org_id
             self._session = aiohttp.ClientSession(headers=headers, timeout=self._timeout)
         return self
 
@@ -52,8 +60,8 @@ class AsyncHttpClient:
         self,
         path: str,
         *,
-        params: Optional[Dict[str, Any]] = None,
-        headers: Optional[Dict[str, str]] = None,
+        params: dict[str, Any] | None = None,
+        headers: dict[str, str] | None = None,
     ) -> Any:
         url = self._abs(path)
         assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
@@ -61,7 +69,7 @@ class AsyncHttpClient:
             return await self._handle_response(resp, url)
 
     async def post_json(
-        self, path: str, *, json: Dict[str, Any], headers: Optional[Dict[str, str]] = None
+        self, path: str, *, json: dict[str, Any], headers: dict[str, str] | None = None
     ) -> Any:
         url = self._abs(path)
         assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
@@ -72,9 +80,9 @@ class AsyncHttpClient:
         self,
         path: str,
         *,
-        data: Dict[str, Any],
-        files: Dict[str, tuple[str, bytes, str | None]],
-        headers: Optional[Dict[str, str]] = None,
+        data: dict[str, Any],
+        files: dict[str, tuple[str, bytes, str | None]],
+        headers: dict[str, str] | None = None,
     ) -> Any:
         url = self._abs(path)
         assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
@@ -91,7 +99,7 @@ class AsyncHttpClient:
         async with self._session.post(url, data=form, headers=headers) as resp:
             return await self._handle_response(resp, url)
 
-    async def delete(self, path: str, *, headers: Optional[Dict[str, str]] = None) -> Any:
+    async def delete(self, path: str, *, headers: dict[str, str] | None = None) -> Any:
         url = self._abs(path)
         assert self._session is not None, "AsyncHttpClient must be used as an async context manager"
         async with self._session.delete(url, headers=headers) as resp:

synth_ai/inference/client.py

@@ -1,6 +1,11 @@
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
+
+from synth_ai.api.models.supported import (
+    UnsupportedModelError,
+    normalize_model_identifier,
+)
 
 from ..http import AsyncHttpClient
 
@@ -13,12 +18,17 @@ class InferenceClient:
 
     async def create_chat_completion(
         self, *, model: str, messages: list[dict], **kwargs: Any
-    ) -> Dict[str, Any]:
-        body: Dict[str, Any] = {"model": model, "messages": messages}
+    ) -> dict[str, Any]:
+        try:
+            normalized_model = normalize_model_identifier(model)
+        except UnsupportedModelError as exc:
+            raise ValueError(str(exc)) from exc
+
+        body: dict[str, Any] = {"model": normalized_model, "messages": messages}
         body.update(kwargs)
         # Backend now expects an explicit thinking_budget; provide a sensible default if omitted
         if "thinking_budget" not in body:
             body["thinking_budget"] = 256
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=self._timeout) as http:
-            # Public learning-v2 inference path mounted under /api/v1
-            return await http.post_json("/api/v1/chat/completions", json=body)
+            # Route through backend inference proxy to Modal
+            return await http.post_json("/api/inference/v1/chat/completions", json=body)