@trac3er/oh-my-god 2.1.4 → 2.1.7

package/lab/forge_runner.py

@@ -0,0 +1,103 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from runtime.subagent_dispatcher import resolve_execution_boundary
+from runtime.untrusted_content import write_sandbox_budget_evidence
+from tools.python_sandbox import execute_budgeted_run
+
+
+@dataclass(frozen=True)
+class ForgeRunSpec:
+    run_id: str
+    adapter: str
+    budget: dict[str, Any]
+    outbound_allowlist: list[str]
+    trainer_code: str = "print('forge trainer ready')"
+    sidecar_code: str | None = None
+    attempted_outbound: list[str] | None = None
+    project_dir: str = "."
+
+
+@dataclass(frozen=True)
+class ForgeRunResult:
+    status: str
+    evidence: dict[str, Any]
+    checkpoint_paths: list[str]
+
+
+def run_forge_sandboxed(spec: ForgeRunSpec) -> ForgeRunResult:
+    budget_time = int(spec.budget.get("time_seconds", 0) or 0)
+    budget_cost = float(spec.budget.get("cost_usd", 0.0) or 0.0)
+    gpu_allowed = bool(spec.budget.get("gpu_allowed", False))
+
+    execution = execute_budgeted_run(
+        trainer_code=spec.trainer_code,
+        sidecar_code=spec.sidecar_code,
+        time_budget_seconds=max(1, budget_time),
+        cost_budget_usd=max(0.0, budget_cost),
+        gpu_allowed=gpu_allowed,
+        outbound_allowlist=spec.outbound_allowlist,
+        attempted_outbound=spec.attempted_outbound,
+    )
+
+    outbound_blocked_count = int(execution.get("outbound_blocked_count", 0))
+    isolation: dict[str, Any] = {
+        **resolve_execution_boundary(isolation="worktree"),
+        "sandbox_mode": str(execution.get("sandbox_mode", "isolated-subprocess")),
+        "outbound_blocked_count": outbound_blocked_count,
+        "process_count": int(execution.get("process_count", 1)),
+    }
+    budget_evidence = {
+        "time_used_seconds": float(execution.get("time_used_seconds", 0.0)),
+        "time_budget_seconds": max(1, budget_time),
+        "cost_estimate_usd": float(execution.get("estimated_cost_usd", 0.0)),
+        "cost_budget_usd": max(0.0, budget_cost),
+        "network_calls_attempted": int(execution.get("network_calls_attempted", 0)),
+        "network_calls_allowed": int(execution.get("network_calls_allowed", 0)),
+        "blocked_targets": list(execution.get("blocked_targets", [])),
+    }
+
+    status = str(execution.get("status", "error"))
+    reason = str(execution.get("error") or "")
+    if outbound_blocked_count > 0:
+        status = "blocked"
+        reason = reason or "outbound target blocked by allowlist"
+    if bool(execution.get("requested_gpu", False)) and not gpu_allowed:
+        status = "blocked"
+        reason = "gpu requested by workload but disallowed by budget"
+
+    isolation_payload: dict[str, Any] = {
+        **isolation,
+        "reason": reason,
+    }
+    evidence: dict[str, Any] = {
+        "run_id": spec.run_id,
+        "adapter": spec.adapter,
+        "status": status,
+        "reason": reason,
+        "budget": budget_evidence,
+        "isolation": isolation_payload,
+    }
+
+    trust_path = write_sandbox_budget_evidence(
+        project_dir=spec.project_dir,
+        run_id=spec.run_id,
+        budget=budget_evidence,
+        isolation=isolation_payload,
+    )
+    evidence["trust_evidence_path"] = trust_path
+
+    checkpoints = [str(path) for path in execution.get("checkpoint_paths", [])]
+    if checkpoints:
+        run_dir = Path(spec.project_dir) / ".omg" / "evidence" / "forge"
+        run_dir.mkdir(parents=True, exist_ok=True)
+        evidence["checkpoint_dir"] = str(run_dir)
+
+    return ForgeRunResult(
+        status=status,
+        evidence=evidence,
+        checkpoint_paths=checkpoints,
+    )

