lyceum-cli 1.2.1__tar.gz → 1.2.3__tar.gz

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lyceum-cli
-Version: 1.2.1
+Version: 1.2.3
 Summary: Command-line interface for Lyceum Cloud
 Author-email: Lyceum <support@lyceum.technology>
 License: MIT

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/lyceum/_version.py

@@ -7,4 +7,4 @@ __version__ lives in this module. A future refactor could move these modules
 under lyceum/cli/, claiming one subpackage the way the other two do.
 """
 
-__version__ = "1.2.1"
+__version__ = "1.2.3"

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/lyceum/external/compute/inference/claude_code.py

@@ -19,7 +19,7 @@ console = Console()
 # or ~/.claude settings on this machine.
 CLAUDE_PROFILE_DIR = Path.home() / ".lyceum" / "claude"
 
-DEFAULT_MODEL = "moonshotai/kimi-k3"
+DEFAULT_MODEL = "moonshotai/kimi-k3.1-pro"
 DEFAULT_FAST_MODEL = "z-ai/glm-5.3-flash"
 
 # Use explicit Lyceum IDs so the backend never has to guess a substitute.

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/lyceum/external/compute/inference/infer.py

@@ -74,7 +74,7 @@ def _is_dedicated_inference_hidden() -> bool:
 
 def _fetch_dedicated_models() -> list[dict]:
     """Serverless models a dedicated deployment may run, on their default GPU shape."""
-    return api_request("GET", "/api/v2/external/inference/models", timeout=20.0).get("models", [])
+    return api_request("GET", "/external/inference/models", timeout=20.0).get("models", [])
 
 
 def _format_gpus(gpu_type: str, gpu_count: int) -> str:
@@ -181,14 +181,27 @@ def deploy_model(
     target_latency: float = typer.Option(None, "--target-latency", hidden=True),
     stabilisation: int = typer.Option(None, "--stabilisation", hidden=True),
     gpu_count: int = typer.Option(
-        None, "--gpu-count", help="GPUs per replica, defaults per model (also sets --tensor-parallel-size)"
+        None,
+        "--gpu-count",
+        help="GPUs per replica, defaults per model (also sets --tensor-parallel-size)",
+    ),
+    offload: bool = typer.Option(
+        None,
+        "--offload/--no-offload",
+        help=(
+            "Serve requests the deployment cannot from Lyceum's serverless capacity (default off). That may include a "
+            "third-party provider under Lyceum's data terms unless your org is restricted to Lyceum's own"
+        ),
     ),
     yes: bool = typer.Option(False, "--yes", "-y", help="Do not ask before creating"),
     wait: bool = typer.Option(False, "--wait", "-w", help="Wait until deployment has healthy replicas"),
 ):
     """Deploy a serverless model on dedicated GPUs."""
     models = _fetch_dedicated_models()
-    model = next((m for m in models if model_id.lower() in (m["serving_name"].lower(), m["hf_model_id"].lower())), None)
+    model = next(
+        (m for m in models if model_id.lower() in (m["serving_name"].lower(), m["hf_model_id"].lower())),
+        None,
+    )
     if model is None:
         console.print(f"[red]{model_id} cannot be deployed on dedicated GPUs.[/red]")
         console.print("[dim]See the models that can: lyceum infer models --dedicated[/dim]")
@@ -222,7 +235,10 @@ def deploy_model(
             raise typer.Exit(0)
 
     if hf_token is None and not yes and not (os.getenv("HF_TOKEN") or os.getenv("HUGGING_FACE_HUB_TOKEN")):
-        if typer.confirm("No HF token detected. Provide one (required for gated models)?", default=False):
+        if typer.confirm(
+            "No HF token detected. Provide one (required for gated models)?",
+            default=False,
+        ):
             hf_token = typer.prompt("HuggingFace Token", hide_input=True)
 
     payload = {
@@ -233,6 +249,7 @@ def deploy_model(
     overrides = {
         "gpu_count": gpu_count,
         "gpu_type": gpu_type,
+        "offload": offload,
         "stabilisation_window": stabilisation,
         "target_latency_p95_ms": target_latency,
         "target_rps": target_rps,
@@ -241,7 +258,7 @@ def deploy_model(
     if hf_token:
         payload["hf_token"] = hf_token
 
-    data = api_request("POST", "/api/v2/external/inference/create", json=payload)
+    data = api_request("POST", "/external/inference/create", json=payload)
     deployment_id = data.get("deployment_id", "?")
 
     console.print("\n[green]Deployment created![/green]")
@@ -261,6 +278,30 @@ def deploy_model(
         _wait_for_healthy(deployment_id, timeout=model["ready_timeout_s"])
 
 
+def _offload_label(enabled: bool | None) -> str:
+    return "enabled" if enabled else "disabled"
+
+
+@infer_app.command("offload", hidden=_is_dedicated_inference_hidden())
+def set_offload(
+    deployment_id: str = typer.Argument(..., help="Deployment ID"),
+    enabled: bool = typer.Option(..., "--enable/--disable", help="Turn offloading on or off"),
+):
+    """Turn offloading on or off for a deployment.
+
+    Enabled, requests the deployment cannot serve go to Lyceum's serverless capacity,
+    which may include a third-party provider under Lyceum's data terms unless your
+    org is restricted to Lyceum's own.
+    """
+    data = api_request(
+        "POST",
+        "/external/inference/offload",
+        json={"deployment_id": deployment_id, "offload": enabled},
+    )
+    console.print(f"  Deployment ID: [cyan]{data.get('deployment_id')}[/cyan]")
+    console.print(f"  Offload:       [yellow]{_offload_label(data.get('offload'))}[/yellow]")
+
+
 @infer_app.command("stop")
 def stop_model(
     deployment_id: str = typer.Argument(..., help="Deployment ID to stop"),
@@ -268,7 +309,7 @@ def stop_model(
     """Stop a deployed model and all its replicas."""
     console.print(f"[dim]Stopping deployment {deployment_id[:12]}...[/dim]")
 
-    data = api_request("DELETE", "/api/v2/external/inference/stop", json={"deployment_id": deployment_id})
+    data = api_request("DELETE", "/external/inference/stop", json={"deployment_id": deployment_id})
     console.print("[green]Deployment stopped![/green]")
     console.print(f"  Deployment ID: [cyan]{data.get('deployment_id')}[/cyan]")
     console.print(f"  Status:        [yellow]{data.get('status')}[/yellow]")
@@ -283,7 +324,7 @@ def deployment_status(
     """Show detailed status of a deployment."""
     dep = api_request(
         "GET",
-        "/api/v2/external/inference/get",
+        "/external/inference/get",
         params={"deployment_id": deployment_id, "include_terminated": str(include_terminated).lower()},
         timeout=15.0,
     )
@@ -307,6 +348,8 @@ def deployment_status(
         console.print(f"  Target p95:     {dep['target_latency_p95_ms']} ms")
     if dep.get("stabilisation_window") is not None:
         console.print(f"  Stabilisation:  {dep['stabilisation_window']} s")
+    if dep.get("offload") is not None:
+        console.print(f"  Offload:        {_offload_label(dep['offload'])}")
 
     replicas = dep.get("replicas", [])
     if replicas:
@@ -359,7 +402,7 @@ def list_deployments(
     """List your dedicated deployments."""
     data = api_request(
         "GET",
-        "/api/v2/external/inference/list",
+        "/external/inference/list",
         params={"include_terminated": str(include_terminated).lower()},
         timeout=15.0,
     )
@@ -425,7 +468,7 @@ def replica_logs(
     replica_id: str = typer.Argument(..., help="Replica ID"),
 ):
     """Show last container logs for a failed replica."""
-    data = api_request("GET", f"/api/v2/external/inference/replica/{replica_id}/logs", timeout=15.0)
+    data = api_request("GET", f"/external/inference/replica/{replica_id}/logs", timeout=15.0)
     error_logs = data.get("error_logs")
     if not error_logs:
         console.print(f"[yellow]No logs available for replica {replica_id}[/yellow]")
@@ -445,7 +488,7 @@ def _wait_for_healthy(deployment_id: str, timeout: int = 600, poll_interval: int
         while time.time() < deadline:
             try:
                 response = httpx.get(
-                    f"{config.base_url}/api/v2/external/inference/get",
+                    f"{config.base_url}/external/inference/get",
                     headers=headers,
                     params={"deployment_id": deployment_id},
                     timeout=15.0,

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/lyceum/external/vms/management.py

@@ -47,6 +47,54 @@ def _print_ssh_command(ip_addr: str):
         console.print(f"\n[cyan]SSH command:[/cyan] ssh -i <your-key> lyceum@{ip_addr}")
 
 
+def _attached_volumes_of(vm_id: str) -> list[dict[str, Any]]:
+    try:
+        data = api_request("GET", f"/api/v2/external/vms/{vm_id}/status", silent=True)
+    except typer.Exit:
+        return []
+    return (data or {}).get("volumes") or []
+
+
+def _print_volumes_with_ids(volumes: list[dict[str, Any]]):
+    for volume in volumes:
+        size = volume.get("size_gb")
+        mount_path = volume.get("mount_path")
+        details = ", ".join(part for part in (f"{size} GB" if size else "", mount_path or "") if part)
+        console.print(f"  [cyan]{volume.get('volume_id', '-')}[/cyan]" + (f"  [dim]{details}[/dim]" if details else ""))
+
+
+def _warn_about_attached_storage_being_not_deleted(volumes: list[dict[str, Any]]):
+    if not volumes:
+        return
+
+    one = len(volumes) == 1
+    noun, them, keep = ("volume", "it", "keeps") if one else ("volumes", "them", "keep")
+    console.print(f"\n[yellow]This VM is holding {len(volumes)} block storage {noun}:[/yellow]")
+    _print_volumes_with_ids(volumes)
+    console.print(
+        f"[yellow]Stopping the VM detaches {them} but does not delete {them}.[/yellow]\n"
+        f"[dim]The {noun} {keep} your data and {keep} being billed until you delete {them} separately.[/dim]\n"
+    )
+
+
+def _report_detached_storage_with_usage_hints(volumes: list[dict[str, Any]]):
+    if not volumes:
+        return
+
+    one = len(volumes) == 1
+    noun = "volume" if one else "volumes"
+    verb = "is" if one else "are"
+    console.print(f"\n[yellow]{len(volumes)} block storage {noun} outlived the VM and {verb} still billed:[/yellow]")
+    _print_volumes_with_ids(volumes)
+    console.print(f"\n[dim]Delete {'it' if one else 'each one'} with:[/dim]")
+    for volume in volumes:
+        console.print(f"  [cyan]lyceum storage block delete {volume.get('volume_id', '<volume-id>')}[/cyan]")
+    console.print(
+        f"[dim]Or keep {'it' if one else 'them'} for the next VM: "
+        "lyceum vm start --attach-storage <volume-id> ...[/dim]"
+    )
+
+
 def _validate_storage_options(
     attach_storage: list[str] | None,
     create_block_storage: int | None,
@@ -73,11 +121,14 @@ def _print_storage_result(data: dict[str, Any]):
     """Report the block storage a VM was created with, if any."""
     volume = data.get("volume")
     if volume:
+        name = volume.get("name", "-")
         console.print(
-            f"[bold]Block storage:[/bold] {volume['volume_id']} "
+            f"[bold]Block storage:[/bold] {name} "
             f"({volume['size_gb']} GB, {_status_style(volume.get('status', 'pending'))})"
         )
-        console.print("[dim]The volume outlives this VM; delete it with: lyceum storage block delete <id>[/dim]")
+        # The volume is named here rather than identified, because the provider
+        # has issued no ID yet. `storage block list` carries it once it has.
+        console.print("[dim]The volume outlives this VM; see it with: lyceum storage block list[/dim]")
 
     notice = data.get("volume_notice")
     if notice:
@@ -575,11 +626,15 @@ def terminate_instance(
 ):
     """Stop and delete a VM instance"""
     if not force:
+        _warn_about_attached_storage_being_not_deleted(_attached_volumes_of(vm_id))
         confirm = typer.confirm(f"Are you sure you want to terminate VM {vm_id}?")
         if not confirm:
             console.print("[yellow]Termination cancelled.[/yellow]")
             return
 
     console.print("[dim]Terminating VM instance...[/dim]")
-    data = api_request("DELETE", f"/api/v2/external/vms/{vm_id}")
+    data = api_request("DELETE", f"/api/v2/external/vms/{vm_id}") or {}
     console.print(f"[green]✓ {data.get('message', 'VM instance terminated successfully')}[/green]")
+    # Taken from the delete rather than the lookup above, so --force hears about
+    # the storage too.
+    _report_detached_storage_with_usage_hints(data.get("detached_volumes") or [])

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/lyceum_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lyceum-cli
-Version: 1.2.1
+Version: 1.2.3
 Summary: Command-line interface for Lyceum Cloud
 Author-email: Lyceum <support@lyceum.technology>
 License: MIT

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/pyproject.toml

@@ -40,6 +40,11 @@ Dashboard = "https://dashboard.lyceum.technology"
 [project.scripts]
 lyceum = "lyceum.main:app"
 
+[dependency-groups]
+test = [
+    "pytest==9.0.2",
+]
+
 [tool.setuptools.dynamic]
 version = { attr = "lyceum._version.__version__" }
 

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/tests/test_block_storage.py

@@ -1,6 +1,7 @@
 """The CLI surface for block storage: `storage block` and `vm start`'s options."""
 
 import pytest
