synth-ai 0.2.9.dev5__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

synth_ai/task/errors.py

@@ -1,14 +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}}
+def error_payload(
+    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
@@ -19,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
@@ -36,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
@@ -46,4 +48,3 @@ def json_error_response(
 
     payload = error_payload(code, message, extra=extra)
     return JSONResponse(status_code=status_code, content=to_jsonable(payload), headers=headers)
-

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,17 +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}"}
-
-

synth_ai/task/json.py

@@ -1,9 +1,9 @@
-from __future__ import annotations
-
 """Shared JSON sanitisation helpers for Task Apps."""
 
+from __future__ import annotations
+
 from collections.abc import Mapping, Sequence
-from dataclasses import is_dataclass, asdict
+from dataclasses import asdict, is_dataclass
 from enum import Enum
 from typing import Any
 
@@ -13,13 +13,19 @@ except Exception:  # pragma: no cover - handled at runtime
     _np = None  # type: ignore
 
 
-def _mask_numpy_array(arr: "_np.ndarray") -> str:
+def _mask_numpy_array(arr: Any) -> str:
     shape = getattr(arr, "shape", None)
     dtype = getattr(arr, "dtype", None)
     return f"<ndarray shape={shape} dtype={dtype}>"
 
 
-def to_jsonable(value: Any) -> Any:
+def to_jsonable(
+    value: Any,
+    *,
+    _visited: set[int] | None = None,
+    _depth: int = 0,
+    _max_depth: int = 32,
+) -> Any:
     """Convert `value` into structures compatible with JSON serialisation.
 
     - numpy scalars are converted to their Python counterparts
@@ -29,25 +35,33 @@ def to_jsonable(value: Any) -> Any:
     - non-serialisable objects fall back to `repr`
     """
 
-    if value is None or isinstance(value, (str, bool, int, float)):
+    if _visited is None:
+        _visited = set()
+
+    if _depth > _max_depth:
+        return f"<max_depth type={type(value).__name__}>"
+
+    if value is None or isinstance(value, str | bool | int | float):
         return value
 
     # numpy scalars / arrays
     if _np is not None:
-        if isinstance(value, (_np.integer,)):
+        if isinstance(value, _np.integer):
             return int(value)
-        if isinstance(value, (_np.floating,)):
+        if isinstance(value, _np.floating):
             return float(value)
-        if isinstance(value, (_np.bool_,)):
+        if isinstance(value, _np.bool_):
             return bool(value)
-        if isinstance(value, (_np.ndarray,)):
+        if isinstance(value, _np.ndarray):
             return _mask_numpy_array(value)
 
     if isinstance(value, Enum):
-        return to_jsonable(value.value)
+        return to_jsonable(value.value, _visited=_visited, _depth=_depth + 1, _max_depth=_max_depth)
 
     if is_dataclass(value):
-        return to_jsonable(asdict(value))
+        return to_jsonable(
+            asdict(value), _visited=_visited, _depth=_depth + 1, _max_depth=_max_depth
+        )
 
     # pydantic BaseModel / attrs objects
     for attr in ("model_dump", "dict", "to_dict", "to_json"):
@@ -56,22 +70,42 @@ def to_jsonable(value: Any) -> Any:
                 dumped = getattr(value, attr)()  # type: ignore[misc]
             except TypeError:
                 dumped = getattr(value, attr)(exclude_none=False)  # pragma: no cover
-            return to_jsonable(dumped)
+            return to_jsonable(
+                dumped, _visited=_visited, _depth=_depth + 1, _max_depth=_max_depth
+            )
 
-    if isinstance(value, Mapping):
-        return {str(k): to_jsonable(v) for k, v in value.items()}
-
-    if isinstance(value, (set, tuple)):
-        return [to_jsonable(v) for v in value]
-
-    if isinstance(value, Sequence) and not isinstance(value, (str, bytes, bytearray)):
-        return [to_jsonable(v) for v in value]
+    obj_id = id(value)
+    if obj_id in _visited:
+        return f"<circular type={type(value).__name__}>"
 
-    if isinstance(value, (bytes, bytearray)):
+    if isinstance(value, Mapping):
+        _visited.add(obj_id)
+        return {
+            str(k): to_jsonable(v, _visited=_visited, _depth=_depth + 1, _max_depth=_max_depth)
+            for k, v in value.items()
+        }
+
+    if isinstance(value, set | tuple):
+        _visited.add(obj_id)
+        return [
+            to_jsonable(v, _visited=_visited, _depth=_depth + 1, _max_depth=_max_depth)
+            for v in value
+        ]
+
+    if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):
+        _visited.add(obj_id)
+        return [
+            to_jsonable(v, _visited=_visited, _depth=_depth + 1, _max_depth=_max_depth)
+            for v in value
+        ]
+
+    if isinstance(value, bytes | bytearray):
         return f"<bytes len={len(value)}>"
 
     if hasattr(value, "__dict__"):
