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

synth_ai/task/proxy.py

@@ -179,7 +179,7 @@ def parse_tool_call_from_text(text: str) -> Tuple[list[str], str]:
     if m:
         items = [part.strip() for part in m.group(1).split(",") if part.strip()]
         if items:
-            reasoning = text[:m.start()].strip()
+            reasoning = text[: m.start()].strip()
             return items, reasoning
 
     # Patterns like "Action 1: move_right"
@@ -242,9 +242,7 @@ def synthesize_tool_call_if_missing(openai_response: dict[str, Any]) -> dict[str
         return openai_response
 
     new_message = copy.deepcopy(message)
-    new_message["tool_calls"] = [
-        _build_tool_call(actions, reasoning)
-    ]
+    new_message["tool_calls"] = [_build_tool_call(actions, reasoning)]
     if "content" not in new_message:
         new_message["content"] = None
 
@@ -255,4 +253,3 @@ def synthesize_tool_call_if_missing(openai_response: dict[str, Any]) -> dict[str
     result = copy.deepcopy(openai_response)
     result["choices"] = new_choices
     return result
-

synth_ai/task/rubrics.py

@@ -155,7 +155,9 @@ def _as_float(value: Any) -> Optional[float]:
         return None
 
 
-def _score(criteria: Iterable[Criterion], values: Dict[str, float], aggregation: str) -> Dict[str, Any]:
+def _score(
+    criteria: Iterable[Criterion], values: Dict[str, float], aggregation: str
+) -> Dict[str, Any]:
     if aggregation == "inherit":
         aggregation = "weighted_sum"
     per_criterion: Dict[str, Dict[str, Any]] = {}
@@ -184,7 +186,9 @@ def _score(criteria: Iterable[Criterion], values: Dict[str, float], aggregation:
     }
 
 
-def score_events_against_rubric(events: list[dict[str, Any]], rubric: Rubric | None) -> Dict[str, Any]:
+def score_events_against_rubric(
+    events: list[dict[str, Any]], rubric: Rubric | None
+) -> Dict[str, Any]:
     if rubric is None:
         return {"aggregation": "none", "score": None, "per_criterion": {}}
     values: Dict[str, float] = {}
@@ -203,7 +207,9 @@ def score_outcome_against_rubric(outcome: dict[str, Any], rubric: Rubric | None)
         return {"aggregation": "none", "score": None, "per_criterion": {}}
     values: Dict[str, float] = {}
     if isinstance(outcome, dict):
-        candidates = outcome.get("criteria") if isinstance(outcome.get("criteria"), dict) else outcome
+        candidates = (
+            outcome.get("criteria") if isinstance(outcome.get("criteria"), dict) else outcome
+        )
         if isinstance(candidates, dict):
             for key, value in candidates.items():
                 score = _as_float(value)

synth_ai/task/server.py

@@ -120,7 +120,9 @@ def _ensure_task_info(obj: Any) -> TaskInfo:
         return obj
     if isinstance(obj, MutableMapping):
         return TaskInfo.model_validate(obj)
-    raise TypeError(f"Task instance provider must yield TaskInfo-compatible objects (got {type(obj)!r})")
+    raise TypeError(
+        f"Task instance provider must yield TaskInfo-compatible objects (got {type(obj)!r})"
+    )
 
 
 def _normalise_seeds(values: Sequence[int]) -> list[int]:
@@ -140,7 +142,9 @@ def _build_proxy_routes(
     if not proxy:
         return
 
-    async def _call_vendor(url: str, payload: dict[str, Any], headers: dict[str, str]) -> dict[str, Any]:
+    async def _call_vendor(
+        url: str, payload: dict[str, Any], headers: dict[str, str]
+    ) -> dict[str, Any]:
         async with httpx.AsyncClient(timeout=httpx.Timeout(600.0), follow_redirects=True) as client:
             response = await client.post(url, json=payload, headers=headers)
         data = (
@@ -168,13 +172,17 @@ def _build_proxy_routes(
             msg_count = len(messages) if isinstance(messages, list) else 0
             tool_count = len(payload.get("tools") or []) if isinstance(payload, dict) else 0
             model = payload.get("model") if isinstance(payload, dict) else None
-            print(f"[task:proxy:{route}] model={model} messages={msg_count} tools={tool_count}", flush=True)
+            print(
+                f"[task:proxy:{route}] model={model} messages={msg_count} tools={tool_count}",
+                flush=True,
+            )
         except Exception:  # pragma: no cover - best effort logging
             pass
 
     system_hint = proxy.system_hint
 
     if proxy.enable_openai:
+
         @app.post("/proxy/v1/chat/completions", dependencies=[Depends(auth_dependency)])
         async def proxy_openai(body: dict[str, Any], request: Request) -> Any:  # type: ignore[no-redef]
             key = get_openai_key_or_503()
@@ -187,6 +195,7 @@ def _build_proxy_routes(
             return to_jsonable(sanitized)
 
     if proxy.enable_groq:
+
         @app.post("/proxy/groq/v1/chat/completions", dependencies=[Depends(auth_dependency)])
         async def proxy_groq(body: dict[str, Any], request: Request) -> Any:  # type: ignore[no-redef]
             key = get_groq_key_or_503()
@@ -194,7 +203,9 @@ def _build_proxy_routes(
             payload = prepare_for_groq(model, body)
             payload = inject_system_hint(payload, system_hint or "")
             _log_proxy("groq", payload)
-            data = await _call_vendor(proxy.groq_url.rstrip("/"), payload, {"Authorization": f"Bearer {key}"})
+            data = await _call_vendor(
+                proxy.groq_url.rstrip("/"), payload, {"Authorization": f"Bearer {key}"}
+            )
             sanitized = synthesize_tool_call_if_missing(data)
             return to_jsonable(sanitized)
 
@@ -278,7 +289,15 @@ def create_task_app(config: TaskAppConfig) -> FastAPI:
     async def health(request: Request) -> Mapping[str, Any]:
         # If we got here, auth_dependency already verified the key exactly matches
         expected = normalize_environment_api_key()
-        return to_jsonable({"healthy": True, "auth": {"required": True, "expected_prefix": (expected[:6] + '...') if expected else '<unset>'}})
+        return to_jsonable(
+            {
+                "healthy": True,
+                "auth": {
+                    "required": True,
+                    "expected_prefix": (expected[:6] + "...") if expected else "<unset>",
+                },
+            }
+        )
 
     @app.get("/info", dependencies=[Depends(auth_dependency)])
     async def info() -> Mapping[str, Any]:
@@ -335,6 +354,7 @@ def create_task_app(config: TaskAppConfig) -> FastAPI:
         raise TypeError("Rollout executor must return RolloutResponse or mapping")
 
     if cfg.expose_debug_env:
+
         @app.get("/debug/env", dependencies=[Depends(auth_dependency)])
         async def debug_env() -> Mapping[str, Any]:
             def _mask(value: str | None) -> str:
@@ -387,6 +407,12 @@ def run_task_app(
         print(f"[task:server] Loaded environment from: {', '.join(loaded_files)}", flush=True)
 
     config = config_factory()
+    # Defensive: ensure the factory produced a valid TaskAppConfig to avoid
+    # confusing attribute errors later in the boot sequence.
+    if not isinstance(config, TaskAppConfig):  # type: ignore[arg-type]
+        raise TypeError(
+            f"Task app config_factory must return TaskAppConfig, got {type(config).__name__}"
+        )
     app = create_task_app(config)
 
     try:

synth_ai/task/tracing_utils.py

@@ -45,7 +45,9 @@ def resolve_tracing_db_url() -> str | None:
     return f"sqlite+aiosqlite:///{fallback_path}"
 
 
-def build_tracer_factory(make_tracer: Callable[..., Any], *, enabled: bool, db_url: str | None) -> Callable[[], Any] | None:
+def build_tracer_factory(
+    make_tracer: Callable[..., Any], *, enabled: bool, db_url: str | None
+) -> Callable[[], Any] | None:
     """Return a factory that instantiates a tracer when enabled, else None."""
 
     if not enabled:
@@ -74,6 +76,9 @@ def resolve_sft_output_dir() -> str | None:
 def unique_sft_path(base_dir: str, *, run_id: str) -> Path:
     """Return a unique JSONL path for an SFT record batch."""
 
-    ts = int(time.time() * 1000)
-    name = f"{run_id}_{ts}.jsonl"
+    from datetime import datetime
+
+    now = datetime.now()
+    timestamp = now.strftime("%Y-%m-%d_%H-%M-%S")
+    name = f"{run_id}_{timestamp}.jsonl"
     return Path(base_dir) / name

synth_ai/task/validators.py

@@ -9,4 +9,3 @@ def validate_task_app_url(url: str, *, name: str = "TASK_APP_BASE_URL") -> None:
     p = urlparse(url)
     if p.scheme not in ("http", "https") or not p.netloc:
         raise ValueError(f"Invalid {name}: malformed: {url}")
-

synth_ai/task/vendors.py

@@ -58,4 +58,3 @@ def get_groq_key_or_503() -> str:
     if not key:
         raise http_exception(503, "missing_groq_api_key", "GROQ_API_KEY is not configured")
     return key
-

synth_ai/tracing_v3/db_config.py

@@ -4,6 +4,7 @@ Centralized database configuration for v3 tracing.
 
 import logging
 import os
+import shutil
 from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
@@ -30,7 +31,7 @@ class DatabaseConfig:
             http_port: HTTP port for sqld daemon. If None, uses DEFAULT_HTTP_PORT from serve.sh.
             use_sqld: Whether to use sqld daemon or direct SQLite.
         """
-        self.use_sqld = use_sqld
+        self.use_sqld = use_sqld and self._sqld_binary_available()
         self.http_port = http_port or int(os.getenv("SQLD_HTTP_PORT", self.DEFAULT_HTTP_PORT))
         self._daemon: SqldDaemon | None = None
 
@@ -70,6 +71,30 @@ class DatabaseConfig:
         # SQLite URLs need 3 slashes for absolute paths
         return f"sqlite+aiosqlite:///{actual_db_path}"
 
+    def _sqld_binary_available(self) -> bool:
+        """Check if the sqld (Turso) binary is available on PATH."""
+        # Respect explicit SQLD_BINARY override when present
+        binary_override = os.getenv("SQLD_BINARY")
+        candidates = [binary_override, "sqld", "libsql-server"]
+
+        for candidate in candidates:
+            if candidate and shutil.which(candidate):
+                return True
+
+        if binary_override:
+            logger.warning(
+                "Configured SQLD_BINARY='%s' but the executable was not found on PATH. "
+                "Falling back to direct SQLite.",
+                binary_override,
+            )
+        else:
+            logger.warning(
+                "sqld binary not detected; falling back to SQLite-only mode. "
+                "Install Turso's sqld or set SQLD_BINARY to enable the Turso daemon."
+            )
+
+        return False
+
     def start_daemon(self, wait_time: float = 2.0):
         """
         Start the sqld daemon if configured.

synth_ai/tracing_v3/decorators.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 """Async-aware decorators for tracing v3.
 
 This module provides decorators and context management utilities for the tracing

synth_ai/tracing_v3/examples/basic_usage.py

@@ -166,8 +166,9 @@ async def main():
 
         tracer.hooks.register("event_recorded", count_events, name="event_counter")
 
-        async with tracer.session(metadata={"example": "hooks"}) as session_id, tracer.timestep(
-            "hook_test"
+        async with (
+            tracer.session(metadata={"example": "hooks"}) as session_id,
+            tracer.timestep("hook_test"),
         ):
             for i in range(3):
                 event = RuntimeEvent(

synth_ai/tracing_v3/hooks.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 """Hook system for extending tracing functionality.
 
 The hook system provides a flexible way to extend the tracing system without
@@ -202,6 +203,7 @@ def create_default_hooks() -> HookManager:
     # Example: Log session starts - useful for debugging and monitoring
     async def log_session_start(session_id: str, metadata: dict[str, Any]):
         import os
+
         if os.getenv("SYNTH_TRACE_VERBOSE", "0") in ("1", "true", "True"):
             print(f"Session started: {session_id}")
 

synth_ai/tracing_v3/replica_sync.py

@@ -180,6 +180,7 @@ class ReplicaSync:
             # Request cancellation
             self._sync_task.cancel()
             import contextlib
+
             with contextlib.suppress(asyncio.CancelledError):
                 # Wait for the task to finish
                 await self._sync_task

synth_ai/tracing_v3/session_tracer.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 """Main SessionTracer class for tracing v3."""
 
 import asyncio
@@ -110,7 +111,9 @@ class SessionTracer:
 
             # Ensure session row exists for incremental writes
             if self.db:
-                await self.db.ensure_session(session_id, created_at=self._current_trace.created_at, metadata=metadata or {})
+                await self.db.ensure_session(
+                    session_id, created_at=self._current_trace.created_at, metadata=metadata or {}
+                )
 
             # Trigger hooks
             await self.hooks.trigger(
@@ -435,7 +438,14 @@ class SessionTracer:
     # Reward recording helpers
     # -------------------------------
 
-    async def record_outcome_reward(self, *, total_reward: int, achievements_count: int, total_steps: int, reward_metadata: dict[str, Any] | None = None) -> int | None:
+    async def record_outcome_reward(
+        self,
+        *,
+        total_reward: int,
+        achievements_count: int,
+        total_steps: int,
+        reward_metadata: dict[str, Any] | None = None,
+    ) -> int | None:
         """Record an episode-level outcome reward for the current session."""
         if self._current_trace is None:
             raise RuntimeError("No active session")
@@ -462,7 +472,18 @@ class SessionTracer:
 
     # StepMetrics removed in favor of event_rewards; use record_event_reward for per-turn shaped values
 
-    async def record_event_reward(self, *, event_id: int, message_id: int | None = None, turn_number: int | None = None, reward_value: float = 0.0, reward_type: str | None = None, key: str | None = None, annotation: dict[str, Any] | None = None, source: str | None = None) -> int | None:
+    async def record_event_reward(
+        self,
+        *,
+        event_id: int,
+        message_id: int | None = None,
+        turn_number: int | None = None,
+        reward_value: float = 0.0,
+        reward_type: str | None = None,
+        key: str | None = None,
+        annotation: dict[str, Any] | None = None,
+        source: str | None = None,
+    ) -> int | None:
         """Record a first-class event-level reward with optional annotations."""
         if self._current_trace is None:
             raise RuntimeError("No active session")

synth_ai/tracing_v3/storage/base.py

@@ -54,7 +54,10 @@ class TraceStorage(ABC):
 
     @abstractmethod
     async def get_model_usage(
-        self, start_date: datetime | None = None, end_date: datetime | None = None, model_name: str | None = None
+        self,
+        start_date: datetime | None = None,
+        end_date: datetime | None = None,
+        model_name: str | None = None,
     ) -> Any:
         """Get model usage statistics.
 

synth_ai/tracing_v3/storage/factory.py

@@ -1,6 +1,5 @@
 """Factory for creating storage instances."""
 
-
 from ..turso.manager import AsyncSQLTraceManager
 from .base import TraceStorage
 from .config import StorageBackend, StorageConfig

synth_ai/tracing_v3/turso/manager.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 """Async SQLAlchemy-based trace manager for Turso/sqld.
 
 This module provides the database interface for the tracing system using
@@ -139,6 +140,7 @@ class AsyncSQLTraceManager:
                 )
                 # Ensure PRAGMA foreign_keys=ON for every connection
                 try:
+
                     @event.listens_for(self.engine.sync_engine, "connect")
                     def _set_sqlite_pragma(dbapi_connection, connection_record):  # type: ignore[no-redef]
                         try:
@@ -408,9 +410,7 @@ class AsyncSQLTraceManager:
                 ],
             }
 
-    async def query_traces(
-        self, query: str, params: dict[str, Any] | None = None
-    ) -> Any:
+    async def query_traces(self, query: str, params: dict[str, Any] | None = None) -> Any:
         """Execute a query and return results.
 
         Returns a pandas DataFrame when pandas is available; otherwise a
@@ -577,10 +577,18 @@ class AsyncSQLTraceManager:
     # Incremental insert helpers
     # -------------------------------
 
-    async def ensure_session(self, session_id: str, *, created_at: datetime | None = None, metadata: dict[str, Any] | None = None):
+    async def ensure_session(
+        self,
+        session_id: str,
+        *,
+        created_at: datetime | None = None,
+        metadata: dict[str, Any] | None = None,
+    ):
         """Ensure a DB session row exists for session_id."""
         async with self.session() as sess:
-            result = await sess.execute(select(DBSessionTrace).where(DBSessionTrace.session_id == session_id))
+            result = await sess.execute(
+                select(DBSessionTrace).where(DBSessionTrace.session_id == session_id)
+            )
             existing = result.scalar_one_or_none()
             if existing:
                 return
@@ -595,11 +603,23 @@ class AsyncSQLTraceManager:
             sess.add(row)
             await sess.commit()
 
-    async def ensure_timestep(self, session_id: str, *, step_id: str, step_index: int, turn_number: int | None = None, started_at: datetime | None = None, completed_at: datetime | None = None, metadata: dict[str, Any] | None = None) -> int:
+    async def ensure_timestep(
+        self,
+        session_id: str,
+        *,
+        step_id: str,
+        step_index: int,
+        turn_number: int | None = None,
+        started_at: datetime | None = None,
+        completed_at: datetime | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> int:
         """Ensure a timestep row exists; return its DB id."""
         async with self.session() as sess:
             result = await sess.execute(
-                select(DBSessionTimestep).where(DBSessionTimestep.session_id == session_id, DBSessionTimestep.step_id == step_id)
+                select(DBSessionTimestep).where(
+                    DBSessionTimestep.session_id == session_id, DBSessionTimestep.step_id == step_id
+                )
             )
             row = result.scalar_one_or_none()
             if row:
@@ -626,7 +646,17 @@ class AsyncSQLTraceManager:
             await sess.commit()
             return row.id
 
-    async def insert_message_row(self, session_id: str, *, timestep_db_id: int | None, message_type: str, content: str, event_time: float | None = None, message_time: int | None = None, metadata: dict[str, Any] | None = None) -> int:
+    async def insert_message_row(
+        self,
+        session_id: str,
+        *,
+        timestep_db_id: int | None,
+        message_type: str,
+        content: str,
+        event_time: float | None = None,
+        message_time: int | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> int:
         """Insert a message and return its id."""
         async with self.session() as sess:
             db_msg = DBMessage(
@@ -649,8 +679,16 @@ class AsyncSQLTraceManager:
             await sess.commit()
             return db_msg.id
 
-    async def insert_event_row(self, session_id: str, *, timestep_db_id: int | None, event: EnvironmentEvent | LMCAISEvent | RuntimeEvent, metadata_override: dict[str, Any] | None = None) -> int:
+    async def insert_event_row(
+        self,
+        session_id: str,
+        *,
+        timestep_db_id: int | None,
+        event: EnvironmentEvent | LMCAISEvent | RuntimeEvent,
+        metadata_override: dict[str, Any] | None = None,
+    ) -> int:
         """Insert an event and return its id."""
+
         def to_cents(cost: float | None) -> int | None:
             return int(cost * 100) if cost is not None else None
 
@@ -669,35 +707,41 @@ class AsyncSQLTraceManager:
                 from dataclasses import asdict
 
                 call_records_data = [asdict(record) for record in event.call_records]
-            event_data.update({
-                "event_type": "cais",
-                "model_name": event.model_name,
-                "provider": event.provider,
-                "input_tokens": event.input_tokens,
-                "output_tokens": event.output_tokens,
-                "total_tokens": event.total_tokens,
-                "cost_usd": to_cents(event.cost_usd),
-                "latency_ms": event.latency_ms,
-                "span_id": event.span_id,
-                "trace_id": event.trace_id,
-                "system_state_before": event.system_state_before,
-                "system_state_after": event.system_state_after,
-                "call_records": call_records_data,
-            })
+            event_data.update(
+                {
+                    "event_type": "cais",
+                    "model_name": event.model_name,
+                    "provider": event.provider,
+                    "input_tokens": event.input_tokens,
+                    "output_tokens": event.output_tokens,
+                    "total_tokens": event.total_tokens,
+                    "cost_usd": to_cents(event.cost_usd),
+                    "latency_ms": event.latency_ms,
+                    "span_id": event.span_id,
+                    "trace_id": event.trace_id,
+                    "system_state_before": event.system_state_before,
+                    "system_state_after": event.system_state_after,
+                    "call_records": call_records_data,
+                }
+            )
         elif isinstance(event, EnvironmentEvent):
-            event_data.update({
-                "event_type": "environment",
-                "reward": event.reward,
-                "terminated": event.terminated,
-                "truncated": event.truncated,
-                "system_state_before": event.system_state_before,
-                "system_state_after": event.system_state_after,
-            })
+            event_data.update(
+                {
+                    "event_type": "environment",
+                    "reward": event.reward,
+                    "terminated": event.terminated,
+                    "truncated": event.truncated,
+                    "system_state_before": event.system_state_before,
+                    "system_state_after": event.system_state_after,
+                }
+            )
         elif isinstance(event, RuntimeEvent):
-            event_data.update({
-                "event_type": "runtime",
-                "event_metadata_json": {**(event.metadata or {}), "actions": event.actions},
-            })
+            event_data.update(
+                {
+                    "event_type": "runtime",
+                    "event_metadata_json": {**(event.metadata or {}), "actions": event.actions},
+                }
+            )
         else:
             event_data["event_type"] = event.__class__.__name__.lower()
 
@@ -718,7 +762,15 @@ class AsyncSQLTraceManager:
     # Reward helpers
     # -------------------------------
 
-    async def insert_outcome_reward(self, session_id: str, *, total_reward: int, achievements_count: int, total_steps: int, reward_metadata: dict | None = None) -> int:
+    async def insert_outcome_reward(
+        self,
+        session_id: str,
+        *,
+        total_reward: int,
+        achievements_count: int,
+        total_steps: int,
+        reward_metadata: dict | None = None,
+    ) -> int:
         async with self.session() as sess:
             row = DBOutcomeReward(
                 session_id=session_id,
@@ -732,7 +784,19 @@ class AsyncSQLTraceManager:
             await sess.commit()
             return row.id
 
-    async def insert_event_reward(self, session_id: str, *, event_id: int, message_id: int | None = None, turn_number: int | None = None, reward_value: float = 0.0, reward_type: str | None = None, key: str | None = None, annotation: dict[str, Any] | None = None, source: str | None = None) -> int:
+    async def insert_event_reward(
+        self,
+        session_id: str,
+        *,
+        event_id: int,
+        message_id: int | None = None,
+        turn_number: int | None = None,
+        reward_value: float = 0.0,
+        reward_type: str | None = None,
+        key: str | None = None,
+        annotation: dict[str, Any] | None = None,
+        source: str | None = None,
+    ) -> int:
         async with self.session() as sess:
             row = DBEventReward(
                 event_id=event_id,

synth_ai/tracing_v3/turso/models.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 """SQLAlchemy declarative models for tracing v3."""
 
 import json
@@ -452,7 +453,9 @@ class EventReward(Base):
     message_id = Column(Integer, ForeignKey("messages.id"), nullable=True)
     turn_number = Column(Integer, nullable=True)
     reward_value = Column(Float, nullable=False, default=0.0)
-    reward_type = Column(String, nullable=True)  # shaped | sparse | achievement | penalty | evaluator | human
+    reward_type = Column(
+        String, nullable=True
+    )  # shaped | sparse | achievement | penalty | evaluator | human
     key = Column(String, nullable=True)  # e.g., achievement name
     annotation = Column(JSONText)  # free-form JSON
     source = Column(String, nullable=True)  # environment | runner | evaluator | human

synth_ai/tracing_v3/utils.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 """Utility functions for tracing v3."""
 
 import hashlib