synth-ai 0.2.17__py3-none-any.whl → 0.2.19__py3-none-any.whl

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/usage.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import contextlib
+from datetime import UTC, datetime, timedelta
+from typing import Any
+
+import click
+
+from ..client import StatusAPIClient
+from ..errors import StatusAPIError
+from ..formatters import console
+from ..utils import common_options, resolve_context_config
+
+
+def _parse_iso(ts: str | None) -> datetime | None:
+    if not ts:
+        return None
+    try:
+        # Python 3.11 handles 'YYYY-mm-ddTHH:MM:SS.ssssss+00:00' and '...Z'
+        if ts.endswith("Z"):
+            ts = ts.replace("Z", "+00:00")
+        return datetime.fromisoformat(ts)
+    except Exception:
+        return None
+
+
+def _extract_total_usd(events: list[dict[str, Any]]) -> tuple[float, int]:
+    """Return (usd_total, tokens_total) for an arbitrary job's events.
+
+    Strategy:
+    - Prefer a consolidated total from any *.completed event with total_usd
+    - Next, prefer any *.billing.end event with total_usd
+    - Otherwise, combine usage.recorded's usd_tokens with billing.sandboxes' usd
+      and sum token counts if present
+    Works for prompt learning and other job types that follow similar conventions.
+    """
+    total_usd = 0.0
+    token_count = 0
+
+    # Prefer consolidated totals from completion events (any namespace)
+    for e in reversed(events):
+        typ = str(e.get("type") or "").lower()
+        if typ.endswith(".completed"):
+            data = e.get("data") or {}
+            try:
+                total_usd = float(data.get("total_usd") or 0.0)
+            except Exception:
+                total_usd = 0.0
+            # Try common token fields
+            tc = 0
+            for k in ("token_count_total", "token_count"):
+                try:
+                    tc = int(data.get(k) or 0)
+                    if tc:
+                        break
+                except Exception:
+                    pass
+            if not tc:
+                try:
+                    tc = int((data.get("token_count_rollouts") or 0) + (data.get("token_count_mutation") or 0))
+                except Exception:
+                    tc = 0
+            token_count = tc
+            return total_usd, token_count
+
+    # Next, billing.end if present with total_usd
+    for e in reversed(events):
+        typ = str(e.get("type") or "").lower()
+        if typ.endswith("billing.end"):
+            data = e.get("data") or {}
+            try:
+                total_usd = float(data.get("total_usd") or 0.0)
+            except Exception:
+                total_usd = 0.0
+            # token_count may not be present here; fall through to usage tokens calc
+            break
+
+    # Fallback: combine usage + sandboxes (prompt learning style); generic scan
+    usd_tokens = 0.0
+    sandbox_usd = 0.0
+    # token fields observed across tasks
+    token_fields = ("token_count_total", "token_count", "tokens_in", "tokens_out",
+                    "token_count_rollouts", "token_count_mutation")
+    for e in events:
+        typ = str(e.get("type") or "").lower()
+        data = e.get("data") or {}
+        # generic usage-style aggregation
+        if "usage" in typ or typ.endswith("usage.recorded"):
+            with contextlib.suppress(Exception):
+                usd_tokens = float(data.get("usd_tokens") or data.get("usd_estimate") or 0.0)
+            # accumulate tokens if any
+            for k in token_fields:
+                with contextlib.suppress(Exception):
+                    token_count += int(data.get(k) or 0)
+        # sandbox billing
+        if typ.endswith("billing.sandboxes"):
+            with contextlib.suppress(Exception):
+                sandbox_usd += float(data.get("usd") or 0.0)
+    return (total_usd or (usd_tokens + sandbox_usd)), token_count
+
+
+@click.command("usage", help="Show recent usage (daily/weekly/monthly) and remaining budget if provided.")
+@common_options()
+@click.option("--budget-usd", type=float, default=None, help="Optional credit/budget to compute remaining.")
+@click.option("--json", "output_json", is_flag=True, help="Emit machine-readable JSON.")
+@click.pass_context
+def usage_command(
+    ctx: click.Context,
+    base_url: str | None,
+    api_key: str | None,
+    timeout: float,
+    budget_usd: float | None,
+    output_json: bool,
+) -> None:
+    cfg = resolve_context_config(ctx, base_url=base_url, api_key=api_key, timeout=timeout)
+    now = datetime.now(UTC)
+    daily_cutoff = (now - timedelta(days=1)).isoformat()
+    weekly_cutoff = (now - timedelta(days=7)).isoformat()
+    monthly_cutoff = (now - timedelta(days=30)).isoformat()
+
+    async def _run() -> tuple[dict[str, float | int], dict[str, float | int], dict[str, float | int]]:
+        daily = {"usd": 0.0, "tokens": 0, "sandbox_seconds": 0.0}
+        weekly = {"usd": 0.0, "tokens": 0, "sandbox_seconds": 0.0}
+        monthly = {"usd": 0.0, "tokens": 0, "sandbox_seconds": 0.0}
+        async with StatusAPIClient(cfg) as client:
+            try:
+                jobs = await client.list_jobs(created_after=weekly_cutoff)
+            except StatusAPIError as exc:
+                raise click.ClickException(f"Backend error: {exc}") from exc
+            for j in jobs or []:
+                job_id = str(j.get("job_id") or j.get("id") or "")
+                if not job_id:
+                    continue
+                try:
+                    events = await client.get_job_events(job_id, since=weekly_cutoff)
+                except StatusAPIError:
+                    events = []
+                if not events:
+                    continue
+                # Use event timestamps for windowing
+                # Weekly
+                weekly_ev = [e for e in events if (_parse_iso(e.get("created_at")) or now) >= datetime.fromisoformat(weekly_cutoff)]
+                w_usd, w_tok = _extract_total_usd(weekly_ev)
+                weekly["usd"] += w_usd
+                weekly["tokens"] += w_tok
+                # sandbox seconds
+                for e in weekly_ev:
+                    if str(e.get("type") or "").lower().endswith("billing.sandboxes"):
+                        with contextlib.suppress(Exception):
+                            weekly["sandbox_seconds"] += float((e.get("data") or {}).get("seconds") or 0.0)
+                # Daily
+                daily_ev = [e for e in events if (_parse_iso(e.get("created_at")) or now) >= datetime.fromisoformat(daily_cutoff)]
+                d_usd, d_tok = _extract_total_usd(daily_ev)
+                daily["usd"] += d_usd
+                daily["tokens"] += d_tok
+                for e in daily_ev:
+                    if str(e.get("type") or "").lower().endswith("billing.sandboxes"):
+                        with contextlib.suppress(Exception):
+                            daily["sandbox_seconds"] += float((e.get("data") or {}).get("seconds") or 0.0)
+                # Monthly
+                monthly_ev = [e for e in events if (_parse_iso(e.get("created_at")) or now) >= datetime.fromisoformat(monthly_cutoff)]
+                m_usd, m_tok = _extract_total_usd(monthly_ev)
+                monthly["usd"] += m_usd
+                monthly["tokens"] += m_tok
+                for e in monthly_ev:
+                    if str(e.get("type") or "").lower().endswith("billing.sandboxes"):
+                        with contextlib.suppress(Exception):
+                            monthly["sandbox_seconds"] += float((e.get("data") or {}).get("seconds") or 0.0)
+        return daily, weekly, monthly
+
+    daily, weekly, monthly = __import__("asyncio").run(_run())
+
+    if output_json:
+        import json as _json
+        payload: dict[str, Any] = {
+            "daily": {
+                "usd": round(float(daily["usd"]), 4),
+                "tokens": int(daily["tokens"]),
+                "sandbox_hours": round(float(daily["sandbox_seconds"]) / 3600.0, 4),
+            },
+            "weekly": {
+                "usd": round(float(weekly["usd"]), 4),
+                "tokens": int(weekly["tokens"]),
+                "sandbox_hours": round(float(weekly["sandbox_seconds"]) / 3600.0, 4),
+            },
+            "monthly": {
+                "usd": round(float(monthly["usd"]), 4),
+                "tokens": int(monthly["tokens"]),
+                "sandbox_hours": round(float(monthly["sandbox_seconds"]) / 3600.0, 4),
+            },
+        }
+        if budget_usd is not None:
+            payload["remaining_vs_budget"] = round(max(0.0, float(budget_usd) - float(weekly["usd"])), 4)
+        console.print(_json.dumps(payload))
+        return
+
+    console.print(f"Daily usage: ${float(daily['usd']):.2f} | tokens {int(daily['tokens'])} | sandbox {float(daily['sandbox_seconds'])/3600.0:.2f}h")
+    console.print(f"Weekly usage: ${float(weekly['usd']):.2f} | tokens {int(weekly['tokens'])} | sandbox {float(weekly['sandbox_seconds'])/3600.0:.2f}h")
+    console.print(f"Monthly usage: ${float(monthly['usd']):.2f} | tokens {int(monthly['tokens'])} | sandbox {float(monthly['sandbox_seconds'])/3600.0:.2f}h")
+    if budget_usd is not None:
+        remaining = max(0.0, float(budget_usd) - float(weekly["usd"]))
+        console.print(f"Remaining (vs weekly budget ${float(budget_usd):.2f}): ${remaining:.2f}")
+

