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

synth_ai/cli/commands/status/subcommands/jobs.py

@@ -0,0 +1,334 @@
+"""`synth jobs` command group implementation."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Any
+
+import click
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import (
+    console,
+    events_panel,
+    job_panel,
+    jobs_table,
+    metrics_table,
+    print_json,
+    runs_table,
+)
+from ..utils import bail, common_options, parse_relative_time, resolve_context_config
+
+
+@click.group("jobs", help="Manage training jobs.")
+@click.pass_context
+def jobs_group(ctx: click.Context) -> None:  # pragma: no cover - Click wiring
+    ctx.ensure_object(dict)
+
+
+def _print_or_json(items: Any, output_json: bool) -> None:
+    if output_json:
+        print_json(items)
+    elif isinstance(items, list):
+        console.print(jobs_table(items))
+    else:
+        console.print(job_panel(items))
+
+
+@jobs_group.command("list")
+@common_options()
+@click.option(
+    "--status",
+    type=click.Choice(["queued", "running", "succeeded", "failed", "cancelled"]),
+    help="Filter by job status.",
+)
+@click.option(
+    "--type",
+    "job_type",
+    type=click.Choice(["sft_offline", "sft_online", "rl_online", "dpo", "sft"]),
+    help="Filter by training job type.",
+)
+@click.option("--created-after", help="Filter by creation date (ISO8601 or relative like '24h').")
+@click.option("--limit", default=20, show_default=True, type=int)
+@click.option("--json", "output_json", is_flag=True, help="Emit raw JSON.")
+@click.pass_context
+def list_jobs(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    status: str | None,
+    job_type: str | None,
+    created_after: str | None,
+    limit: int,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+    created_filter = parse_relative_time(created_after)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                jobs = await client.list_jobs(
+                    status=status,
+                    job_type=job_type,
+                    created_after=created_filter,
+                    limit=limit,
+                )
+                _print_or_json(jobs, output_json)
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("get")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def get_job(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                job = await client.get_job(job_id)
+                _print_or_json(job, output_json)
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("history")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_history(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                runs = await client.list_job_runs(job_id)
+                if output_json:
+                    print_json(runs)
+                else:
+                    console.print(runs_table(runs))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("timeline")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_timeline(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                timeline = await client.get_job_timeline(job_id)
+                if output_json:
+                    print_json(timeline)
+                else:
+                    console.print(events_panel(timeline))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("metrics")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_metrics(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                metrics = await client.get_job_metrics(job_id)
+                if output_json:
+                    print_json(metrics)
+                else:
+                    console.print(metrics_table(metrics))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("config")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_config(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                config = await client.get_job_config(job_id)
+                if output_json:
+                    print_json(config)
+                else:
+                    console.print(job_panel({"job_id": job_id, "config": config}))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("status")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_status(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                status = await client.get_job_status(job_id)
+                if output_json:
+                    print_json(status)
+                else:
+                    console.print(f"[bold]{job_id}[/bold]: {status.get('status', 'unknown')}")
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("cancel")
+@common_options()
+@click.argument("job_id")
+@click.pass_context
+def cancel_job(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                resp = await client.cancel_job(job_id)
+                console.print(resp.get("message") or f"[yellow]Cancellation requested for {job_id}[/yellow]")
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@jobs_group.command("logs")
+@common_options()
+@click.argument("job_id")
+@click.option("--since", help="Only show events emitted after the provided timestamp/relative offset.")
+@click.option("--tail", type=int, help="Show only the last N events.")
+@click.option("--follow/--no-follow", default=False, help="Poll for new events.")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def job_logs(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    since: str | None,
+    tail: int | None,
+    follow: bool,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+    since_filter = parse_relative_time(since)
+
+    async def _loop() -> None:
+        seen_ids: set[str] = set()
+        cursor: str | None = None
+        try:
+            async with StatusAPIClient(cfg) as client:
+                while True:
+                    events = await client.get_job_events(
+                        job_id,
+                        since=cursor or since_filter,
+                        limit=tail,
+                        after=cursor,
+                    )
+                    new_events: list[dict[str, Any]] = []
+                    for event in events:
+                        event_id = str(event.get("event_id") or event.get("id") or event.get("timestamp"))
+                        if event_id in seen_ids:
+                            continue
+                        seen_ids.add(event_id)
+                        new_events.append(event)
+                    if new_events:
+                        cursor = str(new_events[-1].get("event_id") or new_events[-1].get("id") or "")
+                        if output_json:
+                            print_json(new_events)
+                        else:
+                            console.print(events_panel(new_events))
+                    if not follow:
+                        break
+                    await asyncio.sleep(2.0)
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_loop())

synth_ai/cli/commands/status/subcommands/models.py

@@ -0,0 +1,79 @@
+"""`synth models` command group."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+from rich.json import JSON
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import console, models_table, print_json
+from ..utils import bail, common_options, resolve_context_config
+
+
+@click.group("models", help="Inspect fine-tuned models.")
+@click.pass_context
+def models_group(ctx: click.Context) -> None:  # pragma: no cover - Click wiring
+    ctx.ensure_object(dict)
+
+
+@models_group.command("list")
+@common_options()
+@click.option("--limit", type=int, default=None, help="Maximum number of models to return.")
+@click.option("--type", "model_type", type=click.Choice(["rl", "sft"]), default=None, help="Filter by model type.")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def list_models(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    limit: int | None,
+    model_type: str | None,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                models = await client.list_models(limit=limit, model_type=model_type)
+                if output_json:
+                    print_json(models)
+                else:
+                    console.print(models_table(models))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@models_group.command("get")
+@common_options()
+@click.argument("model_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def get_model(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    model_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                model = await client.get_model(model_id)
+                if output_json:
+                    print_json(model)
+                else:
+                    console.print(JSON.from_data(model))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())

synth_ai/cli/commands/status/subcommands/pricing.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import click
+from rich.table import Table
+from synth_ai.pricing.model_pricing import MODEL_PRICES
+
+from ..formatters import console
+
+
+@click.command("pricing", help="List supported provider/model rates (SDK static table).")
+def pricing_command() -> None:
+    table = Table(title="Supported Models and Rates (USD/token)")
+    table.add_column("Provider", style="cyan", no_wrap=True)
+    table.add_column("Model", style="magenta")
+    table.add_column("Input USD", justify="right")
+    table.add_column("Output USD", justify="right")
+    for provider, models in MODEL_PRICES.items():
+        for model, rates in models.items():
+            table.add_row(provider, model, f"{rates.input_usd:.9f}", f"{rates.output_usd:.9f}")
+    console.print(table)
+
+

synth_ai/cli/commands/status/subcommands/runs.py

@@ -0,0 +1,81 @@
+"""`synth runs` command group."""
+
+from __future__ import annotations
+
+import asyncio
+
+import click
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import console, events_panel, print_json, runs_table
+from ..utils import bail, common_options, parse_relative_time, resolve_context_config
+
+
+@click.group("runs", help="Inspect individual job runs/attempts.")
+@click.pass_context
+def runs_group(ctx: click.Context) -> None:  # pragma: no cover - Click wiring
+    ctx.ensure_object(dict)
+
+
+@runs_group.command("list")
+@common_options()
+@click.argument("job_id")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def list_runs(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                runs = await client.list_job_runs(job_id)
+                if output_json:
+                    print_json(runs)
+                else:
+                    console.print(runs_table(runs))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())
+
+
+@runs_group.command("logs")
+@common_options()
+@click.argument("job_id")
+@click.option("--run", "run_id", required=True, help="Run identifier (number or ID) to inspect.")
+@click.option("--since", help="Filter events after the supplied timestamp/relative offset.")
+@click.option("--json", "output_json", is_flag=True)
+@click.pass_context
+def run_logs(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    job_id: str,
+    run_id: str,
+    since: str | None,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+    since_filter = parse_relative_time(since)
+
+    async def _run() -> None:
+        try:
+            async with StatusAPIClient(cfg) as client:
+                events = await client.get_job_events(job_id, since=since_filter, run_id=run_id)
+                if output_json:
+                    print_json(events)
+                else:
+                    console.print(events_panel(events))
+        except StatusAPIError as exc:
+            bail(f"Backend error: {exc}")
+
+    asyncio.run(_run())

synth_ai/cli/commands/status/subcommands/session.py

@@ -0,0 +1,183 @@
+"""Session status command for Synth CLI."""
+
+from __future__ import annotations
+
+import asyncio
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from synth_ai.cli.commands.status.config import resolve_backend_config
+from synth_ai.session import AgentSessionClient, SessionNotFoundError
+
+
+console = Console()
+
+
+@click.command("session", help="Show current agent session status and limits.")
+@click.option(
+    "--session-id",
+    type=str,
+    default=None,
+    help="Session ID to check (default: uses active session from environment)"
+)
+@click.option(
+    "--base-url",
+    envvar="SYNTH_STATUS_BASE_URL",
+    default=None,
+    help="Synth backend base URL (defaults to environment configuration).",
+)
+@click.option(
+    "--api-key",
+    envvar="SYNTH_STATUS_API_KEY",
+    default=None,
+    help="API key for authenticated requests (falls back to Synth defaults).",
+)
+@click.option(
+    "--timeout",
+    default=30.0,
+    show_default=True,
+    type=float,
+    help="HTTP request timeout in seconds.",
+)
+def session_status_cmd(
+    session_id: Optional[str],
+    base_url: Optional[str],
+    api_key: Optional[str],
+    timeout: float,
+) -> None:
+    """Show agent session status, limits, and current usage."""
+    cfg = resolve_backend_config(base_url=base_url, api_key=api_key, timeout=timeout)
+    
+    async def _run() -> None:
+        import os
+        
+        # Use provided session_id or try to get from environment
+        if not session_id:
+            session_id_env = os.getenv("SYNTH_SESSION_ID")
+            if session_id_env:
+                session_id_to_use = session_id_env
+            else:
+                # Try to get active session
+                if not cfg.api_key:
+                    console.print("[red]API key is required. Set SYNTH_API_KEY environment variable.[/red]")
+                    return
+                client = AgentSessionClient(f"{cfg.base_url}/api", cfg.api_key)
+                try:
+                    async with client._http:
+                        sessions = await client.list(status="active", limit=1)
+                        if sessions:
+                            session_id_to_use = sessions[0].session_id
+                        else:
+                            console.print("[yellow]No active session found.[/yellow]")
+                            console.print("Create a session with: [cyan]uvx synth-ai codex[/cyan] or [cyan]uvx synth-ai opencode[/cyan]")
+                            return
+                except Exception as e:
+                    console.print(f"[red]Error fetching active session: {e}[/red]")
+                    return
+        else:
+            session_id_to_use = session_id
+        
+        if not cfg.api_key:
+            console.print("[red]API key is required. Set SYNTH_API_KEY environment variable.[/red]")
+            return
+        client = AgentSessionClient(f"{cfg.base_url}/api", cfg.api_key)
+        try:
+            session = await client.get(session_id_to_use)
+            
+            # Display session info
+            table = Table(title=f"Session: {session.session_id[:16]}...", show_header=True, header_style="bold cyan")
+            table.add_column("Property", style="cyan")
+            table.add_column("Value", style="green")
+            
+            table.add_row("Session ID", session.session_id)
+            table.add_row("Status", f"[bold]{session.status}[/bold]")
+            table.add_row("Created", session.created_at.strftime("%Y-%m-%d %H:%M:%S UTC"))
+            if session.ended_at:
+                table.add_row("Ended", session.ended_at.strftime("%Y-%m-%d %H:%M:%S UTC"))
+            if session.expires_at:
+                table.add_row("Expires", session.expires_at.strftime("%Y-%m-%d %H:%M:%S UTC"))
+            
+            console.print(table)
+            console.print()
+            
+            # Display usage summary
+            usage_table = Table(title="Usage Summary", show_header=True, header_style="bold cyan")
+            usage_table.add_column("Metric", style="cyan")
+            usage_table.add_column("Value", style="green")
+            
+            usage_table.add_row("Tokens", f"{session.usage.tokens:,}")
+            usage_table.add_row("Cost (USD)", f"${session.usage.cost_usd:.4f}")
+            usage_table.add_row("GPU Hours", f"{session.usage.gpu_hours:.4f}")
+            usage_table.add_row("API Calls", f"{session.usage.api_calls:,}")
+            
+            console.print(usage_table)
+            console.print()
+            
+            # Display limits
+            if session.limits:
+                limits_table = Table(title="Session Limits", show_header=True, header_style="bold cyan")
+                limits_table.add_column("Type", style="cyan")
+                limits_table.add_column("Limit", style="green")
+                limits_table.add_column("Used", style="yellow")
+                limits_table.add_column("Remaining", style="green")
+                limits_table.add_column("Status", style="bold")
+                
+                for limit in session.limits:
+                    remaining = limit.remaining
+                    status = "[green]✓ OK[/green]" if remaining > 0 else "[red]✗ EXCEEDED[/red]"
+                    if limit.metric_type == "cost_usd":
+                        limits_table.add_row(
+                            "Cost (USD)",
+                            f"${limit.limit_value:.2f}",
+                            f"${limit.current_usage:.4f}",
+                            f"${remaining:.4f}",
+                            status
+                        )
+                    elif limit.metric_type == "tokens":
+                        limits_table.add_row(
+                            "Tokens",
+                            f"{limit.limit_value:,.0f}",
+                            f"{limit.current_usage:,.0f}",
+                            f"{remaining:,.0f}",
+                            status
+                        )
+                    elif limit.metric_type == "gpu_hours":
+                        limits_table.add_row(
+                            "GPU Hours",
+                            f"{limit.limit_value:.2f}",
+                            f"{limit.current_usage:.4f}",
+                            f"{remaining:.4f}",
+                            status
+                        )
+                    else:
+                        limits_table.add_row(
+                            limit.metric_type,
+                            str(limit.limit_value),
+                            str(limit.current_usage),
+                            str(remaining),
+                            status
+                        )
+                
+                console.print(limits_table)
+                
+                # Warn if any limit exceeded
+                exceeded = [limit for limit in session.limits if limit.current_usage >= limit.limit_value]
+                if exceeded:
+                    console.print()
+                    console.print("[red][bold]⚠ WARNING: Session limits exceeded![/bold][/red]")
+                    console.print("The session will reject new requests until limits are increased.")
+                    for limit in exceeded:
+                        console.print(f"  - {limit.metric_type}: {limit.current_usage} >= {limit.limit_value}")
+            else:
+                console.print("[yellow]No limits configured for this session.[/yellow]")
+                
+        except SessionNotFoundError:
+            console.print(f"[red]Session not found: {session_id_to_use}[/red]")
+        except Exception as e:
+            console.print(f"[red]Error fetching session: {e}[/red]")
+    
+    asyncio.run(_run())
+