synth-ai 0.2.8.dev13__tar.gz → 0.2.9.dev0__tar.gz

{synth_ai-0.2.8.dev13/synth_ai.egg-info → synth_ai-0.2.9.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: synth-ai
-Version: 0.2.8.dev13
+Version: 0.2.9.dev0
 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.8.dev13 → synth_ai-0.2.9.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "synth-ai"
-version = "0.2.8.dev13"
+version = "0.2.9.dev0"
 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.8.dev13 → synth_ai-0.2.9.dev0}/synth_ai/api/train/cli.py

@@ -161,6 +161,27 @@ def train_command(
         explicit_env_paths=env_files,
         required_keys=required_keys,
     )
+
+    missing_keys = [
+        spec.name
+        for spec in required_keys
+        if not spec.optional and not (env_values.get(spec.name) or os.environ.get(spec.name))
+    ]
+    if missing_keys:
+        try:
+            from synth_ai.cli.task_apps import _interactive_fill_env
+        except Exception as exc:  # pragma: no cover - protective fallback
+            raise click.ClickException(f"Unable to prompt for env values: {exc}") from exc
+
+        target_dir = cfg_path.parent
+        generated = _interactive_fill_env(target_dir / ".env")
+        if generated is None:
+            raise click.ClickException("Required environment values missing; aborting.")
+        env_path, env_values = resolve_env(
+            config_path=cfg_path,
+            explicit_env_paths=(str(generated),),
+            required_keys=required_keys,
+        )
     click.echo(f"Using env file: {env_path}")
 
     synth_key = env_values.get("SYNTH_API_KEY") or os.environ.get("SYNTH_API_KEY")

{synth_ai-0.2.8.dev13 → synth_ai-0.2.9.dev0}/synth_ai/api/train/config_finder.py

@@ -37,19 +37,67 @@ def _iter_candidate_paths() -> Iterable[Path]:
             seen.add(resolved)
             yield resolved
 
+    # Additionally, discover configs anywhere under the current working directory
+    # so users can run `uvx synth-ai train` from project roots without passing --config.
+    try:
+        cwd = Path.cwd().resolve()
+    except Exception:
+        cwd = None
+    if cwd and cwd.exists():
+        for path in cwd.rglob("*.toml"):
+            if any(part in _SKIP_DIRS for part in path.parts):
+                continue
+            resolved = path.resolve()
+            if resolved in seen:
+                continue
+            seen.add(resolved)
+            yield resolved
+
 
 def _infer_config_type(data: dict) -> str:
-    if isinstance(data.get("training"), dict) or isinstance(data.get("hyperparameters"), dict):
-        return "sft"
+    # 1) Strong signals from [algorithm]
+    algo = data.get("algorithm")
+    if isinstance(algo, dict):
+        method = str(algo.get("method") or "").lower()
+        algo_type = str(algo.get("type") or "").lower()
+        variety = str(algo.get("variety") or "").lower()
+
+        # RL indicators
+        if method in {"policy_gradient", "ppo", "reinforce"}:
+            return "rl"
+        if algo_type == "online":
+            return "rl"
+        if variety in {"gspo", "grpo", "ppo"}:
+            return "rl"
+
+        # SFT indicators
+        if method in {"supervised_finetune", "sft"}:
+            return "sft"
+        if algo_type == "offline":
+            return "sft"
+        if variety in {"fft"}:
+            return "sft"
+
+    # 2) Other RL signals
     if data.get("job_type") == "rl":
         return "rl"
     services = data.get("services")
     if isinstance(services, dict) and ("task_url" in services or "environment" in services):
         return "rl"
-    compute = data.get("compute")
-    if isinstance(compute, dict) and "gpu_type" in compute:
-        # typically FFT toml
-        return "sft"
+
+    # 3) Other SFT signals
+    training = data.get("training")
+    if isinstance(training, dict):
+        mode = str(training.get("mode") or "").lower()
+        if mode.startswith("sft") or mode == "sft_offline":
+            return "sft"
+    hyper = data.get("hyperparameters")
+    if isinstance(hyper, dict):
+        kind = str(hyper.get("train_kind") or "").lower()
+        if kind in {"sft", "fft"}:
+            return "sft"
+
+    # 4) Fallback
     return "unknown"
 
 