synth_ai/cli/commands/train/judge_schemas.py

@@ -197,3 +197,4 @@ def build_judge_http_options(
         payload["rubric_overrides"] = options_config.rubric_overrides
     
     return payload
+

synth_ai/cli/commands/train/judge_validation.py

@@ -302,3 +302,4 @@ def check_for_deprecated_fields(toml_config: MutableMapping[str, Any]) -> dict[s
                 deprecated["judge.options"] = options_found
     
     return deprecated
+

synth_ai/cli/commands/train/validation.py

@@ -261,23 +261,6 @@ def validate_rl_config(config: MutableMapping[str, Any]) -> dict[str, Any]:
             hint="Specify gpus_for_vllm, gpus_for_training, etc."
         )
     
-    # Validate vllm section and tensor_parallel consistency
-    vllm = config.get("vllm", {})
-    topology_tensor_parallel = topology.get("tensor_parallel")
-    vllm_tensor_parallel = vllm.get("tensor_parallel_size")
-    
-    if topology_tensor_parallel and not vllm_tensor_parallel:
-        raise InvalidRLConfigError(
-            detail="Both [topology].tensor_parallel and [vllm].tensor_parallel_size must be provided",
-            hint=f"Add [vllm] section with tensor_parallel_size={topology_tensor_parallel}"
-        )
-    
-    if vllm_tensor_parallel and not topology_tensor_parallel:
-        raise InvalidRLConfigError(
-            detail="Both [topology].tensor_parallel and [vllm].tensor_parallel_size must be provided",
-            hint=f"Add tensor_parallel={vllm_tensor_parallel} to [topology] section"
-        )
-    
     # Check for training section and its required fields
     training = config.get("training", {})
     if training:
@@ -288,8 +271,6 @@ def validate_rl_config(config: MutableMapping[str, Any]) -> dict[str, Any]:
             "batch_size": "batch size",
             "group_size": "group size",
             "learning_rate": "learning rate",
-            "weight_sync_interval": "weight sync interval",
-            "log_interval": "logging interval",
         }
         
         for field, description in required_training_fields.items():
