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

examples/swe/task_app/morph_backend.py

@@ -0,0 +1,178 @@
+"""Utility classes for running swe-mini environments on Morph Cloud."""
+
+from __future__ import annotations
+
+import contextlib
+import os
+import shlex
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict
+
+_IMPORT_ERROR: Exception | None = None
+
+try:  # pragma: no cover - optional dependency
+    from morphcloud.api import MorphCloudClient
+except Exception as exc:  # pragma: no cover - optional dependency
+    MorphCloudClient = None  # type: ignore[assignment]
+    _IMPORT_ERROR = exc
+
+
+def _quote_env_var(key: str, value: str) -> str:
+    """Return a safe shell export statement."""
+    return f"export {key}={shlex.quote(value)}"
+
+
+def _now() -> float:
+    return time.time()
+
+
+@dataclass
+class MorphSandboxBackend:
+    """Thin wrapper around Morph Cloud instances for command execution.
+
+    The API mirrors the subset consumed by :class:`MiniSweEnvironmentWrapper`:
+    we expose an ``execute`` method that matches the mini-swe environment shape.
+    """
+
+    snapshot_id: str | None = None
+    image_id: str | None = None
+    cwd: str = "/workspace"
+    env: Dict[str, str] | None = None
+    metadata: Dict[str, str] | None = None
+    vcpus: int = 4
+    memory_mb: int = 8192
+    disk_mb: int = 65536
+    startup_timeout: int = 600
+
+    _client: MorphCloudClient = field(init=False)
+    _instance: Any = field(init=False, default=None)
+    _last_exec: Dict[str, Any] = field(init=False, default_factory=dict)
+    _started_at: float | None = field(init=False, default=None)
+
+    def __post_init__(self) -> None:
+        if MorphCloudClient is None:  # pragma: no cover - optional dependency
+            raise RuntimeError(
+                "morphcloud package is required for Morph environments. "
+                "Install with `pip install morphcloud`."
+            ) from _IMPORT_ERROR
+
+        api_key = os.getenv("MORPH_API_KEY", "")
+        if not api_key:
+            raise RuntimeError("Set MORPH_API_KEY before using the Morph backend.")
+
+        # Normalise metadata/env early to avoid shared references.
+        self.metadata = {str(k): str(v) for k, v in (self.metadata or {}).items()}
+        self.env = {str(k): str(v) for k, v in (self.env or {}).items()}
+        self.cwd = self.cwd or "/workspace"
+
+        self._client = MorphCloudClient()
+
+    # Public API -----------------------------------------------------------------
+
+    def execute(self, command: str, timeout: int | None = None) -> Dict[str, Any]:
+        """Execute ``command`` inside the Morph instance."""
+        if not command.strip():
+            command = "true"
+
+        instance = self._ensure_instance()
+
+        script_parts = []
+        for key, value in self.env.items():
+            script_parts.append(_quote_env_var(key, value))
+        if self.cwd:
+            script_parts.append(f"cd {shlex.quote(self.cwd)}")
+        script_parts.append(command)
+
+        script = " && ".join(script_parts)
+        if timeout:
+            wrapped = f"timeout {int(timeout)}s bash -lc {shlex.quote(script)}"
+        else:
+            wrapped = script
+
+        shell_cmd = f"bash -lc {shlex.quote(wrapped)}"
+        started = _now()
+        result = instance.exec(shell_cmd)
+        duration = _now() - started
+
+        payload = {
+            "output": (result.stdout or ""),
+            "stderr": (result.stderr or ""),
+            "returncode": getattr(result, "exit_code", None),
+            "duration": duration,
+        }
+        self._last_exec = payload
+        return payload
+
+    def close(self) -> None:
+        """Stops the Morph instance if one is running."""
+        instance = getattr(self, "_instance", None)
+        if not instance:
+            return
+        try:
+            instance.stop()
+        except Exception:  # pragma: no cover - best-effort shutdown
+            pass
+        finally:
+            self._instance = None
+
+    # Internal helpers -----------------------------------------------------------
+
+    def _ensure_instance(self):
+        instance = getattr(self, "_instance", None)
+        if instance is not None:
+            return instance
+
+        snapshot_id = (
+            self.snapshot_id
+            or os.getenv("SWE_MINI_MORPH_SNAPSHOT_ID")
+            or os.getenv("MORPH_SNAPSHOT_ID")
+        )
+        metadata = dict(self.metadata)
+
+        if snapshot_id:
+            instance = self._client.instances.start(snapshot_id=snapshot_id, metadata=metadata or None)
+        else:
+            image_id = (
+                self.image_id
+                or os.getenv("SWE_MINI_MORPH_IMAGE_ID")
+                or os.getenv("MORPH_IMAGE_ID")
+                or "morphvm-minimal"
+            )
+            snapshot = self._client.snapshots.create(
+                image_id=image_id,
+                vcpus=self.vcpus,
+                memory=self.memory_mb,
+                disk_size=self.disk_mb,
+            )
+            instance = self._client.instances.start(snapshot_id=snapshot.id, metadata=metadata or None)
+            self.snapshot_id = snapshot.id
+
+        self._instance = instance
+        self._started_at = _now()
+        self._wait_until_ready(instance)
+        self._ensure_cwd(instance)
+        return instance
+
+    def _wait_until_ready(self, instance) -> None:
+        deadline = _now() + float(self.startup_timeout)
+        while True:
+            try:
+                instance.wait_until_ready()
+                break
+            except Exception as exc:  # pragma: no cover - SDK may raise while polling
+                if _now() > deadline:
+                    raise TimeoutError(f"Morph instance did not become ready within {self.startup_timeout}s") from exc
+                time.sleep(5.0)
+
+    def _ensure_cwd(self, instance) -> None:
+        if not self.cwd:
+            return
+        try:
+            instance.exec(f"bash -lc {shlex.quote(f'mkdir -p {self.cwd}')}")
+        except Exception as exc:  # pragma: no cover - surface friendly error
+            raise RuntimeError(f"Failed to create remote workspace {self.cwd!r}: {exc}") from exc
+
+    def __del__(self) -> None:  # pragma: no cover - defensive cleanup
+        with contextlib.suppress(Exception):
+            self.close()

