synth-ai 0.2.8.dev4__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/demos/math/task_app_entry.py

@@ -0,0 +1,51 @@
+"""Task app registry entry for the math demo Modal deployment."""
+
+from __future__ import annotations
+
+from contextlib import suppress
+from importlib import import_module
+
+from synth_ai.task.apps import ModalDeploymentConfig, TaskAppEntry, register_task_app
+
+try:
+    from synth_ai.task.apps.math_single_step import build_config as base_build_config
+except ModuleNotFoundError:
+    base_module = import_module("examples.rl.task_app.math_single_step")
+    base_build_config = base_module.build_config
+
+DEMO_MODAL_CONFIG = ModalDeploymentConfig(
+    app_name="hendrycks-math-task-app",
+    pip_packages=(
+        "fastapi>=0.110.0",
+        "uvicorn>=0.23.0",
+        "pydantic>=2.6.0",
+        "httpx>=0.24.0",
+        "numpy>=1.24.0",
+        "aiohttp>=3.8.0",
+        "datasets>=2.16.0",
+        "synth-ai",
+    ),
+)
+
+
+def build_config():
+    """Reuse the shared math single-step TaskAppConfig."""
+
+    return base_build_config()
+
+
+def register_demo_entry() -> None:
+    entry = TaskAppEntry(
+        app_id="hendrycks-math-demo",
+        description="Demo math task app (Modal-focused) shipping with synth-ai demos.",
+        config_factory=build_config,
+        modal=DEMO_MODAL_CONFIG,
+    )
+    with suppress(ValueError):
+        register_task_app(entry=entry)
+
+
+register_demo_entry()
+
+
+__all__ = ["DEMO_MODAL_CONFIG", "build_config", "register_demo_entry"]

synth_ai/environments/environment/core.py

@@ -1,4 +1,10 @@
-from synth_ai.core.system import System
+class System:
+    """Minimal base data structure shared by environment types."""
+
+    id: str
+    name: str
+    description: str
+    pass
 
 
 class Environment(System):

synth_ai/environments/examples/bandit/engine.py

@@ -4,7 +4,6 @@ from dataclasses import dataclass
 from typing import Any
 
 import numpy as np
-
 from synth_ai.environments.environment.shared_engine import (
     GetObservationCallable,
     InternalObservation,
@@ -191,7 +190,9 @@ class BanditEngine(StatefulEngine, IReproducibleEngine):
             step_count=self.step_count,
             max_steps=self.max_steps,
             last_arm=self.last_arm,
-            last_reward=float(reward) if reward is not None else (self.last_reward if self.step_count else None),
+            last_reward=float(reward)
+            if reward is not None
+            else (self.last_reward if self.step_count else None),
             cumulative_reward=float(self.total_reward),
             reward_history=self.reward_history.copy(),
             arm_pull_counts=self.arm_pull_counts.copy(),
@@ -238,7 +239,9 @@ class BanditEngine(StatefulEngine, IReproducibleEngine):
         engine.arm_probabilities = data.get("arm_probabilities", engine.arm_probabilities)
         engine.arm_means = data.get("arm_means", engine.arm_means)
         engine.arm_stds = data.get("arm_stds", engine.arm_stds)
-        engine.true_expected_rewards = list(data.get("true_expected_rewards", engine.true_expected_rewards))
+        engine.true_expected_rewards = list(
+            data.get("true_expected_rewards", engine.true_expected_rewards)
+        )
         engine.arm_count = len(engine.true_expected_rewards)
 
         engine.step_count = int(data.get("step_count", 0))
@@ -247,7 +250,9 @@ class BanditEngine(StatefulEngine, IReproducibleEngine):
         engine.last_arm = data.get("last_arm")
         engine.reward_history = list(data.get("reward_history", []))
         engine.arm_history = list(data.get("arm_history", []))
-        engine.arm_pull_counts = list(data.get("arm_pull_counts", [0 for _ in range(engine.arm_count)]))
+        engine.arm_pull_counts = list(
+            data.get("arm_pull_counts", [0 for _ in range(engine.arm_count)])
+        )
         engine.terminated = bool(data.get("terminated", False))
         engine.status = data.get("status", "in_progress")
 
@@ -287,7 +292,9 @@ class SynthBanditCheckpointObservationCallable(GetObservationCallable):
             "arm_count": pub.arm_count,
             "total_reward": priv.total_reward,
             "steps_taken": pub.step_count,
-            "best_expected_reward": max(priv.true_expected_rewards) if priv.true_expected_rewards else None,
+            "best_expected_reward": max(priv.true_expected_rewards)
+            if priv.true_expected_rewards
+            else None,
             "terminated": pub.terminated,
             "status": pub.status,
         }