@@ -298,44 +279,6 @@ def validate_rl_config(config: MutableMapping[str, Any]) -> dict[str, Any]:
                     detail=f"[training].{field} is required ({description})",
                     hint=f"Add {field} to the [training] section"
                 )
-        
-        # Validate weight_sync_interval is positive
-        weight_sync_interval = training.get("weight_sync_interval")
-        if weight_sync_interval is not None and weight_sync_interval <= 0:
-            raise InvalidRLConfigError(
-                detail="[training].weight_sync_interval must be a positive integer",
-                hint="Set weight_sync_interval to a value >= 1"
-            )
-        
-        # Ensure weight_sync block exists with proper defaults
-        # Backend requires mode="direct" - always inject it
-        if "weight_sync" not in training:
-            training["weight_sync"] = {
-                "enable": True,
-                "mode": "direct",  # Backend requirement
-                "targets": ["policy"],
-                "interval": training.get("weight_sync_interval", 1),
-            }
-        else:
-            weight_sync = training["weight_sync"]
-            # Always force mode to "direct" (backend requirement)
-            weight_sync["mode"] = "direct"
-            
-            # Validate existing weight_sync block
-            if not weight_sync.get("enable"):
-                raise InvalidRLConfigError(
-                    detail="[training.weight_sync].enable must be true",
-                    hint="Set enable=true in the weight_sync section"
-                )
-            targets = weight_sync.get("targets", [])
-            if not targets or "policy" not in targets:
-                raise InvalidRLConfigError(
-                    detail="[training.weight_sync].targets must include 'policy'",
-                    hint="Add targets=['policy'] to the weight_sync section"
-                )
-            # Inject interval if not present
-            if "interval" not in weight_sync:
-                weight_sync["interval"] = training.get("weight_sync_interval", 1)
     
     # Check for evaluation section
     evaluation = config.get("evaluation", {})

