synth-ai 0.2.9.dev0__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/demos/demo_task_apps/math/modal_task_app.py

@@ -1,16 +1,16 @@
-from __future__ import annotations
-
 """Modal task app for Hendrycks MATH single-step RL environment."""
 
-import os
-from pathlib import Path
+from __future__ import annotations
 
-from modal import App, Image, Secret, asgi_app
+import os
+from collections.abc import Iterable
 from functools import lru_cache
-from typing import Iterable
+from pathlib import Path
 
 from starlette.requests import Request
 
+from modal import App, Image, Secret, asgi_app
+
 try:  # Backward compatibility with older installed SDKs
     from synth_ai.demos.demo_task_apps.core import DEFAULT_TASK_APP_SECRET_NAME
 except Exception:  # pragma: no cover - occurs on older deployments
@@ -25,7 +25,9 @@ _SYNTH_HOSTED = None
 try:
     probe = _HERE
     for _ in range(8):
-        candidate = (probe / "backend/app/routes/clustered_training/dev/synth_envs_hosted").resolve()
+        candidate = (
+            probe / "backend/app/routes/clustered_training/dev/synth_envs_hosted"
+        ).resolve()
         if candidate.exists():
             _SYNTH_HOSTED = candidate
             break
@@ -97,16 +99,17 @@ app = App("hendrycks-math-task-app")
 @asgi_app()
 def fastapi_app():
     import httpx
-    from fastapi import Body, HTTPException, status
-    from fastapi import FastAPI
+    from fastapi import Body, FastAPI, HTTPException, status
     from fastapi.middleware.cors import CORSMiddleware
     from fastapi.responses import JSONResponse
+
     try:
         from synth_ai.task.auth import (
             is_api_key_header_authorized,
             normalize_environment_api_key,
         )
     except Exception:  # pragma: no cover - fallback for older synth-ai builds
+
         def _normalize_env_key_fallback() -> str | None:
             key = os.getenv("ENVIRONMENT_API_KEY")
             if key:
@@ -130,7 +133,7 @@ def fastapi_app():
             for value in values:
                 if not isinstance(value, str):
                     continue
-                for chunk in value.split(','):
+                for chunk in value.split(","):
                     chunk = chunk.strip()
                     if chunk:
                         parts.append(chunk)
@@ -172,19 +175,27 @@ def fastapi_app():
 
     def _normalize_answer_text(s: str) -> str:
         import re as _re
+
         return _re.sub(r"[^0-9A-Za-z.+\-/*=]", "", (s or "").strip()).lower()
 
     def _extract_boxed(s: str) -> str:
         import re as _re
+
         m = list(_re.finditer(r"\\boxed\{([^}]+)\}", s or ""))
         return m[-1].group(1) if m else ""
 
     def _load_hendrycks_problem(seed: int, subject: str | None = None) -> tuple[str, str]:
         subj = subject or os.getenv("HENDRYCKS_MATH_CONFIG", "default")
-        ds = _hf_split(subj, os.getenv("HENDRYCKS_MATH_SPLIT", "test"), os.getenv("HENDRYCKS_MATH_SLICE"))
+        ds = _hf_split(
+            subj, os.getenv("HENDRYCKS_MATH_SPLIT", "test"), os.getenv("HENDRYCKS_MATH_SLICE")
+        )
         n = len(ds) if hasattr(ds, "__len__") else 0
         if n == 0 and subject not in {"", "default"}:
-            ds = _hf_split("default", os.getenv("HENDRYCKS_MATH_SPLIT", "test"), os.getenv("HENDRYCKS_MATH_SLICE"))
+            ds = _hf_split(
+                "default",
+                os.getenv("HENDRYCKS_MATH_SPLIT", "test"),
+                os.getenv("HENDRYCKS_MATH_SLICE"),
+            )
             n = len(ds) if hasattr(ds, "__len__") else 0
         if n == 0:
             raise RuntimeError("Hendrycks MATH dataset loaded empty")