examples/task_apps/crafter/task_app/README.md

@@ -6,7 +6,7 @@ underlying FastAPI plumbing.
 
 ## Local development
 ```bash
-uvx synth-ai serve grpo-crafter --port 8001
+uvx synth-ai deploy --runtime uvicorn grpo-crafter --port 8001
 # Optional extras:
 #   --env-file path/to/.env    # load additional environment variables
 #   --reload                   # enable uvicorn auto-reload

examples/task_apps/crafter/task_app/grpo_crafter.py

@@ -7,10 +7,15 @@ import logging
 import os
 import sys
 from collections.abc import Iterable, Sequence
+from contextlib import suppress
 from dataclasses import dataclass
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
+from fastapi import HTTPException
+from pydantic import BaseModel
+
 from synth_ai.task.apps import ModalDeploymentConfig, TaskAppEntry, register_task_app
 from synth_ai.task.contracts import RolloutMetrics, RolloutMode, RolloutRequest, RolloutResponse, TaskInfo
 from synth_ai.task.datasets import TaskDatasetRegistry, TaskDatasetSpec
@@ -614,16 +619,14 @@ def _coerce_math_to_crafter(request: RolloutRequest) -> RolloutRequest:
 
     coerced = request.model_copy(update={"env": updated_env, "policy": updated_policy, "ops": ops_override})
 
-    try:
+    with suppress(Exception):
         print(
             "[rollout] remapped math request -> crafter "
             f"(env={request.env.env_name!r}→{coerced.env.env_name!r}, "
             f"policy={request.policy.policy_name!r}→{coerced.policy.policy_name!r})",
             flush=True,
         )
-    except Exception:
-        pass
-    try:
+    with suppress(Exception):
         logger.info(
             "ROLLOUT_ALIAS: remapped math env/policy to crafter (env=%s→%s, policy=%s→%s)",
             request.env.env_name,
@@ -631,8 +634,6 @@ def _coerce_math_to_crafter(request: RolloutRequest) -> RolloutRequest:
             request.policy.policy_name,
             coerced.policy.policy_name,
         )
-    except Exception:
-        pass
 
     return coerced
 
@@ -654,12 +655,20 @@ def _resolve_trace_correlation_id(policy_cfg: dict[str, Any], mode: Any = None)
             if stripped:
                 return stripped
 
-    return extract_trace_correlation_id(policy_cfg.get("inference_url"), mode=mode)
+    return extract_trace_correlation_id(policy_cfg.get("inference_url"))
 
 
 async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutResponse:
     request = _coerce_math_to_crafter(request)
 
+    record_cfg = request.record.model_copy(
+        update={
+            "return_trace": True,
+            "trace_format": "structured",
+        }
+    )
+    request = request.model_copy(update={"record": record_cfg})
+
     policy_cfg = dict(request.policy.config or {})
     logger.info(
         "ROLLOUT_EXEC: incoming policy config keys=%s inference_url=%s run_id=%s mode=%s",
@@ -803,11 +812,38 @@ async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutR
         trace_correlation_id,
     )
     data = legacy_response.model_dump()
+    logger.debug(
+        "ROLLOUT_EXEC: legacy response keys=%s has_trace=%s",
+        sorted(data.keys()),
+        bool(data.get("trace")),
+    )
     metrics = data.get("metrics", {}) or {}
     metrics.setdefault("outcome_score", None)
     metrics.setdefault("events_score", None)
     metrics.setdefault("details", {})
     data["metrics"] = metrics
+
+    if data.get("trace") is None:
+        legacy_trace = getattr(legacy_response, "trace", None)
+        if legacy_trace is not None:
+            data["trace"] = legacy_trace
+        else:
+            tracer_factory = getattr(fastapi_request.app.state, "session_tracer_factory", None)
+            if callable(tracer_factory):
+                tracer = tracer_factory()
+                logger.debug("ROLLOUT_EXEC: trace backfill factory=%s", type(tracer))
+                if isinstance(tracer, SessionTracer):
+                    try:
+                        await tracer.initialize()
+                        if tracer.db is not None:
+                            trace_row = await tracer.db.get_session_trace(request.run_id)
+                            if trace_row is not None:
+                                data["trace"] = trace_row
+                    except Exception as exc:
+                        logger.warning("TRACE_BACKFILL_FAIL: %s", exc)
+                    finally:
+                        with suppress(Exception):
+                            await tracer.close()
     
     # Add trace_correlation_id at TOP-LEVEL (REQUIRED for RL training pipeline)
     # Use fallback if somehow missing
@@ -823,12 +859,30 @@ async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutR
     if isinstance(policy_cfg.get("inference_url"), str) and policy_cfg["inference_url"]:
         existing_meta.setdefault("inference_url", policy_cfg["inference_url"])
     data["pipeline_metadata"] = existing_meta
-    
+
     # Add trace_correlation_id to each trajectory (required for RL training pipeline)
     if "trajectories" in data:
+        normalized_trajs: list[dict[str, Any]] = []
         for traj in data.get("trajectories", []):
-            if isinstance(traj, dict):
-                traj["trace_correlation_id"] = final_cid
+            if isinstance(traj, BaseModel):
+                traj_dict = traj.model_dump()
+            elif isinstance(traj, dict):
+                traj_dict = dict(traj)
+            else:
+                continue
+            traj_dict["trace_correlation_id"] = final_cid
+            if not traj_dict.get("inference_url"):
+                inferred_url = policy_cfg.get("inference_url")
+                if inferred_url:
+                    traj_dict["inference_url"] = inferred_url
+            normalized_trajs.append(traj_dict)
+        if normalized_trajs:
+            data["trajectories"] = normalized_trajs
+            logger.info(
+                "ROLLOUT_EXEC: normalized trajectory sample run_id=%s inference_url=%s",
+                request.run_id,
+                normalized_trajs[0].get("inference_url") if normalized_trajs else None,
+            )
     logger.info(
         "ROLLOUT_EXEC: final pipeline metadata run_id=%s metadata=%s",
         request.run_id,
@@ -847,6 +901,12 @@ async def rollout_executor(request: RolloutRequest, fastapi_request) -> RolloutR
             request.run_id,
             existing_meta,
         )
+
+    if data.get("trace") is None:
+        raise HTTPException(
+            status_code=500,
+            detail="trace_payload_missing: task app did not emit a SessionTrace",
+        )
     
     # ASSERTION: Verify trace_correlation_id is present in response at all required levels
     assert "trace_correlation_id" in data, (

examples/task_apps/crafter/task_app/grpo_crafter_task_app.py

@@ -3,7 +3,7 @@
 This module now delegates to the TaskAppConfig defined in the colocated example at
 `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.