{synth_ai-0.2.8.dev13 → synth_ai-0.2.9.dev0}/synth_ai/api/train/task_app.py

@@ -18,23 +18,88 @@ class TaskAppHealth:
     detail: str | None = None
 
 
+def _health_response_ok(resp: requests.Response | None) -> tuple[bool, str]:
+    if resp is None:
+        return False, ""
+    status = resp.status_code
+    if status == 200:
+        return True, ""
+    if status in {401, 403}:
+        try:
+            payload = resp.json()
+        except ValueError:
+            payload = {}
+        prefix = payload.get("expected_api_key_prefix")
+        detail = str(payload.get("detail", ""))
+        if prefix or "expected prefix" in detail.lower():
+            note = "auth-optional"
+            if prefix:
+                note += f" (expected-prefix={prefix})"
+            return True, note
+    return False, ""
+
+
 def check_task_app_health(base_url: str, api_key: str, *, timeout: float = 10.0) -> TaskAppHealth:
+    # Send ALL known environment keys so the server can authorize any valid one
+    import os
     headers = {"X-API-Key": api_key}
+    aliases = (os.getenv("ENVIRONMENT_API_KEY_ALIASES") or "").strip()
+    keys: list[str] = [api_key]
+    if aliases:
+        keys.extend([p.strip() for p in aliases.split(",") if p.strip()])
+    if keys:
+        headers["X-API-Keys"] = ",".join(keys)
+        headers.setdefault("Authorization", f"Bearer {api_key}")
     base = base_url.rstrip("/")
-    health_resp = None
     detail_parts: list[str] = []
+
+    health_resp: requests.Response | None = None
+    health_ok = False
     try:
         health_resp = http_get(f"{base}/health", headers=headers, timeout=timeout)
-        detail_parts.append(f"/health={health_resp.status_code}")
+        health_ok, note = _health_response_ok(health_resp)
+        suffix = f" ({note})" if note else ""
+        # On non-200, include brief JSON detail if present
+        if not health_ok and health_resp is not None:
+            try:
+                hjs = health_resp.json()
+                # pull a few helpful fields without dumping everything
+                expected = hjs.get("expected_api_key_prefix")
+                authorized = hjs.get("authorized")
+                detail = hjs.get("detail")
+                extras = []
+                if authorized is not None:
+                    extras.append(f"authorized={authorized}")
+                if expected:
+                    extras.append(f"expected_prefix={expected}")
+                if detail:
+                    extras.append(f"detail={str(detail)[:80]}")
+                if extras:
+                    suffix += " [" + ", ".join(extras) + "]"
+            except Exception:
+                pass
+        detail_parts.append(f"/health={health_resp.status_code}{suffix}")
     except requests.RequestException as exc:
         detail_parts.append(f"/health_error={exc}")
-    task_resp = None
+
+    task_resp: requests.Response | None = None
+    task_ok = False
     try:
         task_resp = http_get(f"{base}/task_info", headers=headers, timeout=timeout)
-        detail_parts.append(f"/task_info={task_resp.status_code}")
+        task_ok = bool(task_resp.status_code == 200)
+        if not task_ok and task_resp is not None:
+            try:
+                tjs = task_resp.json()
+                msg = tjs.get("detail") or tjs.get("status")
+                detail_parts.append(f"/task_info={task_resp.status_code} ({str(msg)[:80]})")
+            except Exception:
+                detail_parts.append(f"/task_info={task_resp.status_code}")
+        else:
+            detail_parts.append(f"/task_info={task_resp.status_code}")
     except requests.RequestException as exc:
         detail_parts.append(f"/task_info_error={exc}")
