synth-ai 0.2.9.dev7__py3-none-any.whl → 0.2.10__py3-none-any.whl

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/environment.py

@@ -1,19 +1,56 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional
+import base64
 import logging
+from io import BytesIO
+from typing import Any
 
-from synth_ai.environments.stateful.core import StatefulEnvironment
+import numpy as np
+from PIL import Image
 from synth_ai.environments.environment.tools import EnvToolCall
+from synth_ai.environments.stateful.core import StatefulEnvironment
 
 from ...utils import convert_numpy_to_python
-from .tools import TOOLS_SCHEMA
 from .shared import CRAFTER_ACTIONS, _format_semantic_map_view
-
+from .tools import TOOLS_SCHEMA
 
 logger = logging.getLogger(__name__)
 
 
+def _encode_image_to_base64(image_array: Any) -> dict[str, Any] | None:
+    """Encode an RGB ndarray into a base64 PNG payload with metadata."""
+
+    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:
+        # Ensure uint8 for PIL compatibility
+        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
+
+
 class CrafterEnvironmentWrapper:
     """Host-side environment wrapper matching the sketch contract.
 
@@ -25,20 +62,20 @@ class CrafterEnvironmentWrapper:
       - snapshot()/restore() handled at route level; this wrapper exposes checkpoint via synth-ai
     """
 
-    def __init__(self, env: StatefulEnvironment, seed: Optional[int] = None) -> None:
+    def __init__(self, env: StatefulEnvironment, seed: int | None = None) -> None:
         self.env = env
         self.seed = seed
         self.step_idx = 0
-        self.last_observation: Optional[Dict[str, Any]] = None
-        self.last_info: Optional[Dict[str, Any]] = None
+        self.last_observation: dict[str, Any] | None = None
+        self.last_info: dict[str, Any] | None = None
 
-    async def initialize(self) -> Dict[str, Any]:
+    async def initialize(self) -> dict[str, Any]:
         obs = await self.env.initialize()
         # synth-ai InternalObservation expected to expose .observation (dict-like)
         self.step_idx = 0
         self.last_observation = getattr(obs, "observation", obs)  # tolerate dict-like
         self.last_info = getattr(obs, "info", None)
-        out_obs: Dict[str, Any] = convert_numpy_to_python(self.last_observation) or {}
+        out_obs = self._prepare_observation(self.last_observation)
         # Attach a 7x7 semantic map patch centered on player for client-side rendering
         try:
             pub = self.env.engine._get_public_state_from_env()  # type: ignore[attr-defined]
@@ -47,13 +84,13 @@ class CrafterEnvironmentWrapper:
             size = 7
             half = size // 2
             patch = []
-            H = len(sem) if hasattr(sem, "__len__") else 0
-            W = len(sem[0]) if H and hasattr(sem[0], "__len__") else 0
+            height = len(sem) if hasattr(sem, "__len__") else 0
+            width = len(sem[0]) if height and hasattr(sem[0], "__len__") else 0
             for dy in range(-half, half + 1):
                 row = []
                 for dx in range(-half, half + 1):
                     x, y = int(px) + dx, int(py) + dy
-                    if 0 <= x < H and 0 <= y < W:
+                    if 0 <= x < height and 0 <= y < width:
                         row.append(int(sem[x][y]))
                     else:
                         row.append(0)
@@ -68,7 +105,7 @@ class CrafterEnvironmentWrapper:
             "step_idx": self.step_idx,
         }
 
-    async def step(self, tool_calls: List[Dict[str, Any]] | List[EnvToolCall]) -> Dict[str, Any]:
+    async def step(self, tool_calls: list[dict[str, Any]] | list[EnvToolCall]) -> dict[str, Any]:
         # Normalize JSON tool_calls into EnvToolCall instances if needed
         # Underlying synth-ai environment expects only tool="interact" with args={"action": <action_name>}.
         # LLM may emit:
@@ -79,9 +116,9 @@ class CrafterEnvironmentWrapper:
         allowed_actions = set(
             TOOLS_SCHEMA[0]["function"]["parameters"]["properties"]["actions"]["items"]["enum"]
         )
