synth-ai 0.2.13.dev2__py3-none-any.whl → 0.2.16__py3-none-any.whl

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

@@ -149,7 +149,11 @@ class OpenAIClient:
             OpenAI-compatible chat completion response
         """
         base = (base_url or self.base_url).rstrip("/")
-        url = base + "/v1/chat/completions"
+        # Don't append /v1/chat/completions if the URL already contains it
+        if "/v1/chat/completions" in base:
+            url = base
+        else:
+            url = base + "/v1/chat/completions"
         timeout = timeout_s or self.timeout_s
 
         # Merge headers
@@ -164,10 +168,28 @@ class OpenAIClient:
         except Exception:
             pass
 
-        # If target is our in-app Groq proxy, force Authorization to use GROQ_API_KEY
+        # Set Authorization header based on the target URL
         try:
             low_url = (url or "").lower()
-            if "/proxy/groq" in low_url or "groq" in low_url:
+            
+            # If calling OpenAI directly (api.openai.com)
+            if "api.openai.com" in low_url:
+                openai_key = os.getenv("OPENAI_API_KEY")
+                if openai_key and isinstance(openai_key, str):
+                    headers["Authorization"] = f"Bearer {openai_key}"
+            
+            # If target is Synth backend (any deployment), use SYNTH_API_KEY
+            # Matches: synth-backend-*, agent-learning*, localhost:8000, 127.0.0.1:8000
+            elif any(pattern in low_url for pattern in [
+                "synth-backend", "synth.run", "agent-learning",
+                "localhost:8000", "127.0.0.1:8000"
+            ]):
+                synth_key = os.getenv("SYNTH_API_KEY")
+                if synth_key and isinstance(synth_key, str):
+                    headers["Authorization"] = f"Bearer {synth_key}"
+            
+            # If target is Groq, use GROQ_API_KEY
+            elif "/proxy/groq" in low_url or "api.groq.com" in low_url:
                 gk = os.getenv("GROQ_API_KEY")
                 if gk and isinstance(gk, str):
                     headers["Authorization"] = f"Bearer {gk}"
@@ -196,8 +218,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}")
@@ -206,6 +240,24 @@ class OpenAIClient:
         with contextlib.suppress(Exception):
             keys_preview = sorted(processed_request.keys())
             logger.info(f"Request keys: {keys_preview}")
+            # 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: ensure unsupported field is not present
         try:

examples/task_apps/crafter/task_app/synth_envs_hosted/policy_routes.py

@@ -10,11 +10,13 @@ from fastapi import APIRouter, HTTPException, Request
 from pydantic import BaseModel
 
 from synth_ai.task.auth import allowed_environment_api_keys, normalize_environment_api_key
+from synth_ai.task.contracts import RolloutMode
 
 from .envs.crafter.policy import CrafterPolicy
 from .inference.openai_client import create_inference_client
 from .registry import registry
 from .storage.volume import storage
+from .utils import ensure_chat_completions_url
 
 # Token budgeting (shared logic with inference server)
 try:
@@ -40,6 +42,7 @@ class PolicyCreateRequest(BaseModel):
     parent_policy_id: str | None = None
     rl_run_id: str
     bound_env_id: str | None = None
+    mode: RolloutMode
 
 
 class PolicyCreateResponse(BaseModel):
@@ -119,6 +122,14 @@ async def create_policy(
             config.setdefault("inference_url", f"{base_url}/proxy")
             config["provider"] = "openai"
 
+        received_url = config.get("inference_url")
+        logger.info(
+            "POLICY_CREATE: policy=%s provider=%s raw_inference_url=%s",
+            request.policy_name,
+            provider,
+            received_url,
+        )
+
         if "inference_url" not in config and task_app is not None:
             task_base_url = getattr(task_app, "vllm_base_url", None)
             if task_base_url:
@@ -133,6 +144,31 @@ async def create_policy(
                 detail="Policy configuration must include 'inference_url' and 'model'.",
             )
 
+        # Get mode from PolicyCreateRequest (defaults to "rl" for backward compatibility)
+        mode = request.mode
+        logger.info("POLICY_CREATE: Using mode=%s for URL processing", mode)
+        
+        sanitized_url = ensure_chat_completions_url(config.get("inference_url"), mode=mode)
+        if isinstance(sanitized_url, str) and sanitized_url:
+            if sanitized_url != config.get("inference_url"):
+                logger.warning(
+                    "POLICY_CREATE: normalized inference_url for policy=%s provider=%s mode=%s from %s to %s",
+                    request.policy_name,
+                    provider,
+                    mode,
+                    config.get("inference_url"),
+                    sanitized_url,
+                )
+            config["inference_url"] = sanitized_url
+        else:
+            logger.warning(
+                "POLICY_CREATE: unable to normalize inference_url for policy=%s provider=%s mode=%s raw=%s",
+                request.policy_name,
+                mode,
+                provider,
+                config.get("inference_url"),
+            )
+
         # Create policy instance based on name
         pname = request.policy_name.lower()
         if pname in ["crafter-react", "crafter"]:
@@ -381,8 +417,6 @@ async def step_policy(
             inf_req = meta["inference_request"]
             msgs = inf_req["messages"]
             model_name = inf_req.get("model") or getattr(policy, "model", None) or ""
-            system_messages: list[str] = []
-            user_messages: list[str] = []
             if msgs and len(msgs) > 0 and msgs[0]["role"] == "system":
                 sys_text = msgs[0]["content"]
                 policy_name = getattr(policy, "name", "") or type(policy).__name__.lower()
@@ -507,7 +541,22 @@ async def step_policy(
 
             # Ensure meta carries the final target URL for downstream logging/clients
             with contextlib.suppress(Exception):
-                meta["inference_url"] = target_url
+                sanitized_target = ensure_chat_completions_url(target_url)
+                if sanitized_target and sanitized_target != target_url:
+                    logger.warning(
+                        "POLICY_STEP: normalized inference_url mid-flight policy=%s from %s to %s",
+                        policy_name,
+                        target_url,
+                        sanitized_target,
+                    )
+                elif not sanitized_target:
+                    logger.info(
+                        "POLICY_STEP: inference_url unchanged policy=%s target=%s",
+                        policy_name,
+                        target_url,
+                    )
+                meta["inference_url"] = sanitized_target if sanitized_target else target_url
+                target_url = sanitized_target or target_url
 
             # Select API key based on resolved target URL
             api_key_override = None
@@ -850,38 +899,71 @@ async def step_policy(
                             req_body["temperature"] = 0.1
                         meta["inference_request"] = req_body
 
-                # Strip image parts: Crafter policy currently only uses text prompts.
-                # Some providers reject image_url payloads entirely, so always flatten to plain text.
-                req_body2 = meta.get("inference_request", {})
-                if isinstance(req_body2, dict):
-                    msgs = req_body2.get("messages")
-                    if isinstance(msgs, list):
-                        new_msgs = []
-                        changed = False
-                        for m in msgs:
-                            try:
-                                if isinstance(m, dict):
-                                    content = m.get("content")
-                                    if isinstance(content, list):
-                                        parts: list[str] = []
-                                        for seg in content:
-                                            if isinstance(seg, dict):
-                                                txt = seg.get("text") or seg.get("content")
-                                                if isinstance(txt, str) and txt:
-                                                    parts.append(txt)
-                                        m2 = dict(m)
-                                        m2["content"] = "\n".join(parts)
-                                        new_msgs.append(m2)
-                                        changed = True
+                # Message flattening: Convert multimodal content to text-only for non-vision models.
+                # SKIP message flattening for vision models to preserve image_url parts!
+                # The old code here was flattening multimodal content (list) to text-only (str),
+                # which strips out image_url parts. This breaks vision models.
+                # Only flatten for non-vision models that can't handle multimodal format.
+                is_vision_model = False
+                try:
+                    # Check if the policy is a vision-capable policy
+                    if isinstance(policy, CrafterPolicy):
+                        is_vision_model = getattr(policy, "use_vision", False)
+                except Exception:
+                    pass
+                
+                logger.debug(f"🔊 [POLICY_ROUTES] is_vision_model={is_vision_model}, will_flatten={not is_vision_model}")
+                
+                if not is_vision_model:
+                    # Only flatten for non-vision models (backward compatibility)
+                    req_body2 = meta.get("inference_request", {})
+                    if isinstance(req_body2, dict):
+                        msgs = req_body2.get("messages")
+                        if isinstance(msgs, list):
+                            new_msgs = []
+                            changed = False
+                            for m in msgs:
+                                try:
+                                    if isinstance(m, dict):
+                                        content = m.get("content")
+                                        if isinstance(content, list):
+                                            parts: list[str] = []
+                                            for seg in content:
+                                                if isinstance(seg, dict):
+                                                    txt = seg.get("text") or seg.get("content")
+                                                    if isinstance(txt, str) and txt:
+                                                        parts.append(txt)
+                                            m2 = dict(m)
+                                            m2["content"] = "\n".join(parts)
+                                            new_msgs.append(m2)
+                                            changed = True
+                                        else:
+                                            new_msgs.append(m)
                                     else:
                                         new_msgs.append(m)
-                                else:
+                                except Exception:
                                     new_msgs.append(m)
-                            except Exception:
-                                new_msgs.append(m)
-                        if changed:
-                            req_body2["messages"] = new_msgs
-                            meta["inference_request"] = req_body2
+                            if changed:
+                                req_body2["messages"] = new_msgs
+                                meta["inference_request"] = req_body2
+                                logger.debug(f"🔊 [POLICY_ROUTES] Flattened messages for non-vision model")
+                else:
+                    logger.debug(f"🔊 [POLICY_ROUTES] Preserving multimodal content for vision model")
+                
+                # DEBUG: Log final message structure before calling inference
+                final_req = meta.get("inference_request", {})
+                if isinstance(final_req, dict):
+                    final_msgs = final_req.get("messages", [])
+                    logger.debug(f"🔊 [POLICY_ROUTES_FINAL] Sending {len(final_msgs)} messages to inference")
+                    for idx, msg in enumerate(final_msgs):
+                        if isinstance(msg, dict):
+                            content = msg.get("content")
+                            logger.debug(f"🔊 [POLICY_ROUTES_FINAL] Message[{idx}]: type={type(content).__name__}, is_list={isinstance(content, list)}")
+                            if isinstance(content, list):
+                                logger.debug(f"🔊 [POLICY_ROUTES_FINAL]   Content list has {len(content)} items")
+                                for part_idx, part in enumerate(content[:3]):  # Show first 3 items
+                                    if isinstance(part, dict):
+                                        logger.debug(f"🔊 [POLICY_ROUTES_FINAL]     Part[{part_idx}]: type={part.get('type')}")
 
             _t_start = _t.time()
             call_started_at = datetime.utcnow()

examples/task_apps/crafter/task_app/synth_envs_hosted/rollout.py

@@ -13,6 +13,7 @@ from pydantic import BaseModel, Field
 from synth_ai.lm.vendors.base import BaseLMResponse
 from synth_ai.task.tracing_utils import unique_sft_path
 from synth_ai.tracing_v3.abstractions import EnvironmentEvent, LMCAISEvent, TimeRecord
+from synth_ai.task.contracts import RolloutMode
 from synth_ai.tracing_v3.llm_call_record_helpers import create_llm_call_record_from_response
 from synth_ai.tracing_v3.session_tracer import SessionTracer
 
@@ -120,6 +121,8 @@ class RolloutRequest(BaseModel):
     # Optional run/session context
     training_session_id: str | None = None
     synth_base_url: str | None = None
+    # Mode controls URL transformation: REQUIRED to make intent explicit
+    mode: RolloutMode
 
 
 class RolloutStep(BaseModel):
@@ -140,6 +143,7 @@ class RolloutTrajectory(BaseModel):
     final: dict[str, Any] | None = None
     length: int
     decision_samples: list[dict[str, Any]] | None = None
+    inference_url: str | None = None
 
 
 def _normalize_step_strategy(raw_strategy: Any) -> str:
@@ -452,11 +456,12 @@ class RolloutMetrics(BaseModel):
 class RolloutResponse(BaseModel):
     run_id: str
     trajectories: list[RolloutTrajectory]
-    branches: dict[str, list[str]] = {}
+    branches: dict[str, list[str]] = Field(default_factory=dict)
     metrics: RolloutMetrics
     aborted: bool = False
     ops_executed: int = 0
     trace: dict[str, Any] | None = None
+    pipeline_metadata: dict[str, Any] = Field(default_factory=dict)
 
 
 class RolloutTracingContext:
@@ -567,7 +572,7 @@ class RolloutTracingContext:
             try:
                 await self.tracer.record_message(
                     content=self._prompt_payload(entry, role="system"),
-                    message_type="policy_system_prompt",
+                    message_type="system",  # Use standard message type
                     metadata=self._message_metadata(),
                 )
             except Exception as exc:
@@ -576,11 +581,16 @@ class RolloutTracingContext:
             try:
                 await self.tracer.record_message(
                     content=self._prompt_payload(entry, role="user"),
-                    message_type="policy_user_prompt",
+                    message_type="user",  # Use standard message type
                     metadata=self._message_metadata(),
                 )
             except Exception as exc:
                 logger.debug("TRACING_USER_MSG_FAIL: %s", exc)
+        
+        # Debug: Check message count
+        if self.tracer and self.tracer._current_trace:
+            msg_count = len(self.tracer._current_trace.markov_blanket_message_history)
+            logger.info(f"[TRACE_DEBUG] After record_policy_prompts: {msg_count} messages in trace")
 
     def _content_to_text(self, content: Any) -> str:
         if isinstance(content, str):
@@ -656,8 +666,8 @@ class RolloutTracingContext:
             try:
                 await self.tracer.record_message(
                     content=self._safe_json(tool_calls),
-                    message_type="policy_tool_call",
-                    metadata=self._message_metadata(),
+                    message_type="assistant",  # Map to standard assistant message type
+                    metadata={**self._message_metadata(), "is_tool_call": True},
                 )
             except Exception as exc:
                 logger.debug("TRACING_TOOL_MSG_FAIL: %s", exc)
@@ -928,11 +938,22 @@ class RolloutTracingContext:
             except Exception as exc:
                 logger.debug("TRACING_OUTCOME_FAIL: %s", exc)
             try:
+                # Debug: Check message count before end_session
+                if self.tracer._current_trace:
+                    msg_count = len(self.tracer._current_trace.markov_blanket_message_history)
+                    logger.info(f"[TRACE_DEBUG] Before end_session: {msg_count} messages in trace")
+                
                 self.session_trace = await self.tracer.end_session()
-                if self.session_trace is not None:
+                
+                # Debug: Check if session was saved
+                if self.session_trace:
+                    logger.info(f"[TRACE_DEBUG] Session ended successfully, session_id={self.session_trace.session_id}")
                     self.session_trace.metadata.update(self.metadata_updates)
+                    logger.info(f"[TRACE_DEBUG] session_trace.metadata keys: {list(self.session_trace.metadata.keys())}")
+                else:
+                    logger.warning("[TRACE_DEBUG] end_session returned None!")
             except Exception as exc:
-                logger.debug("TRACING_END_SESSION_FAIL: %s", exc)
+                logger.warning(f"TRACING_END_SESSION_FAIL: {exc}", exc_info=True)
                 self.session_trace = None
             with contextlib.suppress(Exception):
                 await self.tracer.close()
@@ -964,10 +985,15 @@ class RolloutTracingContext:
     def build_trace_payload(self, session_trace: Any) -> dict[str, Any] | None:
         if not self.return_trace or session_trace is None:
             return None
-        if self.trace_format == "full":
+        
+        # For both "full" and "structured" formats, return the complete session trace
+        # The CLI (synth-ai eval) expects this for proper trace storage
+        if self.trace_format in ("full", "structured"):
             payload = session_trace.to_dict()
             payload.setdefault("metadata", {}).update(self.metadata_updates)
             return payload
+        
+        # For "compact" format, return only summary stats
         metadata = dict(session_trace.metadata)
         metadata.update(self.metadata_updates)
         return {
@@ -1056,12 +1082,14 @@ async def execute_rollout(
     req: Request,
 ) -> RolloutResponse:
     """Execute a rollout with coordinated environment and policy steps."""
+    logger.info("ROLLOUT: mode = %s", request.mode)
+    
     # Emit rollout identifier early for correlation
     with contextlib.suppress(Exception):
         _rid = getattr(request, "run_id", None)
         _pol = getattr(request.policy, "policy_name", None) or getattr(request.policy, "policy_id", None)
         _env = getattr(request.env, "env_name", None) or getattr(request.env, "env_id", None)
-        logger.info("ROLLOUT_BEGIN: run_id=%s policy=%s env=%s", _rid, _pol, _env)
+        logger.info("ROLLOUT_BEGIN: run_id=%s policy=%s env=%s mode=%s", _rid, _pol, _env, request.mode)
         print(f"[rollout] begin run_id={_rid} policy={_pol} env={_env}", flush=True)
     # Enforce per-episode step cap via env-specific parameters; default to 20 if omitted
     try:
@@ -1150,14 +1178,6 @@ async def execute_rollout(
             logger.debug(f"TRACER_FACTORY_FAIL: {exc}")
     tracing_context = RolloutTracingContext(tracer_instance, request, req)
     await tracing_context.start_session()
-    # Print whether tracing is active for this rollout
-    try:
-        print(
-            f"[rollout] tracing enabled={bool(tracing_context.enabled)} run_id={request.run_id}",
-            flush=True,
-        )
-    except Exception:
-        pass
 
     # Register run
     registry.register_run(request.run_id)
@@ -1271,6 +1291,7 @@ async def execute_rollout(
                     config=_policy_config,
                     rl_run_id=request.run_id,
                     bound_env_id=env_id,
+                    mode=request.mode,  # Pass through mode for URL transformation control
                 ),
                 req,
             )
@@ -1601,16 +1622,21 @@ async def execute_rollout(
 
             elif op == "env":
                 if not pending_tool_calls:
+                    # Instead of failing, inject a no-op action to keep the rollout going
                     with contextlib.suppress(Exception):
                         logger.warning(
-                            "POLICY_STEP_FAIL: missing tool_calls; failing rollout run_id=%s op_idx=%s",
+                            "POLICY_STEP_NOOP: missing tool_calls; injecting noop action run_id=%s op_idx=%s",
                             request.run_id,
                             str(op_idx),
                         )
-                    raise HTTPException(
-                        status_code=500,
-                        detail="policy_step_failed: missing tool_calls (no_tool_calls)",
-                    )
+                    # Create a noop tool call in the format expected by the environment
+                    pending_tool_calls = [
+                        {
+                            "id": f"noop_{op_idx}",
+                            "tool": "interact",
+                            "arguments": {"action": "noop"},
+                        }
+                    ]
 
                 # Environment step
                 from .environment_routes import EnvStepRequest, step_environment
@@ -1843,14 +1869,73 @@ async def execute_rollout(
                     timing_final.setdefault("overhead_ms", 0.0)
 
         # Build trajectory
-        # Extract inference_url from policy meta
+        # Extract inference_url from policy config (REQUIRED for trace correlation)
+        # The trainer sets this in policy config with ?cid=... parameter
         inference_url = None
-        if policy_handle is not None:
+        
+        # Try policy config from request first (most reliable source)
+        try:
+            policy_config_snapshot = (
+                request.policy.config if isinstance(request.policy.config, dict) else {}
+            )
+            inference_url = policy_config_snapshot.get("inference_url")
+            if inference_url:
+                logger.info(
+                    "ROLLOUT_TRAJECTORY: extracted inference_url from request.policy.config run_id=%s url=%s",
+                    request.run_id,
+                    inference_url,
+                )
+        except Exception as exc:
+            logger.warning(
+                "ROLLOUT_TRAJECTORY: failed to get inference_url from request.policy.config run_id=%s: %s",
+                request.run_id,
+                exc,
+            )
+        
+        # Fallback: Try policy handle snapshot (if request.policy.config failed)
+        if not inference_url and policy_handle is not None:
             try:
                 policy_snapshot = policy_handle.snapshot()
                 inference_url = policy_snapshot.get("config", {}).get("inference_url")
-            except Exception:
-                pass
+                if inference_url:
+                    logger.info(
+                        "ROLLOUT_TRAJECTORY: extracted inference_url from policy_handle.snapshot run_id=%s url=%s",
+                        request.run_id,
+                        inference_url,
+                    )
+            except Exception as exc:
+                logger.warning(
+                    "ROLLOUT_TRAJECTORY: failed to snapshot policy for run_id=%s policy_id=%s: %s",
+                    request.run_id,
+                    policy_id,
+                    exc,
+                )
+        
+        # ASSERTION: inference_url MUST be present (required by RolloutTrajectory schema)
+        if not inference_url:
+            raise ValueError(
+                f"FATAL: inference_url is required but not found!\n"
+                f"\n"
+                f"run_id: {request.run_id}\n"
+                f"policy_id: {policy_id}\n"
+                f"policy_config_keys: {list(policy_config_snapshot.keys()) if 'policy_config_snapshot' in locals() else 'N/A'}\n"
+                f"\n"
+                f"The trainer MUST set inference_url in policy config with ?cid=... parameter.\n"
+                f"This is required for trace correlation and hydration.\n"
+            )
+        
+        # policy_config_snapshot already set above in try block (line 1876-1878)
+        # Ensure it exists for logging below
+        if 'policy_config_snapshot' not in locals():
+            policy_config_snapshot = {}
+        
+        logger.info(
+            "ROLLOUT_TRAJECTORY: run_id=%s policy_id=%s inference_url=%s trace_id=%s",
+            request.run_id,
+            policy_id,
+            inference_url,
+            policy_config_snapshot.get("trace_correlation_id"),
+        )
         
         trajectory = RolloutTrajectory(
             env_id=env_id,
@@ -1948,12 +2033,17 @@ async def execute_rollout(
             )
             finalized = True
         trace_payload = tracing_context.build_trace_payload(session_trace)
+        
+        # Debug: Check trace payload
+        logger.info(f"[TRACE_DEBUG] trace_payload is None: {trace_payload is None}, return_trace={tracing_context.return_trace}")
+        if trace_payload:
+            logger.info(f"[TRACE_DEBUG] trace_payload keys: {list(trace_payload.keys())}")
 
         # Hard-fail if no steps executed (avg_turns == 0 scenario)
         if metrics.num_steps <= 0:
             raise HTTPException(status_code=500, detail="no_steps_executed: avg_turns == 0")
 
-        return RolloutResponse(
+        response = RolloutResponse(
             run_id=request.run_id,
             trajectories=[trajectory],
             branches={},
@@ -1962,6 +2052,16 @@ async def execute_rollout(
             ops_executed=ops_executed,
             trace=trace_payload,
         )
+        logger.info(
+            "ROLLOUT_RESPONSE: run_id=%s aborted=%s ops_executed=%s metrics_steps=%s trace_present=%s pipeline_metadata=%s",
+            request.run_id,
+            aborted,
+            ops_executed,
+            metrics.num_steps,
+            bool(trace_payload),
+            response.pipeline_metadata,
+        )
+        return response
 
     except Exception as e:
         logger.error(f"Rollout failed for run {request.run_id}: {e}")