+import typer
 from typer.testing import CliRunner
 
 from lyceum.external.storage import block
@@ -271,7 +272,7 @@ def test_a_copy_can_be_switched_off(gateway):
 
 def test_a_new_volume_is_asked_for_by_size(gateway):
     gateway.bodies["/api/v2/external/vms/create"] = _vm_body(
-        volume={"volume_id": "hyd-devel-vol-new", "size_gb": 100, "status": "pending"}
+        volume={"name": "hyd-devel-vol-new", "size_gb": 100, "status": "pending"}
     )
 
     result = runner.invoke(app, [*_VM_ARGS, "--create-block-storage", "100"])
@@ -312,3 +313,87 @@ def test_a_volume_being_copied_is_reported_instead_of_polled(gateway):
     assert result.exit_code == 0
     assert "being copied" in result.output
     assert "lyceum storage block list" in result.output
+
+
+# --- lyceum vm stop ---------------------------------------------------------
+
+
+def _stop_bodies(gateway, volumes: list[dict], detached: list[dict] | None = None):
+    """What the gateway answers a stop with: the VM's storage, then the delete."""
+    gateway.bodies["/api/v2/external/vms/vm-1/status"] = {"vm_id": "vm-1", "status": "ready", "volumes": volumes}
+    gateway.bodies["/api/v2/external/vms/vm-1"] = {
+        "vm_id": "vm-1",
+        "status": "terminated",
+        "message": "VM vm-1 has been terminated",
+        "detached_volumes": volumes if detached is None else detached,
+    }
+
+
+def test_stopping_a_vm_names_its_storage_before_asking(gateway):
+    """The prompt is the last point at which knowing costs the customer nothing."""
+    _stop_bodies(gateway, [_VOLUME])
+
+    result = runner.invoke(app, ["vm", "stop", "vm-1"], input="y\n")
+
+    assert result.exit_code == 0
+    assert "vol-abc" in result.output
+    assert "does not delete" in result.output
+    # Being billed on is the part no other command would have told them.
+    assert "billed" in result.output
+
+
+def test_a_vm_without_storage_is_not_warned_about_any(gateway):
+    _stop_bodies(gateway, [])
+
+    result = runner.invoke(app, ["vm", "stop", "vm-1"], input="y\n")
+
+    assert result.exit_code == 0
+    assert "block storage" not in result.output.lower()
+
+
+def test_declining_the_prompt_stops_nothing(gateway):
+    _stop_bodies(gateway, [_VOLUME])
+
+    result = runner.invoke(app, ["vm", "stop", "vm-1"], input="n\n")
+
+    assert result.exit_code == 0
+    assert "cancelled" in result.output.lower()
+    assert not any(method == "DELETE" for method, _path, _kwargs in gateway.calls)
+
+
+def test_the_storage_left_behind_comes_with_the_command_that_deletes_it(gateway):
+    _stop_bodies(gateway, [_VOLUME])
+
+    result = runner.invoke(app, ["vm", "stop", "vm-1"], input="y\n")
+
+    assert result.exit_code == 0
+    assert "lyceum storage block delete vol-abc" in result.output
+
+
+def test_force_hears_about_the_storage_even_though_it_skips_the_prompt(gateway):
+    """--force waives the question, not the answer: the volumes are still billed."""
+    _stop_bodies(gateway, [_VOLUME])
+
+    result = runner.invoke(app, ["vm", "stop", "vm-1", "--force"])
+
+    assert result.exit_code == 0
+    # Nothing was asked, so the status lookup behind the prompt was not made.
+    assert [path for _method, path, _kwargs in gateway.calls] == ["/api/v2/external/vms/vm-1"]
+    assert "lyceum storage block delete vol-abc" in result.output
+
+
+def test_a_status_lookup_that_fails_does_not_block_the_stop(gateway, monkeypatch):
+    """Not knowing about the storage is no reason to refuse to stop the VM."""
+    _stop_bodies(gateway, [_VOLUME])
+
+    def refuse_the_status(method, path, **kwargs):
+        if path.endswith("/status"):
+            raise typer.Exit(1)
+        return gateway(method, path, **kwargs)
+
+    monkeypatch.setattr(management, "api_request", refuse_the_status)
+
+    result = runner.invoke(app, ["vm", "stop", "vm-1"], input="y\n")
+
+    assert result.exit_code == 0
+    assert "terminated" in result.output