synth_ai/cli/demo.py

@@ -1,5 +1,37 @@
-from __future__ import annotations
+import shutil
+from pathlib import Path
 
-from synth_ai.cli.commands.demo.core import register
+import click
 
-__all__ = ["register"]
+
+DEMO_SOURCES: dict[str, str] = {
+    "local": "crafter",
+    "modal": "math"
+}
+
+
+@click.command()
+@click.option(
+    "--runtime",
+    "runtime",
+    type=click.Choice(tuple(DEMO_SOURCES.keys()), case_sensitive=False),
+    default="local",
+    show_default=True,
+    help="Select runtime to load a demo task app to your cwd. Options: local, modal"
+)
+def demo_cmd(runtime: str) -> None:
+      runtime_key = runtime.lower()
+      demo_name = DEMO_SOURCES[runtime_key]
+      package_root = Path(__file__).resolve().parents[1]
+      src = package_root / "demos" / demo_name
+      if not src.exists():
+          raise click.ClickException(f"Demo source directory not found: {src}")
+
+      dst = Path.cwd() / src.name
+      if dst.exists():
+          raise click.ClickException(
+              f"Destination already exists: {dst}. Remove it first if you want to re-copy."
+          )
+
+      shutil.copytree(src, dst)
+      click.echo(f"Copied {demo_name} demo to {dst}")

synth_ai/cli/deploy/__init__.py

@@ -1,28 +1,43 @@
+"""Deploy command package - imports from deploy.py module."""
 from __future__ import annotations
 
-from .core import command, get_command
-from .errors import (
-    DeployCliError,
-    EnvFileDiscoveryError,
-    EnvironmentKeyLoadError,
-    EnvKeyPreflightError,
-    MissingEnvironmentApiKeyError,
-    ModalCliResolutionError,
-    ModalExecutionError,
-    TaskAppNotFoundError,
-)
-from .validation import validate_deploy_options
+# Import from the deploy.py module file (using importlib to avoid conflicts)
+# This package exists for backwards compatibility
+import importlib
+import importlib.util
+import sys
+from pathlib import Path
+from typing import TYPE_CHECKING
 
-__all__ = [
-    "command",
-    "get_command",
-    "DeployCliError",
-    "MissingEnvironmentApiKeyError",
-    "EnvironmentKeyLoadError",
-    "EnvFileDiscoveryError",
-    "TaskAppNotFoundError",
-    "ModalCliResolutionError",
-    "ModalExecutionError",
-    "EnvKeyPreflightError",
-    "validate_deploy_options",
-]
+if TYPE_CHECKING:
+    from click import Command
+
+try:
+    # Import the deploy.py module directly by file path to avoid package/module conflict
+    deploy_module_path = Path(__file__).parent.parent / "deploy.py"
+    if deploy_module_path.exists():
+        spec = importlib.util.spec_from_file_location("synth_ai.cli.deploy_module", deploy_module_path)
+        if spec and spec.loader:
+            deploy_module = importlib.util.module_from_spec(spec)
+            sys.modules["synth_ai.cli.deploy_module"] = deploy_module
+            spec.loader.exec_module(deploy_module)
+            command: Command | None = getattr(deploy_module, "deploy_cmd", None)  # type: ignore[assignment]
+            deploy_cmd: Command | None = command  # type: ignore[assignment]
+        else:
+            raise ImportError("Could not load deploy.py")
+    else:
+        raise ImportError("deploy.py not found")
+    
+    get_command: None = None  # Not used in current implementation
+    
+    __all__: list[str] = [
+        "command",
+        "deploy_cmd",
+    ]
+except Exception:
+    # If deploy.py doesn't exist or fails to import, provide a stub
+    command: Command | None = None  # type: ignore[assignment]
+    deploy_cmd: Command | None = None  # type: ignore[assignment]
+    get_command: None = None
+    
+    __all__: list[str] = []

synth_ai/cli/deploy.py