+`uvx synth-ai deploy --runtime uvicorn grpo-crafter` for local development and testing.
 """
 
 from __future__ import annotations

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

@@ -59,6 +59,13 @@ class CrafterPolicy(Policy):
         self.trajectory_history: list[dict[str, Any]] = []  # env/policy step records
 
     async def initialize(self, config: dict[str, Any]) -> None:
+        # DEBUG: Log the incoming config
+        import logging
+        _logger = logging.getLogger(__name__)
+        _logger.debug(f"🔊 [POLICY_INIT] Received config keys: {list(config.keys())}")
+        _logger.debug(f"🔊 [POLICY_INIT] use_vision in config: {'use_vision' in config}, value: {config.get('use_vision')}")
+        _logger.debug(f"🔊 [POLICY_INIT] image_only_mode in config: {'image_only_mode' in config}, value: {config.get('image_only_mode')}")
+        
         if "inference_url" in config:
             self.inference_url = config["inference_url"]
         if "model" in config:
@@ -67,6 +74,7 @@ class CrafterPolicy(Policy):
             self.use_tools = bool(config["use_tools"])
         if "use_vision" in config:
             self.use_vision = bool(config["use_vision"])
+            _logger.debug(f"🔊 [POLICY_INIT] Set use_vision={self.use_vision} from config")
         if "image_only_mode" in config:
             self.image_only_mode = bool(config["image_only_mode"])
             # If image_only_mode is enabled, automatically enable vision
@@ -97,6 +105,9 @@ class CrafterPolicy(Policy):
         self.history_messages = []
         self.turn_index = 0
         self.trajectory_history = []
+        
+        # DEBUG: Log final state
+        _logger.debug(f"🔊 [POLICY_INIT] FINAL STATE: use_vision={self.use_vision}, image_only_mode={self.image_only_mode}, model={self.model}")
 
     def _append_user_observation(self, observation_text: str) -> None:
         self.history_messages.append({"role": "user", "content": observation_text})
@@ -131,10 +142,36 @@ class CrafterPolicy(Policy):
             history=history,
             turn=turn,
             image_parts=image_parts,
+            image_only_mode=self.image_only_mode,
         )
+        
+        # DEBUG: Log message structure
+        import logging
+        _logger = logging.getLogger(__name__)
+        _logger.debug(f"🔊 [BUILD_REQUEST] Built {len(messages)} messages")
+        for idx, msg in enumerate(messages):
+            role = msg.get("role")
+            content = msg.get("content")
+            if isinstance(content, list):
+                _logger.debug(f"🔊 [BUILD_REQUEST] Message[{idx}] role={role}, content=list[{len(content)}]")
+                for part_idx, part in enumerate(content):
+                    if isinstance(part, dict):
+                        part_type = part.get("type")
+                        _logger.debug(f"🔊 [BUILD_REQUEST]   Part[{part_idx}]: type={part_type}")
+            else:
+                content_len = len(str(content)) if content else 0
+                _logger.debug(f"🔊 [BUILD_REQUEST] Message[{idx}] role={role}, content_len={content_len}")
+        
         payload: dict[str, Any] = {
             "messages": messages,
         }
+        
+        # DEBUG: Verify messages are in payload correctly
+        _logger.debug(f"🔊 [BUILD_REQUEST_PAYLOAD] Created payload with {len(payload['messages'])} messages")
+        for idx, msg in enumerate(payload["messages"]):
+            content = msg.get("content")
+            _logger.debug(f"🔊 [BUILD_REQUEST_PAYLOAD] Payload message[{idx}]: type={type(content).__name__}, is_list={isinstance(content, list)}, len={len(content) if isinstance(content, list) else len(str(content)) if content else 0}")
+        
         if self.model is not None:
             payload["model"] = self.model
         # Thinking controls
@@ -160,6 +197,8 @@ class CrafterPolicy(Policy):
         if self.use_tools:
             payload["tools"] = TOOLS_SCHEMA
             payload["tool_choice"] = "required"
+            payload["function_call"] = {"name": "interact_many"}
+            payload["parallel_tool_calls"] = False
             # Ensure the inference server injects family-specific stop sequences
             # to terminate immediately after the first tool call for compliance.
             payload["stop_after_tool_calls"] = 1
@@ -170,13 +209,7 @@ class CrafterPolicy(Policy):
         response: dict[str, Any],
         use_tools: bool = True,
     ) -> 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
-          in our simple JSON format: {"tool_name": str, "arguments": {...}}.
-        - If no tools, parse plain-text actions using CrafterReActAgent parser and
-          wrap them into a single interact_many tool call.
-        """
+        """Turn an inference response into environment tool calls."""
         # First check if we got actual tool calls
         choices = response.get("choices", [])
         tool_calls: list[dict[str, Any]] = []
