synth-ai 0.2.9.dev0__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

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/environments/examples/sokoban/taskset.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import logging
 import os
+from collections.abc import Iterable, Sequence
 from dataclasses import asdict, dataclass, fields
 from typing import List, Tuple
 from uuid import UUID, uuid4
@@ -18,6 +21,7 @@ from synth_ai.environments.tasks.core import (
     TaskInstanceMetadataFilter,
     TaskInstanceSet,
 )
+from synth_ai.task.contracts import TaskInfo
 
 logger = logging.getLogger(__name__)
 
@@ -96,6 +100,118 @@ class SokobanTaskInstance(TaskInstance):
         return cls(**filtered_data)
 
 
+def _base_task_info_template() -> TaskInfo:
+    return TaskInfo(
+        task={"id": "sokoban", "name": "Sokoban", "version": "1.0.0"},
+        environment="sokoban",
+        action_space={
+            "type": "tool_call",
+            "tools": [{"name": "interact", "schema": {"action": "int"}}],
+            "max_calls": 1,
+        },
+        observation={"summary": "Sokoban grid observation", "keys": ["grid", "player"]},
+        dataset={"id": "sokoban", "name": "Sokoban", "version": "1.0.0"},
+        rubric={"version": "1", "criteria_count": 1, "source": "inline"},
+        inference={"supports_proxy": False},
+        capabilities={"supports_rollout": True, "supports_env_lifecycle": True},
+        limits={"max_turns": 200},
+    )
+
+
+class SokobanTaskSet:
+    """Minimal helper compatible with Task App expectations."""
+
+    def __init__(self) -> None:
+        self._taskset: TaskInstanceSet | None = None
+        self._seed_index: dict[int, SokobanTaskInstance] = {}
+        self._base_info = _base_task_info_template()
+
+    async def _ensure_loaded(self) -> TaskInstanceSet:
+        if self._taskset is None:
+            dataset = await create_sokoban_taskset()
+            self._taskset = dataset
+            self._seed_index.clear()
+            for inst in dataset.instances:
+                try:
+                    seed_value = int(getattr(inst.metadata, "seed"))
+                except Exception:
+                    continue
+                # Keep the first instance encountered for a seed
+                self._seed_index.setdefault(seed_value, inst)
+        return self._taskset
+
+    def describe(self) -> dict[str, object]:
+        if not self._taskset:
+            return {"id": "sokoban", "name": "Sokoban"}
+        return {
+            "id": "sokoban",
+            "name": self._taskset.name,
+            "description": self._taskset.description,
+            "instance_count": len(self._taskset.instances),
+        }
+
+    async def provide_task_instances(self, seeds: Sequence[int]) -> Iterable[TaskInfo]:
+        await self._ensure_loaded()
+        if not seeds:
+            return []
+
+        infos: list[TaskInfo] = []
+        for raw_seed in seeds:
+            try:
+                seed_value = int(raw_seed)
+            except Exception:
+                continue
+
+            instance = self._seed_index.get(seed_value)
+            if instance is None:
+                # Attempt to construct on the fly; try configured difficulties in order
+                for difficulty in DIFFICULTY_CONFIGS:
+                    try:
+                        instance = await create_task_instance_from_seed(difficulty, seed_value)
+                        break
+                    except Exception:
+                        continue
+                if instance is None:
+                    continue
+                self._seed_index[seed_value] = instance
+
+            metadata = getattr(instance, "metadata", None)
+            base_info = self._base_info.model_copy(deep=True)
+
+            observation = dict(base_info.observation)
+            dataset_info = dict(base_info.dataset)
+            task_metadata = {"seed": seed_value}
+
+            if metadata is not None:
+                for key in ("difficulty", "num_boxes", "dim_room", "max_steps", "shortest_path_length"):
+                    value = getattr(metadata, key, None)
+                    if value is not None:
+                        observation[key] = value
+                        task_metadata[key] = value
+                dataset_info.update(
+                    {
+                        "seed": getattr(metadata, "seed", seed_value),
+                        "difficulty": getattr(metadata, "difficulty", None),
+                        "num_boxes": getattr(metadata, "num_boxes", None),
+                        "dim_room": getattr(metadata, "dim_room", None),
+                    }
+                )
+                generation_params = getattr(metadata, "generation_params", None)
+                if generation_params is not None:
+                    task_metadata["generation_params"] = generation_params
+
+            infos.append(
+                base_info.model_copy(
+                    update={
+                        "observation": observation,
+                        "dataset": dataset_info,
+                        "task_metadata": task_metadata,
+                    }
+                )
+            )
+        return infos
+
+
 async def create_sokoban_taskset() -> TaskInstanceSet:
     """Generates Sokoban task instances from pre-generated verified puzzles."""
     instances = []

synth_ai/environments/examples/verilog/engine.py

