synth-ai 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

synth_ai/environments/examples/red/environment.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import Any, Dict, List, Optional, Union
 import base64
+import time
 from io import BytesIO
 
 from pydantic import BaseModel, Field
@@ -19,6 +20,8 @@ from synth_ai.environments.environment.tools import (
 )
 from synth_ai.environments.reproducibility.core import ReproducibleEnvironment
 from synth_ai.environments.stateful.core import StatefulEnvironment
+from synth_ai.tracing_v3.abstractions import EnvironmentEvent, TimeRecord
+from synth_ai.tracing_v3.session_tracer import SessionTracer
 try:  # optional for image encoding
     import numpy as _np  # type: ignore
     from PIL import Image as _PILImage  # type: ignore
@@ -121,6 +124,7 @@ class PokemonRedEnvironment(StatefulEnvironment, ReproducibleEnvironment[Pokemon
         task_instance: Optional[PokemonRedTaskInstance] = None,
         custom_step_obs: Optional[GetObservationCallable] = None,
         custom_ckpt_obs: Optional[GetObservationCallable] = None,
+        tracer: Optional[SessionTracer] = None,
     ):
         self.name = "PokemonRed"
         self.task_instance = task_instance or DEFAULT_TASK_INSTANCE
@@ -129,6 +133,7 @@ class PokemonRedEnvironment(StatefulEnvironment, ReproducibleEnvironment[Pokemon
             custom_ckpt_obs or PokemonRedObservationCallable()
         )
         self.engine = PokemonRedEngine(self.task_instance)
+        self.tracer = tracer
 
         # Register tools
         self._press_button_tool = PressButtonTool(self.engine)
@@ -203,6 +208,27 @@ class PokemonRedEnvironment(StatefulEnvironment, ReproducibleEnvironment[Pokemon
                 if tool_result.error and hasattr(pub_state, "error_info"):
                     pub_state.error_info = tool_result.error
 
+        # Record EnvironmentEvent for tracing if tracer is available
+        if self.tracer and hasattr(priv_state, 'reward_last_step'):
+            # Get state information for the event
+            prev_state = getattr(self.engine, '_previous_state', None)
+            terminated = getattr(priv_state, 'terminated', False)
+            truncated = getattr(priv_state, 'truncated', False)
+
+            # Convert states to dict for serialization
+            pub_state_dict = pub_state.__dict__ if hasattr(pub_state, '__dict__') else pub_state
+
+            env_event = EnvironmentEvent(
+                system_instance_id="pokemon_red_env",
+                time_record=TimeRecord(event_time=time.time()),
+                reward=float(priv_state.reward_last_step),
+                terminated=terminated,
+                truncated=truncated,
+                system_state_before=prev_state if prev_state else None,
+                system_state_after=pub_state_dict,
+            )
+            await self.tracer.record_event(env_event)
+
         return await self._to_observation(
             priv_state, pub_state, self.custom_step_observation_callable
         )

synth_ai/environments/examples/red/trace_hooks_v3.py

@@ -0,0 +1,168 @@
+"""
+Trace hooks for Pokemon Red environment - v3 version.
+Captures reward information and saves to Turso database.
+"""
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+
+from synth_ai.tracing_v3.abstractions import BaseEvent, EnvironmentEvent
+from synth_ai.tracing_v3.hooks import HookManager
+
+# Pokemon Red achievement categories by reward value
+EXPLORATION_ACHIEVEMENTS = {
+    0.02: "explore_new_area",
+    0.04: "explore_multiple_areas",
+    1.0: "leave_starting_area",
+    1.5: "enter_new_city",
+    2.0: "explore_new_route",
+    5.0: "enter_gym_building",
+}
+
+TRAINING_ACHIEVEMENTS = {
+    0.2: "pokemon_level_up",
+    0.3: "reach_power_level",
+    3.0: "pokemon_ready_for_battle",
+}
+
+BATTLE_ACHIEVEMENTS = {
+    0.1: "encounter_wild_pokemon",
+}
+
+RESOURCE_ACHIEVEMENTS = {
+    0.05: "keep_pokemon_healthy",
+    0.5: "find_valuable_item",
+    0.8: "visit_pokemon_center",
+}
+
+MAJOR_ACHIEVEMENTS = {
+    50.0: "defeat_brock_win_badge",
+}
+
+
+async def track_pokemon_rewards(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that captures detailed Pokemon Red reward information."""
+    # Only process EnvironmentEvents
+    if not isinstance(event_obj, EnvironmentEvent):
+        return None
+
+    reward = event_obj.reward
+    if reward is None or reward == 0.0:
+        return None
+
+    # Determine achievement type based on reward value
+    achievement_type = "unknown"
+    achievement_category = "other"
+
+    # Check each category
+    if reward in EXPLORATION_ACHIEVEMENTS:
+        achievement_type = EXPLORATION_ACHIEVEMENTS[reward]
+        achievement_category = "exploration"
+    elif reward in TRAINING_ACHIEVEMENTS:
+        achievement_type = TRAINING_ACHIEVEMENTS[reward]
+        achievement_category = "training"
+    elif reward in BATTLE_ACHIEVEMENTS:
+        achievement_type = BATTLE_ACHIEVEMENTS[reward]
+        achievement_category = "battle"
+    elif reward in RESOURCE_ACHIEVEMENTS:
+        achievement_type = RESOURCE_ACHIEVEMENTS[reward]
+        achievement_category = "resource"
+    elif reward in MAJOR_ACHIEVEMENTS:
+        achievement_type = MAJOR_ACHIEVEMENTS[reward]
+        achievement_category = "major"
+
+    return {
+        "reward_value": reward,
+        "achievement_type": achievement_type,
+        "achievement_category": achievement_category,
+        "timestamp": datetime.now().isoformat(),
+        "system_state_before": event_obj.system_state_before,
+        "system_state_after": event_obj.system_state_after,
+    }
+
+
+async def track_pokemon_milestones(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that tracks significant Pokemon Red milestones."""
+    # Only process EnvironmentEvents
+    if not isinstance(event_obj, EnvironmentEvent):
+        return None
+
+    reward = event_obj.reward
+    if reward is None:
+        return None
+
+    # Track major milestones
+    if reward >= 1.0:  # Significant progress rewards
+        return {
+            "milestone": "major_progress",
+            "reward": reward,
+            "timestamp": datetime.now().isoformat(),
+        }
+    elif reward >= 0.5:  # Moderate rewards
+        return {
+            "milestone": "moderate_progress",
+            "reward": reward,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    return None
+
+
+async def track_pokemon_outcomes(event_obj: BaseEvent, **kwargs) -> Optional[Dict[str, Any]]:
+    """Hook that tracks episode outcomes for Pokemon Red."""
+    # Only process EnvironmentEvents
+    if not isinstance(event_obj, EnvironmentEvent):
+        return None
+
+    # Check for termination conditions
+    if event_obj.terminated or event_obj.truncated:
+        total_reward = getattr(event_obj, 'total_reward', 0.0)
+        steps_taken = getattr(event_obj, 'step_count', 0)
+
+        # Extract achievement information from system state
+        achievements_count = 0
+        if event_obj.system_state_after:
+            # Count positive rewards as achievements
+            # This is a simplified count - in practice you'd track actual achievements
+            achievements_count = max(1, int(total_reward / 0.1))  # Rough estimate
+
+        return {
+            "outcome_type": "episode_end",
+            "total_reward": total_reward,
+            "steps_taken": steps_taken,
+            "achievements_count": achievements_count,
+            "terminated": event_obj.terminated,
+            "truncated": event_obj.truncated,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    return None
+
+
+# Create the global POKEMON_RED_HOOKS instance
+POKEMON_RED_HOOKS = HookManager()
+
+# Register all hooks
+POKEMON_RED_HOOKS.register(
+    "event_recorded",
+    track_pokemon_rewards,
+    name="pokemon_rewards",
+    priority=10,
+    event_types=["environment"],
+)
+
+POKEMON_RED_HOOKS.register(
+    "event_recorded",
+    track_pokemon_milestones,
+    name="pokemon_milestones",
+    priority=5,
+    event_types=["environment"],
+)
+
+POKEMON_RED_HOOKS.register(
+    "event_recorded",
+    track_pokemon_outcomes,
+    name="pokemon_outcomes",
+    priority=5,
+    event_types=["environment"],
+)

synth_ai/http.py

@@ -0,0 +1,12 @@
+"""
+Backward-compatible HTTP client exports.
+
+Historically, some modules imported ``synth_ai.http``. The canonical location
+is ``synth_ai.http_client``; this module simply re-exports the same symbols so
+legacy imports keep working.
+"""
+
+
+from synth_ai.http_client import AsyncHttpClient, HTTPError, sleep
+
+__all__ = ["AsyncHttpClient", "HTTPError", "sleep"]

synth_ai/judge_schemas.py

@@ -9,7 +9,7 @@ This is the canonical contract that the backend MUST conform to.
 
 from __future__ import annotations
 
-from typing import Any, Literal
+from typing import Any, Literal, Optional
 
 from pydantic import BaseModel, Field
 
@@ -31,7 +31,7 @@ class ReviewPayload(BaseModel):
         description="Map of criterion keys to their scores"
     )
     total: float = Field(default=0.0, description="Aggregated total score")
-    summary: str | None = Field(None, description="Optional text summary")
+    summary: Optional[str] = Field(None, description="Optional text summary")
 
 
 class JudgeScoreResponse(BaseModel):
@@ -46,7 +46,7 @@ class JudgeScoreResponse(BaseModel):
         default_factory=list,
         description="List of per-event rubric reviews (one per step)"
     )
-    outcome_review: ReviewPayload | None = Field(
+    outcome_review: Optional[ReviewPayload] = Field(
         None,
         description="Optional outcome-level rubric review"
     )
@@ -63,7 +63,7 @@ class JudgeScoreResponse(BaseModel):
         description="Request metadata (provider, options, etc.)"
     )
 
-    def aggregate_event_reward(self) -> float | None:
+    def aggregate_event_reward(self) -> Optional[float]:
         """
         Aggregate all event totals into a single reward.
         
@@ -74,7 +74,7 @@ class JudgeScoreResponse(BaseModel):
             return None
         return sum(self.event_totals)
 
-    def aggregate_outcome_reward(self) -> float | None:
+    def aggregate_outcome_reward(self) -> Optional[float]:
         """
         Extract outcome reward from outcome_review.
         
@@ -92,15 +92,15 @@ class JudgeTaskApp(BaseModel):
     """Task application metadata."""
     
     id: str = Field(..., description="Task app identifier")
-    base_url: str | None = Field(None, description="Optional base URL for task app")
+    base_url: Optional[str] = Field(None, description="Optional base URL for task app")
 
 
 class JudgeOptions(BaseModel):
     """Judge provider and configuration options."""
     
-    provider: str | None = Field(None, description="Judge provider (e.g., 'openai', 'groq')")
-    model: str | None = Field(None, description="Model identifier")
-    rubric_id: str | None = Field(None, description="Rubric identifier")
+    provider: Optional[str] = Field(None, description="Judge provider (e.g., 'openai', 'groq')")
+    model: Optional[str] = Field(None, description="Model identifier")
+    rubric_id: Optional[str] = Field(None, description="Rubric identifier")
     event: bool = Field(True, description="Enable event-level judging")
     outcome: bool = Field(True, description="Enable outcome-level judging")
 
@@ -123,5 +123,4 @@ class JudgeScoreRequest(BaseModel):
     task_app: JudgeTaskApp = Field(..., description="Task application metadata")
     trace: JudgeTracePayload = Field(..., description="Trajectory trace to evaluate")
     options: JudgeOptions = Field(default_factory=lambda: JudgeOptions(), description="Judge options")
-    rubric: dict[str, Any] | None = Field(None, description="Optional explicit rubric criteria")
-
+    rubric: Optional[dict[str, Any]] = Field(None, description="Optional explicit rubric criteria")

synth_ai/learning/rl/client.py

@@ -107,7 +107,9 @@ class RlClient:
         async with AsyncHttpClient(self._base_url, self._api_key, timeout=30.0) as http:
             try:
                 js = await http.get(
-                    f"{_api_base(self._base_url)}/learning/jobs/{job_id}/events", params=params
+                    f"{_api_base(self._base_url)}/learning/jobs/{job_id}/events",
+                    params=params,
+                    headers={"accept": "application/json"},
                 )
             except HTTPError as he:
                 with suppress(Exception):

synth_ai/streaming/__init__.py

@@ -0,0 +1,29 @@
+from .config import StreamConfig
+from .handlers import (
+    BufferedHandler,
+    CallbackHandler,
+    CLIHandler,
+    IntegrationTestHandler,
+    JSONHandler,
+    LossCurveHandler,
+    RichHandler,
+    StreamHandler,
+)
+from .streamer import JobStreamer, StreamEndpoints
+from .types import StreamMessage, StreamType
+
+__all__ = [
+    "BufferedHandler",
+    "CallbackHandler",
+    "CLIHandler",
+    "IntegrationTestHandler",
+    "JSONHandler",
+    "LossCurveHandler",
+    "JobStreamer",
+    "RichHandler",
+    "StreamEndpoints",
+    "StreamConfig",
+    "StreamHandler",
+    "StreamMessage",
+    "StreamType",
+]

synth_ai/streaming/config.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .types import StreamType
+
+
+@dataclass(slots=True)
+class StreamConfig:
+    """Configuration describing which streams to consume and how to filter them."""
+
+    enabled_streams: set[StreamType] = field(default_factory=lambda: set(StreamType))
+    event_types: set[str] | None = None  # Whitelist: only include these event types
+    event_types_exclude: set[str] | None = None  # Blacklist: exclude these event types
+    event_levels: set[str] | None = None
+    metric_names: set[str] | None = None
+    metric_phases: set[str] | None = None
+    timeline_phases: set[str] | None = None
+    sample_rate: float = 1.0
+    max_events_per_poll: int | None = None
+    deduplicate: bool = True
+
+    @classmethod
+    def default(cls) -> StreamConfig:
+        """Return a configuration representing the default (all streams) view."""
+        return cls(
+            event_types_exclude={
+                # Filter out noisy events that just announce what metrics already show
+                "sft.progress",  # Generic "Training progress" with no data
+                "sft.loss",      # Generic "Loss update" with no data
+                "sft.upstream.status",  # Very verbose status echo events
+            }
+        )
+
+    @classmethod
+    def minimal(cls) -> StreamConfig:
+        """Return a configuration streaming status updates only."""
+        return cls(enabled_streams={StreamType.STATUS})
+
+    @classmethod
+    def verbose(cls) -> StreamConfig:
+        """Return a configuration with all streams and events (no filters)."""
+        return cls()
+
+    @classmethod
+    def progress_only(cls) -> StreamConfig:
+        """Return a configuration tailored to show training progress."""
+        return cls(
+            enabled_streams={StreamType.STATUS, StreamType.EVENTS, StreamType.METRICS},
+            event_types={"sft.progress", "rl.train.step", "sft.validation.summary"},
+            metric_names={"train.loss", "eval.reward_mean"},
+        )
+
+    @classmethod
+    def errors_only(cls) -> StreamConfig:
+        """Return a configuration that focuses on heightened severity signals."""
+        return cls(
+            enabled_streams={StreamType.STATUS, StreamType.EVENTS},
+            event_levels={"error", "warning"},
+        )
+
+    def should_include_event(self, event: dict[str, Any]) -> bool:
+        """Determine whether an event message should be included."""
+        event_type = event.get("type")
+        
+        # Apply blacklist first (takes precedence)
+        if self.event_types_exclude and event_type in self.event_types_exclude:
+            return False
+        
+        # Then apply whitelist
+        if self.event_types and event_type not in self.event_types:
+            return False
+        
+        if self.event_levels:
+            return event.get("level") in self.event_levels
+        return True
+
+    def should_include_metric(self, metric: dict[str, Any]) -> bool:
+        """Determine whether a metric point should be included."""
+        if self.metric_names and metric.get("name") not in self.metric_names:
+            return False
+        if self.metric_phases:
+            return metric.get("phase") in self.metric_phases
+        return True
+
+    def should_include_timeline(self, timeline_entry: dict[str, Any]) -> bool:
+        """Determine whether a timeline entry should be included."""
+        if self.timeline_phases:
+            return timeline_entry.get("phase") in self.timeline_phases
+        return True
+
+
+__all__ = ["StreamConfig"]