-        normalized: List[EnvToolCall] = []
+        normalized: list[EnvToolCall] = []
 
-        def _action_to_int(action: Any) -> Optional[int]:
+        def _action_to_int(action: Any) -> int | None:
             # Handle invalid actions gracefully instead of failing
             if isinstance(action, int):
                 return action
@@ -153,10 +190,8 @@ class CrafterEnvironmentWrapper:
                         if isinstance(args, dict) and "action" in args:
                             candidate_action = args["action"]
                         # If the caller provided a numeric action id, accept it directly
-                        action_int: Optional[int]
-                        if isinstance(candidate_action, int):
-                            action_int = _action_to_int(candidate_action)
-                        elif (
+                        action_int: int | None
+                        if isinstance(candidate_action, int) or (
                             isinstance(candidate_action, str)
                             and candidate_action in allowed_actions
                         ):
@@ -175,7 +210,7 @@ class CrafterEnvironmentWrapper:
             normalized.append(EnvToolCall(tool="interact", args={"action": 0}))  # noop action
 
         # Pre-step logging: capture current public state and print concise summary
-        before_state: Optional[Dict[str, Any]] = None
+        before_state: dict[str, Any] | None = None
         try:
             pub_before = self.env.engine._get_public_state_from_env()  # type: ignore[attr-defined]
             before_state = {
@@ -231,7 +266,7 @@ class CrafterEnvironmentWrapper:
         ach_added_latest: list[str] | None = None
         try:
             pub_after = self.env.engine._get_public_state_from_env()  # type: ignore[attr-defined]
-            after_dict: Dict[str, Any] = {
+            after_dict: dict[str, Any] = {
                 "inventory": pub_after.inventory,
                 "achievements_status": pub_after.achievements_status,
                 "player_position": list(pub_after.player_position),
@@ -255,8 +290,8 @@ class CrafterEnvironmentWrapper:
                     # Position delta
                     pb = before_state.get("player_position", [0, 0])
                     pa = after_dict.get("player_position", [0, 0])
-                    pb_t = (int(pb[0]), int(pb[1])) if isinstance(pb, (list, tuple)) else (0, 0)
-                    pa_t = (int(pa[0]), int(pa[1])) if isinstance(pa, (list, tuple)) else (0, 0)
+                    pb_t = (int(pb[0]), int(pb[1])) if isinstance(pb, list | tuple) else (0, 0)
+                    pa_t = (int(pa[0]), int(pa[1])) if isinstance(pa, list | tuple) else (0, 0)
                     delta = (pa_t[0] - pb_t[0], pa_t[1] - pb_t[1])
 
                     # Inventory changes
@@ -280,9 +315,9 @@ class CrafterEnvironmentWrapper:
                     ach_a = {
                         k for k, v in (after_dict.get("achievements_status", {}) or {}).items() if v
                     }
-                    ach_added = sorted(list(ach_a - ach_b))
+                    ach_added = sorted(ach_a - ach_b)
                     ach_added_latest = ach_added
-                    ach_removed = sorted(list(ach_b - ach_a))
+                    ach_removed = sorted(ach_b - ach_a)
 
                     logger.info(
                         "Changes: pos %s->%s Δ=%s | inv %s | ach +%s -%s",
@@ -312,8 +347,8 @@ class CrafterEnvironmentWrapper:
             )
         except Exception as _:
             pass
-        result: Dict[str, Any] = {
-            "observation": convert_numpy_to_python(observation),
+        result: dict[str, Any] = {
+            "observation": self._prepare_observation(observation),
             "step_idx": self.step_idx,
             "done": bool(done) if done is not None else False,  # Ensure boolean
         }
@@ -325,13 +360,13 @@ class CrafterEnvironmentWrapper:
             size = 7
             half = size // 2
             patch = []
-            H = len(sem) if hasattr(sem, "__len__") else 0
-            W = len(sem[0]) if H and hasattr(sem[0], "__len__") else 0
+            height = len(sem) if hasattr(sem, "__len__") else 0
+            width = len(sem[0]) if height and hasattr(sem[0], "__len__") else 0
             for dy in range(-half, half + 1):
                 row = []
                 for dx in range(-half, half + 1):
                     x, y = px + dx, py + dy
-                    if 0 <= x < H and 0 <= y < W:
+                    if 0 <= x < height and 0 <= y < width:
                         row.append(int(sem[x][y]))
                     else:
                         row.append(0)
@@ -341,10 +376,7 @@ class CrafterEnvironmentWrapper:
                 obs_out["semantic_map_patch7"] = patch
         except Exception:
             pass
-        if info is not None:
-            result_info = convert_numpy_to_python(info)
-        else:
-            result_info = {}
+        result_info = convert_numpy_to_python(info) if info is not None else {}
         # Attach achievements delta for downstream metrics if useful
         if ach_added_latest is not None:
             try:
@@ -404,9 +436,37 @@ class CrafterEnvironmentWrapper:
             )
         except Exception:
             pass
+
         return result
 
-    async def checkpoint(self) -> Dict[str, Any]:
+    def _prepare_observation(self, observation: Any) -> dict[str, Any]:
+        """Convert raw observation into a JSON-serializable dict with encoded image."""
+
+        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"))
+            # Work on a shallow copy to avoid mutating engine state
+            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
+
+    async def checkpoint(self) -> dict[str, Any]:
         obs = await self.env.checkpoint()
         observation = getattr(obs, "observation", obs)
         info = getattr(obs, "info", None)
@@ -416,7 +476,7 @@ class CrafterEnvironmentWrapper:
             "step_idx": self.step_idx,
         }
 
-    async def terminate(self) -> Dict[str, Any]:
+    async def terminate(self) -> dict[str, Any]:
         obs = await self.env.terminate()
         observation = getattr(obs, "observation", obs)
         info = getattr(obs, "info", None)
@@ -426,7 +486,7 @@ class CrafterEnvironmentWrapper:
             "step_idx": self.step_idx,
         }
 
-    def state_dict(self) -> Dict[str, Any]:
+    def state_dict(self) -> dict[str, Any]:
         return {
             "seed": self.seed,
             "step_idx": self.step_idx,
@@ -434,13 +494,13 @@ class CrafterEnvironmentWrapper:
             "last_info": self.last_info,
         }
 
-    def load_state_dict(self, state: Dict[str, Any]) -> None:
+    def load_state_dict(self, state: dict[str, Any]) -> None:
         self.seed = state["seed"]
         self.step_idx = int(state["step_idx"])
         self.last_observation = state["last_observation"]
         self.last_info = state["last_info"]
 
-    async def serialize(self) -> Dict[str, Any]:
+    async def serialize(self) -> dict[str, Any]:
         return {
             "name": "crafter",
             "config": {"seed": self.seed},
@@ -450,9 +510,9 @@ class CrafterEnvironmentWrapper:
     @classmethod
     async def deserialize(
         cls,
-        payload: Dict[str, Any],
+        payload: dict[str, Any],
         env: StatefulEnvironment,
-    ) -> "CrafterEnvironmentWrapper":
+    ) -> CrafterEnvironmentWrapper:
         seed = payload["config"]["seed"]
         wrapper = cls(env=env, seed=seed)
         wrapper.load_state_dict(payload["state"])

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/policy.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Tuple
 from abc import ABC, abstractmethod
+from typing import Any
+
 from .react_agent import CrafterReActAgent
 from .tools import TOOLS_SCHEMA
 
@@ -12,15 +13,15 @@ class Policy(ABC):
 
     @abstractmethod
     def prepare_inference_request(
-        self, observation: Dict[str, Any], history: List[Dict[str, Any]] = None
-    ) -> Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]:
+        self, observation: dict[str, Any], history: list[dict[str, Any]] = None
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]] | None]:
         """Prepare an inference request."""
         pass
 
     @abstractmethod
     def parse_model_response(
-        self, response: str, observation: Dict[str, Any]
-    ) -> List[Dict[str, Any]]:
+        self, response: str, observation: dict[str, Any]
+    ) -> list[dict[str, Any]]:
         """Parse model response into tool calls."""
         pass
 