@@ -235,24 +268,6 @@ class CrafterPolicy(Policy):
                     normalized.append(tc)
             return normalized
 
-        # Otherwise, parse plain text content for actions
-        text = ""
-        for choice in choices:
-            msg = choice.get("message", {})
-            content = msg.get("content", "")
-            if content:
-                text = content
-                break
-
-        if text:
-            # Try to parse actions from the text
-            from .shared import parse_actions
-
-            actions = parse_actions(text)
-            if actions:
-                # Wrap actions in interact_many tool call
-                return [{"tool_name": "interact_many", "arguments": {"actions": actions}}]
-
         # No actions found
         return []
 
@@ -360,7 +375,18 @@ class CrafterPolicy(Policy):
             raw_candidate = metadata.get("raw_observation")
             if isinstance(raw_candidate, dict):
                 raw_observation = raw_candidate
+        
+        # DEBUG: Log image extraction
+        import logging
+        _logger = logging.getLogger(__name__)
+        _logger.debug(f"🔊 [POLICY] use_vision={self.use_vision}, has_raw_obs={raw_observation is not None}")
+        if raw_observation:
+            obs = raw_observation.get("observation", raw_observation)
+            data_url = obs.get("observation_image_data_url") if isinstance(obs, dict) else None
+            _logger.debug(f"🔊 [POLICY] has_data_url={data_url is not None}, url_preview={data_url[:50] if data_url else 'NONE'}...")
+        
         image_parts = self._extract_image_parts(raw_observation)