@@ -46,7 +46,7 @@ class VerilogCompileSuccessComponent(RewardComponent):
         if hasattr(action, "get") and action.get("type") == "compile":
             # Check if compilation was successful (returncode 0)
             if action.get("returncode") == 0:
-                return 0.1
+                return 0.01  # Normalized: 0.1 / 10.0 = 0.01
         return 0.0
 
 
@@ -55,24 +55,37 @@ class VerilogSimulationPassComponent(RewardComponent):
         if hasattr(action, "get") and action.get("type") == "simulate":
             # Check if simulation passed
             if action.get("passed", False):
-                return 1.0
+                return 0.1  # Normalized: 1.0 / 10.0 = 0.1
         return 0.0
 
 
 class VerilogStepPenaltyComponent(RewardComponent):
-    def __init__(self, penalty: float = -0.01):
+    def __init__(self, penalty: float = 0.0):  # No per-step reward - only reward accomplishments
         self.penalty = penalty
 
     async def score(self, state: Any, action: Any) -> float:
         return self.penalty
 
 
+class VerilogSubmitSuccessComponent(RewardComponent):
+    """Reward for successful submission (tests passed). Max reward = 1.0 (normalized)."""
+    async def score(self, state: VerilogPublicState, action: Any) -> float:
+        if hasattr(action, "get") and action.get("type") == "submit":
+            # Check if submission passed
+            if action.get("passed", False):
+                return 1.0  # Normalized: Maximum reward is now 1.0
+        return 0.0
+
+
 class VerilogEngine(StatefulEngine):
     """
     Stateful Verilog evaluation engine with persistent artifact snapshots.
     """
 
     def __init__(self, task_instance: TaskInstance):
+        # Validate required Verilog tools are available
+        self._validate_verilog_tools()
+        
         self.task_instance = task_instance
         self._total_reward = 0.0
         self._current_action_for_reward: Optional[Dict[str, Any]] = None
@@ -81,7 +94,8 @@ class VerilogEngine(StatefulEngine):
             components=[
                 VerilogCompileSuccessComponent(),
                 VerilogSimulationPassComponent(),
-                VerilogStepPenaltyComponent(penalty=-0.01),
+                VerilogSubmitSuccessComponent(),
+                VerilogStepPenaltyComponent(penalty=0.0),  # No per-step reward
             ]
         )
 
@@ -92,6 +106,39 @@ class VerilogEngine(StatefulEngine):
         # Track last compile/simulate outputs
         self._last_compile_output: Optional[str] = None
         self._last_simulate_output: Optional[str] = None
+    
+    @staticmethod
+    def _validate_verilog_tools() -> None:
+        """Validate that required Verilog tools (iverilog, vvp) are available."""
+        missing_tools = []
+        
+        if not shutil.which("iverilog"):
+            missing_tools.append("iverilog")
+        if not shutil.which("vvp"):
+            missing_tools.append("vvp")
+        
+        if missing_tools:
+            error_msg = (
+                f"🚨🚨🚨 CRITICAL CONFIGURATION ERROR 🚨🚨🚨\n"
+                f"\n"
+                f"Missing required Verilog tools: {', '.join(missing_tools)}\n"
+                f"\n"
+                f"The Verilog environment CANNOT function without these tools.\n"
+                f"ALL compile/simulate operations will FAIL.\n"
+                f"ALL rewards will be ZERO.\n"
+                f"Training or evaluation will be COMPLETELY BROKEN.\n"
+                f"\n"
+                f"🔧 FIX THIS NOW:\n"
+                f"1. Add 'iverilog' to apt_packages in Modal deployment config\n"
+                f"2. Location: examples/task_apps/verilog/task_app/grpo_verilog.py\n"
+                f"3. Look for: modal=ModalDeploymentConfig(\n"
+                f"4. Add: apt_packages=('iverilog',)  # Provides both iverilog and vvp\n"
+                f"5. Redeploy: uvx synth-ai modal-serve grpo-verilog\n"
+                f"\n"
+                f"{'='*80}"
+            )
+            print(f"\n{'='*80}\n{error_msg}\n{'='*80}\n", flush=True)
+            raise RuntimeError(error_msg)
 
     async def _reset_engine(
         self, *, seed: Optional[int] = None
@@ -122,6 +169,13 @@ class VerilogEngine(StatefulEngine):
     ) -> Tuple[VerilogPrivateState, VerilogPublicState]:
         """Process an action result and update engine state."""
         self._current_action_for_reward = action_result
+        
+        # DEBUG: Print action_result
+        print(f"\n[ENGINE DEBUG] _step_engine called")
+        print(f"  action_result: {action_result}")
+        print(f"  action_result.type: {action_result.get('type')}")
+        print(f"  action_result.returncode: {action_result.get('returncode')}")
+        print(f"  action_result.ok: {action_result.get('ok')}")
 
         # Update last outputs if this is a compile or simulate action
         if action_result.get("type") == "compile":