@@ -39,23 +40,23 @@ class CrafterPolicy(Policy):
 
     name: str = "crafter-react"
 
-    def __init__(self, inference_url: str, model: Optional[str] = None) -> None:
+    def __init__(self, inference_url: str, model: str | None = None) -> None:
         self.inference_url = inference_url
         self.model = model
         self.use_tools = True
         # Sampling parameters (populated via initialize(config))
-        self.temperature: Optional[float] = None
-        self.top_p: Optional[float] = None
-        self.max_tokens: Optional[int] = None
+        self.temperature: float | None = None
+        self.top_p: float | None = None
+        self.max_tokens: int | None = None
         # Thinking controls (populated via initialize(config))
-        self.thinking_mode: Optional[str] = None
-        self.thinking_budget: Optional[int] = None
+        self.thinking_mode: str | None = None
+        self.thinking_budget: int | None = None
         # Rolling conversation and action history for non-Markov policies
-        self.history_messages: List[Dict[str, str]] = []  # chat-style without system
+        self.history_messages: list[dict[str, str]] = []  # chat-style without system
         self.turn_index: int = 0
-        self.trajectory_history: List[Dict[str, Any]] = []  # env/policy step records
+        self.trajectory_history: list[dict[str, Any]] = []  # env/policy step records
 
