synth-ai 0.2.6.dev3__tar.gz → 0.2.6.dev5__tar.gz

{synth_ai-0.2.6.dev3/synth_ai.egg-info → synth_ai-0.2.6.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.2.6.dev3
+Version: 0.2.6.dev5
 Summary: RL as a service SDK - Core AI functionality and tracing
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT

{synth_ai-0.2.6.dev3 → synth_ai-0.2.6.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-ai"
-version = "0.2.6.dev3"
+version = "0.2.6.dev5"
 description = "RL as a service SDK - Core AI functionality and tracing"
 authors = [{name = "Synth AI", email = "josh@usesynth.ai"}]
 license = "MIT"

{synth_ai-0.2.6.dev3 → synth_ai-0.2.6.dev5}/synth_ai/__init__.py

@@ -25,7 +25,7 @@ tracing = None  # type: ignore
 EventPartitionElement = RewardSignal = SystemTrace = TrainingQuestion = None  # type: ignore
 trace_event_async = trace_event_sync = upload = None  # type: ignore
 
-__version__ = "0.2.6.dev1"
+__version__ = "0.2.6.dev4"
 __all__ = [
     "LM",
     "OpenAI",

{synth_ai-0.2.6.dev3 → synth_ai-0.2.6.dev5}/synth_ai/demos/core/cli.py

@@ -224,8 +224,59 @@ def _popen_stream_capture(cmd: list[str], cwd: str | None = None, env: dict | No
     return int(proc.returncode or 0), "\n".join(buf_lines)
 
 
+def _mask_secret_args(args: list[str]) -> list[str]:
+    masked: list[str] = []
+    for a in args:
+        if "=" in a and any(a.startswith(prefix) for prefix in ("ENVIRONMENT_API_KEY=", "OPENAI_API_KEY=", "SYNTH_API_KEY=")):
+            try:
+                key, value = a.split("=", 1)
+                tail = value[-5:] if len(value) >= 5 else value
+                masked.append(f"{key}=***{tail}")
+            except Exception:
+                masked.append("<masked>")
+        else:
+            masked.append(a)
+    return masked
+
+
+def _ensure_modal_secret(
+    secret_name: str,
+    *,
+    values: dict[str, str],
+    label: str = "deploy",
+    replace: bool = False,
+) -> bool:
+    prefix = f"[{label}]"
+    if not secret_name.strip():
+        raise RuntimeError("Secret name is required")
+
+    if not values:
+        raise RuntimeError("No values provided to create Modal secret")
+
+    create_args = [f"{k}={v}" for k, v in values.items()]
+    create_cmd = ["uv", "run", "modal", "secret", "create", secret_name, *create_args]
+
+    if replace:
+        print(f"{prefix} Removing Modal secret '{secret_name}' (if present)…")
+        delete_cmd = ["bash", "-lc", f"printf 'y\\n' | uv run modal secret delete {secret_name}"]
+        print(f"{prefix} Command:", " ".join(delete_cmd))
+        delete_code = _popen_stream(delete_cmd)
+        if delete_code != 0:
+            print(f"{prefix} Warning: delete command exited with {delete_code}; continuing to create")
+
+    print(f"\n{prefix} Creating Modal secret '{secret_name}'…")
+    print(f"{prefix} Command:", " ".join(_mask_secret_args(create_cmd)))
+    code = _popen_stream(create_cmd)
+    if code != 0:
+        raise RuntimeError("Failed to provision Modal secret (see logs above)")
+
+    return True
+
+
 def cmd_deploy(args: argparse.Namespace) -> int:
     env = demo_core.load_env()
+    cwd_env_path = os.path.join(os.getcwd(), ".env")
+    local_env = demo_core.load_dotenv_file(cwd_env_path)
     url = ""
     app_name = env.task_app_name or ""
     try:
@@ -279,6 +330,51 @@ def cmd_deploy(args: argparse.Namespace) -> int:
                 if not proceed:
                     print("Aborted by user.")
                     return 1
+
+                secret_name = (env.task_app_secret_name or "").strip() or f"{name_in}-secret"
+                env_key = (env.env_api_key or "").strip() or None
+                if env_key is None:
+                    from synth_ai.rl.secrets import mint_environment_api_key
+
+                    env_key = mint_environment_api_key()
+                    demo_core.persist_env_api_key(env_key)
+                    demo_core.persist_dotenv_values({"ENVIRONMENT_API_KEY": env_key})
+                    os.environ["ENVIRONMENT_API_KEY"] = env_key
+                    env.env_api_key = env_key
+                    local_env["ENVIRONMENT_API_KEY"] = env_key
+                    print("[deploy] Minted new ENVIRONMENT_API_KEY")
+
+                synth_key = (env.synth_api_key or os.environ.get("SYNTH_API_KEY") or local_env.get("SYNTH_API_KEY") or "").strip()
+                if not synth_key:
+                    synth_key = input("Enter SYNTH_API_KEY for Modal secret (required): ").strip()
+                    if not synth_key:
+                        print("SYNTH_API_KEY is required to create the Modal secret.")
+                        return 1
+                    demo_core.persist_api_key(synth_key)
+                    demo_core.persist_dotenv_values({"SYNTH_API_KEY": synth_key})
+                    env.synth_api_key = synth_key
+
+                openai_key = (os.environ.get("OPENAI_API_KEY") or local_env.get("OPENAI_API_KEY") or "").strip()
+                if not openai_key:
+                    openai_key = input("Enter OPENAI_API_KEY for Modal secret (required): ").strip()
+                    if not openai_key:
+                        print("OPENAI_API_KEY is required to create the Modal secret.")
+                        return 1
+                    demo_core.persist_dotenv_values({"OPENAI_API_KEY": openai_key})
+                    local_env["OPENAI_API_KEY"] = openai_key
+
+                values = {"SYNTH_API_KEY": synth_key, "OPENAI_API_KEY": openai_key}
+                if env_key:
+                    values["ENVIRONMENT_API_KEY"] = env_key
+
+                try:
+                    created = _ensure_modal_secret(secret_name, values=values, label="deploy", replace=True)
+                except RuntimeError as secret_err:
+                    print(f"Failed to prepare Modal secret '{secret_name}': {secret_err}")
+                    return 2
+                if created:
+                    print(f"[deploy] Modal secret '{secret_name}' provisioned.")
+
                 deploy_cmd = ["uv", "run", "python", "-m", "modal", "deploy", "--name", name_in, app_path]
                 print("\nStreaming Modal build/deploy logs (this can take several minutes on first run)…\n")
                 code, deploy_logs = _popen_stream_capture(deploy_cmd)
@@ -346,8 +442,6 @@ def cmd_deploy(args: argparse.Namespace) -> int:
 
 
 def cmd_configure(args: argparse.Namespace) -> int:
-    from synth_ai.rl.secrets import mint_environment_api_key
-
     env = demo_core.load_env()
     cwd_env_path = os.path.join(os.getcwd(), ".env")
     local_env = demo_core.load_dotenv_file(cwd_env_path)
@@ -362,13 +456,9 @@ def cmd_configure(args: argparse.Namespace) -> int:
     demo_core.persist_dotenv_values({"SYNTH_API_KEY": synth_key})
 
     env_key = env.env_api_key.strip()
-    minted_env_key = False
     if not env_key:
-        env_key = mint_environment_api_key()
-        minted_env_key = True
-        print("Minted new ENVIRONMENT_API_KEY")
-    demo_core.persist_env_api_key(env_key)
-    demo_core.persist_dotenv_values({"ENVIRONMENT_API_KEY": env_key})
+        print("ENVIRONMENT_API_KEY missing; run `uvx synth-ai rl_demo deploy` to mint and store one.")
+        return 1
 
     task_url = env.task_app_base_url
     if not task_url or not _is_modal_public_url(task_url):
@@ -418,43 +508,20 @@ def cmd_configure(args: argparse.Namespace) -> int:
     })
 
     # Ensure Modal secret has the environment API key (and optional extras).
-    secret_args = [f"ENVIRONMENT_API_KEY={env_key}"]
     openai_key = (os.environ.get("OPENAI_API_KEY") or local_env.get("OPENAI_API_KEY") or "").strip()
-    if openai_key:
-        secret_args.append(f"OPENAI_API_KEY={openai_key}")
     synth_for_secret = synth_key
-    if synth_for_secret:
-        secret_args.append(f"SYNTH_API_KEY={synth_for_secret}")
 
-    create_cmd = ["uv", "run", "modal", "secret", "create", secret_name, *secret_args]
-    def _mask_args(args: list[str]) -> list[str]:
-        masked: list[str] = []
-        for a in args:
-            if "=" in a and any(a.startswith(k + "=") for k in ("ENVIRONMENT_API_KEY", "OPENAI_API_KEY", "SYNTH_API_KEY")):
-                try:
-                    k, v = a.split("=", 1)
-                    suf = v[-5:] if len(v) >= 5 else ""
-                    masked.append(f"{k}=***{suf}")
-                except Exception:
-                    masked.append("<masked>")
-            else:
-                masked.append(a)
-        return masked
+    secret_values: dict[str, str] = {"ENVIRONMENT_API_KEY": env_key}
+    if openai_key:
+        secret_values["OPENAI_API_KEY"] = openai_key
+    if synth_for_secret:
+        secret_values["SYNTH_API_KEY"] = synth_for_secret
 
-    print("\n[configure] Creating Modal secret (streaming logs)…")
-    print("[configure] Command:", " ".join(_mask_args(create_cmd)))
-    code = _popen_stream(create_cmd)
-    if code != 0:
-        print("[configure] Secret create failed; attempting delete → create")
-        delete_cmd = ["bash", "-lc", f"printf 'y\\n' | uv run modal secret delete {secret_name}"]
-        print("[configure] Command:", " ".join(delete_cmd))
-        _popen_stream(delete_cmd)
-        print("[configure] Retrying secret create…")
-        print("[configure] Command:", " ".join(_mask_args(create_cmd)))
-        code = _popen_stream(create_cmd)
-        if code != 0:
-            print("[configure] Failed to provision Modal secret.")
-            return 2
+    try:
+        _ensure_modal_secret(secret_name, values=secret_values, label="configure", replace=True)
+    except RuntimeError as err:
+        print(f"[configure] Failed to provision Modal secret: {err}")
+        return 2
 
     # Verify task app can read the secret by hitting rollout health with X-API-Key.
     rollout_url = task_url.rstrip("/") + "/health/rollout"
@@ -557,8 +624,6 @@ def cmd_configure(args: argparse.Namespace) -> int:
         "TASK_APP_NAME": app_name,
         "TASK_APP_SECRET_NAME": secret_name,
     }, indent=2))