package/lab/gazebo_adapter.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+import shutil
+import uuid
+from pathlib import Path
+from time import monotonic
+from typing import Any
+
+ADAPTER_NAME = "gazebo"
+ADAPTER_KIND = "simulator"
+
+VALID_STATUSES = frozenset({"dry_run_contract", "skipped_unavailable_backend", "invoked", "error"})
+
+
+def _check_gazebo_available() -> bool:
+    return shutil.which("gz") is not None or shutil.which("gazebo") is not None
+
+
+def _compute_fingerprint(job: dict[str, Any]) -> str | None:
+    try:
+        return hashlib.sha256(json.dumps(job, sort_keys=True).encode()).hexdigest()[:16]
+    except (TypeError, ValueError):
+        return None
+
+
+def _validate_job(job: dict[str, Any]) -> tuple[bool, str]:
+    if not job:
+        return False, "invalid job: missing required fields"
+    if "domain" not in job:
+        return False, "invalid job: missing required field 'domain'"
+    return True, ""
+
+
+def _derive_seed(job: dict[str, Any], run_id: str) -> int:
+    explicit = job.get("seed")
+    if isinstance(explicit, int):
+        return explicit
+    material = json.dumps({"run_id": run_id, "job": _compute_fingerprint(job)}, sort_keys=True)
+    return int(hashlib.sha256(material.encode("utf-8")).hexdigest()[:8], 16)
+
+
+def _run_fidelity_probe(*, seed: int) -> dict[str, Any]:
+    started = monotonic()
+    rng = random.Random(seed)
+    reward = 0.0
+    steps = 12
+    for _idx in range(steps):
+        reward += rng.uniform(-0.01, 0.08)
+    return {
+        "steps": steps,
+        "reward": round(reward, 6),
+        "duration_ms": int((monotonic() - started) * 1000),
+        "backend_version": "gazebo-jetty",
+    }
+
+
+def run(
+    job: dict[str, Any],
+    *,
+    backend_mode: str = "preflight",
+    run_id: str | None = None,
+    timeout_seconds: int = 30,
+    sandbox_root: str = ".",
+) -> dict[str, Any]:
+    del timeout_seconds
+
+    active_run_id = run_id or str(uuid.uuid4())
+    ok, validation_reason = _validate_job(job)
+    available = _check_gazebo_available()
+    seed = _derive_seed(job, active_run_id)
+
+    base_result: dict[str, Any] = {
+        "adapter": ADAPTER_NAME,
+        "kind": ADAPTER_KIND,
+        "backend": "gazebo",
+        "fidelity_backend": True,
+        "throughput_role": "validation_fidelity",
+        "run_id": active_run_id,
+        "seed": seed,
+        "episode_stats": {"steps": 0, "reward": 0.0, "duration_ms": 0},
+        "replay_metadata": {
+            "run_id": active_run_id,
+            "seed": seed,
+            "backend_version": "unavailable",
+        },
+    }
+
+    if not ok:
+        return {
+            **base_result,
+            "status": "error",
+            "available": False,
+            "reason": validation_reason,
+            "availability_reason": "job validation failed",
+        }
+
+    unavailable_reason = (
+        "Gazebo Jetty (gz) required for validation/fidelity runs; neither 'gz' nor 'gazebo' "
+        "binary found on host."
+    )
+
+    if backend_mode == "preflight":
+        if available:
+            return {
+                **base_result,
+                "status": "dry_run_contract",
+                "available": True,
+                "reason": "preflight mode: fidelity backend available but execution not requested",
+                "availability_reason": "Gazebo Jetty (gz) binary found on host",
+            }
+        return {
+            **base_result,
+            "status": "skipped_unavailable_backend",
+            "available": False,
+            "reason": "gazebo backend not available",
+            "availability_reason": unavailable_reason,
+        }
+
+    if backend_mode == "live":
+        if not available:
+            return {
+                **base_result,
+                "status": "skipped_unavailable_backend",
+                "available": False,
+                "reason": "gazebo backend not available",
+                "availability_reason": unavailable_reason,
+            }
+
+        try:
+            sandbox_path = Path(sandbox_root)
+            sandbox_path.mkdir(parents=True, exist_ok=True)
+            probe = _run_fidelity_probe(seed=seed)
+            return {
+                **base_result,
+                "status": "invoked",
+                "available": True,
+                "reason": "gazebo fidelity validation executed",
+                "availability_reason": "Gazebo Jetty (gz) binary found on host",
+                "episode_stats": {
+                    "steps": int(probe["steps"]),
+                    "reward": float(probe["reward"]),
+                    "duration_ms": int(probe["duration_ms"]),
+                },
+                "replay_metadata": {
+                    "run_id": active_run_id,
+                    "seed": seed,
+                    "backend_version": str(probe["backend_version"]),
+                },
+            }
+        except Exception as exc:  # noqa: BLE001
+            return {
+                **base_result,
+                "status": "error",
+                "available": available,
+                "reason": f"live execution failed: {exc}",
+                "availability_reason": "Gazebo Jetty (gz) required for validation/fidelity runs",
+            }
+
+    return {
+        **base_result,
+        "status": "error",
+        "available": available,
+        "reason": f"unknown backend_mode: {backend_mode!r}",
+        "availability_reason": "Gazebo Jetty (gz) required for validation/fidelity runs",
+    }