-    async def initialize(self, config: Dict[str, Any]) -> None:
+    async def initialize(self, config: dict[str, Any]) -> None:
         if "inference_url" in config:
             self.inference_url = config["inference_url"]
         if "model" in config:
@@ -91,15 +92,15 @@ class CrafterPolicy(Policy):
 
     def _append_assistant_turn(
         self,
-        assistant_text: Optional[str],
-        tool_calls: Optional[List[Dict[str, Any]]],
-        env_result: Optional[Dict[str, Any]],
+        assistant_text: str | None,
+        tool_calls: list[dict[str, Any]] | None,
+        env_result: dict[str, Any] | None,
     ) -> None:
         # Record assistant content (if any)
         if assistant_text is not None:
             self.history_messages.append({"role": "assistant", "content": assistant_text})
         # Keep structured step record for training/analysis
-        record: Dict[str, Any] = {"turn": self.turn_index}
+        record: dict[str, Any] = {"turn": self.turn_index}
         if tool_calls is not None:
             record["tool_calls"] = tool_calls
         if env_result is not None:
@@ -109,13 +110,17 @@ class CrafterPolicy(Policy):
     def build_inference_request(
         self,
         observation_text: str,
-        history: Optional[List[Dict[str, str]]] = None,
-        turn: Optional[int] = None,
-    ) -> Dict[str, Any]:
+        history: list[dict[str, Any]] | None = None,
+        turn: int | None = None,
+        image_parts: list[dict[str, Any]] | None = None,
+    ) -> dict[str, Any]:
         messages = CrafterReActAgent.build_messages(
-            observation=observation_text, history=history, turn=turn
+            observation=observation_text,
+            history=history,
+            turn=turn,
+            image_parts=image_parts,
         )
-        payload: Dict[str, Any] = {
+        payload: dict[str, Any] = {
             "messages": messages,
         }
         if self.model is not None:
@@ -150,9 +155,9 @@ class CrafterPolicy(Policy):
 
     @staticmethod
     def parse_response_to_tool_calls(
-        response: Dict[str, Any],
+        response: dict[str, Any],
         use_tools: bool = True,
-    ) -> List[Dict[str, Any]]:
+    ) -> list[dict[str, Any]]:
         """Turn an inference response into environment tool calls.
 
         - If tools were used, expect tool_calls-compatible output and forward as-is
@@ -162,7 +167,7 @@ class CrafterPolicy(Policy):
         """
         # First check if we got actual tool calls
         choices = response.get("choices", [])
-        tool_calls: List[Dict[str, Any]] = []
+        tool_calls: list[dict[str, Any]] = []
 
         for choice in choices:
             msg = choice.get("message", {})
@@ -192,7 +197,7 @@ class CrafterPolicy(Policy):
         if tool_calls:
             # Normalize common degenerate pattern ["move_right", "do"] when nothing is nearby.
             # If previous env_result indicates no interaction target, drop trailing 'do'.
