synth-ai 0.2.8.dev4__py3-none-any.whl → 0.2.23.dev3__py3-none-any.whl

synth_ai/cli/opencode.py

@@ -0,0 +1,256 @@
+import subprocess
+from pathlib import Path
+from typing import Any
+
+import click
+from synth_ai.types import MODEL_NAMES, ModelName
+from synth_ai.urls import BACKEND_URL_SYNTH_RESEARCH_BASE
+from synth_ai.utils import (
+    create_and_write_json,
+    get_bin_path,
+    install_bin,
+    load_json_to_dict,
+    resolve_env_var,
+    verify_bin,
+    write_agents_md,
+    get_backend_from_env,
+)
+
+CONFIG_PATH = Path.home() / ".config" / "opencode" / "opencode.json"
+AUTH_PATH = Path.home() / ".local" / "share" / "opencode" / "auth.json"
+SYNTH_PROVIDER_ID = "synth"
+
+try:
+    import tomllib  # Python 3.11+
+except ImportError:
+    try:
+        import tomli as tomllib  # type: ignore
+    except ImportError:
+        tomllib = None  # type: ignore
+
+
+def _load_session_config(config_path: Path | None = None) -> dict[str, Any]:
+    """Load session configuration from TOML file.
+    
+    Looks for [session] section with:
+    - limit_cost_usd: float (default: 20.0)
+    - limit_tokens: int | None
+    - limit_gpu_hours: float | None
+    
+    Returns dict with session limits.
+    """
+    if config_path is None:
+        # Look for opencode.toml or synth.toml in current directory
+        for name in ["opencode.toml", "synth.toml"]:
+            path = Path(name)
+            if path.exists():
+                config_path = path
+                break
+    
+    if config_path is None or not config_path.exists():
+        # Default: $20 cost limit
+        return {"limit_cost_usd": 20.0}
+    
+    if tomllib is None:
+        return {"limit_cost_usd": 20.0}
+    
+    try:
+        with config_path.open("rb") as f:
+            config = tomllib.load(f)
+        
+        session_config = config.get("session", {})
+        result: dict[str, Any] = {}
+        
+        # Default cost limit is $20 if not specified
+        result["limit_cost_usd"] = session_config.get("limit_cost_usd", 20.0)
+        
+        if "limit_tokens" in session_config:
+            result["limit_tokens"] = session_config["limit_tokens"]
+        if "limit_gpu_hours" in session_config:
+            result["limit_gpu_hours"] = session_config["limit_gpu_hours"]
+        
+        return result
+    except Exception as e:
+        click.echo(f"Warning: Failed to load session config from {config_path}: {e}", err=True)
+        return {"limit_cost_usd": 20.0}
+
+
+@click.command("opencode")
+@click.option(
+    "--model",
+    "model_name",
+    type=str,
+    default=None
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Prompt for API keys even if cached values exist."
+)
+@click.option(
+    "--url",
+    "override_url",
+    type=str,
+    default=None,
+)
+@click.option(
+    "--config",
+    "config_path",
+    type=click.Path(exists=True, path_type=Path),
+    default=None,
+    help="Path to TOML config file (default: opencode.toml or synth.toml in current directory)"
+)
+def opencode_cmd(
+    model_name: ModelName | None = None,
+    force: bool = False,
+    override_url: str | None = None,
+    config_path: Path | None = None,
+) -> None:
+
+    while True:
+        bin_path = get_bin_path("opencode")
+        if bin_path:
+            break
+        if not install_bin(
+            "OpenCode",
+            [
+                "brew install opencode",
+                "bun add -g opencode-ai",
+                "curl -fsSL https://opencode.ai/install | bash",
+                "npm i -g opencode-ai",
+                "paru -S opencode"
+            ]
+        ):
+            print("Failed to find your installed OpenCode")
+            print("Please install from: https://opencode.ai")
+            return
+    print(f"Using OpenCode at {bin_path}")
+
+    if not verify_bin(bin_path):
+        print("Failed to verify OpenCode is runnable")
+        return
+
+    write_agents_md()
+
+    # Load session config from TOML
+    session_config = _load_session_config(config_path)
+    session_limit_cost = session_config.get("limit_cost_usd")
+    session_limit_tokens = session_config.get("limit_tokens")
+    session_limit_gpu_hours = session_config.get("limit_gpu_hours")
+    
+    # Get API key and base URL for session creation
+    synth_api_key = resolve_env_var("SYNTH_API_KEY", override_process_env=force)
+    if override_url:
+        base_url = override_url.rstrip("/")
+        if base_url.endswith("/api"):
+            base_url = base_url[:-4]
+    else:
+        base_url, _ = get_backend_from_env()
+    
+    # Create agent session with limits from config (default: $20 cost limit)
+    session_id: str | None = None
+    if session_limit_tokens or session_limit_cost or session_limit_gpu_hours:
+        try:
+            import asyncio
+            
+            # Create session - org_id will be fetched from backend /me endpoint
+            async def create_session():
+                from synth_ai.session import AgentSessionClient
+                
+                client = AgentSessionClient(f"{base_url}/api", synth_api_key)
+                
+                limits = []
+                if session_limit_tokens:
+                    limits.append({
+                        "limit_type": "hard",
+                        "metric_type": "tokens",
+                        "limit_value": float(session_limit_tokens),
+                    })
+                if session_limit_cost:
+                    limits.append({
+                        "limit_type": "hard",
+                        "metric_type": "cost_usd",
+                        "limit_value": float(session_limit_cost),
+                    })
+                if session_limit_gpu_hours:
+                    limits.append({
+                        "limit_type": "hard",
+                        "metric_type": "gpu_hours",
+                        "limit_value": float(session_limit_gpu_hours),
+                    })
+                
+                # org_id will be automatically fetched from /api/v1/me endpoint
+                session = await client.create(
+                    org_id=None,  # Will be fetched from backend
+                    limits=limits,
+                    tracing_session_id=None,
+                    session_type="opencode_agent",
+                )
+                return session.session_id
+            
+            session_id = asyncio.run(create_session())
+            click.echo(f"✓ Created agent session: {session_id}")
+            if session_limit_tokens:
+                click.echo(f"  Token limit: {session_limit_tokens:,}")
+            if session_limit_cost:
+                click.echo(f"  Cost limit: ${session_limit_cost:.2f}")
+            if session_limit_gpu_hours:
+                click.echo(f"  GPU hours limit: {session_limit_gpu_hours:.2f}")
+        except Exception as e:
+            click.echo(f"Warning: Failed to create agent session: {e}", err=True)
+            click.echo("Continuing without session limits...", err=True)
+
+    if model_name is not None:
+        if model_name not in MODEL_NAMES:
+            raise ValueError(
+                f"model_name={model_name} is invalid. Valid values for model_name: {MODEL_NAMES}"
+            )
+        synth_api_key = resolve_env_var("SYNTH_API_KEY", override_process_env=force)
+        data = load_json_to_dict(AUTH_PATH)
+        good_entry = {
+            "type": "api",
+            "key": synth_api_key,
+        }
+        if data.get(SYNTH_PROVIDER_ID) != good_entry:
+            data[SYNTH_PROVIDER_ID] = good_entry
+        create_and_write_json(AUTH_PATH, data)
+        config = load_json_to_dict(CONFIG_PATH)
+        config.setdefault("$schema", "https://opencode.ai/config.json")
+        if override_url:
+            url = override_url
+            print("Using override URL:", url)
+        else:
+            url = BACKEND_URL_SYNTH_RESEARCH_BASE
+        provider_section = config.setdefault("provider", {})
+        synth_provider = provider_section.setdefault(SYNTH_PROVIDER_ID, {})
+        synth_provider["npm"] = "@ai-sdk/openai-compatible"
+        synth_provider.setdefault("name", "Synth")
+        models = synth_provider.setdefault("models", {})
+        models.setdefault(model_name, {})
+        options = synth_provider.setdefault("options", {})
+        options["baseURL"] = url
+        full_model_name = f"{SYNTH_PROVIDER_ID}/{model_name}"
+        config["model"] = full_model_name
+        create_and_write_json(CONFIG_PATH, config)
+
+    try:
+        subprocess.run([str(bin_path)], check=True)
+    except subprocess.CalledProcessError:
+        print("Failed to launch OpenCode")
+    finally:
+        # End session if created
+        if session_id is not None:
+            try:
+                # Assign to local variable to help type checker
+                final_session_id: str = session_id
+                import asyncio
+                
+                async def end_session():
+                    from synth_ai.session import AgentSessionClient
+                    client = AgentSessionClient(f"{base_url}/api", synth_api_key)
+                    await client.end(final_session_id)
+                    click.echo(f"✓ Ended agent session: {final_session_id}")
+                
+                asyncio.run(end_session())
+            except Exception as e:
+                click.echo(f"Warning: Failed to end agent session: {e}", err=True)