+        _logger.debug(f"🔊 [POLICY] Extracted {len(image_parts)} image parts")
 
         payload = self.build_inference_request(
             combined_text,
@@ -368,7 +394,17 @@ class CrafterPolicy(Policy):
             turn=self.turn_index,
             image_parts=image_parts,
         )
-        # print("Debugging only:; ", payload)
+        
+        # DEBUG: Verify payload before returning
+        _logger.debug(f"🔊 [POLICY_STEP_RETURN] About to return payload with {len(payload.get('messages', []))} messages")
+        for idx, msg in enumerate(payload.get("messages", [])):
+            content = msg.get("content")
+            _logger.debug(f"🔊 [POLICY_STEP_RETURN] Return message[{idx}]: type={type(content).__name__}, is_list={isinstance(content, list)}")
+            if isinstance(content, list):
+                _logger.debug(f"🔊 [POLICY_STEP_RETURN]   Content list has {len(content)} items")
+                # Add assertion to catch corruption early
+                assert len(content) > 0, f"Message content list is empty! This should contain images."
+        
         meta_out = {
             "inference_url": self.inference_url,
             "inference_request": payload,
@@ -484,7 +520,7 @@ class CrafterPolicy(Policy):
             "claude-3",         # All Claude 3 models support vision
             "gemini",           # Gemini models
             "qwen-vl",          # Qwen Vision-Language models
-            "qwen2-vl",         # Qwen2 VL
+            "qwen3-vl",         # Qwen3 VL
             "pixtral",          # Mistral's vision model
             "llava",            # LLaVA models
             "phi-3-vision",     # Microsoft Phi-3 Vision

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

@@ -45,8 +45,7 @@ class CrafterReActAgent:
             "Action policy:\n"
             "- Always return a single tool call: interact_many({actions: [...]})\n"
             "- Use 2–5 actions per call; prefer long movement sequences to explore.\n"
-            "- Mix in 'do' only when it makes sense (tree, stone, animal, enemy nearby).\n"
-            "- Do not spam the same exact sequence twice in a row—explore in varied directions.\n\n"
+            "- Mix in 'do' only when it makes sense (tree, stone, animal, enemy nearby).\n\n"
             "Available actions: noop, move_up, move_down, move_left, move_right, do (interact), sleep, "
             "place_stone, place_table, place_furnace, place_plant, make_wood_pickaxe, make_stone_pickaxe, "
             "make_iron_pickaxe, make_wood_sword, make_stone_sword, make_iron_sword\n"

examples/task_apps/crafter/task_app/synth_envs_hosted/inference/openai_client.py

@@ -50,20 +50,19 @@ class OpenAIClient:
         # Make a copy to avoid modifying the original
         fixed_request = request.copy()
 
-        # Determine if target is OpenAI-compatible (OpenAI, Azure OpenAI, Groq);
-        # strip fields those endpoints don't accept
+        # Determine if target is OpenAI-compatible (OpenAI, Azure OpenAI).
+        # Groq shares the API surface but we keep tool enforcement fields intact.
         is_openai = False
+        is_groq = False
         try:
             if isinstance(target_url, str):
                 low = target_url.lower()
-                is_openai = (
-                    ("openai.com" in low)
-                    or ("azure" in low and ".openai." in low)
-                    or ("groq.com" in low)
-                    or ("/openai" in low)
-                    or ("/proxy/groq" in low)
-                    or ("/proxy/openai" in low)
-                )
+                if "groq.com" in low or "/proxy/groq" in low:
+                    is_groq = True
+                elif ("openai.com" in low) or ("azure" in low and ".openai." in low) or (
+                    "/proxy/openai" in low
+                ):
+                    is_openai = True
         except Exception:
             is_openai = False
 
@@ -218,8 +217,20 @@ class OpenAIClient:
             # Do NOT fall back silently; surface the error so callers fail fast
             raise
 
+        # DEBUG: Log request BEFORE _fix_model_parameters
+        logger.debug(f"🔊 [OPENAI_CLIENT_PRE_FIX] Request message[1] content type: {type(request.get('messages', [])[1].get('content') if len(request.get('messages', [])) > 1 else None)}")
+        if len(request.get("messages", [])) > 1:
+            msg1_content = request["messages"][1].get("content")
+            logger.debug(f"🔊 [OPENAI_CLIENT_PRE_FIX] Message[1] content value: {msg1_content if not isinstance(msg1_content, list) else f'list[{len(msg1_content)}]'}")
+        
         # Fix parameter compatibility for newer models
         processed_request = self._fix_model_parameters(request, target_url=url)
+        
+        # DEBUG: Log request AFTER _fix_model_parameters
+        logger.debug(f"🔊 [OPENAI_CLIENT_POST_FIX] Processed message[1] content type: {type(processed_request.get('messages', [])[1].get('content') if len(processed_request.get('messages', [])) > 1 else None)}")
+        if len(processed_request.get("messages", [])) > 1:
+            msg1_content_post = processed_request["messages"][1].get("content")
+            logger.debug(f"🔊 [OPENAI_CLIENT_POST_FIX] Message[1] content value: {msg1_content_post if not isinstance(msg1_content_post, list) else f'list[{len(msg1_content_post)}]'}")
 
         # Log request (redact messages in production)
         logger.info(f"Inference POST target: {url}")
@@ -228,14 +239,32 @@ class OpenAIClient:
         with contextlib.suppress(Exception):
             keys_preview = sorted(processed_request.keys())
             logger.info(f"Request keys: {keys_preview}")
-
-        # Final hard-guard for OpenAI: ensure unsupported field is not present
+            # DEBUG: Log message structure for vision debugging
+            if "messages" in processed_request:
+                msgs = processed_request["messages"]
+                if isinstance(msgs, list):
+                    logger.debug(f"🔊 [OPENAI_CLIENT] Request has {len(msgs)} messages")
+                    for idx, msg in enumerate(msgs):
+                        if isinstance(msg, dict):
+                            role = msg.get("role")
+                            content = msg.get("content")
+                            if isinstance(content, list):
+                                logger.debug(f"🔊 [OPENAI_CLIENT] Message[{idx}] role={role}, content=list[{len(content)}]")
+                                for part_idx, part in enumerate(content):
+                                    if isinstance(part, dict):
+                                        part_type = part.get("type")
+                                        logger.debug(f"🔊 [OPENAI_CLIENT]   Part[{part_idx}]: type={part_type}")
+                            else:
+                                content_len = len(str(content)) if content else 0
+                                logger.debug(f"🔊 [OPENAI_CLIENT] Message[{idx}] role={role}, content_type={type(content).__name__}, len={content_len}")
+
+        # Final hard-guard for OpenAI/Groq: drop unsupported field
         try:
-            if "openai" in url.lower() and "stop_after_tool_calls" in processed_request:
+            low_url = url.lower()
+            if ("openai" in low_url or "groq.com" in low_url or "/proxy/groq" in low_url) and "stop_after_tool_calls" in processed_request:
                 processed_request.pop("stop_after_tool_calls", None)
-                logger.info("Removed stop_after_tool_calls for OpenAI request")
+                logger.info("Removed stop_after_tool_calls for %s request", "Groq/OpenAI")
             # Groq-specific requirement: when using JSON mode, one of the messages must contain the word 'json'
-            low_url = url.lower()
             if ("groq.com" in low_url or "/openai" in low_url) and isinstance(
                 processed_request, dict
             ):
@@ -516,47 +545,16 @@ class OpenAIClient:
                                     error_block.get("code") or error_block.get("type") or ""
                                 ).lower()
                             if error_code in {"tool_use_failed", "tool_call_failed"}:
