envloop-cli 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

envloop/agent_runs.py

@@ -2,7 +2,7 @@
 
 The platform stores no run object. Agents tag every Train Job they create with
 ``user_metadata`` (the RSI loop: ``rsi_run``, ``rsi_round``, ``rsi_checkpoint``...);
-this module pages through ``GET /v1/train/jobs`` and derives runs from those tags,
+this module pages through ``GET /v1/job`` and derives runs from those tags,
 using the same rules as the Console's agent runs page.
 """
 
@@ -19,8 +19,8 @@ KEYS = {
     "checkpoint": ("agent_checkpoint", "rsi_checkpoint"),
 }
 RUN_KEYS = KEYS["run"]  # first non-empty string wins
-ACTIVE_STATUSES = frozenset({"LAUNCHING", "STARTING", "RUNNING", "RECOVERING"})
-TERMINAL_STATUSES = frozenset({"SUCCEEDED", "FAILED", "CANCELLED"})
+ACTIVE_STATUSES = frozenset({"LAUNCHING", "STARTING", "RUNNING", "RECOVERING", "queued", "pending", "starting", "running", "recovering", "cancelling"})
+TERMINAL_STATUSES = frozenset({"SUCCEEDED", "FAILED", "CANCELLED", "completed", "failed", "cancelled"})
 PAGE_LIMIT = 100  # the platform's maximum page size
 
 
@@ -70,7 +70,7 @@ def _round(job) -> int | None:
 
 def _order(job):
     # Creation order, as the platform pages jobs (newest first, reversed here).
-    return (str(job.get("created_at") or ""), str(job.get("train_job_id") or ""))
+    return (str(job.get("created_at") or ""), str(job.get("job_id") or job.get("train_job_id") or ""))
 
 
 def _duration_sec(job) -> int | None:
@@ -97,7 +97,7 @@ def _checkpoint(job) -> dict | None:
 def _job_view(job) -> dict:
     metadata = _metadata(job)
     return {
-        "train_job_id": job.get("train_job_id"),
+        "train_job_id": job.get("job_id") or job.get("train_job_id"),
         "status": job.get("status"),
         "round": _round(job),
         "purpose": _field(job, "purpose"),
@@ -121,11 +121,11 @@ def _summary(run: str, jobs: list) -> dict:
         status = "running"
     else:
         status = str(latest.get("status") or "unknown").lower()
-    succeeded = [job for job in jobs if job.get("status") == "SUCCEEDED"]
+    succeeded = [job for job in jobs if job.get("status") in {"SUCCEEDED", "completed"}]
     latest_saved = next((job for job in reversed(jobs) if _checkpoint(job) is not None), None)
     latest_checkpoint = _checkpoint(latest_saved) if latest_saved is not None else None
     if latest_checkpoint is not None:
-        latest_checkpoint["train_job_id"] = latest_saved.get("train_job_id")
+        latest_checkpoint["train_job_id"] = latest_saved.get("job_id") or latest_saved.get("train_job_id")
     rounds = [number for number in map(_round, jobs) if number is not None]
     activity = [stamp for job in jobs if isinstance(stamp := job.get("updated_at") or job.get("created_at"), str)]
     return {
@@ -172,7 +172,7 @@ class AgentRuns:
             if observed_at is None:
                 observed_at = page.get("observed_at")
             for job in page.get("items") or []:
-                job_id = job.get("train_job_id") if isinstance(job, dict) else None
+                job_id = job.get("job_id") or job.get("train_job_id") if isinstance(job, dict) else None
                 if not isinstance(job, dict) or job_id in ids:
                     continue
                 if job_id is not None:

envloop/auth_cli.py

@@ -277,9 +277,12 @@ def run_auth(args, parser):
                             config=False, environment=False).list_jobs(limit=1)
                 report["check"] = "access_confirmed" if connection.api_key else "reachable_anonymous"
             except (ConfigError, RemoteError) as error:
+                from .cli_errors import format_error, safe_error_code
+
                 report["check"] = {401: "authentication_rejected", 403: "authorization_denied"}.get(
-                    getattr(error, "status_code", None), error.code)
+                    getattr(error, "status_code", None), safe_error_code(error))
                 _print(report, args.json)
+                print(format_error(error, args=args, program=parser.prog), file=sys.stderr)
                 return 1
     _print(report, getattr(args, "json", False))
     return 0

envloop/cli.py

@@ -19,8 +19,8 @@ except PackageNotFoundError:
 
 SECTIONS = {
     'OVERVIEW': ('dashboard',),
-    'EXPERIMENT': ('job', 'train', 'inference', 'trail'),
-    'DATA': ('dataset', 'checkpoint', 'profile'),
+    'EXPERIMENT': ('job', 'trail'),
+    'DATA': ('dataset', 'runner', 'checkpoint', 'profile'),
     'MANAGE': ('billing', 'limit', 'member', 'setting'),
     'TOOLS': ('auth', 'help'),
 }
@@ -111,20 +111,32 @@ def nonnegative_seconds(value):
     return seconds
 
 
-def runner_arguments(submit):
-    def reference(value):
-        from .client import runner_selector
+def wait_seconds(value):
+    try:
+        seconds = float(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError("seconds must be finite and non-negative") from None
+    if not math.isfinite(seconds) or seconds < 0:
+        raise argparse.ArgumentTypeError("seconds must be finite and non-negative")
+    return seconds
+
+
+def log_page_size(value):
+    try:
+        count = int(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError("expected an integer from 1 to 1000") from None
+    if not 1 <= count <= 1000:
+        raise argparse.ArgumentTypeError("expected an integer from 1 to 1000")
+    return count
 
-        try:
-            return runner_selector(value)
-        except ValueError as exc:
-            raise argparse.ArgumentTypeError(str(exc)) from None
 
-    submit.add_argument("--runner", type=reference, metavar="NAME@REVISION",
-                        help="override the Dataset's pinned runner with an explicit commit, tag or branch")
+def runner_arguments(submit):
+    submit.add_argument("--runner", metavar="NAME[@REVISION]",
+                        help="Agent: override the Dataset runner with NAME@REVISION; Sandbox: registered Runner name (for example base)")
     submit.add_argument("--job-id", help="caller-selected Job ID")
     submit.add_argument("--tag", help="run label")
-    submit.add_argument("--priority", type=int, default=0, help="waiting priority; larger values run first (default: 0)")
+    submit.add_argument("--priority", type=int, help="waiting priority; larger values run first (default: 0)")
     submit.add_argument("--command", help="shell script override executed in the runner directory; preserves multiline text")
 
 
@@ -132,7 +144,7 @@ def parser():
     cli = HelpArgumentParser(
         prog=Path(sys.argv[0]).name if Path(sys.argv[0]).name in {"envloop", "el"} else "el",
         usage="%(prog)s [options] [command]", formatter_class=CommandHelpFormatter,
-        description="Manage jobs, training, agent runs, and trials with EnvLoop.\nConfigure your connection with 'auth config'.",
+        description="Manage Agent, Sandbox, Train and Inference Jobs and worker trials with EnvLoop.\nConfigure your connection with 'auth config'.",
     )
     cli._optionals.title = "Options"
     cli.set_defaults(api_url=None, workspace_id=None)
@@ -140,8 +152,11 @@ def parser():
     groups = cli.add_subparsers(dest="group", title="Commands", prog=cli.prog, required=True)
     from .auth_cli import add_auth_commands
 
-    jobs = groups.add_parser("job", help="Submit and manage Agent jobs").add_subparsers(dest="action", required=True)
-    job_submit = jobs.add_parser("submit")
+    jobs = groups.add_parser("job", help="Submit and manage Agent, Sandbox, Train and Inference Jobs").add_subparsers(dest="action", required=True)
+    job_submit = jobs.add_parser("submit", help="Submit an Agent, Sandbox, Train or Inference Job")
+    job_submit.add_argument("--type", choices=("agent", "sandbox", "train", "inference"), default="agent", help="Job type (default: agent)")
+    job_submit.add_argument("--image", metavar="IMAGE", help="Sandbox Docker image override (server default: python:3.11)")
+    job_submit.add_argument("--file", type=Path, help="Train or Inference Job request JSON (spec or Train trials array)")
     job_submit.add_argument("--source", type=Path, help="two-file directory for a single-task Job")
     job_submit.add_argument("--task-id", help="select one task within the dataset")
     job_submit.add_argument(
@@ -154,42 +169,49 @@ def parser():
     job_submit.add_argument("--split", help="one complete split name; omitted selects all splits")
     job_submit.add_argument("--revision", help="Git branch/tag/commit; must match the platform's pinned snapshot")
     runner_arguments(job_submit)
-    job_submit.add_argument("--attempts", type=int, default=1)
+    job_submit.add_argument("--attempts", type=int)
     job_submit.add_argument("--request-id")
     job_submit.add_argument("--profile", type=profile_reference, metavar="NAME[@VERSION]",
                             help="named runtime Profile; omitted version requires an explicit default")
     job_submit.add_argument("--seed", type=int)
-    job_submit.add_argument("--timeout-sec", type=int)
+    job_submit.add_argument("--timeout-sec", type=wait_seconds,
+                            help="Agent/Sandbox execution timeout (whole seconds); Train wait timeout (default: 600)")
     job_submit.add_argument("--delete-delay", type=nonnegative_seconds, metavar="SECONDS",
                             help="keep each sandbox (E2B or Fly) after completion for SECONDS (default: 0); cancellation/timeout delete immediately")
     job_submit.add_argument("--wait", action="store_true")
-    for action in ("get", "stop", "result"):
-        jobs.add_parser(action).add_argument("job_id")
+    for action in ("get", "stop", "result", "pause", "resume", "wake", "event"):
+        command = jobs.add_parser(action)
+        command.add_argument("job_id")
+        if action == 'event':
+            command.add_argument('--json', action='store_true')
+            command.set_defaults(_list_view=True)
+    from .resource_cli import add_job_resources
+    add_job_resources(jobs)
     listing = jobs.add_parser("list")
-    listing.add_argument('--type', choices=['agent', 'train'], help='Select Agent or training Jobs')
+    listing.add_argument('--type', choices=['agent', 'sandbox', 'train', 'inference'], help='Select Agent, Sandbox, Train or Inference Jobs')
+    listing.add_argument('--status', help='Filter by Job status')
     listing.add_argument("--cursor")
     listing.add_argument("--json", action="store_true", help="Output the complete response as JSON (default: table)")
     listing.add_argument("--limit", type=int, default=25)
-    trains = groups.add_parser("train", help="Submit and inspect independent Train Jobs").add_subparsers(dest="action", required=True)
-    train_submit = trains.add_parser("submit")
-    train_submit.add_argument("--file", type=Path, required=True, help="Train Job request JSON")
-    train_submit.add_argument("--wait", action="store_true")
-    train_submit.add_argument("--timeout-sec", type=float, default=600)
-    for action in ("get", "result", "stop"):
-        trains.add_parser(action).add_argument("train_job_id")
-    train_list = trains.add_parser("list", help="List visible Train Jobs")
-    train_list.add_argument("--status")
-    train_list.add_argument("--cursor")
-    train_list.add_argument("--limit", type=int, default=25)
-    train_list.add_argument("--json", action="store_true", help="Output the complete response as JSON (default: table)")
-    runs = trains.add_parser("run", help="Inspect runs grouped from their Train Jobs").add_subparsers(dest="run_action", required=True)
+    train_log = jobs.add_parser("log", help="Read or follow Agent, Sandbox or Train Job logs")
+    train_log.add_argument("job_id")
+    train_log.add_argument("--source", choices=("all", "system", "runtime"), default="all")
+    position = train_log.add_mutually_exclusive_group()
+    position.add_argument("--tail", type=log_page_size, help="Start with the last N records (default: 200)")
+    position.add_argument("--cursor", help="Resume from a previously returned log cursor")
+    train_log.add_argument("--limit", type=log_page_size, default=200, help="Maximum records per page (default: 200)")
+    train_log.add_argument("--follow", action="store_true", help="Drain pages and poll until collection ends; Ctrl-C exits without stopping the Job")
+    train_log.add_argument("--json", action="store_true", help="Output the complete page as JSON; --follow emits one page per line (NDJSON)")
+    runs = jobs.add_parser("run", help="Inspect runs grouped from their Train Jobs").add_subparsers(dest="run_action", required=True)
     runs_list = runs.add_parser("list", help="List agent runs, most recently updated first")
     runs_list.add_argument("--json", action="store_true", help="Output the complete response as JSON (default: table)")
     runs_get = runs.add_parser("get", help="Show a run's rounds, Train Jobs and checkpoints")
     runs_get.add_argument("run", metavar="RUN", help="run label: user_metadata.rsi_run or agent_run")
     runs_get.add_argument("--json", action="store_true", help="Output the complete run as JSON (default: tables)")
     tasks = groups.add_parser("trail", help="Inspect and control existing trials").add_subparsers(dest="action", required=True)
-    listing = tasks.add_parser("list")
+    listing = tasks.add_parser("list", help="List Agent, Sandbox, Train and Inference worker Trials")
+    listing.add_argument("--type", choices=("agent", "sandbox", "train", "inference"), help="Filter by Trial type")
+    listing.add_argument("--job-id", help="Filter by parent Job ID")
     listing.add_argument("--cursor")
     listing.add_argument("--limit", type=int, default=25)
     snapshot = tasks.add_parser("snapshot")
@@ -212,6 +234,17 @@ def parser():
     put.add_argument("name")
     put.add_argument("version")
     put.add_argument("--file", type=Path, required=True, help="ProfileSpec JSON file")
+    secret_input = put.add_mutually_exclusive_group()
+    secret_input.add_argument("--prompt-model-api-key", action="store_true", help="Read the model API key from a non-echoing prompt")
+    secret_input.add_argument("--model-api-key-stdin", action="store_true", help="Read the model API key from one line of standard input")
+    update = profiles.add_parser("update", help="Edit an existing Profile by publishing a new immutable version")
+    update.add_argument("name")
+    update.add_argument("version", help="New version; existing versions cannot be overwritten")
+    update.add_argument("--from-version", help="Source version; omit to use the explicit default")
+    update.add_argument("--file", type=Path, required=True, help="JSON patch: merge literal params keys, replace supplied metadata; preserve omitted fields")
+    update_secret = update.add_mutually_exclusive_group()
+    update_secret.add_argument("--prompt-model-api-key", action="store_true", help="Read an encrypted model connection key from a non-echoing prompt")
+    update_secret.add_argument("--model-api-key-stdin", action="store_true", help="Read an encrypted model connection key from one line of standard input")
     get = profiles.add_parser("get")
     get.add_argument("name")
     get.add_argument("--version")
@@ -245,11 +278,11 @@ def parser():
 
 def submission_options(args):
     options = {}
-    for key in ("runner", "job_id", "tag", "command"):
+    for key in ("runner", "job_id", "tag", "command", "image"):
         value = getattr(args, key, None)
         if value is not None:
             options[key] = value
-    options["priority"] = args.priority
+    options["priority"] = args.priority if args.priority is not None else 0
     if args.profile:
         if args.runner is not None:
             options["profile_id"] = args.profile
@@ -322,58 +355,96 @@ def main(argv=None):
 
             return run_auth(args, cli)
         except (EOFError, KeyboardInterrupt):
-            print("AUTH_INPUT_CANCELLED", file=sys.stderr)
+            from .cli_errors import format_error
+            from .config import ConfigError
+
+            print(format_error(ConfigError('AUTH_INPUT_CANCELLED'), args=args, program=cli.prog), file=sys.stderr)
             return 1
         except Exception as exc:
-            print(getattr(exc, "code", None) or type(exc).__name__, file=sys.stderr)
+            from .cli_errors import format_error
+
+            print(format_error(exc, args=args, program=cli.prog), file=sys.stderr)
             return 1
     if args.group == "job" and args.action == "submit":
-        if sum(value is not None for value in (args.dataset, args.dataset_option, args.source)) != 1:
-            cli.error("provide exactly one positional dataset, --dataset or --source")
-        args.dataset = args.dataset if args.dataset is not None else args.dataset_option
-        if args.source is not None and any(getattr(args, key) is not None for key in ("runner", "task_id", "config", "split", "revision")):
-            cli.error("dataset selection options require a dataset")
+        if args.type in {"train", "inference"}:
+            if args.file is None:
+                cli.error(f"--type {args.type} requires --file REQUEST.json")
+            if args.type == 'inference' and (args.wait or args.timeout_sec is not None):
+                cli.error('Inference is a continuous service; --wait and --timeout-sec do not apply')
+            agent_fields = ("dataset", "dataset_option", "source", "task_id", "config", "split", "revision",
+                            "runner", "job_id", "tag", "priority", "command", "attempts", "request_id",
+                            "profile", "seed", "delete_delay", "image")
+            if any(getattr(args, key) is not None for key in agent_fields):
+                cli.error(f"--type {args.type} accepts its request through --file; Agent submission options cannot be combined")
+        elif args.type == 'sandbox':
+            from .sandbox import sandbox_runner_selector, validate_image
+
+            if any(getattr(args, key) is not None for key in (
+                    'file', 'dataset', 'dataset_option', 'source', 'task_id', 'config', 'split', 'revision', 'seed')):
+                cli.error('--type sandbox accepts --runner without Dataset, Task, Train file or seed options')
+            try:
+                args.runner = sandbox_runner_selector(args.runner)
+                if args.image is not None:
+                    args.image = validate_image(args.image)
+            except ValueError as exc:
+                cli.error(str(exc))
+            if args.timeout_sec is not None:
+                if not args.timeout_sec.is_integer():
+                    cli.error('Sandbox --timeout-sec must be whole seconds')
+                args.timeout_sec = int(args.timeout_sec)
+        else:
+            if args.file is not None:
+                cli.error("--file requires --type train or inference")
+            if args.image is not None:
+                cli.error('--image requires --type sandbox')
+            if args.runner is not None:
+                from .client import runner_selector
+
+                try:
+                    args.runner = runner_selector(args.runner)
+                except ValueError as exc:
+                    cli.error(str(exc))
+            if sum(value is not None for value in (args.dataset, args.dataset_option, args.source)) != 1:
+                cli.error("provide exactly one positional dataset, --dataset or --source")
+            args.dataset = args.dataset if args.dataset is not None else args.dataset_option
+            if args.source is not None and any(getattr(args, key) is not None for key in ("runner", "task_id", "config", "split", "revision")):
+                cli.error("dataset selection options require a dataset")
+            if args.timeout_sec is not None:
+                if not args.timeout_sec.is_integer():
+                    cli.error("Agent --timeout-sec must be whole seconds")
+                args.timeout_sec = int(args.timeout_sec)
     args._command_path = args._help_parser.prog.split()[1:]
     if args.group == 'setting' and args.action == 'update' and not any(getattr(args, key) is not None for key in ('name', 'slug', 'region')):
         cli.error('provide at least one of --name, --slug or --region')
     try:
         resolved = resolve_cli_connection(args.api_url, args.workspace_id)
         args.api_url = resolved.api_url
-        if args.group == "train" and args.action != "run":
-            if args.action == "submit" and args.wait and (not math.isfinite(args.timeout_sec) or args.timeout_sec < 0):
-                print("INVALID_TRAIN_WAIT_TIMEOUT", file=sys.stderr)
-                return 1
-            if not args.api_url:
-                print("TRAIN_API_URL_REQUIRED", file=sys.stderr)
-                return 1
-            from .http import HttpService
-            from .train import TrainJobs
-
-            train = TrainJobs(HttpService(args.api_url, api_key=resolved.api_key, workspace_id=resolved.workspace_id,
-                                          project_id=resolved.project_id, config=False, environment=False))
-            if args.action == "submit":
-                result = train.submit(json.loads(args.file.read_text(encoding="utf-8")))
-                if args.wait:
-                    result = train.wait(result["train_job_id"], timeout=args.timeout_sec)
-            elif args.action == "list":
-                result = train.list(status=args.status, cursor=args.cursor, limit=args.limit)
-            else:
-                result = getattr(train, 'status' if args.action == 'get' else args.action)(args.train_job_id)
-            if args.action == "list" and not args.json:
-                from .cli_output import list_output
-
-                print(list_output(result, args, cli.prog))
-            else:
-                print(json.dumps(result, ensure_ascii=False))
-            return 1 if result.get("status") in {"FAILED", "CANCELLED"} else 0
         connection = Client.remote(args.api_url, api_key=resolved.api_key, workspace_id=resolved.workspace_id,
                                    project_id=resolved.project_id, config=False)
         with connection as client:
             if args.group == "profile":
-                if args.action == "create":
-                    result = client.profiles.import_spec(
-                        args.file.read_bytes(), name=args.name, version=args.version
-                    )
+                if args.action in {"create", "update"}:
+                    secrets = None
+                    if args.prompt_model_api_key:
+                        import getpass
+                        import warnings
+
+                        # Fail closed if the terminal cannot disable echo.
+                        with warnings.catch_warnings():
+                            warnings.simplefilter("error", getpass.GetPassWarning)
+                            key = getpass.getpass("Model API key: ")
+                        secrets = {"model_api_key": key}
+                    elif args.model_api_key_stdin:
+                        secrets = {"model_api_key": sys.stdin.readline(4098).rstrip("\r\n")}
+                    if args.action == "update":
+                        from .profile_updates import read_profile_patch
+
+                        result = client.profiles.update(args.name, args.version,
+                            patch=read_profile_patch(args.file.read_bytes()), from_version=args.from_version, secrets=secrets)
+                    else:
+                        result = client.profiles.import_spec(
+                            args.file.read_bytes(), name=args.name, version=args.version, secrets=secrets
+                        )
                 elif args.action == "get":
                     result = client.profiles.get(args.name, args.version)
                 elif args.action == "list":
@@ -396,20 +467,37 @@ def main(argv=None):
                     return 0
             elif args.group == "job":
                 if args.action == "submit":
-                    result = client.jobs.submit(args.dataset, source=args.source, task_id=args.task_id, attempts=args.attempts, request_id=args.request_id,
-                                                config=args.config, split=args.split,
-                                                revision=args.revision, **submission_options(args))
+                    if args.type == 'inference':
+                        result = client.jobs.submit_inference(json.loads(args.file.read_text(encoding='utf-8')))
+                    elif args.type == "train":
+                        result = client.training_jobs.submit(json.loads(args.file.read_text(encoding="utf-8")))
+                    else:
+                        result = client.jobs.submit(args.dataset, type=args.type, source=args.source, task_id=args.task_id,
+                                                    attempts=args.attempts if args.attempts is not None else 1,
+                                                    request_id=args.request_id, config=args.config, split=args.split,
+                                                    revision=args.revision, **submission_options(args))
                     if args.wait:
-                        result = client.jobs.wait(result["job_id"])
+                        wait_options = {"timeout": args.timeout_sec} if args.type == "train" and args.timeout_sec is not None else {}
+                        result = client.jobs.wait(result["job_id"], **wait_options)
+                elif args.action == 'event':
+                    result = client.jobs.events(args.job_id)
+                elif args.action in {'serving-profile', 'adapter'}:
+                    from .resource_cli import run_job_resource
+                    result = run_job_resource(client, args)
+                elif args.action == "log":
+                    from .train_log_cli import read_logs
+
+                    return read_logs(client.jobs, args)
+                elif args.action == "run":
+                    result = client.agent_runs.list() if args.run_action == "list" else client.agent_runs.get(args.run)
                 elif args.action == "list":
                     options = {'cursor': args.cursor, 'limit': args.limit}
-                    if args.type is not None:
-                        options['type'] = args.type
+                    for field in ('type', 'status'):
+                        if getattr(args, field) is not None:
+                            options[field] = getattr(args, field)
                     result = client.jobs.list(**options)
                 else:
                     result = getattr(client.jobs, 'status' if args.action == 'get' else args.action)(args.job_id)
-            elif args.group == "train":
-                result = client.agent_runs.list() if args.run_action == "list" else client.agent_runs.get(args.run)
             elif args.group == "trail":
                 if args.action == "artifact":
                     if args.artifact_action == "download":
@@ -417,19 +505,30 @@ def main(argv=None):
                     else:
                         result = client.trials.artifacts(args.trial_id, cursor=args.cursor, limit=args.limit)
                 elif args.action == "list":
-                    result = client.trials.list(cursor=args.cursor, limit=args.limit)
+                    options = {'cursor': args.cursor, 'limit': args.limit}
+                    for field in ('type', 'job_id'):
+                        if getattr(args, field) is not None:
+                            options[field] = getattr(args, field)
+                    result = client.trials.list(**options)
                 else:
                     result = getattr(client.trials, 'status' if args.action == 'get' else args.action)(args.trial_id)
             else:
                 from .resource_cli import execute
 
                 result = execute(args, client)
-            if args.group == 'train' and args.action == 'run' and args.run_action == 'get' and not args.json:
+            if isinstance(result, dict) and 'operation_id' in result:
+                from .cli_errors import operation_output
+                from .resources import CleanupError
+
+                if result.get('status') in {'FAILED', 'CANCELLED', 'RETRYABLE_FAILED', 'BLOCKED'}:
+                    raise CleanupError(result)
+                result = operation_output(result)
+            if args.group == 'job' and args.action == 'run' and args.run_action == 'get' and not args.json:
                 from .cli_output import run_output
 
                 print(run_output(result))
             elif (args.action == 'list' or getattr(args, '_list_view', False)
-                  or (args.group == 'train' and args.action == 'run' and args.run_action == 'list')) and not args.json:
+                  or (args.group == 'job' and args.action == 'run' and args.run_action == 'list')) and not args.json:
                 from .cli_output import list_output
 
                 print(list_output(result, args, cli.prog))
@@ -437,14 +536,15 @@ def main(argv=None):
                 print(json.dumps(result, ensure_ascii=False))
             return 1 if isinstance(result, dict) and (result.get('status') in {'failed', 'FAILED', 'CANCELLED', 'RETRYABLE_FAILED', 'BLOCKED'} or result.get('skipped')) else 0
     except Exception as exc:
+        from .cli_errors import format_error, operation_output
         from .resources import CleanupError
 
         if isinstance(exc, CleanupError):
-            print(json.dumps(exc.operation, ensure_ascii=False))
-            print('CLEANUP_INCOMPLETE', file=sys.stderr)
+            print(json.dumps(operation_output(exc.operation), ensure_ascii=False))
+            print(format_error(exc, args=args, program=cli.prog), file=sys.stderr)
             return 1
         # Do not emit arbitrary exception messages, file content or credentials.
-        print(getattr(exc, "code", None) or type(exc).__name__, file=sys.stderr)
+        print(format_error(exc, args=args, program=cli.prog), file=sys.stderr)
         return 1