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

synth_ai/learning/validators.py

@@ -1,40 +1,37 @@
 from __future__ import annotations
 
-from pathlib import Path
 import json
-from typing import Any, Dict
-from urllib.parse import urlparse
+from pathlib import Path
+from typing import Any
+
+from synth_ai.learning.sft import SFTDataError, parse_jsonl_line
 
 
 def validate_training_jsonl(path: str | Path, *, sample_lines: int = 50) -> None:
     p = Path(path)
     if not p.exists():
         raise FileNotFoundError(str(p))
-    lines = p.read_text().splitlines()
-    if not lines:
+
+    max_samples = max(1, sample_lines)
+    non_empty_lines = 0
+
+    with p.open("r", encoding="utf-8") as fh:
+        for lineno, raw_line in enumerate(fh, start=1):
+            stripped = raw_line.strip()
+            if not stripped:
+                continue
+            non_empty_lines += 1
+            if non_empty_lines > max_samples:
+                break
+            try:
+                parse_jsonl_line(stripped, min_messages=2)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"invalid json on line {lineno}: {exc}") from exc
+            except SFTDataError as exc:
+                raise ValueError(f"line {lineno}: {exc}") from exc
+
+    if non_empty_lines == 0:
         raise ValueError("empty JSONL")
-    for i, line in enumerate(lines[: max(1, sample_lines)], start=1):
-        if not line.strip():
-            continue
-        try:
-            obj = json.loads(line)
-        except Exception as e:
-            raise ValueError(f"invalid json on line {i}: {e}") from e
-        msgs = obj.get("messages")
-        if not isinstance(msgs, list) or len(msgs) < 2:
-            raise ValueError(f"line {i}: missing messages[] with at least 2 turns")
-        roles = [m.get("role") for m in msgs if isinstance(m, dict)]
-        if not roles or not isinstance(roles[0], str):
-            raise ValueError(f"line {i}: missing first role")
-        for m in msgs:
-            if not isinstance(m, dict):
-                raise ValueError(f"line {i}: non-dict message")
-            if (
-                not isinstance(m.get("role"), str)
-                or not isinstance(m.get("content"), str)
-                or not m["content"].strip()
-            ):
-                raise ValueError(f"line {i}: invalid role/content")
 
 
 def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
@@ -43,7 +40,7 @@ def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
     _vt(url, name=name)
 
 
-def validate_trainer_cfg_rl(trainer: Dict[str, Any]) -> None:
+def validate_trainer_cfg_rl(trainer: dict[str, Any]) -> None:
     bs = int(trainer.get("batch_size", 1))
     gs = int(trainer.get("group_size", 2))
     if bs < 1:

synth_ai/lm/__init__.py

@@ -1,51 +1,25 @@
-"""
-Synth AI Language Model Interface.
+"""Deprecated shim forwarding to synth_ai.v0.lm."""
 
-Provides a unified interface for multiple LLM providers including OpenAI and Synth.
-"""
+import importlib as _importlib
+import pkgutil as _pkgutil
+import sys as _sys
+from pathlib import Path as _Path
 
-from .config import OpenAIConfig, SynthConfig
-from .core.main_v3 import LM
-from .unified_interface import (
-    OpenAIProvider,
-    SynthProvider,
-    UnifiedLMClient,
-    UnifiedLMProvider,
-    create_provider,
-)
-from .vendors.synth_client import (
-    AsyncSynthClient,
-    SyncSynthClient,
-    create_async_client,
-    create_chat_completion_async,
-    create_chat_completion_sync,
-    create_sync_client,
-)
-from .warmup import get_warmup_status, warmup_synth_model
+_TARGET_PREFIX = "synth_ai.v0.lm"
+_ALIAS_PREFIX = __name__
 
-__all__ = [
-    # Configuration
-    "SynthConfig",
-    "OpenAIConfig",
-    # Warmup utilities
-    "warmup_synth_model",
-    "get_warmup_status",
-    # Unified interface
-    "UnifiedLMProvider",
-    "OpenAIProvider",
-    "SynthProvider",
-    "UnifiedLMClient",
-    "create_provider",
-    # Synth client
-    "AsyncSynthClient",
-    "SyncSynthClient",
-    "create_async_client",
-    "create_sync_client",
-    "create_chat_completion_async",
-    "create_chat_completion_sync",
-    # Core LM class
-    "LM",
-]
+_alias_path = _Path(__file__).resolve().parents[1] / "v0" / "lm"
+__path__ = [str(_alias_path)]  # type: ignore[assignment]
 