synth_ai/environments/examples/bandit/environment.py

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

synth_ai/environments/examples/bandit/taskset.py

@@ -156,10 +156,10 @@ async def create_bandit_taskset(
         )
 
         expected = _expected_rewards(metadata)
-        arm_count = len(expected) if expected else (
-            len(metadata.arm_probabilities or [])
-            or len(metadata.arm_means or [])
-            or 0
+        arm_count = (
+            len(expected)
+            if expected
+            else (len(metadata.arm_probabilities or []) or len(metadata.arm_means or []) or 0)
         )
         if arm_count == 0:
             arm_count = 1

synth_ai/environments/examples/crafter_classic/engine_deterministic_patch.py

@@ -6,16 +6,18 @@ the hash-based set-iteration nondeterminism that caused the drift.
 """
 
 import collections
+import os
 
 import crafter
 
-print("[PATCH] Attempting to apply Crafter deterministic patch...")
+# Patch messages permanently disabled to reduce noise
+# print("[PATCH] Attempting to apply Crafter deterministic patch...")
 
 # -----------------------------------------------------------------------------
 # 1.  Make per–chunk object order stable
 # -----------------------------------------------------------------------------
 if not hasattr(crafter.Env, "_orig_balance_object"):
-    print("[PATCH] Patching crafter.Env._balance_object...")
+    # print("[PATCH] Patching crafter.Env._balance_object...")
     crafter.Env._orig_balance_object = crafter.Env._balance_object
 
     def _balance_object_det(self, chunk, objs, *args, **kwargs):
@@ -25,9 +27,10 @@ if not hasattr(crafter.Env, "_orig_balance_object"):
         return crafter.Env._orig_balance_object(self, chunk, objs, *args, **kwargs)
 
     crafter.Env._balance_object = _balance_object_det
-    print("[PATCH] crafter.Env._balance_object patched.")
+    # print("[PATCH] crafter.Env._balance_object patched.")
 else:
-    print("[PATCH] crafter.Env._balance_object already patched or _orig_balance_object exists.")
+    pass
+    # print("[PATCH] crafter.Env._balance_object already patched or _orig_balance_object exists.")
 
 # -----------------------------------------------------------------------------
 # 2.  Make *chunk* iteration order stable

synth_ai/environments/examples/crafter_classic/engine_serialization_patch_v3.py

@@ -4,6 +4,7 @@ This version handles player references for Zombie and Skeleton objects.
 """
 
 import collections
+import os
 import pickle
 from typing import Any, Dict, Optional, Set
 
@@ -11,11 +12,12 @@ import crafter
 import numpy as np
 from crafter import objects
 
-print("[PATCH] Attempting to apply Crafter serialization patch v3...")
+# Patch messages permanently disabled
+# print("[PATCH] Attempting to apply Crafter serialization patch v3...")
 
 # Check if already patched
 if not hasattr(crafter.Env, "save"):
-    print("[PATCH] Adding enhanced save/load methods to crafter.Env...")
+    # print("[PATCH] Adding enhanced save/load methods to crafter.Env...")
 
     def _save(self) -> Dict[str, Any]:
         """Save complete environment state including all details."""
@@ -260,8 +262,10 @@ if not hasattr(crafter.Env, "save"):
     crafter.Env.save = _save
     crafter.Env.load = _load
 
-    print("[PATCH] crafter.Env.save() and load() methods added (v3).")
+    pass
+    # print("[PATCH] crafter.Env.save() and load() methods added (v3).")
 else:
-    print("[PATCH] crafter.Env already has save/load methods.")
+    pass
+    # print("[PATCH] crafter.Env already has save/load methods.")
 
-print("[PATCH] Crafter serialization patch v3 complete.")
+# print("[PATCH] Crafter serialization patch v3 complete.")

synth_ai/environments/examples/crafter_classic/environment.py

@@ -2,11 +2,16 @@
 
 from __future__ import annotations
 
+import base64
 import dataclasses
 import logging
 import time
+from io import BytesIO
 from typing import Any, Dict, List, Optional, Union
 
+import numpy as np
+from PIL import Image
+
 # Import tracing abstractions
 from synth_ai.tracing_v3.abstractions import (
     RuntimeEvent,
@@ -43,6 +48,51 @@ from synth_ai.environments.reproducibility.core import ReproducibleEnvironment
 from synth_ai.environments.stateful.core import StatefulEnvironment
 
 
+def _convert_numpy_to_python(obj: Any) -> Any:
+    if isinstance(obj, np.integer):
+        return int(obj)
+    if isinstance(obj, np.floating):
+        return float(obj)
+    if isinstance(obj, np.ndarray):
+        return obj.tolist()
+    if isinstance(obj, dict):
+        return {k: _convert_numpy_to_python(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_convert_numpy_to_python(item) for item in obj]
+    return obj
+
+
+def _encode_image_to_base64(image_array: Any) -> dict[str, Any] | None:
+    if not isinstance(image_array, np.ndarray):
+        return None
+    if image_array.ndim != 3 or image_array.shape[-1] not in (1, 3, 4):
+        return None
+    try:
+        array_uint8 = (
+            image_array.astype("uint8")
+            if image_array.dtype != np.uint8
+            else image_array  # pragma: no cover - fast path
+        )
+        mode = "L" if array_uint8.shape[-1] == 1 else "RGB"
+        if array_uint8.shape[-1] == 4:
+            mode = "RGBA"
+        img = Image.fromarray(array_uint8, mode=mode)
+        buffer = BytesIO()
+        img.save(buffer, format="PNG")
+        encoded = base64.b64encode(buffer.getvalue()).decode("ascii")
+        width = int(array_uint8.shape[1])
+        height = int(array_uint8.shape[0])
+        return {
+            "format": "png",
+            "width": width,
+            "height": height,
+            "data": encoded,
+            "data_url": f"data:image/png;base64,{encoded}",
+        }
+    except Exception:
+        return None
+
+
 # --- Tool Definition ---
 class CrafterActionInput(BaseModel):
     action: int = Field(..., description="Integer action for the Crafter environment.")
@@ -140,6 +190,22 @@ class SynthCrafterObservationCallable(GetObservationCallable):
         obs_dict["truncated"] = priv.truncated
         if pub.error_info:
             obs_dict["tool_error"] = pub.error_info
+        counts_payload = {}
+        try:
+            counts = getattr(priv, "achievements_current_values", {}) or {}
+            for k, v in counts.items():
+                try:
+                    counts_payload[str(k)] = int(v)
+                except Exception:
+                    try:
+                        counts_payload[str(k)] = int(float(v))
+                    except Exception:
+                        continue
+            if counts_payload:
+                obs_dict["achievements_counts"] = counts_payload
+        except Exception:
+            # Best effort; omit counts if coercion fails
+            pass
 
         # Derive a simple local semantic patch around the player for easy rendering
         try:
@@ -331,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
@@ -362,7 +428,8 @@ class CrafterClassicEnvironment(StatefulEnvironment, ReproducibleEnvironment[Cra
         state_before = {"private_state": priv, "public_state": pub}
 
         active_obs_cb = obs_cb or SynthCrafterObservationCallable()
-        observation = await active_obs_cb.get_observation(pub, priv)
+        raw_observation = await active_obs_cb.get_observation(pub, priv)
+        observation = self._prepare_observation(raw_observation)
         if extra_obs and isinstance(observation, dict):
             observation.update(extra_obs)
 
@@ -385,6 +452,30 @@ class CrafterClassicEnvironment(StatefulEnvironment, ReproducibleEnvironment[Cra
 
         return observation
 
+    def _prepare_observation(self, observation: Any) -> dict[str, Any]:
+        obs_dict: dict[str, Any]
+        image_payload: dict[str, Any] | None = None
+
+        if isinstance(observation, dict):
+            image_payload = _encode_image_to_base64(observation.get("observation_image"))
+            sanitized = dict(observation)
+            sanitized.pop("observation_image", None)
+            obs_dict = _convert_numpy_to_python(sanitized) or {}
+        else:
+            obs_dict = _convert_numpy_to_python(observation) or {}
+
+        if not isinstance(obs_dict, dict):
+            obs_dict = {"value": obs_dict}
+
+        if image_payload:
+            obs_dict["observation_image_base64"] = image_payload["data"]
+            obs_dict["observation_image_format"] = image_payload["format"]
+            obs_dict["observation_image_width"] = image_payload["width"]
+            obs_dict["observation_image_height"] = image_payload["height"]
+            obs_dict["observation_image_data_url"] = image_payload["data_url"]
+
+        return obs_dict
+
     # ────────────────────────────────────────────────────────────────────
     # ReproducibleEnvironment plumbing
     # ────────────────────────────────────────────────────────────────────

synth_ai/environments/examples/crafter_classic/world_config_patch_simple.py

@@ -9,7 +9,8 @@ from typing import Any, Dict, Optional
 
 import crafter
 
-print("[PATCH] Attempting to apply simplified Crafter world configuration patch...")
+# Patch messages permanently disabled
+# print("[PATCH] Attempting to apply simplified Crafter world configuration patch...")
 
 # World configuration presets
 WORLD_CONFIGS = {
@@ -279,8 +280,8 @@ def patched_env_init(
 
 crafter.Env.__init__ = patched_env_init
 
-print("[PATCH] Simplified Crafter world configuration patch complete.")
-print("[PATCH] Available configs: easy, normal, hard, peaceful")
+# print("[PATCH] Simplified Crafter world configuration patch complete.")
+# print("[PATCH] Available configs: easy, normal, hard, peaceful")
 
 # Example custom config
 EXAMPLE_CUSTOM_CONFIG = {

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
 
@@ -13,12 +14,15 @@ from synth_ai.environments.stateful.engine import StatefulEngine, StatefulEngine
 from synth_ai.environments.tasks.core import TaskInstance
 
 from .engine_helpers.reward_components import (
-    BadgeRewardComponent,
-    BattleVictoryComponent,
-    LevelUpComponent,
-    MapTransitionComponent,
+    RouteExplorationReward,
+    StrategicTrainingReward,
+    BattleProgressionReward,
+    GymPreparationReward,
+    ItemCollectionReward,
+    HealingManagementReward,
+    EfficientExplorationReward,
+    BadgeVictoryReward,
     StepPenaltyComponent,
-    XPGainComponent,
 )
 from .engine_helpers.state_extraction import extract_game_state
 
@@ -122,6 +126,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 = ""
@@ -260,15 +271,27 @@ class PokemonRedEngine(StatefulEngine, IReproducibleEngine):
             # For testing purposes, use None emulator
             self.emulator = None
 
-        # Initialize reward stack with dense components
+        # Initialize reward stack with comprehensive progress-based components
         self.reward_stack = RewardStack(
             components=[
-                BadgeRewardComponent(),
-                MapTransitionComponent(),
-                BattleVictoryComponent(),
-                LevelUpComponent(),
-                XPGainComponent(),
-                StepPenaltyComponent(),
+                # Major progress rewards
+                BadgeVictoryReward(),        # +50.0 for Boulder Badge (main goal)
+                RouteExplorationReward(),    # +1.0-5.0 for reaching key areas
+                GymPreparationReward(),      # +3.0 for being gym-ready
+
+                # Training and battle rewards
+                StrategicTrainingReward(),   # +0.2-3.0 for level ups and milestones
+                BattleProgressionReward(),   # +0.1-1.0 for battles
+
+                # Resource management rewards
+                ItemCollectionReward(),      # +0.1-0.5 for collecting items
+                HealingManagementReward(),   # +0.05-0.8 for healing Pokemon
+
+                # Exploration efficiency
+                EfficientExplorationReward(), # +0.02 for discovering new positions
+
+                        # No penalty for unproductive actions
+                        StepPenaltyComponent(penalty=0.0),        # 0.0 per step
             ]
         )
 
@@ -278,12 +301,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 +565,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 +651,16 @@ 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)),
+                        "prev_player_x": int(prev_state.get("player_x", 0)),
+                        "prev_player_y": int(prev_state.get("player_y", 0)),
+                        "prev_party": prev_state.get("party", []),
+                        "prev_inventory": prev_state.get("inventory", []),
+                        "prev_party_hp_current": int(prev_state.get("party_hp_current", 0)),
+                        "prev_party_hp_max": int(prev_state.get("party_hp_max", 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)