synth_ai/cli/recent.py

@@ -5,40 +5,46 @@ CLI: experiments active in the last K hours with summary stats.
 
 import asyncio
 from datetime import datetime, timedelta
+from typing import TYPE_CHECKING, Any
 
 import click
 from rich import box
 from rich.console import Console
 from rich.table import Table
 
+from ._storage import load_storage
 
-def _fmt_int(v) -> str:
+if TYPE_CHECKING:  # pragma: no cover - typing only
+    import pandas as pd
+else:
+    pd = Any  # type: ignore[assignment]
+
+def _fmt_int(v: Any) -> str:
     try:
         return f"{int(v):,}"
     except Exception:
         return "0"
 
 
-def _fmt_money(v) -> str:
+def _fmt_money(v: Any) -> str:
     try:
         return f"${float(v or 0.0):.4f}"
     except Exception:
         return "$0.0000"
 
 
-def _fmt_time(v) -> str:
+def _fmt_time(v: Any) -> str:
     try:
         return str(v)
     except Exception:
         return "-"
 
 
-async def _fetch_recent(db_url: str, hours: float):
-    from synth_ai.tracing_v3.turso.manager import AsyncSQLTraceManager
-
+async def _fetch_recent(db_url: str, hours: float) -> "pd.DataFrame":
     start_time = datetime.now() - timedelta(hours=hours)
 
