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

examples/swe/task_app/hosted/inference/openai_client.py

@@ -156,13 +156,13 @@ class OpenAIClient:
             keys_preview = sorted(processed_request.keys())
             logger.info(f"Request keys: {keys_preview}")
 
-        # Final hard-guard for OpenAI: ensure unsupported field is not present
+        # Final hard-guard for OpenAI/Groq: ensure unsupported field is not present
         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 Groq/OpenAI request")
             # 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
             ):
@@ -340,40 +340,6 @@ class OpenAIClient:
                                 pass
                 except Exception:
                     pass
-                # Gracefully degrade on 422 so rollouts can still produce a trajectory
-                if status == 422:
-                    try:
-                        # Best-effort parse of error for diagnostics
-                        err = None
-                        try:
-                            err = e.response.json()
-                        except Exception:
-                            err = {"error": "unprocessable", "detail": (text or "")[:200]}
-                        logger.warning(
-                            {
-                                "inference_422_recovered": True,
-                                "detail": err,
-                            }
-                        )
-                    except Exception:
-                        pass
-                    # Return a minimal OpenAI-compatible response with no tool_calls/content
-                    import time as _t
-
-                    return {
-                        "id": f"cmpl-{int(_t.time())}",
-                        "object": "chat.completion",
-                        "created": int(_t.time()),
-                        "model": processed_request.get("model") or "unknown",
-                        "choices": [
-                            {
-                                "index": 0,
-                                "message": {"role": "assistant", "content": "", "tool_calls": []},
-                                "finish_reason": "stop",
-                            }
-                        ],
-                        "usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
-                    }
                 raise
             except Exception as e:
                 logger.error(f"Unexpected error calling {url}: {e}")

examples/swe/task_app/hosted/policy_routes.py

@@ -945,6 +945,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/swe/task_app/hosted/rollout.py

@@ -251,14 +251,16 @@ class RolloutTracingContext:
             await self.tracer.initialize()
         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)
             )
         except Exception as exc:
             logger.warning("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

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/banking77/__init__.py

@@ -0,0 +1,6 @@
+"""Banking77 task app package."""
+
+from .banking77_task_app import build_config
+
+__all__ = ["build_config"]
+