package/lab/isaac_gym_adapter.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import hashlib
+import importlib
+import importlib.util
+import json
+import uuid
+from pathlib import Path
+from time import monotonic
+from typing import Any
+
+ADAPTER_NAME = "isaac_gym"
+ADAPTER_KIND = "simulator"
+
+VALID_STATUSES = frozenset({"dry_run_contract", "unavailable_backend", "invoked", "error"})
+
+
+def _has_cuda() -> bool:
+    try:
+        torch = importlib.import_module("torch")
+    except Exception:
+        return False
+    cuda = getattr(torch, "cuda", None)
+    if cuda is None:
+        return False
+    is_available = getattr(cuda, "is_available", None)
+    if not callable(is_available):
+        return False
+    try:
+        return bool(is_available())
+    except Exception:
+        return False
+
+
+def _check_isaac_lab_available() -> bool:
+    for candidate in ("isaaclab", "omni.isaac.lab"):
+        try:
+            if importlib.util.find_spec(candidate) is not None:
+                return True
+        except (ImportError, ModuleNotFoundError, ValueError):
+            continue
+    return False
+
+
+def _validate_job(job: dict[str, Any]) -> tuple[bool, str]:
+    if not job:
+        return False, "invalid job: missing required fields"
+    if "domain" not in job:
+        return False, "invalid job: missing required field 'domain'"
+    return True, ""
+
+
+def _derive_seed(job: dict[str, Any], run_id: str) -> int:
+    explicit = job.get("seed")
+    if isinstance(explicit, int):
+        return explicit
+    digest = hashlib.sha256(json.dumps({"run_id": run_id, "job": job}, sort_keys=True).encode("utf-8")).hexdigest()
+    return int(digest[:8], 16)
+
+
+def _bounded_gpu_episode(*, seed: int, steps: int) -> dict[str, Any]:
+    torch = importlib.import_module("torch")
+    started = monotonic()
+    gen = torch.Generator(device="cuda")
+    gen.manual_seed(seed)
+    state = torch.zeros((), device="cuda")
+    reward = torch.zeros((), device="cuda")
+    for _idx in range(steps):
+        noise = torch.rand((), generator=gen, device="cuda") - 0.25
+        state = state + noise
+        reward = reward + torch.relu(state)
+    return {
+        "steps": steps,
+        "reward": float(reward.item()),
+        "duration_ms": int((monotonic() - started) * 1000),
+        "backend_version": str(getattr(torch, "__version__", "unknown")),
+    }
+
+
+def run(
+    job: dict[str, Any],
+    *,
+    backend_mode: str = "preflight",
+    run_id: str | None = None,
+    timeout_seconds: int = 30,
+    sandbox_root: str = ".",
+) -> dict[str, Any]:
+    del timeout_seconds
+
+    active_run_id = run_id or str(uuid.uuid4())
+    ok, validation_reason = _validate_job(job)
+    seed = _derive_seed(job, active_run_id)
+    cuda_ready = _has_cuda()
+    isaac_lab_ready = _check_isaac_lab_available()
+    available = cuda_ready and isaac_lab_ready
+    max_steps_raw = job.get("max_steps", 16)
+    try:
+        max_steps = max(1, min(int(max_steps_raw), 256))
+    except (TypeError, ValueError):
+        max_steps = 16
+
+    base_result: dict[str, Any] = {
+        "adapter": ADAPTER_NAME,
+        "kind": ADAPTER_KIND,
+        "backend": "isaac_lab",
+        "run_id": active_run_id,
+        "seed": seed,
+        "episode_stats": {"steps": 0, "reward": 0.0, "duration_ms": 0},
+        "replay_metadata": {
+            "run_id": active_run_id,
+            "seed": seed,
+            "backend_version": "unavailable",
+        },
+    }
+
+    if not ok:
+        return {
+            **base_result,
+            "status": "error",
+            "available": False,
+            "reason": validation_reason,
+            "availability_reason": "job validation failed",
+        }
+
+    unavailable_reason = "isaac_lab_requires_cuda"
+
+    if backend_mode == "preflight":
+        if available:
+            return {
+                **base_result,
+                "status": "dry_run_contract",
+                "available": True,
+                "reason": "preflight mode: isaac lab backend available",
+                "availability_reason": "isaac_lab_cuda_ready",
+            }
+        return {
+            **base_result,
+            "status": "unavailable_backend",
+            "available": False,
+            "reason": unavailable_reason,
+            "availability_reason": unavailable_reason,
+        }
+
+    if backend_mode == "live":
+        if not available:
+            return {
+                **base_result,
+                "status": "unavailable_backend",
+                "available": False,
+                "reason": unavailable_reason,
+                "availability_reason": unavailable_reason,
+            }
+
+        try:
+            sandbox_path = Path(sandbox_root)
+            sandbox_path.mkdir(parents=True, exist_ok=True)
+            episode = _bounded_gpu_episode(seed=seed, steps=max_steps)
+            return {
+                **base_result,
+                "status": "invoked",
+                "available": True,
+                "reason": "isaac lab gpu episode executed",
+                "availability_reason": "isaac_lab_cuda_ready",
+                "episode_stats": {
+                    "steps": int(episode["steps"]),
+                    "reward": float(episode["reward"]),
+                    "duration_ms": int(episode["duration_ms"]),
+                },
+                "replay_metadata": {
+                    "run_id": active_run_id,
+                    "seed": seed,
+                    "backend_version": str(episode["backend_version"]),
+                },
+            }
+        except Exception as exc:  # noqa: BLE001
+            return {
+                **base_result,
+                "status": "error",
+                "available": available,
+                "reason": f"live execution failed: {exc}",
+                "availability_reason": "isaac_lab_cuda_ready",
+            }
+
+    return {
+        **base_result,
+        "status": "error",
+        "available": available,
+        "reason": f"unknown backend_mode: {backend_mode!r}",
+        "availability_reason": unavailable_reason,
+    }