-    if minted_env_key:
-        print(f"Stored minted ENVIRONMENT_API_KEY in {cwd_env_path}")
     print("Next: uvx synth-ai rl_demo run")
     return 0
 
@@ -938,96 +1003,6 @@ def cmd_run(args: argparse.Namespace) -> int:
     return 0
 
 
-def cmd_eval(args: argparse.Namespace) -> int:
-    env = demo_core.load_env()
-    # Ensure required env
-    if not env.task_app_base_url:
-        print("Task app URL missing. Run: uvx synth-ai rl_demo deploy")
-        return 1
-    # Load config: prefer CWD demo_config.toml; else packaged default
-    cfg_path: str | None = None
-    if getattr(args, "config", None):
-        p = os.path.abspath(args.config)
-        if not os.path.isfile(p):
-            print(f"Config not found: {p}")
-            return 1
-        cfg_path = p
-    else:
-        cwd_prepared = os.path.abspath(os.path.join(os.getcwd(), "demo_config.toml"))
-        if os.path.isfile(cwd_prepared):
-            cfg_path = cwd_prepared
-        else:
-            packaged = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", "demo_task_apps", "math", "config.toml"))
-            cfg_path = packaged if os.path.isfile(packaged) else None
-    if not cfg_path:
-        print("No config TOML found.")
-        return 1
-
-    import tomllib
-    with open(cfg_path, "rb") as fh:
-        inline_cfg = tomllib.load(fh)
-
-    # Model selection prompt
-    default_model = (args.model or (inline_cfg.get("model", {}) or {}).get("name") or "Qwen/Qwen3-0.6B")
-    entered = input(f"Model to evaluate [{default_model}]: ").strip()
-    model = entered or default_model
-    confirm = (input(f"Use model '{model}'? [Y/n]: ").strip().lower() or "y").startswith("y")
-    if not confirm:
-        print("Aborted by user.")
-        return 1
-
-    # Build on-board rollout request to the Task App (no backend RL job)
-    # Use Synth backend chat-completions proxy as inference URL (derive from DEV_BACKEND_URL)
-    # Ensure /api suffix for backend, then use proxy prefix for chat completions
-    backend_api = (env.dev_backend_url or "https://agent-learning.onrender.com/api").rstrip("/")
-    if not backend_api.endswith("/api"):
-        backend_api = f"{backend_api}/api"
-    inference_url = f"{backend_api}/proxy"
-    # ops: alternate agent/env for a small number of decisions (from config max_steps_per_episode if present)
-    try:
-        steps = int((inline_cfg.get("rollout", {}) or {}).get("max_steps_per_episode", 4))
-    except Exception:
-        steps = 4
-    ops: list[str] = []
-    for _ in range(max(1, steps // 2)):
-        ops.extend(["agent", "env"])
-    env_name = (inline_cfg.get("rollout", {}) or {}).get("env_name") or "math"
-    policy_name = (inline_cfg.get("rollout", {}) or {}).get("policy_name") or "math-react"
-    run_id = f"eval-{int(time.time())}"
-    body: Dict[str, Any] = {
-        "run_id": run_id,
-        "env": {
-            "env_name": env_name,
-            "config": inline_cfg.get("rollout", {}) or {},
-        },
-        "policy": {
-            "policy_name": policy_name,
-            "config": {"model": model, "inference_url": inference_url},
-        },
-        "ops": ops,
-        "on_done": "terminate",
-    }
-    # POST to task app rollout endpoint
-    headers = {"Content-Type": "application/json"}
-    if env.env_api_key:
-        headers["X-API-Key"] = env.env_api_key
-    rc, resp = _http("POST", env.task_app_base_url.rstrip("/") + "/rollout", headers=headers, body=body)
-    if rc not in (200, 201) or not isinstance(resp, dict):
-        print("Eval rollout failed:", rc)
-        try:
-            print(json.dumps(resp, indent=2) if isinstance(resp, dict) else str(resp))
-        except Exception:
-            print(str(resp))
-        print("Request body was:\n" + json.dumps(body, indent=2))
-        return 2
-    metrics = (resp.get("metrics") if isinstance(resp, dict) else None) or {}
-    mean = metrics.get("mean_return")
-    if mean is not None:
-        print(f"eval.reward_mean={mean}")
-    else:
-        print(json.dumps(resp, indent=2))
-    return 0
-
 def main(argv: list[str] | None = None) -> int:
     p = argparse.ArgumentParser(prog="synth-ai")
     sub = p.add_subparsers(dest="cmd")
@@ -1069,14 +1044,6 @@ def main(argv: list[str] | None = None) -> int:
 
     _add_parser(["rl_demo.run", "demo.run"], configure=_run_opts)
 
-    def _eval_opts(parser):
-        parser.add_argument("--config", type=str, default=None, help="Path to TOML config (optional)")
-        parser.add_argument("--model", type=str, default=None, help="Model to evaluate (default Qwen/Qwen3-0.6B)")
-        parser.add_argument("--timeout", type=int, default=300, help="Seconds to wait for metrics")
-        parser.set_defaults(func=cmd_eval)
-
-    _add_parser(["rl_demo.eval", "demo.eval"], configure=_eval_opts)
-
     args = p.parse_args(argv)
     if not hasattr(args, "func"):
         p.print_help()

{synth_ai-0.2.6.dev3 → synth_ai-0.2.6.dev5/synth_ai.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.2.6.dev3
+Version: 0.2.6.dev5
 Summary: RL as a service SDK - Core AI functionality and tracing
 Author-email: Synth AI <josh@usesynth.ai>
 License-Expression: MIT