-            normalized: List[Dict[str, Any]] = []
+            normalized: list[dict[str, Any]] = []
             for tc in tool_calls:
                 if tc and isinstance(tc, dict) and tc.get("tool_name") == "interact_many":
                     args = tc.get("arguments")
@@ -242,9 +247,9 @@ class CrafterPolicy(Policy):
     async def step(
         self,
         observation_text: str,
-        state: Optional[Dict[str, Any]] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-    ) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        state: dict[str, Any] | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
         """Stateful step: update policy history and prepare inference request.
 
         Inputs (via metadata, optional):
@@ -261,9 +266,9 @@ class CrafterPolicy(Policy):
         """
         # If caller provided results from previous cycle, record them first
         if metadata is not None:
-            prev_assistant_text: Optional[str] = None
-            prev_tool_calls: Optional[List[Dict[str, Any]]] = None
-            prev_env_result: Optional[Dict[str, Any]] = None
+            prev_assistant_text: str | None = None
+            prev_tool_calls: list[dict[str, Any]] | None = None
+            prev_env_result: dict[str, Any] | None = None
             if "prev_assistant_text" in metadata:
                 prev_assistant_text = metadata["prev_assistant_text"]
             if "prev_tool_calls" in metadata:
@@ -283,7 +288,7 @@ class CrafterPolicy(Policy):
         # Build user message by combining the current observation text
         # (formatted surroundings/inventory) with the previous 3 tool calls as context.
         # Most recent first.
-        lines: List[str] = []
+        lines: list[str] = []
 
         def _format_tool_call_line_for_context(
             tool_name: str, arguments: Any, max_chars: int = 500
@@ -291,7 +296,7 @@ class CrafterPolicy(Policy):
             import json as _json
 
             # Render arguments compactly, then clip to max_chars
-            if isinstance(arguments, (dict, list)):
+            if isinstance(arguments, dict | list):
                 try:
                     rendered = _json.dumps(arguments, ensure_ascii=False, separators=(",", ":"))
                 except Exception:
@@ -321,7 +326,7 @@ class CrafterPolicy(Policy):
 
         # If trajectory history is empty (first few turns), fall back to metadata once
         if not lines and metadata is not None and metadata.get("prev_tool_calls"):
-            calls: List[Dict[str, Any]] = metadata["prev_tool_calls"]
+            calls: list[dict[str, Any]] = metadata["prev_tool_calls"]
             for call in reversed(calls):
                 if len(lines) >= 3:
                     break
@@ -338,10 +343,18 @@ class CrafterPolicy(Policy):
         # Combine observation with context so the model always sees surroundings/inventory
         combined_text = f"{observation_text}\n\n{context_text}"
 
+        raw_observation: dict[str, Any] | None = None
+        if metadata is not None:
+            raw_candidate = metadata.get("raw_observation")
+            if isinstance(raw_candidate, dict):
+                raw_observation = raw_candidate
+        image_parts = self._extract_image_parts(raw_observation)
+
         payload = self.build_inference_request(
             combined_text,
             history=[],  # no prior user/assistant history
             turn=self.turn_index,
+            image_parts=image_parts,
         )
         # print("Debugging only:; ", payload)
         meta_out = {
@@ -352,19 +365,19 @@ class CrafterPolicy(Policy):
         }
         return [], meta_out
 
-    def state_dict(self) -> Dict[str, Any]:
+    def state_dict(self) -> dict[str, Any]:
         return {
             "turn_index": self.turn_index,
             "history_messages": self.history_messages,
             "trajectory_history": self.trajectory_history,
         }
 
-    def load_state_dict(self, state: Dict[str, Any]) -> None:
+    def load_state_dict(self, state: dict[str, Any]) -> None:
         self.turn_index = int(state["turn_index"])
         self.history_messages = state["history_messages"]
         self.trajectory_history = state["trajectory_history"]
 
-    async def serialize(self) -> Dict[str, Any]:
+    async def serialize(self) -> dict[str, Any]:
         return {
             "name": self.name,
             "config": {
@@ -376,7 +389,7 @@ class CrafterPolicy(Policy):
         }
 
     @classmethod
-    async def deserialize(cls, payload: Dict[str, Any]) -> "CrafterPolicy":
+    async def deserialize(cls, payload: dict[str, Any]) -> CrafterPolicy:
         config = payload["config"]
         state = payload["state"]
         policy = cls(
@@ -391,22 +404,26 @@ class CrafterPolicy(Policy):
         return None
 
     def prepare_inference_request(
-        self, observation: Dict[str, Any], history: List[Dict[str, Any]] = None
-    ) -> Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]:
+        self, observation: dict[str, Any], history: list[dict[str, Any]] = None
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]] | None]:
         """Prepare an inference request (implementing abstract method)."""
         # Format observation with rich contextual information
         observation_text = self._format_observation_for_llm(observation)