-        return to_jsonable(vars(value))
+        _visited.add(obj_id)
+        return to_jsonable(
+            vars(value), _visited=_visited, _depth=_depth + 1, _max_depth=_max_depth
+        )
 
     return repr(value)
-

synth_ai/task/proxy.py

@@ -1,14 +1,14 @@
-from __future__ import annotations
-
 """Shared helpers for Task App proxy endpoints (OpenAI, Groq, etc.)."""
 
+from __future__ import annotations
+
 import copy
 import json
 import re
-from typing import Any, Iterable, List, Tuple
-
+from collections.abc import Iterable
+from typing import Any
 
-INTERACT_TOOL_SCHEMA: List[dict[str, Any]] = [
+INTERACT_TOOL_SCHEMA: list[dict[str, Any]] = [
     {
         "type": "function",
         "function": {
@@ -80,9 +80,13 @@ def prepare_for_groq(model: str | None, payload: dict[str, Any]) -> dict[str, An
 
     sanitized = prepare_for_openai(model, payload)
     # Groq supports `max_tokens`; prefer their native parameter when present
-    if model and "gpt-5" not in (model or ""):
-        if "max_completion_tokens" in sanitized and "max_tokens" not in payload:
-            sanitized["max_tokens"] = sanitized.pop("max_completion_tokens")
+    if (
+        model
+        and "gpt-5" not in model
+        and "max_completion_tokens" in sanitized
+        and "max_tokens" not in payload
+    ):
+        sanitized["max_tokens"] = sanitized.pop("max_completion_tokens")
     return sanitized
 
 
@@ -146,7 +150,7 @@ def _parse_actions_from_json_candidate(candidate: Any) -> tuple[list[str], str]:
     return actions, reasoning
 
 
-def parse_tool_call_from_text(text: str) -> Tuple[list[str], str]:
+def parse_tool_call_from_text(text: str) -> tuple[list[str], str]:
     """Derive tool-call actions and reasoning from assistant text."""
 
     text = (text or "").strip()
@@ -179,7 +183,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 +246,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 +257,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

@@ -1,10 +1,11 @@
-from __future__ import annotations
-
 """Rubric schema, loading, and scoring helpers for Task Apps."""
 
+from __future__ import annotations
+
 import json
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, Dict, Iterable, Optional
+from typing import Any
 
 from pydantic import BaseModel, Field, field_validator
 
@@ -48,14 +49,14 @@ class Rubric(BaseModel):
         return criteria
 
 
-def _load_text(source: str) -> tuple[str, Optional[str]]:
+def _load_text(source: str) -> tuple[str, str | None]:
     path = Path(source)
     if path.exists():
         return path.read_text(encoding="utf-8"), path.suffix.lower()
     return source, None
 
 
-def _parse_structured(text: str, suffix: Optional[str]) -> Dict[str, Any]:
+def _parse_structured(text: str, suffix: str | None) -> dict[str, Any]:
     text = text.strip()
     if not text:
         raise ValueError("Rubric source is empty")
@@ -66,7 +67,7 @@ def _parse_structured(text: str, suffix: Optional[str]) -> Dict[str, Any]:
             raise RuntimeError("PyYAML is required to load YAML rubrics") from exc
         data = yaml.safe_load(text)
         if not isinstance(data, dict):
-            raise ValueError("Rubric YAML must produce a mapping")
+            raise ValueError("Rubric YAML must produce a mapping") from None
         return data
     if text.startswith("{"):
         return json.loads(text)
@@ -85,7 +86,7 @@ def _parse_structured(text: str, suffix: Optional[str]) -> Dict[str, Any]:
             raise RuntimeError("PyYAML is required to load rubric text") from exc
         data = yaml.safe_load(text)
         if not isinstance(data, dict):
-            raise ValueError("Rubric text must decode to a mapping")
+            raise ValueError("Rubric text must decode to a mapping") from None
         return data
 
 
@@ -148,17 +149,19 @@ def blend_rubrics(base: Rubric | None, override: Rubric | None) -> Rubric | None
     )
 
 
-def _as_float(value: Any) -> Optional[float]:
+def _as_float(value: Any) -> float | None:
     try:
         return float(value)
     except Exception:
         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]] = {}
+    per_criterion: dict[str, dict[str, Any]] = {}
     total = 0.0
     total_weight = 0.0
     for criterion in criteria:
@@ -184,10 +187,12 @@ 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] = {}
+    values: dict[str, float] = {}
     for event in events or []:
         if not isinstance(event, dict):
             continue
@@ -198,12 +203,14 @@ def score_events_against_rubric(events: list[dict[str, Any]], rubric: Rubric | N
     return _score(rubric.criteria, values, rubric.aggregation)
 
 
-def score_outcome_against_rubric(outcome: dict[str, Any], rubric: Rubric | None) -> Dict[str, Any]:
+def score_outcome_against_rubric(outcome: dict[str, Any], rubric: Rubric | None) -> dict[str, Any]:
     if rubric is None:
         return {"aggregation": "none", "score": None, "per_criterion": {}}
-    values: Dict[str, float] = {}
+    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

@@ -1,39 +1,34 @@
-from __future__ import annotations
-
 """FastAPI scaffolding for Task Apps (local dev + deployment)."""
 
+from __future__ import annotations
+
 import asyncio
 import inspect
 import os
+from collections.abc import Awaitable, Callable, Iterable, Mapping, MutableMapping, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Awaitable, Callable, Iterable, Mapping, MutableMapping, Sequence
+from typing import Any
 
 import httpx
 from fastapi import APIRouter, Depends, FastAPI, Query, Request
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
 from starlette.middleware import Middleware
 
-from .auth import (
-    is_api_key_header_authorized,
-    normalize_environment_api_key,
-    require_api_key_dependency,
-)
+from .auth import normalize_environment_api_key, require_api_key_dependency
 from .contracts import RolloutRequest, RolloutResponse, TaskInfo
 from .datasets import TaskDatasetRegistry
 from .errors import http_exception
 from .json import to_jsonable
 from .proxy import (
+    inject_system_hint,
     prepare_for_groq,
     prepare_for_openai,
-    inject_system_hint,
     synthesize_tool_call_if_missing,
 )
 from .rubrics import Rubric
 from .vendors import get_groq_key_or_503, get_openai_key_or_503, normalize_vendor_keys
 
-
 TasksetDescriptor = Callable[[], Mapping[str, Any] | Awaitable[Mapping[str, Any]]]
 InstanceProvider = Callable[[Sequence[int]], Iterable[TaskInfo] | Awaitable[Iterable[TaskInfo]]]
 RolloutExecutor = Callable[[RolloutRequest, Request], Any | Awaitable[Any]]
@@ -81,7 +76,7 @@ class TaskAppConfig:
     startup_hooks: Sequence[Callable[[], None | Awaitable[None]]] = field(default_factory=tuple)
     shutdown_hooks: Sequence[Callable[[], None | Awaitable[None]]] = field(default_factory=tuple)
 
-    def clone(self) -> "TaskAppConfig":
+    def clone(self) -> TaskAppConfig:
         """Return a shallow copy safe to mutate when wiring the app."""
 
         return TaskAppConfig(
@@ -120,7 +115,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 +137,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 +167,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 +190,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 +198,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 +284,20 @@ 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.post("/done", dependencies=[Depends(auth_dependency)])
+    async def done() -> Mapping[str, Any]:
+        # Coordination endpoint for tests and automation; indicates app is reachable
+        return to_jsonable({"ok": True, "service": cfg.app_id})
 
     @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

@@ -1,11 +1,11 @@
-from __future__ import annotations
-
 """Utilities for wiring tracing_v3 into task apps."""
 
+from __future__ import annotations
+
 import os
-import time
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable
+from typing import Any
 
 
 def tracing_env_enabled(default: bool = False) -> bool:
@@ -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

@@ -1,9 +1,8 @@
-from __future__ import annotations
-
 """Vendor API key helpers shared by Task Apps."""
 
+from __future__ import annotations
+
 import os
-from typing import Optional
 
 from .errors import http_exception
 
@@ -20,7 +19,7 @@ def _mask(value: str, *, prefix: int = 4) -> str:
     return f"{visible}{'…' if len(value) > prefix else ''}"
 
 
-def _normalize_single(key: str) -> Optional[str]:
+def _normalize_single(key: str) -> str | None:
     direct = os.getenv(key)
     if direct:
         return direct
@@ -37,10 +36,10 @@ def _normalize_single(key: str) -> Optional[str]:
     return None
 
 
-def normalize_vendor_keys() -> dict[str, Optional[str]]:
+def normalize_vendor_keys() -> dict[str, str | None]:
     """Normalise known vendor keys from dev fallbacks and return the mapping."""
 
-    resolved: dict[str, Optional[str]] = {}
+    resolved: dict[str, str | None] = {}
     for key in _VENDOR_KEYS:
         resolved[key] = _normalize_single(key)
     return resolved
@@ -58,4 +57,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/__init__.py

@@ -75,6 +75,7 @@ from .abstractions import (
     EnvironmentEvent,
     RuntimeEvent,
     SessionEventMarkovBlanketMessage,
+    SessionMessageContent,
     SessionTimeStep,
     SessionTrace,
     TimeRecord,
@@ -90,6 +91,7 @@ __all__ = [
     "RuntimeEvent",
     "EnvironmentEvent",
     "SessionEventMarkovBlanketMessage",
+    "SessionMessageContent",
     "TimeRecord",
     "TursoConfig",
 ]