-    ok = bool(health_resp and health_resp.status_code == 200 and task_resp and task_resp.status_code == 200)
+
+    ok = bool(health_ok and task_ok)
     detail = ", ".join(detail_parts)
     return TaskAppHealth(
         ok=ok,

{synth_ai-0.2.8.dev13 → synth_ai-0.2.9.dev0}/synth_ai/cli/rl_demo.py

@@ -67,9 +67,15 @@ def register(cli):
         _forward(["rl_demo.configure"]) 
 
     @_rlg.command("init")
-    @click.option("--force", is_flag=True, help="Overwrite existing files in CWD")
-    def rl_init(force: bool):
+    @click.option("--template", type=str, default=None, help="Template id to instantiate")
+    @click.option("--dest", type=click.Path(), default=None, help="Destination directory for files")
+    @click.option("--force", is_flag=True, help="Overwrite existing files in destination")
+    def rl_init(template: str | None, dest: str | None, force: bool):
         args = ["rl_demo.init"]
+        if template:
+            args.extend(["--template", template])
+        if dest:
+            args.extend(["--dest", dest])
         if force:
             args.append("--force")
         _forward(args)
@@ -130,9 +136,15 @@ def register(cli):
         _forward(["rl_demo.configure"]) 
 
     @cli.command("rl_demo.init")
-    @click.option("--force", is_flag=True, help="Overwrite existing files in CWD")
-    def rl_init_alias(force: bool):
+    @click.option("--template", type=str, default=None, help="Template id to instantiate")
+    @click.option("--dest", type=click.Path(), default=None, help="Destination directory for files")
+    @click.option("--force", is_flag=True, help="Overwrite existing files in destination")
+    def rl_init_alias(template: str | None, dest: str | None, force: bool):
         args = ["rl_demo.init"]
+        if template:
+            args.extend(["--template", template])
+        if dest:
+            args.extend(["--dest", dest])
         if force:
             args.append("--force")
         _forward(args)

{synth_ai-0.2.8.dev13 → synth_ai-0.2.9.dev0}/synth_ai/cli/root.py

@@ -14,6 +14,20 @@ import sys
 import time
 
 import click
+try:
+    from importlib.metadata import PackageNotFoundError, version as _pkg_version
+    try:
+        __pkg_version__ = _pkg_version("synth-ai")
+    except PackageNotFoundError:
+        try:
+            from synth_ai import __version__ as __pkg_version__  # type: ignore
+        except Exception:
+            __pkg_version__ = "unknown"
+except Exception:
+    try:
+        from synth_ai import __version__ as __pkg_version__  # type: ignore
+    except Exception:
+        __pkg_version__ = "unknown"
 
 
 def find_sqld_binary() -> str | None:
@@ -66,9 +80,10 @@ rm -rf "$TMP_DIR"
     return os.path.expanduser("~/.local/bin/sqld")
 
 
-@click.group()
+@click.group(help=f"Synth AI v{__pkg_version__} - Software for aiding the best and multiplying the will.")
+@click.version_option(version=__pkg_version__, prog_name="synth-ai")
 def cli():
-    """Synth AI - Software for aiding the best and multiplying the will."""
+    """Top-level command group for Synth AI."""
 
 
 # === Legacy demo command group (aliases new rl_demo implementation) ===
@@ -84,7 +99,7 @@ def _forward_to_demo(args: list[str]) -> None:
     except Exception as e:  # pragma: no cover
         click.echo(f"Failed to import demo CLI: {e}")
         sys.exit(1)
-    rc = int(demo_cli.main(args) or 0)
+    rc = int(getattr(demo_cli, "main")(args) or 0)  # type: ignore[attr-defined]
     if rc != 0:
         sys.exit(rc)
 
@@ -123,6 +138,22 @@ def setup():
     _forward_to_demo(["rl_demo.setup"])
 
 
+@demo.command()
+@click.option("--template", type=str, default=None, help="Template id to instantiate")
+@click.option("--dest", type=str, default=None, help="Destination directory for files")
+@click.option("--force", is_flag=True, help="Overwrite existing files in destination")
+def init(template: str | None, dest: str | None, force: bool):
+    """Copy demo task app template into the current directory."""
+    args: list[str] = ["demo.init"]
+    if template:
+        args.extend(["--template", template])
+    if dest:
+        args.extend(["--dest", dest])
+    if force:
+        args.append("--force")
+    _forward_to_demo(args)
+
+
 @demo.command()
 @click.option("--batch-size", type=int, default=None)
 @click.option("--group-size", type=int, default=None)
@@ -142,8 +173,8 @@ def run(batch_size: int | None, group_size: int | None, model: str | None, timeo
     _forward_to_demo(args)
 
 
-@cli.command()
-def setup():
+@cli.command(name="setup")
+def setup_command():
     """Perform SDK handshake and write keys to .env."""
     _forward_to_demo(["rl_demo.setup"])