synth-ai 0.2.16__py3-none-any.whl → 0.2.19__py3-none-any.whl

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

@@ -4,6 +4,7 @@ import contextlib
 import logging
 import os
 from datetime import datetime
+import asyncio
 from typing import Any
 
 from fastapi import APIRouter, HTTPException, Request
@@ -35,6 +36,13 @@ logger = logging.getLogger(__name__)
 
 router = APIRouter()
 
+# Global concurrency limit for outbound inference to avoid backend overload/timeouts
+try:
+    _INFERENCE_CONCURRENCY = int(os.getenv("INFERENCE_CONCURRENCY", "2") or "2")
+except Exception:  # pragma: no cover
+    _INFERENCE_CONCURRENCY = 2
+_inference_sem = asyncio.Semaphore(max(1, _INFERENCE_CONCURRENCY))
+
 
 class PolicyCreateRequest(BaseModel):
     policy_name: str
@@ -250,6 +258,11 @@ async def step_policy(
         task_app = req.app.state.task_app
         policy = handle.policy
         tracing_context = getattr(req.state, "rollout_tracing", None)
+        if tracing_context is None:
+            print(
+                f"[TRACE_DEBUG] Missing tracing context on policy step; policy_id={request.policy_id}",
+                flush=True,
+            )
 
         obs_text = request.observation
         if isinstance(request.observation, dict):
@@ -462,6 +475,8 @@ async def step_policy(
                 )
 
             # Emit full system/user prompts for observability (no secrets included)
+            system_prompt_records: list[dict[str, Any]] = []
+            user_prompt_records: list[dict[str, Any]] = []
             try:
 
                 def _as_text(content: object) -> str:
@@ -481,8 +496,6 @@ async def step_policy(
                         return "".join(parts)
                     return str(content)
 
-                system_prompt_records: list[dict[str, Any]] = []
-                user_prompt_records: list[dict[str, Any]] = []
                 for message in msgs:
                     role = message.get("role")
                     raw_content = message.get("content")
@@ -525,6 +538,11 @@ async def step_policy(
 
             if tracing_context is not None:
                 try:
+                    logger.info(
+                        "[TRACE_DEBUG] record_policy_prompts sys=%s user=%s",
+                        len(system_prompt_records),
+                        len(user_prompt_records),
+                    )
                     await tracing_context.record_policy_prompts(
                         system_prompt_records, user_prompt_records
                     )
@@ -541,6 +559,14 @@ async def step_policy(
 
             # Ensure meta carries the final target URL for downstream logging/clients
             with contextlib.suppress(Exception):
+                # Bulletproof normalizer at the call site (in addition to client-side)
+                try:
+                    from examples.task_apps.crafter.task_app.synth_envs_hosted.utils import (
+                        force_normalize_chat_completions_url,
+                    )
+                    target_url = force_normalize_chat_completions_url(target_url)
+                except Exception:
+                    pass
                 sanitized_target = ensure_chat_completions_url(target_url)
                 if sanitized_target and sanitized_target != target_url:
                     logger.warning(
@@ -589,6 +615,28 @@ async def step_policy(
             except Exception:
                 api_key_override = None
 
+            # Fallback: If target is OpenAI but OPENAI_API_KEY is missing, route to Synth API
+            try:
+                import os as _os2
+                _low = str(target_url or "").lower()
+                if ("api.openai.com" in _low) and not (_os2.getenv("OPENAI_API_KEY")):
+                    # Prefer task_app.synth_base_url if available; else default
+                    synth_base = getattr(task_app, "synth_base_url", None)
+                    if isinstance(synth_base, str) and synth_base.strip():
+                        base = synth_base.rstrip("/")
+                        fallback = base + "/inference/v1/chat/completions"
+                    else:
+                        fallback = "https://api.synth.run/api/inference/v1/chat/completions"
+                    fixed = ensure_chat_completions_url(fallback)
+                    logger.warning(
+                        "POLICY_STEP: OPENAI key missing; falling back to Synth route %s",
+                        fixed,
+                    )
+                    meta["inference_url"] = fixed
+                    target_url = fixed
+            except Exception:
+                pass
+
             if api_key_override:
                 try:
                     masked = f"{api_key_override[:6]}…{api_key_override[-4:]}"
@@ -780,9 +828,10 @@ async def step_policy(
                 "sokoban-react",
                 "crafter-react",
             ) and getattr(policy, "use_tools", True):
-                req_tools = meta["inference_request"]["tools"]
-                req_tool_choice = meta["inference_request"]["tool_choice"]
-                req_stop_after = meta["inference_request"]["stop_after_tool_calls"]
+                inf_req = meta.get("inference_request", {})
+                req_tools = inf_req.get("tools")
+                req_tool_choice = inf_req.get("tool_choice")
+                req_stop_after = inf_req.get("stop_after_tool_calls")
                 logger.info(
                     f"TOOLCALL_CONFIG: policy={policy_name} tools_present={bool(req_tools)} tool_choice={req_tool_choice} stop_after={req_stop_after}"
                 )
@@ -791,6 +840,8 @@ async def step_policy(
                         status_code=500,
                         detail=f"TOOLCALL_ASSERTION_FAIL: Missing tools or tool_choice!=required for policy {policy_name}",
                     )
+                if req_stop_after is None:
+                    inf_req["stop_after_tool_calls"] = 1
 
             # Call inference service with retries for Flash cold-start (503)
             import time as _t
@@ -967,13 +1018,14 @@ async def step_policy(
 
             _t_start = _t.time()
             call_started_at = datetime.utcnow()
-            inference_response = await client.generate_with_retries(
-                request=meta["inference_request"],
-                base_url=meta["inference_url"],
-                max_retries=12,
-                backoff_factor=2.0,
-                extra_headers=extra_headers,
-            )
+            async with _inference_sem:
+                inference_response = await client.generate_with_retries(
+                    request=meta["inference_request"],
+                    base_url=meta["inference_url"],
+                    max_retries=12,
+                    backoff_factor=2.0,
+                    extra_headers=extra_headers,
+                )
             meta["inference_ms"] = int((_t.time() - _t_start) * 1000)
             call_completed_at = datetime.utcnow()
 
@@ -1053,6 +1105,23 @@ async def step_policy(
                 except Exception as exc:
                     logger.debug(f"TRACING_LLM_FAIL: {exc}")
 
+        if not tool_calls:
+            preview = ""
+            try:
+                preview = str(meta.get("raw_response") or "")[:400]
+            except Exception:
+                preview = "<unavailable>"
+            logger.error(
+                {
+                    "rollout.policy_step": True,
+                    "policy_id": request.policy_id,
+                    "error": "no_tool_calls",
+                    "inference_url": meta.get("inference_url"),
+                    "raw_preview": preview,
+                }
+            )
+            raise RuntimeError("Policy step produced no tool calls; inference response unusable.")
+
         return PolicyStepResponse(
             tool_calls=tool_calls,
             meta=meta,

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

@@ -491,6 +491,10 @@ class RolloutTracingContext:
             getattr(request.record, "trace_format", "compact") or "compact"
         ).lower()
         self.return_trace = bool(getattr(request.record, "return_trace", False))
+        print(
+            f"[TRACE_DEBUG] RolloutTracingContext init: trace_format={self.trace_format} return_trace={self.return_trace}",
+            flush=True,
+        )
         self.sft_output_dir = getattr(fastapi_request.app.state, "sft_output_dir", None)
         self.session_trace = None
         self.metadata_updates: dict[str, Any] = {}
@@ -513,19 +517,24 @@ class RolloutTracingContext:
 
     async def start_session(self) -> None:
         if not self.enabled or self.tracer is None:
+            print("[TRACE_DEBUG] start_session skipped: tracer disabled", flush=True)
             return
         try:
             await self.tracer.initialize()
+            print("[TRACE_DEBUG] tracer initialized", flush=True)
         except Exception as exc:
             logger.debug("TRACING_INIT_FAIL: %s", exc)
+            # Hard fail: tracing requested but cannot initialize
+            raise
         try:
             await self.tracer.start_session(
                 session_id=self.run_id, metadata=dict(self.metadata_base)
             )
+            print(f"[TRACE_DEBUG] start_session succeeded for run_id={self.run_id}", flush=True)
         except Exception as exc:
             logger.info("TRACING_START_FAIL: %s", exc)
-            self.enabled = False
-            self.tracer = None
+            # Hard fail: tracing requested but cannot start session
+            raise
 
     async def start_decision(self, turn_number: int) -> None:
         self.current_turn = turn_number
@@ -590,7 +599,7 @@ class RolloutTracingContext:
         # 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")
+            print(f"[TRACE_DEBUG] After record_policy_prompts: {msg_count} messages", flush=True)
 
     def _content_to_text(self, content: Any) -> str:
         if isinstance(content, str):
@@ -664,11 +673,20 @@ class RolloutTracingContext:
             return
         if self.enabled and self.tracer is not None:
             try:
+                payload = {
+                    "role": "assistant",
+                    "tool_calls": tool_calls,
+                }
                 await self.tracer.record_message(
-                    content=self._safe_json(tool_calls),
-                    message_type="assistant",  # Map to standard assistant message type
+                    content=payload,
+                    message_type="assistant",
                     metadata={**self._message_metadata(), "is_tool_call": True},
                 )
+                if self.tracer._current_trace:
+                    print(
+                        f"[TRACE_DEBUG] After tool invocation: messages={len(self.tracer._current_trace.markov_blanket_message_history)}",
+                        flush=True,
+                    )
             except Exception as exc:
                 logger.debug("TRACING_TOOL_MSG_FAIL: %s", exc)
 
@@ -774,9 +792,33 @@ class RolloutTracingContext:
             }
         )
 
+        assistant_structured = assistant_content if assistant_content is not None else ""
+        assistant_text = self._content_to_text(assistant_content)
+
+        if self.enabled and self.tracer is not None:
+            assistant_payload: dict[str, Any] = {
+                "role": "assistant",
+                "content": assistant_structured,
+                "text": assistant_text,
+            }
+            if isinstance(assistant_message, dict):
+                if assistant_message.get("tool_calls"):
+                    assistant_payload["tool_calls"] = assistant_message.get("tool_calls")
+                if assistant_message.get("reasoning"):
+                    assistant_payload["reasoning"] = assistant_message.get("reasoning")
+                if assistant_message.get("thinking"):
+                    assistant_payload["thinking"] = assistant_message.get("thinking")
+            try:
+                await self.tracer.record_message(
+                    content=assistant_payload,
+                    message_type="assistant",
+                    metadata=self._message_metadata(),
+                )
+            except Exception as exc:
+                logger.debug("TRACING_ASSISTANT_MSG_FAIL: %s", exc)
+
         if self.sft_output_dir is not None:
             assistant_structured = assistant_content if assistant_content is not None else ""
-            assistant_text = self._content_to_text(assistant_content)
             dialogue_structured: list[dict[str, Any]] = []
             for content in self.latest_system_prompt_content:
                 if content is None:
@@ -941,17 +983,23 @@ class RolloutTracingContext:
                 # 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")
-                
+                    print(f"[TRACE_DEBUG] Before end_session: {msg_count} messages in trace", flush=True)
+
                 self.session_trace = await self.tracer.end_session()
                 
                 # 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}")
+                    print(
+                        f"[TRACE_DEBUG] Session ended successfully, session_id={self.session_trace.session_id}",
+                        flush=True,
+                    )
                     self.session_trace.metadata.update(self.metadata_updates)
-                    logger.info(f"[TRACE_DEBUG] session_trace.metadata keys: {list(self.session_trace.metadata.keys())}")
+                    print(
+                        f"[TRACE_DEBUG] session_trace.metadata keys: {list(self.session_trace.metadata.keys())}",
+                        flush=True,
+                    )
                 else:
-                    logger.warning("[TRACE_DEBUG] end_session returned None!")
+                    print("[TRACE_DEBUG] end_session returned None!", flush=True)
             except Exception as exc:
                 logger.warning(f"TRACING_END_SESSION_FAIL: {exc}", exc_info=True)
                 self.session_trace = None
@@ -991,6 +1039,10 @@ class RolloutTracingContext:
         if self.trace_format in ("full", "structured"):
             payload = session_trace.to_dict()
             payload.setdefault("metadata", {}).update(self.metadata_updates)
+            print(
+                f"[TRACE_DEBUG] build_trace_payload returning structured trace with messages={len(payload.get('markov_blanket_message_history') or [])}",
+                flush=True,
+            )
             return payload
         
         # For "compact" format, return only summary stats
@@ -1929,6 +1981,15 @@ async def execute_rollout(
         if 'policy_config_snapshot' not in locals():
             policy_config_snapshot = {}
         
+        # Normalize inference URL for trajectory (and ensure no path in query)
+        try:
+            from .utils import force_normalize_chat_completions_url, ensure_chat_completions_url
+            inference_url = force_normalize_chat_completions_url(inference_url)
+            # apply mode-aware normalization too (keeps cid, appends path if missing)
+            inference_url = ensure_chat_completions_url(inference_url, mode=request.mode)
+        except Exception:
+            pass
+
         logger.info(
             "ROLLOUT_TRAJECTORY: run_id=%s policy_id=%s inference_url=%s trace_id=%s",
             request.run_id,
@@ -2043,6 +2104,16 @@ async def execute_rollout(
         if metrics.num_steps <= 0:
             raise HTTPException(status_code=500, detail="no_steps_executed: avg_turns == 0")
 
+        # Ensure at least one tool call executed successfully
+        tool_call_executed = any(
+            isinstance(step.tool_calls, list) and len(step.tool_calls) > 0 for step in trajectory_steps
+        )
+        if not tool_call_executed:
+            raise HTTPException(
+                status_code=502,
+                detail="no_tool_calls_executed: model failed to produce actionable tool calls.",
+            )
+
         response = RolloutResponse(
             run_id=request.run_id,
             trajectories=[trajectory],

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

@@ -11,6 +11,129 @@ logger = logging.getLogger(__name__)
 _CHAT_COMPLETIONS_SUFFIX = "/v1/chat/completions"
 
 
+def force_normalize_chat_completions_url(raw_url: Any) -> str:
+    """
+    Bulletproof normalizer: converts ANY malformed inference URL into the
+    correct chat-completions URL form.
+
+    Rules:
+    - Final path MUST end with /v1/chat/completions
+    - Query MUST NOT contain any '/' characters (no path segments in query)
+    - If the original query contained a path (e.g., '?cid=.../v1/chat/completions'),
+      extract that path and move it to the URL path; keep remaining query params
+    - Preserve scheme, host, port and existing query params order as much as possible
+
+    Examples:
+      https://host?cid=trace_123/v1/chat/completions
+        -> https://host/v1/chat/completions?cid=trace_123
+      https://host:8000?cid=trace_abc/v1/chat/completions&foo=bar
+        -> https://host:8000/v1/chat/completions?cid=trace_abc&foo=bar
+      https://host?cid=trace_123/v1/chat/completions?other=param
+        -> https://host/v1/chat/completions?cid=trace_123&other=param
+    """
+    if not isinstance(raw_url, str):
+        return raw_url
+    url = raw_url.strip()
+    if not url:
+        return raw_url
+
+    parsed = urlparse(url)
+    path = (parsed.path or "").rstrip("/")
+    query = parsed.query or ""
+
+    # If query contains a path (has '/'), extract and repair
+    if query and "/" in query:
+        # Split query at the first '/' (everything before is real query params)
+        before_slash, after_slash = query.split("/", 1)
+
+        # after_slash may contain path and then more query params separated by '&' or '?' (malformed)
+        sep_indices = [i for i in [after_slash.find("&"), after_slash.find("?")] if i >= 0]
+        cut_idx = min(sep_indices) if sep_indices else len(after_slash)
+        path_from_query = "/" + after_slash[:cut_idx]  # restore leading '/'
+        extra_query = after_slash[cut_idx + 1 :] if cut_idx < len(after_slash) else ""
+
+        # Merge query params: base (before_slash) + extra_query
+        merged_query = before_slash
+        if extra_query:
+            merged_query = f"{merged_query}&{extra_query}" if merged_query else extra_query
+
+        # Decide final path
+        if path_from_query.startswith(_CHAT_COMPLETIONS_SUFFIX):
+            final_path = path_from_query
+        else:
+            final_path = f"{path_from_query.rstrip('/')}{_CHAT_COMPLETIONS_SUFFIX}"
+
+        parsed = parsed._replace(path=final_path, query=merged_query)
+        url = urlunparse(parsed)
+        parsed = urlparse(url)
+        path = parsed.path or ""
+        query = parsed.query or ""
+
+    # Ensure path ends with chat completions suffix
+    if not path.endswith(_CHAT_COMPLETIONS_SUFFIX):
+        new_path = f"{path}{_CHAT_COMPLETIONS_SUFFIX}" if path else _CHAT_COMPLETIONS_SUFFIX
+        parsed = parsed._replace(path=new_path)
+        url = urlunparse(parsed)
+        parsed = urlparse(url)
+        path = parsed.path or ""
+        query = parsed.query or ""
+
+    # Final validation: no '/' in query
+    if query and "/" in query:
+        # As a last resort, drop anything after the first '/'
+        safe_query = query.split("/")[0]
+        parsed = parsed._replace(query=safe_query)
+        url = urlunparse(parsed)
+
+    return url
+
+
+def _validate_url_structure(url: str, context: str = "") -> None:
+    """
+    Validate that a URL has correct structure (path before query, not vice versa).
+    
+    Raises ValueError if URL is malformed.
+    
+    Args:
+        url: The URL to validate
+        context: Optional context for error messages
+        
+    Raises:
+        ValueError: If URL is malformed (path-like segments in query string)
+    """
+    if not isinstance(url, str) or not url.strip():
+        return
+    
+    try:
+        parsed = urlparse(url)
+        query = parsed.query or ""
+        
+        # CRITICAL CHECK: If query contains path-like segments (contains /), it's malformed
+        if query and "/" in query:
+            path_segment = query.split("/", 1)[1] if "/" in query else ""
+            error_msg = (
+                f"FATAL [TASK_APP_URL_VALIDATION]: Malformed inference URL detected!\n"
+                f"\n"
+                f"URL: {url}\n"
+                f"Context: {context}\n"
+                f"\n"
+                f"The URL has a path-like segment ('/{path_segment}') in the query string.\n"
+                f"This indicates incorrect URL construction upstream.\n"
+                f"\n"
+                f"Expected: https://host/v1/chat/completions?cid=trace_123\n"
+                f"Malformed: https://host?cid=trace_123/v1/chat/completions\n"
+                f"\n"
+                f"This should be caught by the trainer, but if you see this,\n"
+                f"the trainer's URL validation may have failed.\n"
+            )
+            logger.error(error_msg)
+            raise ValueError(error_msg)
+    except ValueError:
+        raise
+    except Exception as e:
+        logger.warning(f"[URL_VALIDATION] Failed to parse URL: {url} (context: {context}, error: {e})")
+
+
 def ensure_chat_completions_url(raw_url: Any, mode: str | None = None) -> Any:
     """
     Ensure inference URLs point at the chat completions endpoint.
@@ -43,9 +166,75 @@ def ensure_chat_completions_url(raw_url: Any, mode: str | None = None) -> Any:
 
     parsed = urlparse(url)
     path = (parsed.path or "").rstrip("/")
+    query = parsed.query
+    
+    logger.debug(
+        "ensure_chat_completions_url: parsing url=%s -> path=%r query=%r",
+        url,
+        path,
+        query,
+    )
+    
+    # CRITICAL: Check for malformed URLs (path in query) and fix them FIRST
+    # Example: https://host?cid=trace_123/v1/chat/completions
+    # Should be: https://host/v1/chat/completions?cid=trace_123
+    if query and "/" in query:
+        logger.error(
+            f"[URL_FIX] Detected malformed URL in ensure_chat_completions_url: {url}\n"
+            f"Path-like segment found in query string. Attempting to fix..."
+        )
+        # Split query at first "/" to separate query params from path
+        query_parts = query.split("/", 1)
+        if len(query_parts) == 2:
+            # query_parts[0] is the actual query (e.g., "cid=trace_123")
+            # query_parts[1] is the path that was incorrectly put in query
+            actual_query = query_parts[0]
+            path_and_more = query_parts[1]  # Could be "v1/chat/completions" or "v1/chat/completions&foo=bar"
+            
+            # Extract the path part (everything before "&" or "?" if present)
+            # Handle both "&" (query param separator) and "?" (another malformed query separator)
+            if "&" in path_and_more:
+                # Path is followed by more query params (separated by &)
+                path_segment, extra_query = path_and_more.split("&", 1)
+                path_in_query = "/" + path_segment  # Restore leading slash
+                # Merge extra query params with actual_query
+                actual_query = f"{actual_query}&{extra_query}"
+            elif "?" in path_and_more:
+                # Path is followed by more query params (separated by ?, which is malformed)
+                path_segment, extra_query = path_and_more.split("?", 1)
+                path_in_query = "/" + path_segment  # Restore leading slash
+                # Merge extra query params with actual_query (use & as separator)
+                actual_query = f"{actual_query}&{extra_query}"
+            else:
+                # No extra query params, just the path
+                path_in_query = "/" + path_and_more  # Restore leading slash
+            
+            # If the path_in_query already contains /v1/chat/completions, use it
+            # Otherwise, append /v1/chat/completions
+            if path_in_query.startswith("/v1/chat/completions"):
+                final_path = path_in_query
+            else:
+                # Append /v1/chat/completions to whatever path we found
+                final_path = path_in_query.rstrip("/") + "/v1/chat/completions"
+            
+            # Reconstruct URL correctly: path comes before query
+            parsed = parsed._replace(path=final_path, query=actual_query)
+            fixed_url = urlunparse(parsed)
+            logger.warning(f"[URL_FIX] Fixed malformed URL:\n  FROM: {url}\n  TO:   {fixed_url}")
+            url = fixed_url
+            # Re-parse after fix
+            parsed = urlparse(url)
+            path = parsed.path.rstrip("/")
+            query = parsed.query
+        else:
+            # Can't parse - this shouldn't happen but validate will catch it
+            logger.error(f"[URL_FIX] Could not parse malformed query: {query}")
+            _validate_url_structure(url, context="ensure_chat_completions_url input - cannot fix")
+    
     if path.endswith("/v1/chat/completions"):
         logger.debug("ensure_chat_completions_url: URL already normalized %s", url)
-        # Already targeting the desired endpoint; keep original to preserve trailing slash.
+        # Validate final URL
+        _validate_url_structure(url, context="ensure_chat_completions_url output")
         return url
 
     if not path:
@@ -55,6 +244,10 @@ def ensure_chat_completions_url(raw_url: Any, mode: str | None = None) -> Any:
 
     rebuilt = parsed._replace(path=new_path)
     normalized = urlunparse(rebuilt)
+    
+    # CRITICAL: Validate the normalized URL
+    _validate_url_structure(normalized, context="ensure_chat_completions_url output")
+    
     logger.info(
         "ensure_chat_completions_url: RL mode - normalized inference URL from %s to %s",
         url,

examples/task_apps/enron/task_app/grpo_enron_task_app.py

@@ -2,7 +2,7 @@
 
 This mirrors the structure of the Crafter task app wrapper while delegating
 all configuration to the colocated `grpo_enron.py` module. Normal usage should
-prefer invoking `uvx synth-ai serve grpo-enron`, but this module remains for
+prefer invoking `uvx synth-ai deploy --runtime uvicorn grpo-enron`, but this module remains for
 direct execution or importing the FastAPI app object.
 """
 

examples/task_apps/gepa_benchmarks/__init__.py

@@ -0,0 +1,7 @@
+"""GEPA benchmark task apps (HotpotQA, IFBench, HoVer, PUPA)."""
+
+# Import modules for side effects (task app registration) when package is imported.
+from . import hotpotqa_task_app  # noqa: F401
+from . import hover_task_app  # noqa: F401
+from . import ifbench_task_app  # noqa: F401
+from . import pupa_task_app  # noqa: F401