@@ -0,0 +1,162 @@
+from pathlib import Path
+from types import SimpleNamespace
+from typing import Literal, TypeAlias, get_args
+
+import click
+from synth_ai.task_app_cfgs import LocalTaskAppConfig, ModalTaskAppConfig
+from synth_ai.utils.cli import PromptedChoiceOption, PromptedChoiceType, PromptedPathOption
+from synth_ai.utils.modal import deploy_modal_app, get_default_modal_bin_path
+from synth_ai.utils.uvicorn import deploy_uvicorn_app
+
+RuntimeType: TypeAlias = Literal[
+    "local",
+    "modal"
+]
+RUNTIMES = get_args(RuntimeType)
+
+MODAL_RUNTIME_OPTIONS = [
+    "task_app_name",
+    "cmd_arg",
+    "modal_bin_path",
+    "dry_run",
+    "modal_app_path",
+]
+LOCAL_RUNTIME_OPTIONS = [
+    "trace",
+    "host",
+    "port"
+]
+
+RUNTIME_MSG = SimpleNamespace(
+    init="[deploy]",
+    local="[deploy --runtime local]",
+    modal="[deploy --runtime modal]",
+)
+
+
+@click.command("deploy")
+# --- Required options ---
+@click.option(
+    "--task-app",
+    "task_app_path",
+    cls=PromptedPathOption,
+    type=click.Path(
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        path_type=Path
+    ),
+    file_type=".py",
+    help=f"{RUNTIME_MSG.init} Enter the path to your task app",
+)
+@click.option(
+    "--runtime",
+    "runtime",
+    cls=PromptedChoiceOption,
+    type=PromptedChoiceType(RUNTIMES),
+    required=True
+)
+# --- Local-only options ---
+@click.option(
+    "--trace/--no-trace",
+    "trace",
+    default=True,
+    help=f"{RUNTIME_MSG.local} Enable or disable trace output"
+)
+@click.option(
+    "--host",
+    "host",
+    default="127.0.0.1", 
+    help=f"{RUNTIME_MSG.local} Host to bind to"
+)
+@click.option(
+    "--port",
+    "port",
+    default=8000,
+    type=int,
+    help=f"{RUNTIME_MSG.local} Port to bind to"
+)
+# --- Modal-only options ---
+@click.option(
+    "--modal-app",
+    "modal_app_path",
+    cls=PromptedPathOption,
+    type=click.Path(
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        path_type=Path
+    ),
+    file_type=".py",
+    prompt_guard=lambda ctx: (ctx.params.get("runtime") != "local"),
+    help=f"{RUNTIME_MSG.modal} Enter the path to your Modal app",
+)
+@click.option(
+    "--name",
+    "task_app_name",
+    default=None,
+    help=f"{RUNTIME_MSG.modal} Override Modal app name"
+)
+@click.option(
+    "--modal-mode",
+    "cmd_arg",
+    default="deploy",
+    help=f"{RUNTIME_MSG.modal} Mode: deploy or serve"
+)
+@click.option(
+    "--modal-cli",
+    "modal_bin_path",
+    type=click.Path(
+        dir_okay=False,
+        file_okay=True,
+        exists=True,
+        path_type=Path
+    ),
+    default=None,
+    help=f"{RUNTIME_MSG.modal} Path to Modal CLI",
+)
+@click.option(
+    "--dry-run",
+    "dry_run",
+    is_flag=True,
+    help=f"{RUNTIME_MSG.modal} Print Modal command without executing"
+)
+@click.option(
+    "--env-file",
+    "env_file",
+    multiple=True,
+    type=click.Path(exists=True),
+    help="Path to .env file(s) to load"
+)
+def deploy_cmd(
+    task_app_path: Path,
+    runtime: RuntimeType,
+    env_file: tuple[str, ...],
+    **kwargs
+) -> None:
+    """Deploy a task app to local or Modal runtime."""
+    match runtime:
+        case "local":
+            opts = {k: v for k, v in kwargs.items() if k in LOCAL_RUNTIME_OPTIONS}
+            deploy_uvicorn_app(LocalTaskAppConfig(**opts, task_app_path=task_app_path))
+
+        case "modal":
+            opts = {k: v for k, v in kwargs.items() if k in MODAL_RUNTIME_OPTIONS}
+
+            if "modal_app_path" not in opts or opts["modal_app_path"] is None:
+                raise click.ClickException("Modal app path required")
+            
+            if opts["cmd_arg"] == "serve" and opts["dry_run"] is True:
+                raise click.ClickException("--modal-mode=serve cannot be combined with --dry-run")
+            
+            modal_bin_path = opts.get("modal_bin_path") or get_default_modal_bin_path()
+            if not modal_bin_path:
+                raise click.ClickException(
+                    "Modal CLI not found. Install the `modal` package or pass --modal-cli with its path."
+                )
+            if isinstance(modal_bin_path, str):
+                modal_bin_path = Path(modal_bin_path)
+            opts["modal_bin_path"] = modal_bin_path
+            deploy_modal_app(ModalTaskAppConfig(**opts, task_app_path=task_app_path))
+
+__all__ = ["deploy_cmd"]