@@ -225,7 +236,11 @@ def fastapi_app():
 
         def _resolve_env_keys() -> set[str]:
             keys: set[str] = set()
-            for alias in ("ENVIRONMENT_API_KEY", "dev_environment_api_key", "DEV_ENVIRONMENT_API_KEY"):
+            for alias in (
+                "ENVIRONMENT_API_KEY",
+                "dev_environment_api_key",
+                "DEV_ENVIRONMENT_API_KEY",
+            ):
                 value = os.environ.get(alias)
                 if value:
                     os.environ.setdefault("ENVIRONMENT_API_KEY", value)
@@ -250,8 +265,12 @@ def fastapi_app():
                 candidates.append(primary.strip())
             secondary = x_api_keys or headers.get("x-api-keys")
             if secondary:
-                candidates.extend([value.strip() for value in secondary.split(",") if value.strip()])
-            auth_header = authorization or headers.get("authorization") or headers.get("Authorization")
+                candidates.extend(
+                    [value.strip() for value in secondary.split(",") if value.strip()]
+                )
+            auth_header = (
+                authorization or headers.get("authorization") or headers.get("Authorization")
+            )
             if auth_header and auth_header.lower().startswith("bearer "):
                 token = auth_header.split(" ", 1)[1].strip()
                 if token:
@@ -274,7 +293,10 @@ def fastapi_app():
         async def info():
             return {
                 "service": {"base_url": os.getenv("SERVICE_BASE_URL", "")},
-                "inference": {"base_url": "", "endpoints": {"chat_completions": "/v1/chat/completions"}},
+                "inference": {
+                    "base_url": "",
+                    "endpoints": {"chat_completions": "/v1/chat/completions"},
+                },
             }
 
         @app.get("/health")
@@ -282,7 +304,10 @@ def fastapi_app():
             env_keys = _resolve_env_keys()
             env_key = next(iter(env_keys), None)
             if not env_key:
-                return JSONResponse(status_code=503, content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"})
+                return JSONResponse(
+                    status_code=503,
+                    content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"},
+                )
             # Authorize using all header variants; avoid typed Header params to prevent 422s
             authorized = is_api_key_header_authorized(request)
             if not authorized:
@@ -302,7 +327,10 @@ def fastapi_app():
             env_keys = _resolve_env_keys()
             env_key = next(iter(env_keys), None)
             if not env_key:
-                return JSONResponse(status_code=503, content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"})
+                return JSONResponse(
+                    status_code=503,
+                    content={"status": "unhealthy", "detail": "Missing ENVIRONMENT_API_KEY"},
+                )
             authorized = is_api_key_header_authorized(request)
             if not authorized:
                 prefix = _log_env_key_prefix("health/rollout", env_key)
@@ -321,17 +349,22 @@ def fastapi_app():
         async def task_info(seed: int = 0, subject: str = "default"):
             """Return Hendrycks MATH problem/answer and tool schema for a seed."""
             q, a = _load_hendrycks_problem(int(seed), subject=subject)
-            tools = [{
-                "name": "submit_answer",
-                "description": "Provide the final numerical or algebraic answer for the current math problem.",
-                "parameters": {
-                    "type": "object",
-                    "properties": {
-                        "answer": {"type": "string", "description": "The proposed final answer"},
+            tools = [
+                {
+                    "name": "submit_answer",
+                    "description": "Provide the final numerical or algebraic answer for the current math problem.",
+                    "parameters": {
+                        "type": "object",
+                        "properties": {
+                            "answer": {
+                                "type": "string",
+                                "description": "The proposed final answer",
+                            },
+                        },
+                        "required": ["answer"],
                     },
-                    "required": ["answer"],
-                },
-            }]
+                }
+            ]
             return {
                 "seed": int(seed),
                 "subject": subject,
@@ -354,7 +387,7 @@ def fastapi_app():
         try:
             hdr = request.headers
             snapshot = {
-                "path": str(getattr(request, "url").path),
+                "path": str(request.url.path),
                 "have_x_api_key": bool(hdr.get("x-api-key")),
                 "have_x_api_keys": bool(hdr.get("x-api-keys")),
                 "have_authorization": bool(hdr.get("authorization")),
@@ -363,7 +396,9 @@ def fastapi_app():
             print("[422] validation", snapshot, flush=True)
         except Exception:
             pass
-        return JSONResponse(status_code=422, content={"status": "invalid", "detail": exc.errors()[:5]})
+        return JSONResponse(
+            status_code=422, content={"status": "invalid", "detail": exc.errors()[:5]}
+        )
 
     @api.get("/")
     async def root_probe():
@@ -376,27 +411,32 @@ def fastapi_app():
     env_key = (
         os.environ.get("ENVIRONMENT_API_KEY")
         or os.environ.get("DEV_ENVIRONMENT_API_KEY")
-        or os.environ.get("dev_environment_api_key")
+        or os.environ.get("DEV_ENVIRONMENT_API_KEY")
     )
     if not env_key:
         raise RuntimeError("ENVIRONMENT_API_KEY missing in task app environment")
 
-    OPENAI_REMOVE_FIELDS = ("stop_after_tool_calls", "thinking_mode", "thinking_budget", "reasoning")
-    OPENAI_REMOVE_SAMPLING_FIELDS = ("temperature", "top_p")
-    TOOL_CHOICE_FORCE = {"type": "function", "function": {"name": "submit_answer"}}
+    openai_remove_fields = (
+        "stop_after_tool_calls",
+        "thinking_mode",
+        "thinking_budget",
+        "reasoning",
+    )
+    openai_remove_sampling_fields = ("temperature", "top_p")
+    tool_choice_force = {"type": "function", "function": {"name": "submit_answer"}}
 
     def _prepare_openai_payload(model: str | None, payload: dict[str, object]) -> dict[str, object]:
         sanitized = dict(payload)
-        for key in OPENAI_REMOVE_FIELDS:
+        for key in openai_remove_fields:
             sanitized.pop(key, None)
         if model and "gpt-5" in model:
             if "max_tokens" in sanitized and "max_completion_tokens" not in sanitized:
                 sanitized["max_completion_tokens"] = sanitized.pop("max_tokens")
             else:
                 sanitized.pop("max_tokens", None)
-            for field in OPENAI_REMOVE_SAMPLING_FIELDS:
+            for field in openai_remove_sampling_fields:
                 sanitized.pop(field, None)
-                sanitized["tool_choice"] = TOOL_CHOICE_FORCE
+                sanitized["tool_choice"] = tool_choice_force
                 sanitized["parallel_tool_calls"] = False
             return sanitized
 
@@ -404,12 +444,18 @@ def fastapi_app():
     def proxy_chat_completions(request: dict[str, object] = Body(...)):
         key = os.environ.get("OPENAI_API_KEY")
         if not key:
-            raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="OPENAI_API_KEY missing")
+            raise HTTPException(
+                status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail="OPENAI_API_KEY missing"
+            )
         model = request.get("model") if isinstance(request, dict) else None
-        payload = _prepare_openai_payload(model if isinstance(model, str) else None, request if isinstance(request, dict) else {})
+        payload = _prepare_openai_payload(
+            model if isinstance(model, str) else None, request if isinstance(request, dict) else {}
+        )
         headers = {"Authorization": f"Bearer {key}"}
         with httpx.Client(timeout=httpx.Timeout(180.0), follow_redirects=True) as client:
-            resp = client.post("https://api.openai.com/v1/chat/completions", json=payload, headers=headers)
+            resp = client.post(
+                "https://api.openai.com/v1/chat/completions", json=payload, headers=headers
+            )
             try:
                 data = resp.json()
             except Exception:
@@ -423,8 +469,8 @@ def fastapi_app():
     # Minimal math rollout endpoint: alternates agent/env; calls inference_url chat/completions
     @api.post("/rollout")
     def rollout(request: dict[str, object] = Body(...)):
-        from typing import Any
         import json as _json
+        from typing import Any
 
         run_id = str(request.get("run_id"))
         data = request if isinstance(request, dict) else {}
@@ -442,15 +488,25 @@ def fastapi_app():
         env_cfg = (env or {}).get("config") or {}
         # Prefer env.seed; fall back to env.config.seed -> default 0
         try:
-            seed_val = int((env or {}).get("seed")) if isinstance(env, dict) and (env or {}).get("seed") is not None else 0
+            seed_val = (
+                int((env or {}).get("seed"))
+                if isinstance(env, dict) and (env or {}).get("seed") is not None
+                else 0
+            )
         except Exception:
             seed_val = 0
         if seed_val == 0:
             try:
-                seed_val = int(env_cfg.get("seed")) if isinstance(env_cfg, dict) and env_cfg.get("seed") is not None else 0
+                seed_val = (
+                    int(env_cfg.get("seed"))
+                    if isinstance(env_cfg, dict) and env_cfg.get("seed") is not None
+                    else 0
+                )
             except Exception:
                 seed_val = 0
-        subject = (env_cfg.get("subject") if isinstance(env_cfg, dict) else None) or os.getenv("HENDRYCKS_MATH_CONFIG", "default")
+        subject = (env_cfg.get("subject") if isinstance(env_cfg, dict) else None) or os.getenv(
+            "HENDRYCKS_MATH_CONFIG", "default"
+        )
         # Load real Hendrycks problem text/solution (download if necessary). Crash on failure.
         qh, ah = _load_hendrycks_problem(seed_val, subject=subject)
         question = qh
@@ -468,7 +524,10 @@ def fastapi_app():
                     sanitized.pop("max_tokens", None)
                 for field in ("temperature", "top_p"):
                     sanitized.pop(field, None)
-                sanitized["tool_choice"] = {"type": "function", "function": {"name": "submit_answer"}}
+                sanitized["tool_choice"] = {
+                    "type": "function",
+                    "function": {"name": "submit_answer"},
+                }
                 sanitized["parallel_tool_calls"] = False
             return sanitized
 
@@ -503,25 +562,27 @@ def fastapi_app():
 
         user_prompt = (
             str(question)
-            if isinstance(question, (str, int, float)) and str(question).strip()
+            if isinstance(question, str | int | float) and str(question).strip()
             else "Solve the problem. Provide answer steps succinctly."
         )
         payload = {
             "model": model,
             "messages": [{"role": "user", "content": user_prompt}],
-            "tools": [{
-                "type": "function",
-                "function": {
-                    "name": "submit_answer",
-                    "parameters": {
-                        "type": "object",
-                        "properties": {
-                            "answer": {"type": "string"},
+            "tools": [
+                {
+                    "type": "function",
+                    "function": {
+                        "name": "submit_answer",
+                        "parameters": {
+                            "type": "object",
+                            "properties": {
+                                "answer": {"type": "string"},
+                            },
+                            "required": ["answer"],
                         },
-                        "required": ["answer"],
                     },
-                },
-            }],
+                }
+            ],
             "max_tokens": 256,
             "temperature": 0.2,
         }
@@ -529,13 +590,13 @@ def fastapi_app():
 
         try:
             tool_names = []
-            for t in (payload.get("tools") or []):
+            for t in payload.get("tools") or []:
                 if isinstance(t, dict):
                     fn = (t.get("function") or {}) if isinstance(t.get("function"), dict) else {}
                     name = fn.get("name")
                     if isinstance(name, str):
                         tool_names.append(name)
-            print(f"[math] system: <none>", flush=True)
+            print("[math] system: <none>", flush=True)
             print(f"[math] user: {user_prompt}", flush=True)
             print(f"[math] tools: {tool_names}", flush=True)
         except Exception:
@@ -547,7 +608,9 @@ def fastapi_app():
             if sk:
                 headers["Authorization"] = f"Bearer {sk}"
         with httpx.Client(timeout=httpx.Timeout(180.0), follow_redirects=True) as client:
-            resp = client.post(f"{inference_url}/v1/chat/completions", json=to_send, headers=headers)
+            resp = client.post(
+                f"{inference_url}/v1/chat/completions", json=to_send, headers=headers
+            )
             try:
                 data = resp.json()
             except Exception:
@@ -580,14 +643,21 @@ def fastapi_app():
 
         tool_answer = _parse_tool_answer(data)
         history.append({"answer": tool_answer})
-        steps.append({
-            "obs": {},
-            "tool_calls": [{"tool_name": "submit_answer", "arguments": _json.dumps({"answer": tool_answer})}],
-            "reward": None,
-            "done": False,
-            "truncated": False,
-            "info": None,
-        })
+        steps.append(
+            {
+                "obs": {},
+                "tool_calls": [
+                    {
+                        "tool_name": "submit_answer",
+                        "arguments": _json.dumps({"answer": tool_answer}),
+                    }
+                ],
+                "reward": None,
+                "done": False,
+                "truncated": False,
+                "info": None,
+            }
+        )
 
         # Evaluate answer correctness using tool output (or fall back to assistant text)
         reward_val = 0.0
@@ -605,25 +675,57 @@ def fastapi_app():
         except Exception:
             reward_val = 0.0
 
+        # Immediate, concise rollout logging mirroring RL format
+        try:
+            preview = tool_answer[:120] + (
+                "…" if isinstance(tool_answer, str) and len(tool_answer) > 120 else ""
+            )
+            components = {
+                "env": float(reward_val),
+                "rubric_event": 1.0 if bool(tool_answer.strip()) else 0.0,
+                "rubric_outcome": 1.0 if float(reward_val) > 0.0 else 0.0,
+            }
+            print(
+                "[MATH_ROLLOUT] run=",
+                run_id,
+                " seed=",
+                seed_val,
+                " subject=",
+                subject,
+                " tool=submit_answer answer=",
+                preview,
+                " reward=",
+                float(reward_val),
+                " components=",
+                components,
+                flush=True,
+            )
+        except Exception:
+            pass
+
         total_reward += float(reward_val)
-        steps.append({
-            "obs": {},
-            "tool_calls": [],
-            "reward": reward_val,
-            "done": True,
-            "truncated": False,
-            "info": None,
-        })
+        steps.append(
+            {
+                "obs": {},
+                "tool_calls": [],
+                "reward": reward_val,
+                "done": True,
+                "truncated": False,
+                "info": None,
+            }
+        )
 
         return {
             "run_id": run_id,
-            "trajectories": [{
-                "env_id": env_name,
-                "policy_id": (policy or {}).get("policy_name") or "math-react",
-                "steps": steps,
-                "final": {"observation": {}},
-                "length": len(steps),
-            }],
+            "trajectories": [
+                {
+                    "env_id": env_name,
+                    "policy_id": (policy or {}).get("policy_name") or "math-react",
+                    "steps": steps,
+                    "final": {"observation": {}},
+                    "length": len(steps),
+                }
+            ],
             "branches": {},
             "metrics": {
                 "episode_returns": [total_reward],

synth_ai/demos/demo_task_apps/math/task_app_entry.py

@@ -5,7 +5,6 @@ from __future__ import annotations
 from synth_ai.task.apps import ModalDeploymentConfig, TaskAppEntry, register_task_app
 from synth_ai.task.apps.math_single_step import build_config as base_build_config
 
-
 DEMO_MODAL_CONFIG = ModalDeploymentConfig(
     app_name="hendrycks-math-task-app",
     pip_packages=(
@@ -36,4 +35,3 @@ register_task_app(
         modal=DEMO_MODAL_CONFIG,
     )
 )
-

synth_ai/demos/math/__init__.py

@@ -0,0 +1 @@
+# Package namespace for Math demo task app

synth_ai/demos/math/_common.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+"""Minimal helpers for the math task app.
+
+This module provides a local fallback for install_problem_bank_into_shared so
+the modal task app can import it without requiring an external math_rl package.
+"""
+
+
+def install_problem_bank_into_shared() -> None:
+    """No-op placeholder for installing the Hendrycks MATH problem bank.
+
+    In production deployments, this can download or unpack the problem bank
+    into a shared directory. For the demo scaffold, it is a no-op.
+    """
+    return None

synth_ai/demos/math/app.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import os
+
+from fastapi import FastAPI
+from starlette.middleware.cors import CORSMiddleware
+
+# Reuse the examples/rl task_app routes if available
+try:
+    from synth_ai.examples.rl.task_app import make_app as make_rl_app  # type: ignore
+except Exception:  # fallback path when imported from repo root
+    try:
+        from examples.rl.task_app import make_app as make_rl_app  # type: ignore
+    except Exception as e:  # pragma: no cover
+        raise ImportError(f"Unable to import RL task app: {e}") from e
+
+
+def create_app() -> FastAPI:
+    # Configure math defaults via env (consumed by RL task_app helpers)
+    os.environ.setdefault("DEMO_ENV_NAME", "math")
+    os.environ.setdefault("DEMO_POLICY_NAME", "math-react")
+    # Build base app
+    app = make_rl_app()
+    # CORS for local demo
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    return app
+
+
+def run(host: str = "127.0.0.1", port: int = 8080):
+    import uvicorn
+
+    uvicorn.run(create_app(), host=host, port=int(os.getenv("PORT", port)))

synth_ai/demos/math/config.toml

@@ -0,0 +1,76 @@
+type = "rl"
+
+[algorithm]
+type = "online"
+method = "policy_gradient"
+variety = "gspo"
+
+[services]
+task_url = "http://localhost:8101"
+
+[model]
+base = "Qwen/Qwen3-1.7B"
+
+[policy]
+model = "Qwen/Qwen3-1.7B"
+inference_url = "http://localhost:8000/api/inference"
+max_tokens = 1028
+temperature = 0.2
+
+[data]
+split = "train"
+seed_start = 0
+episodes_per_iteration = 1280  # 8 per group * 4 groups per batch * 2 batches per step * 20 steps
+evaluation_split = "validation"
+evaluation_episodes = 50
+
+[training]
+max_turns = 1
+ops = ["agent", "env"]
+batch_size = 2
+group_size = 16
+reward_positive = 1.0
+reward_negative_no_tool = -1.0
+reward_negative_no_answer = -0.5
+learning_rate = 5e-6
+log_interval = 1
+weight_sync_interval = 1
+
+[training.weight_sync]
+enable = true
+targets = ["policy"]
+
+[compute]
+gpu_type = "H100"
+gpu_count = 4
+
+[topology]
+type = "single_node_split"
+gpus_for_vllm = 2
+gpus_for_training = 1
+gpus_for_ref = 1
+tensor_parallel = 1
+
+[vllm]
+tensor_parallel_size = 1
+max_model_len = 4096
+
+[reference]
+placement = "dedicated"
+port = 8002
+tp = 1
+health_max_wait_s = 180
+health_interval_ms = 300
+
+[rollout]
+policy_name = "math-single-step"
+max_turns = 1
+episodes_per_batch = 32  # group_size * batch_size
+
+[evaluation]
+instances = 32
+every_n_iters = 10
+seeds = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
+
+[tags]
+experiment = "math_single_step_qwen17"