-                                logger.warning(
+                                logger.error(
                                     {
                                         "tool_use_failed": True,
                                         "target": (base_url or self.base_url),
                                         "message": error_block.get("message") if isinstance(error_block, dict) else None,
                                     }
                                 )
-                                fallback_actions = ["move_right", "move_up", "do"]
-                                fallback_response = {
-                                    "id": f"fallback-{int(time.time() * 1000)}",
-                                    "object": "chat.completion",
-                                    "created": int(time.time()),
-                                    "model": processed_request.get("model"),
-                                    "choices": [
-                                        {
-                                            "index": 0,
-                                            "message": {
-                                                "role": "assistant",
-                                                "content": "",
-                                                "tool_calls": [
-                                                    {
-                                                        "id": f"call_fallback_{int(time.time() * 1000)}",
-                                                        "type": "function",
-                                                        "function": {
-                                                            "name": "interact_many",
-                                                            "arguments": json.dumps(
-                                                                {"actions": fallback_actions}
-                                                            ),
-                                                        },
-                                                    }
-                                                ],
-                                            },
-                                            "finish_reason": "tool_calls",
-                                        }
-                                    ],
-                                }
-                                if isinstance(response_data.get("usage"), dict):
-                                    fallback_response["usage"] = response_data["usage"]
-                                if isinstance(error_block, dict):
-                                    fallback_response["error"] = error_block
-                                return fallback_response
+                                raise RuntimeError(
+                                    f"Inference 400 response (tool call failed): {error_block.get('message') if isinstance(error_block, dict) else 'Tool call failed'}"
+                                ) from e
                             # This is a different type of 400 error, don't retry
                             try:
                                 redacted_headers = {}