synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.10__py3-none-any.whl

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.
@@ -256,7 +253,9 @@ class TrajectoryTreeStore:
     def reconstruct_actions(self, snap_id: str) -> tuple[Any, ...]:
         """Return the sequence of *actions* from the root → `snap_id`."""
         actions = []
-        for child, parent in zip(self.path_to_root(snap_id)[:-1], self.path_to_root(snap_id)[1:], strict=False):
+        for child, parent in zip(
+            self.path_to_root(snap_id)[:-1], self.path_to_root(snap_id)[1:], strict=False
+        ):
             actions.append(self.graph.edges[parent, child]["action"])
         return tuple(reversed(actions))
 

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
 
@@ -951,7 +948,9 @@ async def register_environment_api(request: RegisterEnvironmentRequest) -> dict[
         ) from e
     except Exception as e:
         logger.error(f"Failed to register environment {request.name}: {e}")
-        raise HTTPException(status_code=500, detail=f"Failed to register environment: {str(e)}") from e
+        raise HTTPException(
+            status_code=500, detail=f"Failed to register environment: {str(e)}"
+        ) from e
 
 
 @api_router.delete("/registry/environments/{env_name}")
@@ -984,7 +983,9 @@ async def unregister_environment_api(env_name: str) -> dict[str, Any]:
 
     except Exception as e:
         logger.error(f"Failed to unregister environment {env_name}: {e}")
-        raise HTTPException(status_code=500, detail=f"Failed to unregister environment: {str(e)}") from e
+        raise HTTPException(
+            status_code=500, detail=f"Failed to unregister environment: {str(e)}"
+        ) from e
 
 
 @api_router.get("/registry/environments")

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/evals/base.py

@@ -1,5 +1,3 @@
-
-
 class Judgement:
     def __init__(
         self, criteria: str, score: float, reasoning: str = "", evidence: list[str] = None

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")
@@ -72,7 +74,9 @@ 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]:
+def poll_handshake_token(
+    device_code: str, origin: str | None = None, *, timeout_s: int | None = None
+) -> dict[str, Any]:
     base = (origin or _origin()).rstrip("/")
     api_origin, _ = _split_origin(base)
     url = urljoin(api_origin.rstrip("/") + "/", "api/sdk/handshake/token")
@@ -82,7 +86,7 @@ def poll_handshake_token(device_code: str, origin: str | None = None, *, timeout
             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:
@@ -98,10 +102,8 @@ def poll_handshake_token(device_code: str, origin: str | None = None, *, timeout
         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
 
@@ -48,30 +56,50 @@ class AsyncHttpClient:
             path = path[4:]  # Remove leading /api
         return f"{self._base_url}/{path.lstrip('/')}"
 
-    async def get(self, path: str, *, params: Optional[Dict[str, Any]] = None, headers: Optional[Dict[str, str]] = None) -> Any:
+    async def get(
+        self,
+        path: str,
+        *,
+        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"
         async with self._session.get(url, params=params, headers=headers) as resp:
             return await self._handle_response(resp, url)
 
-    async def post_json(self, path: str, *, json: Dict[str, Any], headers: Optional[Dict[str, str]] = None) -> Any:
+    async def post_json(
+        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"
         async with self._session.post(url, json=json, headers=headers) as resp:
             return await self._handle_response(resp, url)
 
-    async def post_multipart(self, path: str, *, data: Dict[str, Any], files: Dict[str, tuple[str, bytes, str | None]], headers: Optional[Dict[str, str]] = None) -> Any:
+    async def post_multipart(
+        self,
+        path: str,
+        *,
+        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"
         form = aiohttp.FormData()
         for k, v in data.items():
             form.add_field(k, str(v))
         for field, (filename, content, content_type) in files.items():
-            form.add_field(field, content, filename=filename, content_type=content_type or "application/octet-stream")
+            form.add_field(
+                field,
+                content,
+                filename=filename,
+                content_type=content_type or "application/octet-stream",
+            )
         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:
@@ -95,10 +123,14 @@ class AsyncHttpClient:
             detail = await resp.json()
         except Exception:
             detail = None
-        raise HTTPError(status=resp.status, url=url, message="request_failed", body_snippet=body_snippet, detail=detail)
+        raise HTTPError(
+            status=resp.status,
+            url=url,
+            message="request_failed",
+            body_snippet=body_snippet,
+            detail=detail,
+        )
 
 
 async def sleep(seconds: float) -> None:
     await asyncio.sleep(seconds)
-
-

synth_ai/inference/__init__.py

@@ -3,5 +3,3 @@ from .client import InferenceClient
 __all__ = [
     "InferenceClient",
 ]
-
-

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
 
@@ -11,10 +16,19 @@ class InferenceClient:
         self._api_key = api_key
         self._timeout = timeout
 
-    async def create_chat_completion(self, *, model: str, messages: list[dict], **kwargs: Any) -> Dict[str, Any]:
-        body: Dict[str, Any] = {"model": model, "messages": messages}
+    async def create_chat_completion(
+        self, *, model: str, messages: list[dict], **kwargs: Any
+    ) -> 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:
-            return await http.post_json("/v1/chat/completions", json=body)
-
-
+            # Route through backend inference proxy to Modal
+            return await http.post_json("/api/inference/v1/chat/completions", json=body)