synth_ai/cli/legacy_root_backup.py

@@ -253,7 +253,7 @@ def view(url: str):
 
 @cli.command()
 @click.option("--db-file", default="synth_ai.db", help="Database file path")
-@click.option("--sqld-port", default=8080, type=int, help="Port for sqld HTTP interface")
+@click.option("--sqld-port", default=8080, type=int, help="Port for sqld Hrana WebSocket interface (HTTP API will be port+1)")
 @click.option("--env-port", default=8901, type=int, help="Port for environment service")
 @click.option("--no-sqld", is_flag=True, help="Skip starting sqld daemon")
 @click.option("--no-env", is_flag=True, help="Skip starting environment service")
@@ -298,32 +298,37 @@ def serve(
 
     # Start sqld if requested
     if not no_sqld:
+        hrana_port = sqld_port
+        http_port = sqld_port + 1
         # Check if sqld is already running
         try:
             result = subprocess.run(
-                ["pgrep", "-f", f"sqld.*--http-listen-addr.*:{sqld_port}"],
+                ["pgrep", "-f", f"sqld.*(--hrana-listen-addr.*:{hrana_port}|--http-listen-addr.*:{http_port})"],
                 capture_output=True,
                 text=True,
             )
             if result.returncode == 0:
-                click.echo(f"✅ sqld already running on port {sqld_port}")
+                click.echo(f"✅ sqld already running on hrana port {hrana_port}, HTTP API port {http_port}")
                 click.echo(f"   Database: {db_file}")
-                click.echo(f"   HTTP API: http://127.0.0.1:{sqld_port}")
+                click.echo(f"   libsql: libsql://127.0.0.1:{hrana_port}")
+                click.echo(f"   HTTP API: http://127.0.0.1:{http_port}")
             else:
                 # Find or install sqld
                 sqld_bin = find_sqld_binary()
                 if not sqld_bin:
                     sqld_bin = install_sqld()
 
-                click.echo(f"🗄️  Starting sqld (local only) on port {sqld_port}")
+                click.echo(f"🗄️  Starting sqld (local only) on hrana port {hrana_port}, HTTP API port {http_port}")
 
                 # Start sqld
                 sqld_cmd = [
                     sqld_bin,
                     "--db-path",
                     db_file,
+                    "--hrana-listen-addr",
+                    f"127.0.0.1:{hrana_port}",
                     "--http-listen-addr",
-                    f"127.0.0.1:{sqld_port}",
+                    f"127.0.0.1:{http_port}",
                 ]
 
                 # Create log file
@@ -346,7 +351,8 @@ def serve(
 
                 click.echo("✅ sqld started successfully!")
                 click.echo(f"   Database: {db_file}")
-                click.echo(f"   HTTP API: http://127.0.0.1:{sqld_port}")
+                click.echo(f"   libsql: libsql://127.0.0.1:{hrana_port}")
+                click.echo(f"   HTTP API: http://127.0.0.1:{http_port}")
                 click.echo(f"   Log file: {os.path.abspath('sqld.log')}")
 
         except FileNotFoundError:
@@ -417,7 +423,7 @@ def serve(
         click.echo(f"   Working directory: {os.getcwd()}")
         click.echo("")
         click.echo("🔄 Starting services...")
-        click.echo(f"   - sqld daemon: http://127.0.0.1:{sqld_port}")
+        click.echo(f"   - sqld daemon: libsql://127.0.0.1:{sqld_port} (HTTP API: http://127.0.0.1:{sqld_port + 1})")
         click.echo(f"   - Environment service: http://127.0.0.1:{env_port}")
         click.echo("")
         click.echo("💡 Tips:")