-# Version info
-__version__ = "0.1.0"
+_pkg = _importlib.import_module(_TARGET_PREFIX)
+_sys.modules[_ALIAS_PREFIX] = _pkg
+
+for _finder, _name, _ispkg in _pkgutil.walk_packages(_pkg.__path__, prefix=_TARGET_PREFIX + "."):  # type: ignore[attr-defined]
+    try:
+        _module = _importlib.import_module(_name)
+    except Exception:  # pragma: no cover - best effort
+        continue
+    _alias = _ALIAS_PREFIX + _name[len(_TARGET_PREFIX) :]
+    _sys.modules[_alias] = _module
+
+del _finder, _name, _ispkg, _module, _alias, _TARGET_PREFIX, _ALIAS_PREFIX, _alias_path

synth_ai/task/__init__.py

@@ -1,59 +1,57 @@
-from .validators import validate_task_app_url
-from .health import task_app_health
+from .auth import (
+    is_api_key_header_authorized,
+    normalize_environment_api_key,
+    require_api_key_dependency,
+)
+from .client import TaskAppClient
 from .contracts import (
-    TaskAppContract,
-    TaskAppEndpoints,
     RolloutEnvSpec,
+    RolloutMetrics,
     RolloutPolicySpec,
     RolloutRecordConfig,
-    RolloutSafetyConfig,
     RolloutRequest,
     RolloutResponse,
-    RolloutTrajectory,
+    RolloutSafetyConfig,
     RolloutStep,
-    RolloutMetrics,
+    RolloutTrajectory,
+    TaskAppContract,
+    TaskAppEndpoints,
     TaskInfo,
 )
+from .datasets import TaskDatasetRegistry, TaskDatasetSpec
+from .errors import error_payload, http_exception, json_error_response
+from .health import task_app_health
 from .json import to_jsonable
-from .auth import (
-    normalize_environment_api_key,
-    is_api_key_header_authorized,
-    require_api_key_dependency,
-)
-from .vendors import (
-    normalize_vendor_keys,
-    get_openai_key_or_503,
-    get_groq_key_or_503,
-)
 from .proxy import (
     INTERACT_TOOL_SCHEMA,
-    prepare_for_openai,
-    prepare_for_groq,
-    inject_system_hint,
     extract_message_text,
+    inject_system_hint,
     parse_tool_call_from_text,
+    prepare_for_groq,
+    prepare_for_openai,
     synthesize_tool_call_if_missing,
 )
-from .datasets import TaskDatasetSpec, TaskDatasetRegistry
 from .rubrics import (
     Criterion,
     Rubric,
-    load_rubric,
     blend_rubrics,
+    load_rubric,
     score_events_against_rubric,
     score_outcome_against_rubric,
 )
-from .client import TaskAppClient
-from .errors import error_payload, http_exception, json_error_response
-
-
 from .server import (
-    TaskAppConfig,
     ProxyConfig,
     RubricBundle,
+    TaskAppConfig,
     create_task_app,
     run_task_app,
 )