{lyceum_cli-1.2.1 → lyceum_cli-1.2.3}/tests/test_dedicated_deploy.py

@@ -29,11 +29,14 @@ def gateway(monkeypatch):
     creates = []
 
     def api_request(method, path, **kw):
-        if path == "/api/v2/external/inference/models":
+        if path == "/external/inference/models":
             return {"models": [GLM52, FLASH]}
-        if path == "/api/v2/external/inference/create":
+        if path == "/external/inference/create":
             creates.append(kw["json"])
             return {"deployment_id": "d1", "status": "pending"}
+        if path == "/external/inference/offload":
+            creates.append(kw["json"])
+            return kw["json"]
         raise AssertionError(path)
 
     monkeypatch.setattr(infer, "api_request", api_request)
@@ -103,3 +106,24 @@ def test_wait_uses_the_model_ready_timeout(gateway, monkeypatch):
     monkeypatch.setattr(infer, "_wait_for_healthy", lambda d, timeout: waited.append((d, timeout)))
     assert _run("deploy", "deepseek/deepseek-v4-flash-0731", "--wait").exit_code == 0
     assert waited == [("d1", 4800)]
+
+
+def test_deploy_offload_is_sent_only_when_given(gateway):
+    assert _run("deploy", "deepseek/deepseek-v4-flash-0731").exit_code == 0
+    assert "offload" not in gateway[0]
+    assert _run("deploy", "deepseek/deepseek-v4-flash-0731", "--offload").exit_code == 0
+    assert gateway[1]["offload"] is True
+    assert _run("deploy", "deepseek/deepseek-v4-flash-0731", "--no-offload").exit_code == 0
+    assert gateway[2]["offload"] is False
+
+
+def test_offload_command_posts_the_switch(gateway):
+    result = _run("offload", "d1", "--enable")
+    assert result.exit_code == 0
+    assert "enabled" in result.output
+    assert _run("offload", "d1", "--disable").exit_code == 0
+    assert gateway == [
+        {"deployment_id": "d1", "offload": True},
+        {"deployment_id": "d1", "offload": False},
+    ]
+    assert _run("offload", "d1").exit_code == 2