synth-ai 0.2.13.dev1__py3-none-any.whl → 0.2.14__py3-none-any.whl

synth_ai/cli/traces.py

@@ -11,7 +11,7 @@ from rich import box
 from rich.console import Console
 from rich.table import Table
 
-from ._storage import load_storage
+from synth_ai.cli._storage import load_storage
 
 
 def register(cli):

synth_ai/cli/tui.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+CLI: Interactive TUI dashboard for Synth AI.
+"""
+
+import os
+
+import click
+from rich.console import Console
+
+
+def register(cli):
+    @cli.command()
+    @click.option(
+        "--url",
+        "db_url",
+        default="sqlite+libsql://http://127.0.0.1:8080",
+        help="Database URL (default: sqlite+libsql://http://127.0.0.1:8080)",
+    )
+    @click.option("--debug", is_flag=True, help="Enable debug logging")
+    def tui(db_url: str, debug: bool):
+        """Launch interactive TUI dashboard showing experiments, balance, and active runs."""
+        console = Console()
+
+        # Import here to avoid circular imports and handle optional dependencies
+        try:
+            from synth_ai.tui.dashboard import main as tui_main
+        except (ImportError, ModuleNotFoundError) as e:
+            console.print("[red]Error:[/red] TUI dashboard not available.")
+            console.print(f"Missing dependencies: {e}")
+            console.print("Install with: pip install textual")
+            return
+        except Exception as e:
+            # Handle other import errors (like missing libsql, type annotation issues, etc.)
+            console.print("[red]Error:[/red] TUI dashboard not available.")
+            console.print("This may be due to missing dependencies or Python version compatibility.")
+            console.print("Try: pip install textual libsql")
+            console.print("If using Python < 3.10, you may need to update Python or install eval_type_backport.")
+            return
+
+        # Set environment variables for the TUI to use
+        os.environ.setdefault("TUI_DB_URL", db_url)
+        if debug:
+            os.environ["TUI_DEBUG"] = "1"
+
+        # Run the TUI by calling the module directly with sanitized argv
+        try:
+            tui_args = ["--url", db_url]
+            if debug:
+                tui_args.append("--debug")
+            tui_main(tui_args)
+        except KeyboardInterrupt:
+            console.print("\n[blue]TUI closed.[/blue]")
+        except Exception as e:
+            console.print(f"\n[red]Error running TUI:[/red] {e}")
+            if debug:
+                raise

synth_ai/cli/turso.py

@@ -6,7 +6,7 @@ import subprocess
 
 import click
 
-from .root import SQLD_VERSION, find_sqld_binary, install_sqld
+from synth_ai.cli.root import SQLD_VERSION, find_sqld_binary, install_sqld
 
 
 def register(cli: click.Group) -> None:

synth_ai/cli/watch.py

@@ -16,7 +16,7 @@ from rich.console import Console, Group
 from rich.panel import Panel
 from rich.table import Table
 
-from ._storage import load_storage
+from synth_ai.cli._storage import load_storage
 
 
 def _open_db(db_url: str):

synth_ai/demos/demo_task_apps/crafter/grpo_crafter_task_app.py

@@ -1,7 +1,7 @@
 """Compatibility wrapper for the GRPO Crafter task app.
 
 This module now delegates to the TaskAppConfig defined in the local example at
-`examples/warming_up_to_rl/task_app/grpo_crafter.py`. It is kept for legacy usage
+`examples/task_apps/crafter/task_app/grpo_crafter.py`. It is kept for legacy usage
 (running the file directly or targeting `fastapi_app` from external tooling).
 Prefer using `uvx synth-ai serve grpo-crafter` for local development and testing.
 """
@@ -21,31 +21,43 @@ from synth_ai.task.server import TaskAppConfig, create_task_app, run_task_app
 
 
 def _load_build_config():
-    # Find synth_ai package location to locate examples/
-    import synth_ai
+    """Load the example's build_config, preferring package import with file fallback."""
+    # First try to import by package name (installed 'examples' package)
+    try:
+        module = importlib.import_module("examples.task_apps.crafter.task_app.grpo_crafter")
+        return module.build_config  # type: ignore[attr-defined]
+    except Exception:
+        # Fallback: locate the file within the installed synth_ai distribution and exec it
+        import sys as _sys
+
+        import synth_ai
+
+        synth_ai_path = Path(synth_ai.__file__).resolve().parent.parent
+        module_path = (
+            synth_ai_path / "examples" / "task_apps" / "crafter" / "task_app" / "grpo_crafter.py"
+        )
 
-    synth_ai_path = Path(synth_ai.__file__).resolve().parent.parent
-    module_path = synth_ai_path / "examples" / "warming_up_to_rl" / "task_app" / "grpo_crafter.py"
+        if not module_path.exists():
+            raise ImportError(
+                f"Could not find task app module at {module_path}. Make sure you're running from the synth-ai repository."
+            ) from None
 