-    db = AsyncSQLTraceManager(db_url)
+    create_storage, storage_config = load_storage()
+    db: Any = create_storage(storage_config(connection_string=db_url))
     await db.initialize()
     try:
         query = """

synth_ai/cli/rl_demo.py

@@ -15,19 +15,31 @@ For convenience, dotted aliases are also exposed:
 
 from __future__ import annotations
 
+import importlib
+from typing import Any, cast
+
 import click
+from click.exceptions import Exit
+
+demo_commands = cast(Any, importlib.import_module("synth_ai.demos.core.cli"))
+
 
+def _run_demo_command(func, *args, **kwargs) -> None:
+    """Invoke a demo command and exit via Click on non-zero status codes."""
+
+    try:
+        result = func(*args, **kwargs)
+    except SystemExit as exc:  # pragma: no cover - defensive
+        raise Exit(exc.code or 1) from exc
 
-def _forward(args: list[str]) -> None:
-    import sys
+    if result is None:
+        return
     try:
-        from synth_ai.demos.core import cli as demo_cli  # type: ignore
-    except Exception as e:  # pragma: no cover
-        click.echo(f"Failed to import RL demo CLI: {e}")
-        sys.exit(1)
-    rc = int(demo_cli.main(args) or 0)
-    if rc != 0:
-        sys.exit(rc)
+        code = int(result)
+    except (TypeError, ValueError):
+        return
+    if code != 0:
+        raise Exit(code)
 
 
 def register(cli):
@@ -36,167 +48,207 @@ def register(cli):
         """RL Demo commands (separate from legacy demo)."""
 
     # Help pyright understand dynamic Click group attributes
-    from typing import Any, cast as _cast
-    _rlg = _cast(Any, rl_demo)
+    _rlg = cast(Any, rl_demo)
 
     @_rlg.command("setup")
     def rl_setup():
-        _forward(["rl_demo.setup"])  # primary setup command
+        _run_demo_command(demo_commands.setup)
 
     # (prepare command removed; consolidated into configure)
 
     @_rlg.command("deploy")
     @click.option("--local", is_flag=True, help="Run local FastAPI instead of Modal deploy")
-    @click.option("--app", type=click.Path(), default=None, help="Path to Modal app.py for uv run modal deploy")
+    @click.option(
+        "--app",
+        type=click.Path(),
+        default=None,
+        help="Path to Modal app.py for uv run modal deploy",
+    )
     @click.option("--name", type=str, default="synth-math-demo", help="Modal app name")
-    @click.option("--script", type=click.Path(), default=None, help="Path to deploy_task_app.sh (optional legacy)")
+    @click.option(
+        "--script",
+        type=click.Path(),
+        default=None,
+        help="Path to deploy_task_app.sh (optional legacy)",
+    )
     def rl_deploy(local: bool, app: str | None, name: str, script: str | None):
-        args: list[str] = ["rl_demo.deploy"]
-        if local:
-            args.append("--local")
-        if app:
-            args.extend(["--app", app])
-        if name:
-            args.extend(["--name", name])
-        if script:
-            args.extend(["--script", script])
-        _forward(args)
+        _run_demo_command(
+            demo_commands.deploy,
+            local=local,
+            app=app,
+            name=name,
+            script=script,
+        )
 
     @_rlg.command("configure")
     def rl_configure():
-        _forward(["rl_demo.configure"]) 
+        _run_demo_command(demo_commands.run)
 
     @_rlg.command("init")
-    @click.option("--force", is_flag=True, help="Overwrite existing files in CWD")
-    def rl_init(force: bool):
-        args = ["rl_demo.init"]
-        if force:
-            args.append("--force")
-        _forward(args)
+    @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):
+        _run_demo_command(
+            demo_commands.init,
+            template=template,
+            dest=dest,
+            force=force,
+        )
 
     @_rlg.command("run")
-    @click.option("--config", type=click.Path(), default=None, help="Path to TOML config (skip prompt)")
+    @click.option(
+        "--config", type=click.Path(), default=None, help="Path to TOML config (skip prompt)"
+    )
     @click.option("--batch-size", type=int, default=None)
     @click.option("--group-size", type=int, default=None)
     @click.option("--model", type=str, default=None)
     @click.option("--timeout", type=int, default=600)
     @click.option("--dry-run", is_flag=True, help="Print request body and exit")
-    def rl_run(config: str | None, batch_size: int | None, group_size: int | None, model: str | None, timeout: int, dry_run: bool):
-        args = ["rl_demo.run"]
-        if config:
-            args.extend(["--config", config])
-        if batch_size is not None:
-            args.extend(["--batch-size", str(batch_size)])
-        if group_size is not None:
-            args.extend(["--group-size", str(group_size)])
-        if model:
-            args.extend(["--model", model])
-        if timeout is not None:
-            args.extend(["--timeout", str(timeout)])
-        if dry_run:
-            args.append("--dry-run")
-        _forward(args)
+    def rl_run(
+        config: str | None,
+        batch_size: int | None,
+        group_size: int | None,
+        model: str | None,
+        timeout: int,
+        dry_run: bool,
+    ):
+        _run_demo_command(
+            demo_commands.run,
+            config=config,
+            batch_size=batch_size,
+            group_size=group_size,
+            model=model,
+            timeout=timeout,
+            dry_run=dry_run,
+        )
 
     # Dotted aliases (top-level): legacy check → setup
     @cli.command("rl_demo.check")
     def rl_check_alias():
-        _forward(["rl_demo.setup"]) 
+        _run_demo_command(demo_commands.setup)
 
     @cli.command("rl_demo.setup")
     def rl_setup_alias():
-        _forward(["rl_demo.setup"]) 
+        _run_demo_command(demo_commands.setup)
 
     # (prepare alias removed)
 
     @cli.command("rl_demo.deploy")
     @click.option("--local", is_flag=True, help="Run local FastAPI instead of Modal deploy")
-    @click.option("--app", type=click.Path(), default=None, help="Path to Modal app.py for uv run modal deploy")
+    @click.option(
+        "--app",
+        type=click.Path(),
+        default=None,
+        help="Path to Modal app.py for uv run modal deploy",
+    )
     @click.option("--name", type=str, default="synth-math-demo", help="Modal app name")
-    @click.option("--script", type=click.Path(), default=None, help="Path to deploy_task_app.sh (optional legacy)")
+    @click.option(
+        "--script",
+        type=click.Path(),
+        default=None,
+        help="Path to deploy_task_app.sh (optional legacy)",
+    )
     def rl_deploy_alias(local: bool, app: str | None, name: str, script: str | None):
-        args: list[str] = ["rl_demo.deploy"]
-        if local:
-            args.append("--local")
-        if app:
-            args.extend(["--app", app])
-        if name:
-            args.extend(["--name", name])
-        if script:
-            args.extend(["--script", script])
-        _forward(args)
+        _run_demo_command(
+            demo_commands.deploy,
+            local=local,
+            app=app,
+            name=name,
+            script=script,
+        )
 
     @cli.command("rl_demo.configure")
     def rl_configure_alias():
-        _forward(["rl_demo.configure"]) 
+        _run_demo_command(demo_commands.run)
 
     @cli.command("rl_demo.init")
-    @click.option("--force", is_flag=True, help="Overwrite existing files in CWD")
-    def rl_init_alias(force: bool):
-        args = ["rl_demo.init"]
-        if force:
-            args.append("--force")
-        _forward(args)
+    @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):
+        _run_demo_command(
+            demo_commands.init,
+            template=template,
+            dest=dest,
+            force=force,
+        )
 
     @cli.command("rl_demo.run")
-    @click.option("--config", type=click.Path(), default=None, help="Path to TOML config (skip prompt)")
+    @click.option(
+        "--config", type=click.Path(), default=None, help="Path to TOML config (skip prompt)"
+    )
     @click.option("--batch-size", type=int, default=None)
     @click.option("--group-size", type=int, default=None)
     @click.option("--model", type=str, default=None)
     @click.option("--timeout", type=int, default=600)
     @click.option("--dry-run", is_flag=True, help="Print request body and exit")
-    def rl_run_alias(config: str | None, batch_size: int | None, group_size: int | None, model: str | None, timeout: int, dry_run: bool):
-        args = ["rl_demo.run"]
-        if config:
-            args.extend(["--config", config])
-        if batch_size is not None:
-            args.extend(["--batch-size", str(batch_size)])
-        if group_size is not None:
-            args.extend(["--group-size", str(group_size)])
-        if model:
-            args.extend(["--model", model])
-        if timeout is not None:
-            args.extend(["--timeout", str(timeout)])
-        if dry_run:
-            args.append("--dry-run")
-        _forward(args)
+    def rl_run_alias(
+        config: str | None,
+        batch_size: int | None,
+        group_size: int | None,
+        model: str | None,
+        timeout: int,
+        dry_run: bool,
+    ):
+        _run_demo_command(
+            demo_commands.run,
+            config=config,
+            batch_size=batch_size,
+            group_size=group_size,
+            model=model,
+            timeout=timeout,
+            dry_run=dry_run,
+        )
 
     # Top-level convenience alias: `synth-ai deploy`
-    @cli.command("deploy")
+    @cli.command("demo-deploy")
     @click.option("--local", is_flag=True, help="Run local FastAPI instead of Modal deploy")
-    @click.option("--app", type=click.Path(), default=None, help="Path to Modal app.py for uv run modal deploy")
+    @click.option(
+        "--app",
+        type=click.Path(),
+        default=None,
+        help="Path to Modal app.py for uv run modal deploy",
+    )
     @click.option("--name", type=str, default="synth-math-demo", help="Modal app name")
-    @click.option("--script", type=click.Path(), default=None, help="Path to deploy_task_app.sh (optional legacy)")
-    def deploy_top(local: bool, app: str | None, name: str, script: str | None):
-        args: list[str] = ["rl_demo.deploy"]
-        if local:
-            args.append("--local")
-        if app:
-            args.extend(["--app", app])
-        if name:
-            args.extend(["--name", name])
-        if script:
-            args.extend(["--script", script])
-        _forward(args)
+    @click.option(
+        "--script",
+        type=click.Path(),
+        default=None,
+        help="Path to deploy_task_app.sh (optional legacy)",
+    )
+    def deploy_demo(local: bool, app: str | None, name: str, script: str | None):
+        _run_demo_command(
+            demo_commands.deploy,
+            local=local,
+            app=app,
+            name=name,
+            script=script,
+        )
 
     @cli.command("run")
-    @click.option("--config", type=click.Path(), default=None, help="Path to TOML config (skip prompt)")
+    @click.option(
+        "--config", type=click.Path(), default=None, help="Path to TOML config (skip prompt)"
+    )
     @click.option("--batch-size", type=int, default=None)
     @click.option("--group-size", type=int, default=None)
     @click.option("--model", type=str, default=None)
     @click.option("--timeout", type=int, default=600)
     @click.option("--dry-run", is_flag=True, help="Print request body and exit")
-    def run_top(config: str | None, batch_size: int | None, group_size: int | None, model: str | None, timeout: int, dry_run: bool):
-        args = ["run"]
-        if config:
-            args.extend(["--config", config])
-        if batch_size is not None:
-            args.extend(["--batch-size", str(batch_size)])
-        if group_size is not None:
-            args.extend(["--group-size", str(group_size)])
-        if model:
-            args.extend(["--model", model])
-        if timeout is not None:
-            args.extend(["--timeout", str(timeout)])
-        if dry_run:
-            args.append("--dry-run")
-        _forward(args)
+    def run_top(
+        config: str | None,
+        batch_size: int | None,
+        group_size: int | None,
+        model: str | None,
+        timeout: int,
+        dry_run: bool,
+    ):
+        _run_demo_command(
+            demo_commands.run,
+            config=config,
+            batch_size=batch_size,
+            group_size=group_size,
+            model=model,
+            timeout=timeout,
+            dry_run=dry_run,
+        )