+from .validators import validate_task_app_url
+from .vendors import (
+    get_groq_key_or_503,
+    get_openai_key_or_503,
+    normalize_vendor_keys,
+)
 
 __all__ = [
     "validate_task_app_url",

synth_ai/task/apps/__init__.py

@@ -1,13 +1,12 @@
-from __future__ import annotations
-
 """Registry for Task Apps exposed via the shared FastAPI harness."""
 
+from __future__ import annotations
+
 import importlib
-import os
 import sys
+from collections.abc import Callable, Iterable, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Callable, Dict, Iterable, List, Sequence
 
 from ..server import TaskAppConfig
 
@@ -45,8 +44,8 @@ class TaskAppRegistry:
     """In-memory registry of known task apps."""
 
     def __init__(self) -> None:
-        self._entries: Dict[str, TaskAppEntry] = {}
-        self._alias_to_id: Dict[str, str] = {}
+        self._entries: dict[str, TaskAppEntry] = {}
+        self._alias_to_id: dict[str, str] = {}
 
     def register(self, entry: TaskAppEntry) -> None:
         if entry.app_id in self._entries:
@@ -63,7 +62,7 @@ class TaskAppRegistry:
             raise KeyError(f"Unknown task app id: {app_id}")
         return self._entries[resolved]
 
-    def list(self) -> List[TaskAppEntry]:
+    def list(self) -> list[TaskAppEntry]:
         return sorted(self._entries.values(), key=lambda entry: entry.app_id)
 
     def __iter__(self) -> Iterable[TaskAppEntry]:
@@ -116,7 +115,7 @@ def discover_task_apps_from_cwd() -> None:
             try:
                 # Import the module to trigger registration
                 importlib.import_module(module_name)
-            except Exception as exc:
+            except Exception:
                 # Silently skip modules that can't be imported
                 # This allows for graceful handling of missing dependencies
                 continue

synth_ai/task/auth.py

@@ -1,9 +1,11 @@
-from __future__ import annotations
-
 """Authentication helpers shared by Task Apps."""
 
+from __future__ import annotations
+
 import os
-from typing import Iterable, Optional, Any, Set
+from collections.abc import Iterable
+from contextlib import suppress
+from typing import Any
 
 from .errors import http_exception
 
@@ -24,7 +26,7 @@ def _mask(value: str, *, prefix: int = 4) -> str:
     return f"{visible}{'…' if len(value) > prefix else ''}"
 
 
-def normalize_environment_api_key() -> Optional[str]:
+def normalize_environment_api_key() -> str | None:
     """Ensure `ENVIRONMENT_API_KEY` is populated from dev fallbacks.
 
     Returns the resolved key (if any) so callers can branch on configuration.
@@ -45,7 +47,7 @@ def normalize_environment_api_key() -> Optional[str]:
     return None
 
 
-def allowed_environment_api_keys() -> Set[str]:
+def allowed_environment_api_keys() -> set[str]:
     """Return the set of valid environment API keys for this Task App.
 
     Includes:
@@ -135,7 +137,7 @@ def require_api_key_dependency(request: Any) -> None:
             bearer.append(a.split(" ", 1)[1].strip())
     candidates = _split_csv(single + multi + bearer)
     if not any(candidate in allowed for candidate in candidates):
-        try:
+        with suppress(Exception):
             print(
                 {
                     "task_auth_failed": True,
@@ -149,8 +151,6 @@ def require_api_key_dependency(request: Any) -> None:
                 },
                 flush=True,
             )
-        except Exception:
-            pass
         # Use 400 to make failures unmistakable during preflight
         raise http_exception(
             400,

synth_ai/task/client.py

@@ -1,10 +1,10 @@
-from __future__ import annotations
-
 """Async HTTP client for interacting with Task Apps."""
 
+from __future__ import annotations
+
 import asyncio
-from typing import Any, Dict, Iterable, List, Optional
 import os
+from typing import Any
 
 import httpx
 from pydantic import BaseModel
@@ -37,7 +37,7 @@ class TaskAppClient:
         self._client: httpx.AsyncClient | None = None
         self.env = _TaskAppEnvironmentClient(self)
 
-    async def __aenter__(self) -> "TaskAppClient":
+    async def __aenter__(self) -> TaskAppClient:
         await self._ensure_client()
         return self
 
@@ -53,8 +53,8 @@ class TaskAppClient:
             )
         return self._client
 
-    def _headers(self) -> Dict[str, str]:
-        headers: Dict[str, str] = {}
+    def _headers(self) -> dict[str, str]:
+        headers: dict[str, str] = {}
         # Primary key
         primary = (self.api_key or "").strip()
         if primary:
@@ -85,7 +85,7 @@ class TaskAppClient:
         method: str,
         path: str,
         *,
-        params: Optional[Dict[str, Any] | List[tuple[str, Any]]] = None,
+        params: dict[str, Any] | list[tuple[str, Any]] | None = None,
         json_payload: Any = None,
     ) -> httpx.Response:
         client = await self._ensure_client()
@@ -118,16 +118,16 @@ class TaskAppClient:
             raise last_exc
         raise RuntimeError("Unreachable code in TaskAppClient._request")
 
-    async def health(self) -> Dict[str, Any]:
+    async def health(self) -> dict[str, Any]:
         response = await self._request("GET", "/health")
         return response.json()
 
-    async def info(self) -> Dict[str, Any]:
+    async def info(self) -> dict[str, Any]:
         response = await self._request("GET", "/info")
         return response.json()
 
     async def task_info(self, seeds: list[int] | None = None) -> TaskInfo | list[TaskInfo]:
-        params: Optional[List[tuple[str, Any]]] = None
+        params: list[tuple[str, Any]] | None = None
         if seeds:
             params = [("seed", seed) for seed in seeds]
         response = await self._request("GET", "/task_info", params=params)
@@ -146,21 +146,21 @@ class _TaskAppEnvironmentClient:
     def __init__(self, client: TaskAppClient) -> None:
         self._client = client
 