-    if not module_path.exists():
-        raise ImportError(
-            f"Could not find task app module at {module_path}. Make sure you're running from the synth-ai repository."
+        spec = importlib.util.spec_from_file_location(
+            "examples.task_apps.crafter.task_app.grpo_crafter", module_path
         )
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load task app module at {module_path}") from None
 
-    spec = importlib.util.spec_from_file_location(
-        "warming_up_to_rl.task_app.grpo_crafter", module_path
-    )
-    if spec is None or spec.loader is None:
-        raise ImportError(f"Could not load task app module at {module_path}")
-    module = importlib.util.module_from_spec(spec)
-    spec.loader.exec_module(module)
-    return module.build_config
+        module = importlib.util.module_from_spec(spec)
+        _sys.modules[spec.name] = module
+        spec.loader.exec_module(module)
+        return module.build_config  # type: ignore[attr-defined]
 
 
 build_config = _load_build_config()
 
 
-APP_ID = "grpo-crafter"
+APP_ID = "grpo-crafter-task-app"
 
 
 def _build_base_config() -> TaskAppConfig:

synth_ai/environments/examples/crafter_classic/environment.py

@@ -397,7 +397,7 @@ class CrafterClassicEnvironment(StatefulEnvironment, ReproducibleEnvironment[Cra
             priv_state, pub_state, self.custom_step_observation_callable
         )
         total_step_time = time.time() - step_start_time
-        logger.info(
+        logger.debug(
             f"CrafterClassic step completed in {total_step_time:.3f}s (interact: {interact_time:.3f}s)"
         )
         return obs

synth_ai/environments/examples/enron/engine.py

@@ -26,7 +26,10 @@ from synth_ai.environments.examples.enron.taskset import EnronTaskInstance
 
 # SQLite-backed helpers
 from synth_ai.environments.stateful.engine import StatefulEngine, StatefulEngineSnapshot
-from synth_ai.zyk import LM  # Import LM class
+try:  # pragma: no cover - optional dependency
+    from synth_ai.zyk import LM  # type: ignore
+except ImportError:  # pragma: no cover - fallback when LM unavailable
+    LM = None
 
 # --------------------------------------------------------------------------- actions
 ACTION_SEARCH = "search"
@@ -244,7 +247,9 @@ class EnronEngine(StatefulEngine):
 async def determine_if_answer_is_correct(
     question: str, gold_answer: str, agent_answer: str
 ) -> bool:
-    # Instantiate LM for the judge
+    if LM is None:
+        return gold_answer.strip().lower() == agent_answer.strip().lower()
+
     llm = LM(model_name="gpt-4.1-nano", formatting_model_name="gpt-4.1-nano", temperature=0.0)
 
     system_prompt = (

synth_ai/environments/examples/enron/environment.py

@@ -9,6 +9,7 @@ from synth_ai.environments.environment.shared_engine import (
     InternalObservation,
 )
 from synth_ai.environments.environment.tools import (
+    AbstractTool,
     TOOL_REGISTRY,
     EnvToolCall,
     ToolResult,
@@ -65,6 +66,73 @@ class Terminate(EnvToolCall):
         self.action = (ACTION_ANSWER, "")
 
 
+class TerminateArgs(BaseModel):
+    pass
+
+
+class SearchEmailsTool(AbstractTool):
+    name = "search_emails"
+    call_schema = SearchEmailsArgs
+
+    def __init__(self, engine: EnronEngine):
+        self.engine = engine
+
+    async def __call__(self, call: EnvToolCall) -> ToolResult:
+        try:
+            args = self.call_schema.model_validate(call.args or {})
+            results = await self.engine.search_emails_action(args.model_dump())
+            return ToolResult(ok=True, payload={"search_results": results})
+        except Exception as exc:  # pragma: no cover - runtime safety
+            return ToolResult(ok=False, error=str(exc))
+
+
+class ReadEmailTool(AbstractTool):
+    name = "read_email"
+    call_schema = ReadEmailArgs
+
+    def __init__(self, engine: EnronEngine):
+        self.engine = engine
+
+    async def __call__(self, call: EnvToolCall) -> ToolResult:
+        try:
+            args = self.call_schema.model_validate(call.args or {})
+            email = await self.engine.read_email_action(args.message_id)
+            return ToolResult(ok=True, payload={"email": email})
+        except Exception as exc:  # pragma: no cover
+            return ToolResult(ok=False, error=str(exc))
+
+
+class AnswerQuestionTool(AbstractTool):
+    name = "answer_question"
+    call_schema = AnswerQuestionArgs
+
+    def __init__(self, engine: EnronEngine):
+        self.engine = engine
+
+    async def __call__(self, call: EnvToolCall) -> ToolResult:
+        try:
+            args = self.call_schema.model_validate(call.args or {})
+            await self.engine.answer_question_action(args.answer)
+            return ToolResult(ok=True, payload={"status": "answer_recorded"})
+        except Exception as exc:  # pragma: no cover
+            return ToolResult(ok=False, error=str(exc))
+
+
+class TerminateTool(AbstractTool):
+    name = "terminate"
+    call_schema = TerminateArgs
+
+    def __init__(self, engine: EnronEngine):
+        self.engine = engine
+
+    async def __call__(self, call: EnvToolCall) -> ToolResult:
+        try:
+            await self.engine.answer_question_action("")
+            return ToolResult(ok=True, payload={"status": "terminated"})
+        except Exception as exc:  # pragma: no cover
+            return ToolResult(ok=False, error=str(exc))
+
+
 # -------- observation callable (optional for formatted observations)
 class SynthEnronObservationCallable(GetObservationCallable):
     async def get_observation(

synth_ai/environments/examples/red/engine.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
+import os
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
@@ -122,6 +123,13 @@ class GameSystemState:
     menu_state: int
     text_box_active: bool
     warp_flag: int
+    # Battle-specific data
+    enemy_hp_current: int = 0
+    enemy_hp_max: int = 0
+    enemy_hp_percentage: float = 0.0
+    enemy_level: int = 0
+    enemy_species_id: int = 0
+    battle_turn: int = 0
     # TODO: Add when available
     # current_menu_type: str = ""
     # dialogue_speaker: str = ""
@@ -278,12 +286,21 @@ class PokemonRedEngine(StatefulEngine, IReproducibleEngine):
 
     def _get_rom_path(self) -> Path:
         """Get path to Pokemon Red ROM file"""
+        # Highest priority: explicit environment variable
+        env_rom = os.getenv("POKEMON_RED_ROM")
+        if env_rom:
+            p = Path(env_rom).expanduser()
+            if p.exists():
+                return p
+
         # Check several possible locations
         possible_paths = [
             Path(__file__).parent / "roms" / "pokemon_red.gb",
             Path(__file__).parent / "roms" / "PokemonRed.gb",
             Path(__file__).parent / "vendor" / "pokemon_red.gb",
             Path.home() / "Games" / "pokemon_red.gb",
+            # Common example location where users may drop the ROM
+            Path(__file__).resolve().parents[5] / "examples" / "task_apps" / "pokemon_red" / "Pokemon - Red Version (USA, Europe) (SGB Enhanced).gb",
         ]
 
         for path in possible_paths:
@@ -533,6 +550,12 @@ class PokemonRedEngine(StatefulEngine, IReproducibleEngine):
                     menu_state=int(current_state.get("menu_state", 0)),
                     text_box_active=bool(current_state.get("text_box_active", False)),
                     warp_flag=int(current_state.get("warp_flag", 0)),
+                    enemy_hp_current=int(current_state.get("enemy_hp_current", 0)),
+                    enemy_hp_max=int(current_state.get("enemy_hp_max", 0)),
+                    enemy_hp_percentage=float(current_state.get("enemy_hp_percentage", 0.0)),
+                    enemy_level=int(current_state.get("enemy_level", 0)),
+                    enemy_species_id=int(current_state.get("enemy_species_id", 0)),
+                    battle_turn=int(current_state.get("battle_turn", 0)),
                 ),
             )
 
@@ -613,6 +636,10 @@ class PokemonRedEngine(StatefulEngine, IReproducibleEngine):
                         "prev_in_battle": bool(prev_state.get("in_battle", False)),
                         "prev_party_level": int(prev_state.get("party_level", 0)),
                         "prev_party_xp": int(prev_state.get("party_xp", 0)),
+                        "prev_party_count": int(prev_state.get("party_count", 0)),
+                        "prev_text_box_active": bool(prev_state.get("text_box_active", False)),
+                        "prev_enemy_hp_current": int(prev_state.get("enemy_hp_current", 0)),
+                        "prev_enemy_hp_percentage": float(prev_state.get("enemy_hp_percentage", 0.0)),
                     },
                 )
             except Exception as e:

synth_ai/environments/examples/red/engine_helpers/memory_map.py

@@ -6,6 +6,13 @@ PLAYER_Y = 0xD361  # player Y coordinate
 IN_BATTLE_FLAG = 0xD057  # battle state flag
 BATTLE_OUTCOME = 0xD089  # 0=ongoing, 1=win, 2=lose
 
+# Battle-specific data
+ENEMY_HP_CURRENT = 0xCFE6  # enemy Pokemon current HP (2 bytes)
+ENEMY_HP_MAX = 0xCFE8  # enemy Pokemon max HP (2 bytes)
+ENEMY_LEVEL = 0xD127  # enemy Pokemon level
+ENEMY_SPECIES = 0xCFE5  # enemy Pokemon species ID
+BATTLE_TURN = 0xCC2F  # current battle turn counter
+
 # Party Pokemon data (up to 6 Pokemon)
 PARTY_COUNT = 0xD163  # number of Pokemon in party (0-6)
 PARTY_SPECIES = 0xD164  # species of each Pokemon (6 bytes)