package/lab/mock_isaac_env.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import random
+from typing import Any
+
+
+class MockIsaacEnv:
+    metadata = {"render_modes": ["human", "ansi"], "name": "MockIsaacEnv-v1"}
+
+    def __init__(self, *, max_steps: int = 32, reward_scale: float = 1.0) -> None:
+        self.max_steps = max(1, int(max_steps))
+        self.reward_scale = float(reward_scale)
+        self._rng = random.Random(0)
+        self._seed = 0
+        self._step_count = 0
+        self._state = 0.0
+        self._closed = False
+
+    def reset(self, *, seed: int | None = None, options: dict[str, Any] | None = None) -> tuple[list[float], dict[str, Any]]:
+        del options
+        if seed is not None:
+            self._seed = int(seed)
+        self._rng = random.Random(self._seed)
+        self._step_count = 0
+        self._state = round(self._rng.uniform(-0.25, 0.25), 6)
+        return [self._state], {"seed": self._seed, "step": self._step_count}
+
+    def step(self, action: Any) -> tuple[list[float], float, bool, bool, dict[str, Any]]:
+        if self._closed:
+            raise RuntimeError("environment is closed")
+        action_value = float(action) if isinstance(action, (int, float)) else 0.0
+        drift = self._rng.uniform(-0.1, 0.1)
+        self._state = round(self._state + drift + (0.01 * action_value), 6)
+        reward = round((1.0 - abs(self._state)) * self.reward_scale, 6)
+        self._step_count += 1
+        terminated = self._step_count >= self.max_steps
+        truncated = False
+        info = {"seed": self._seed, "step": self._step_count}
+        return [self._state], reward, terminated, truncated, info
+
+    def render(self, mode: str = "human") -> str | None:
+        if mode == "ansi":
+            return f"MockIsaacEnv(step={self._step_count}, state={self._state:.4f})"
+        return None
+
+    def close(self) -> None:
+        self._closed = True