+        image_parts = self._extract_image_parts(observation)
 
         # Build messages (observation_text already formatted; no raw matrices)
         messages = CrafterReActAgent.build_messages(
-            observation=observation_text, history=history, turn=self.turn_index
+            observation=observation_text,
+            history=history,
+            turn=self.turn_index,
+            image_parts=image_parts,
         )
 
         # Return messages and tools schema
         tools = TOOLS_SCHEMA if self.use_tools else None
         return messages, tools
 
-    def _format_observation_for_llm(self, observation: Dict[str, Any]) -> str:
+    def _format_observation_for_llm(self, observation: dict[str, Any]) -> str:
         """Format observation with rich contextual information for the LLM using the shared formatter."""
         from .shared import format_observation
 
@@ -423,17 +440,22 @@ class CrafterPolicy(Policy):
 
         # Get additional info from the observation wrapper
         info = observation.get("info", {})
-        if isinstance(info, dict):
-            # Merge health from info into obs_data for the formatter
-            if "health" in info and "health" not in obs_data:
-                obs_data = dict(obs_data)  # Make a copy
-                obs_data["health"] = info["health"]
+        if isinstance(info, dict) and "health" in info and "health" not in obs_data:
+            obs_data = dict(obs_data)  # Make a copy
+            obs_data["health"] = info["health"]
 
         return format_observation(obs_data, step_count=step_idx, max_steps=max_steps)
 
+    def _extract_image_parts(
+        self, observation: dict[str, Any] | None
+    ) -> list[dict[str, Any]]:
+        """Crafter policy uses text-only prompts; do not attach image parts."""
+
+        return []
+
     def parse_model_response(
-        self, response: str, observation: Dict[str, Any]
-    ) -> List[Dict[str, Any]]:
+        self, response: str, observation: dict[str, Any]
+    ) -> list[dict[str, Any]]:
         """Parse model response into tool calls (implementing abstract method).
 
         Note: Despite the type hint, vLLM actually returns a dict response,

examples/warming_up_to_rl/task_app/synth_envs_hosted/envs/crafter/react_agent.py

@@ -7,7 +7,7 @@ utilities to keep a single parser.
 
 from __future__ import annotations
 
-from typing import Dict, List, Optional
+from typing import Any
 
 from .shared import parse_actions
 
@@ -81,19 +81,27 @@ class CrafterReActAgent:
 
     @staticmethod
     def build_messages(
-        observation: str, history: Optional[List[Dict[str, str]]] = None, turn: Optional[int] = None
-    ) -> List[Dict[str, str]]:
+        observation: str,
+        history: list[dict[str, Any]] | None = None,
+        turn: int | None = None,
+        image_parts: list[dict[str, Any]] | None = None,
+    ) -> list[dict[str, Any]]:
         """Construct OpenAI-style messages list for vLLM generation."""
-        msgs: List[Dict[str, str]] = [
+        msgs: list[dict[str, Any]] = [
             {"role": "system", "content": CrafterReActAgent.get_system_prompt()}
         ]
         if history:
             msgs.extend(history)
-        msgs.append({"role": "user", "content": observation})
+        user_content: Any
+        if image_parts:
+            user_content = [{"type": "text", "text": observation}] + list(image_parts)
+        else:
+            user_content = observation
+        msgs.append({"role": "user", "content": user_content})
         return msgs
 
     @staticmethod
-    def parse_actions_from_response(response_text: str) -> List[str]:
+    def parse_actions_from_response(response_text: str) -> list[str]:
         return parse_actions(response_text)