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

{synth_ai-0.2.6.dev4/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.dev4
+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.dev4 → synth_ai-0.2.6.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-ai"
-version = "0.2.6.dev4"
+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.dev4 → 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
 

{synth_ai-0.2.6.dev4 → 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.dev4
+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