-    async def initialize(self, env_name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def initialize(self, env_name: str, payload: dict[str, Any]) -> dict[str, Any]:
         response = await self._client._request(
             "POST", f"/env/{env_name}/initialize", json_payload=payload
         )
         return response.json()
 
-    async def step(self, env_name: str, payload: Dict[str, Any]) -> Dict[str, Any]:
+    async def step(self, env_name: str, payload: dict[str, Any]) -> dict[str, Any]:
         response = await self._client._request(
             "POST", f"/env/{env_name}/step", json_payload=payload
         )
         return response.json()
 
     async def terminate(
-        self, env_name: str, payload: Dict[str, Any] | None = None
-    ) -> Dict[str, Any]:
+        self, env_name: str, payload: dict[str, Any] | None = None
+    ) -> dict[str, Any]:
         response = await self._client._request(
             "POST", f"/env/{env_name}/terminate", json_payload=payload or {}
         )

synth_ai/task/contracts.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Optional, Any, Dict, List, Literal
+from typing import Any, Literal
+
 from pydantic import BaseModel, Field
 
 
@@ -40,7 +41,7 @@ class TaskAppContract:
     """
 
     base_url: str
-    env_name: Optional[str] = None
+    env_name: str | None = None
     requires_api_key_header: bool = True
 
 
@@ -48,16 +49,16 @@ class TaskAppContract:
 
 
 class RolloutEnvSpec(BaseModel):
-    env_id: Optional[str] = None
-    env_name: Optional[str] = None
-    config: Dict[str, Any] = {}
-    seed: Optional[int] = None
+    env_id: str | None = None
+    env_name: str | None = None
+    config: dict[str, Any] = Field(default_factory=dict)
+    seed: int | None = None
 
 
 class RolloutPolicySpec(BaseModel):
-    policy_id: Optional[str] = None
-    policy_name: Optional[str] = None
-    config: Dict[str, Any] = {}
+    policy_id: str | None = None
+    policy_name: str | None = None
+    config: dict[str, Any] = Field(default_factory=dict)
 
 
 class RolloutRecordConfig(BaseModel):
@@ -77,60 +78,60 @@ class RolloutRequest(BaseModel):
     run_id: str
     env: RolloutEnvSpec
     policy: RolloutPolicySpec
-    ops: List[Dict[str, Any]] | List[str]
+    ops: list[dict[str, Any]] | list[str]
     record: RolloutRecordConfig = RolloutRecordConfig()
     on_done: str = "reset"
     safety: RolloutSafetyConfig = RolloutSafetyConfig()
-    training_session_id: Optional[str] = None
-    synth_base_url: Optional[str] = None
+    training_session_id: str | None = None
+    synth_base_url: str | None = None
 
 
 class RolloutStep(BaseModel):
-    obs: Dict[str, Any]
-    tool_calls: List[Dict[str, Any]]
-    reward: Optional[float] = None
+    obs: dict[str, Any]
+    tool_calls: list[dict[str, Any]]
+    reward: float | None = None
     done: bool = False
-    truncated: Optional[bool] = None
-    info: Optional[Dict[str, Any]] = None
+    truncated: bool | None = None
+    info: dict[str, Any] | None = None
 
 
 class RolloutTrajectory(BaseModel):
     env_id: str
     policy_id: str
-    steps: List[RolloutStep]
-    final: Optional[Dict[str, Any]] = None
+    steps: list[RolloutStep]
+    final: dict[str, Any] | None = None
     length: int
 
 
 class RolloutMetrics(BaseModel):
-    episode_returns: List[float]
+    episode_returns: list[float]
     mean_return: float
     num_steps: int
     num_episodes: int = 0
-    outcome_score: Optional[float] = None
-    events_score: Optional[float] = None
-    details: Dict[str, Any] = Field(default_factory=dict)
+    outcome_score: float | None = None
+    events_score: float | None = None
+    details: dict[str, Any] = Field(default_factory=dict)
 
 
 class RolloutResponse(BaseModel):
     run_id: str
-    trajectories: List[RolloutTrajectory]
-    branches: Dict[str, List[str]] = {}
+    trajectories: list[RolloutTrajectory]
+    branches: dict[str, list[str]] = Field(default_factory=dict)
     metrics: RolloutMetrics
     aborted: bool = False
     ops_executed: int = 0
-    trace: Dict[str, Any] | None = None
+    trace: dict[str, Any] | None = None
 
 
 class TaskInfo(BaseModel):
     """Static metadata describing the capabilities of a Task App task."""
 
-    task: Dict[str, Any]
-    environments: List[str]
-    action_space: Dict[str, Any]
-    observation: Dict[str, Any]
-    dataset: Dict[str, Any]
-    rubric: Dict[str, Any]
-    inference: Dict[str, Any]
-    capabilities: Dict[str, Any]
-    limits: Dict[str, Any]
+    task: dict[str, Any]
+    environments: list[str]
+    action_space: dict[str, Any]
+    observation: dict[str, Any]
+    dataset: dict[str, Any]
+    rubric: dict[str, Any]
+    inference: dict[str, Any]
+    capabilities: dict[str, Any]
+    limits: dict[str, Any]

synth_ai/task/datasets.py

@@ -1,8 +1,9 @@
-from __future__ import annotations
-
 """Dataset registry and helpers shared by Task Apps."""
 
-from typing import Any, Callable, Dict, Hashable, Tuple
+from __future__ import annotations
+
+from collections.abc import Callable, Hashable
+from typing import Any
 
 from pydantic import BaseModel, Field, field_validator
 
@@ -34,8 +35,8 @@ class TaskDatasetRegistry:
     """Lightweight registry mapping dataset specs to loader callables."""
 
     def __init__(self) -> None:
-        self._entries: Dict[str, Tuple[TaskDatasetSpec, RegistryLoader, bool]] = {}
-        self._cache: Dict[Hashable, Any] = {}
+        self._entries: dict[str, tuple[TaskDatasetSpec, RegistryLoader, bool]] = {}
+        self._cache: dict[Hashable, Any] = {}
 
     def register(
         self, spec: TaskDatasetSpec, loader: RegistryLoader, *, cache: bool = True

synth_ai/task/errors.py

@@ -1,16 +1,16 @@
-from __future__ import annotations
-
 """Error helpers used across Task App implementations."""
 
-from typing import Any, Dict, Optional
+from __future__ import annotations
+
+from typing import Any
 
 from .json import to_jsonable
 
 
 def error_payload(
-    code: str, message: str, *, extra: Optional[Dict[str, Any]] = None
-) -> Dict[str, Any]:
-    payload: Dict[str, Any] = {"error": {"code": code, "message": message}}
+    code: str, message: str, *, extra: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    payload: dict[str, Any] = {"error": {"code": code, "message": message}}
     if extra:
         payload["error"].update(extra)
     return payload
@@ -21,8 +21,8 @@ def http_exception(
     code: str,
     message: str,
     *,
-    extra: Optional[Dict[str, Any]] = None,
-    headers: Optional[Dict[str, str]] = None,
+    extra: dict[str, Any] | None = None,
+    headers: dict[str, str] | None = None,
 ):
     try:
         from fastapi import HTTPException  # type: ignore
@@ -38,8 +38,8 @@ def json_error_response(
     code: str,
     message: str,
     *,
-    extra: Optional[Dict[str, Any]] = None,
-    headers: Optional[Dict[str, str]] = None,
+    extra: dict[str, Any] | None = None,
+    headers: dict[str, str] | None = None,
 ):
     try:
         from fastapi.responses import JSONResponse  # type: ignore

synth_ai/task/health.py

@@ -1,10 +1,13 @@
+"""Helpers for probing Task App health endpoints."""
+
 from __future__ import annotations
 
-from typing import Any, Dict
+from typing import Any
+
 import aiohttp
 
 
-async def task_app_health(task_app_url: str) -> Dict[str, Any]:
+async def task_app_health(task_app_url: str) -> dict[str, Any]:
     """Probe a Task App base URL for basic reachability.
 
     Behavior:
@@ -12,15 +15,20 @@ async def task_app_health(task_app_url: str) -> Dict[str, Any]:
     - Fallback to GET if HEAD is unsupported
     - Returns {ok: bool, status?: int, error?: str}
     """
+
+    async def _try_request(session: aiohttp.ClientSession, method: str) -> dict[str, Any] | None:
+        request = getattr(session, method)
+        async with request(task_app_url, allow_redirects=True) as response:
+            if 200 <= response.status < 400:
+                return {"ok": True, "status": response.status}
+        return None
+
     try:
         async with aiohttp.ClientSession() as session:
-            async with session.head(task_app_url, allow_redirects=True) as r:
-                if 200 <= r.status < 400:
-                    return {"ok": True, "status": r.status}
-        async with aiohttp.ClientSession() as session:
-            async with session.get(task_app_url, allow_redirects=True) as r2:
-                if 200 <= r2.status < 400:
-                    return {"ok": True, "status": r2.status}
+            for method in ("head", "get"):
+                result = await _try_request(session, method)
+                if result is not None:
+                    return result
         return {"ok": False, "status": None}
     except Exception as e:
         return {"ok": False, "error": f"{type(e).__name__}: {e}"}