@@ -136,18 +190,21 @@ class VerilogEngine(StatefulEngine):
         current_pub_state = VerilogPublicState(
             files=self._get_file_contents(),
             build_dir=str(self.build_dir),
-            task_completed=action_result.get("passed", False),
+            task_completed=action_result.get("submitted", False) and action_result.get("passed", False),
         )
 
         reward_from_stack = await self.reward_stack.step_reward(
             state=current_pub_state, action=self._current_action_for_reward
         )
         self._current_action_for_reward = None
+        
+        # DEBUG: Print reward
+        print(f"[ENGINE DEBUG] reward_from_stack: {reward_from_stack}")
 
         self._total_reward += reward_from_stack
 
-        # Check termination conditions
-        terminated = action_result.get("passed", False) or action_result.get("submitted", False)
+        # Check termination conditions - only terminate if submitted (regardless of pass/fail)
+        terminated = action_result.get("submitted", False)
 
         priv = VerilogPrivateState(
             reward_last=reward_from_stack,
@@ -159,7 +216,7 @@ class VerilogEngine(StatefulEngine):
         pub = VerilogPublicState(
             files=self._get_file_contents(),
             build_dir=str(self.build_dir),
-            task_completed=action_result.get("passed", False),
+            task_completed=action_result.get("submitted", False) and action_result.get("passed", False),
             last_compile_output=self._last_compile_output,
             last_simulate_output=self._last_simulate_output,
         )
@@ -248,6 +305,16 @@ class VerilogEngine(StatefulEngine):
             }
         except subprocess.TimeoutExpired:
             return {"ok": False, "error": "Compilation timeout", "type": "compile"}
+        except FileNotFoundError:
+            error_msg = (
+                "🚨 CRITICAL ERROR: 'iverilog' executable not found! 🚨\n"
+                "The Verilog compiler (iverilog) is not installed in this environment.\n"
+                "This will cause ALL compile operations to fail and result in ZERO rewards.\n"
+                "Fix: Add 'iverilog' to apt_packages in the Modal deployment config.\n"
+                "Location: examples/task_apps/verilog/task_app/grpo_verilog.py -> modal=ModalDeploymentConfig(apt_packages=('iverilog',))"
+            )
+            print(f"\n{'='*80}\n{error_msg}\n{'='*80}\n", flush=True)
+            raise RuntimeError(error_msg) from None
         except Exception as e:
             return {"ok": False, "error": str(e), "type": "compile"}
 
@@ -279,18 +346,43 @@ class VerilogEngine(StatefulEngine):
             }
         except subprocess.TimeoutExpired:
             return {"ok": False, "error": "Simulation timeout", "type": "simulate"}
+        except FileNotFoundError:
+            error_msg = (
+                "🚨 CRITICAL ERROR: 'vvp' executable not found! 🚨\n"
+                "The Verilog simulator (vvp) is not installed in this environment.\n"
+                "This will cause ALL simulate operations to fail and result in ZERO rewards.\n"
+                "Fix: Add 'iverilog' to apt_packages in the Modal deployment config (provides both iverilog and vvp).\n"
+                "Location: examples/task_apps/verilog/task_app/grpo_verilog.py -> modal=ModalDeploymentConfig(apt_packages=('iverilog',))"
+            )
+            print(f"\n{'='*80}\n{error_msg}\n{'='*80}\n", flush=True)
+            raise RuntimeError(error_msg) from None
         except Exception as e:
             return {"ok": False, "error": str(e), "type": "simulate"}
 
     async def submit(self) -> Dict[str, Any]:
         """Submit solution for grading."""
-        # For now, simple check based on last simulation
-        # In a full implementation, this would call the task's verify method
+        # Check if the last simulation passed
+        # Parse the last simulation output to determine if tests passed
+        passed = False
+        detail = "No simulation run yet"
+        
+        if self._last_simulate_output:
+            stdout = self._last_simulate_output
+            passed = (
+                "ALL_TESTS_PASSED" in stdout
+                or ("Mismatches: 0 " in stdout and "samples" in stdout)
+                or ("no mismatches" in stdout.lower() and "errors" not in stdout.lower())
+            )
+            if passed:
+                detail = "All tests passed"
+            else:
+                detail = "Tests failed - please review simulation output"
+        
         return {
             "ok": True,
             "type": "submit",
-            "passed": True,  # Placeholder
-            "detail": "Submission processed",
+            "passed": passed,
+            "detail": detail,
             "submitted": True,
         }
 

synth_ai/environments/examples/wordle/environment.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 from typing import Any
 
 from pydantic import BaseModel, Field
-
 from synth_ai.environments.environment.shared_engine import (
     GetObservationCallable,
     InternalObservation,

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