envloop-cli 0.4.0__py3-none-any.whl → 1.7.0__py3-none-any.whl

envloop/agent_runs.py

@@ -7,6 +7,7 @@ using the same rules as the Console's agent runs page.
 """
 
 from datetime import datetime
+from urllib.parse import quote, urlencode
 
 from .train import TrainJobs
 
@@ -206,3 +207,38 @@ class AgentRuns:
         if run not in runs:
             raise AgentRunError("AGENT_RUN_NOT_FOUND")
         return {**_detail(run, runs[run]), "observed_at": observed_at}
+
+    # The RSI loop service behind the platform (``/v1/agent-runs/rsi``). Starting spends money, so
+    # ``start`` needs a key with ``training.run``; ``control(stop)`` also needs ``training.stop``.
+    def _rsi(self, method: str, path: str, body=None) -> dict:
+        return self._train_jobs.transport.request(method, "/v1/agent-runs/rsi" + path, body)
+
+    def start(self, run: str, brief: str, *, model_usd_cap: float, usd_cap: float | None = None,
+              model_request_cap: int | None = None, domain: str | None = None, rounds: int | None = None,
+              dry_run: bool = False, student_model: str | None = None) -> dict:
+        """Start a new RSI run; the platform validates every field. ``dry_run`` uses no GPU."""
+        limits = {"model_usd_cap": model_usd_cap}
+        for key, value in (("usd_cap", usd_cap), ("model_request_cap", model_request_cap)):
+            if value is not None:
+                limits[key] = value
+        body = {"run": run, "brief": brief, "limits": limits}
+        for key, value in (("domain", domain), ("rounds", rounds), ("student_model", student_model)):
+            if value is not None:
+                body[key] = value
+        if dry_run:
+            body["dry_run"] = True
+        return self._rsi("POST", "/runs", body)
+
+    def live(self, run: str, since: int | None = None) -> dict:
+        """What a run does now; pass the previous ``next_cursor`` as ``since`` for newer events."""
+        query = "?" + urlencode({"since": since}) if since is not None else ""
+        return self._rsi("GET", f"/runs/{quote(run, safe='')}/live{query}")
+
+    def steer(self, run: str, text: str) -> dict:
+        """Queue a message for the running operator (1 to 4000 characters)."""
+        return self._rsi("POST", f"/runs/{quote(run, safe='')}/steer", {"text": text})
+
+    def control(self, run: str, action: str, rounds: int | None = None) -> dict:
+        """``extend`` (needs ``rounds``), ``stop`` (after the current round) or ``resume``."""
+        return self._rsi("POST", f"/runs/{quote(run, safe='')}/control",
+                         {"action": action, **({} if rounds is None else {"rounds": rounds})})

envloop/cli.py

@@ -133,11 +133,11 @@ def log_page_size(value):
 
 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)")
+                        help="Agent/Train: namespace/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, 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")
+    submit.add_argument("--command", help="Agent/Sandbox: shell override; Train: declared run_command parameter passed to the published Runner entrypoint; preserves multiline text")
 
 
 def parser():
@@ -153,10 +153,20 @@ def parser():
     from .auth_cli import add_auth_commands
 
     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 = jobs.add_parser("submit", help="Submit an Agent, Sandbox, Train or Inference Job", allow_abbrev=False)
     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("--image", metavar="IMAGE", help="Sandbox image override (server default: python:3.11); Train Runner: public spelling of --docker")
+    from .train_runner_cli import memory_mebibytes, positive_integer
+
+    job_submit.add_argument("--docker", metavar="IMAGE", help="Train Runner Docker image override; omitted uses the Runner declaration")
+    job_submit.add_argument("--trails", type=positive_integer, metavar="COUNT", help="Train Runner: 1–16 independent Trials (default: 1)")
+    job_submit.add_argument("--gput-type", metavar="MODEL", help="Train Runner: GPU model for each Trial (for example H100)")
+    job_submit.add_argument("--gpu", type=positive_integer, metavar="COUNT", help="Train Runner: positive GPU count per Trial")
+    job_submit.add_argument("--cpu", type=positive_integer, metavar="COUNT", help="Train Runner: positive CPU count per Trial")
+    for option in ('memory', 'disk', 'shm-size'):
+        job_submit.add_argument('--' + option, type=memory_mebibytes, metavar="SIZE",
+                                help="Train Runner: per-Trial size in Mi/Gi/Ti (for example 64Gi)")
+    job_submit.add_argument("--file", type=Path, help="Managed Train or Inference Job JSON (spec or Train trials array; interactive training is unsupported)")
     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(
@@ -175,10 +185,11 @@ def parser():
                             help="named runtime Profile; omitted version requires an explicit default")
     job_submit.add_argument("--seed", type=int)
     job_submit.add_argument("--timeout-sec", type=wait_seconds,
-                            help="Agent/Sandbox execution timeout (whole seconds); Train wait timeout (default: 600)")
+                            help="Agent/Sandbox or Train Runner execution timeout (whole seconds); Train --file 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")
+    job_submit.add_argument("--json", action="store_true", help="Output the complete response as JSON (the default for submit; accepted for consistency with list commands)")
     for action in ("get", "stop", "result", "pause", "resume", "wake", "event"):
         command = jobs.add_parser(action)
         command.add_argument("job_id")
@@ -208,6 +219,27 @@ def parser():
     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)")
+    runs_start = runs.add_parser("start", help="Start a new RSI loop run (paid; needs training.run)")
+    runs_start.add_argument("run", metavar="RUN", help="new run id: lower-case letters, digits and dashes")
+    brief = runs_start.add_mutually_exclusive_group(required=True)
+    brief.add_argument("--brief", help="the goal of the run (up to 4000 characters)")
+    brief.add_argument("--brief-file", metavar="PATH", help="read the goal from a file, or - for standard input")
+    runs_start.add_argument("--model-usd-cap", type=float, required=True, help="strong-model spend cap in USD (the hard stop)")
+    runs_start.add_argument("--usd-cap", type=float, help="cap in USD for model plus GPU training together")
+    runs_start.add_argument("--model-request-cap", type=int, help="cap on model requests")
+    runs_start.add_argument("--domain", help="task family (default: the service's default; an unknown value is rejected)")
+    runs_start.add_argument("--rounds", type=int, help="target rounds (default: the service's default)")
+    runs_start.add_argument("--dry-run", action="store_true", help="GPU-free run: trains nothing; exercises the loop, spends model budget only")
+    runs_start.add_argument("--student-model", help="gateway student model of a dry run")
+    runs_live = runs.add_parser("live", help="Show what a run does now; --follow streams new events")
+    runs_live.add_argument("run", metavar="RUN")
+    runs_live.add_argument("--since", type=int, help="only events after this cursor (the previous next_cursor)")
+    runs_live.add_argument("--follow", action="store_true", help="poll and print new events until the run ends; Ctrl-C exits without stopping it")
+    runs_steer = runs.add_parser("steer", help="Message the running operator now (needs training.run)")
+    runs_steer.add_argument("run", metavar="RUN")
+    runs_steer.add_argument("text", metavar="TEXT", help="1 to 4000 characters")
+    runs_stop = runs.add_parser("stop", help="Stop a run after its current round (needs training.run and training.stop)")
+    runs_stop.add_argument("run", metavar="RUN")
     tasks = groups.add_parser("trail", help="Inspect and control existing trials").add_subparsers(dest="action", required=True)
     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")
@@ -230,11 +262,11 @@ def parser():
     download.add_argument("trial_id")
     download.add_argument("directory", type=Path)
     profiles = groups.add_parser("profile", help="Manage platform runtime profiles").add_subparsers(dest="action", required=True)
-    put = profiles.add_parser("create", help="Create an immutable Profile version from JSON")
+    put = profiles.add_parser("create", help="Create an immutable Profile version from TOML or JSON")
     put.add_argument("name")
     put.add_argument("version")
-    put.add_argument("--file", type=Path, required=True, help="ProfileSpec JSON file")
-    put.add_argument("--runner", metavar="RUNNER", help="Bind org/name@<full-commit> to this version")
+    put.add_argument("--file", type=Path, required=True, help="Profile TOML or JSON file")
+    put.add_argument("--runner", metavar="RUNNER", help="Bind a Runner revision to this version")
     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")
@@ -242,11 +274,16 @@ def parser():
     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.add_argument("--runner", metavar="RUNNER", help="Bind a Runner name@full-commit; omit to preserve the source binding")
+    update.add_argument("--file", type=Path, required=True, help="TOML or JSON patch: merge params keys, replace supplied metadata; preserve omitted fields")
+    update.add_argument("--runner", metavar="RUNNER", help="Bind a Runner revision; v1 requires a full commit; omit to preserve the source binding")
     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")
+    fork = profiles.add_parser('fork', help='Fork an existing Profile into a new immutable identity')
+    fork.add_argument('source_name')
+    fork.add_argument('source_version')
+    fork.add_argument('name')
+    fork.add_argument('version')
     get = profiles.add_parser("get")
     get.add_argument("name")
     get.add_argument("--version")
@@ -368,16 +405,27 @@ def main(argv=None):
             print(format_error(exc, args=args, program=cli.prog), file=sys.stderr)
             return 1
     if args.group == "job" and args.action == "submit":
+        from .train_runner_cli import SHORTCUT_FIELDS, runner_request
+
+        runner_mode = args.type == 'train' and args.file is None
+        if not runner_mode and any(getattr(args, key) is not None for key in SHORTCUT_FIELDS):
+            cli.error('Train Runner shortcuts require --type train --runner and cannot be combined with --file')
         if args.type in {"train", "inference"}:
-            if args.file is None:
+            if args.file is None and not runner_mode:
                 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")
+                            "job_id", "tag", "priority", "attempts", "profile", "seed", "delete_delay")
+            if not runner_mode:
+                agent_fields += ('runner', 'command', 'request_id', '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")
+                cli.error(f"--type {args.type} cannot be combined with Agent submission options or mixed --file/Runner input")
+            if runner_mode:
+                try:
+                    args.train_request = runner_request(args)
+                except ValueError as exc:
+                    cli.error(str(exc))
         elif args.type == 'sandbox':
             from .sandbox import sandbox_runner_selector, validate_image
 
@@ -406,7 +454,8 @@ def main(argv=None):
                     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:
+            selections = sum(value is not None for value in (args.dataset, args.dataset_option, args.source))
+            if selections != 1 and not (selections == 0 and args.profile):
                 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")):
@@ -430,7 +479,7 @@ def main(argv=None):
 
                     raw = args.file.read_bytes()
                     patch = read_profile_patch(raw)
-                    if args.runner is not None:
+                    if args.action == 'update' and args.runner is not None:
                         patch = with_runner(patch, args.runner)
                         raw = json.dumps(patch).encode('utf-8')
                     secrets = None
@@ -450,8 +499,10 @@ def main(argv=None):
                             patch=patch, from_version=args.from_version, secrets=secrets)
                     else:
                         result = client.profiles.import_spec(
-                            raw, name=args.name, version=args.version, secrets=secrets
+                            raw, name=args.name, version=args.version, secrets=secrets, runner=args.runner
                         )
+                elif args.action == 'fork':
+                    result = client.profiles.fork(args.source_name, args.source_version, name=args.name, version=args.version)
                 elif args.action == "get":
                     result = client.profiles.get(args.name, args.version)
                 elif args.action == "list":
@@ -477,14 +528,15 @@ def main(argv=None):
                     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")))
+                        request = args.train_request if args.file is None else json.loads(args.file.read_text(encoding="utf-8"))
+                        result = client.training_jobs.submit(request)
                     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:
-                        wait_options = {"timeout": args.timeout_sec} if args.type == "train" and args.timeout_sec is not None else {}
+                        wait_options = {"timeout": args.timeout_sec} if args.type == "train" and args.file is not None 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)
@@ -495,6 +547,12 @@ def main(argv=None):
                     from .train_log_cli import read_logs
 
                     return read_logs(client.jobs, args)
+                elif args.action == "run" and args.run_action in {"start", "live", "steer", "stop"}:
+                    from .rsi_cli import run_rsi
+
+                    result = run_rsi(client.agent_runs, args)
+                    if result is None:
+                        return 0
                 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":

envloop/cli_errors.py

@@ -82,9 +82,19 @@ _register("RUNNER_NOT_FOUND", "The Runner reference was not found or is not read
 _register("INVALID_SANDBOX_RUNNER", "The Runner revision cannot execute as a standalone Sandbox Job.", "Check '{program} runner list' and select a frozen Runner revision whose environment supports execution without a Dataset.")
 _register("INVALID_SANDBOX_IMAGE", "The Sandbox image reference is invalid.", "Use a Docker image reference name[:tag][@sha256:digest] and check '{command} --help'.")
 
+_register("RSI_RUN_NOT_FOUND", "No RSI run with this name is visible in the current project.", "Check the name with '{program} job run list' and the scope with '{program} auth config show'; a run you just started appears once the service has accepted it.")
+_register("INVALID_RSI_REQUEST INVALID_STEER INVALID_DIRECTIVE", "The RSI service rejected the request fields.", "Check '{command} --help' and https://docs.envloop.ai/agent-docs/en/guides/agent-runs.md for the run id format, the allowed domain and rounds, and the required spend cap.")
+_register("RSI_CONFLICT RSI_RUN_NOT_ACTIVE", "The run id exists, the run is not in a state that allows this action, or no loop machine is free.", "Pick a new run id for a start; read the run with '{program} job run live RUN' before steering or stopping it.")
+_register("RSI_CONTROL_UNCONFIGURED RSI_CONTROL_UNAVAILABLE RSI_CONTROL_TIMEOUT", "The RSI loop service is not available through this platform right now.", _RETRY_HINT)
+
 _register("JOB_ACTION_UNSUPPORTED", "This Job type does not support the requested action.", "Check the Job type with '{program} job get JOB_ID' and use its supported actions.")
 _register("INFERENCE_ROUTE_RETIRED", "The global inference route has been retired.", "Use the owning Job's base URL: API_BASE/v1/job/JOB_ID/Inference, and a model deployed by that Job.")
 
+_register("CHECKPOINT_UNAVAILABLE CHECKPOINT_NOT_DURABLE CHECKPOINT_FILES_MISSING", "The fixed inference input is unavailable or not durable.", "Inspect checkpoint publication, expiry, deletion and permissions. Do not retry with different weights under the same request ID.")
+_register("CHECKPOINT_INTEGRITY_FAILED CHECKPOINT_FORMAT_UNSUPPORTED CHECKPOINT_BASE_MISMATCH", "The fixed input failed integrity or compatibility validation.", "Use a verified durable checkpoint matching the serving profile. A different input requires a new Job and request ID.")
+_register("INFERENCE_AUTHORIZATION_DENIED INFERENCE_AUTHORIZATION_UNAVAILABLE", "The platform could not authorize a new inference worker.", "Check current project membership and Runner/input access before waking or resuming the Job.")
+_register("INFERENCE_PROFILE_UNSUPPORTED INFERENCE_RUNNER_INVALID INFERENCE_MODEL_UNPINNED INFERENCE_RUNNER_IMAGE_MISMATCH INFERENCE_RUNNER_IMAGE_UNAVAILABLE INFERENCE_RUNTIME_UNAVAILABLE", "The selected Runner or frozen inference configuration is unavailable or unsupported.", "Discover a published compatible Runner and serving profile. Submit a new Job for changes to weights, base model or Runner.")
+
 # Public service identifiers verified against EnvPlatform. Keep unexpected codes
 # private even when they look uppercase: a server can echo a submitted secret in
 # that field. HTTP status still supplies useful recovery for newer service codes.

envloop/client.py

@@ -343,16 +343,38 @@ class Profiles:
 
         Omitted fields and Secret markers are preserved. Supplied metadata,
         including secret_params, replaces that field. Parameter values replace
-        whole values, including objects; keys are literal. The default is unchanged.
+        whole values, including objects. V1 keys are literal; v2 keys are case
+        insensitive and live in spec.params. The default is unchanged.
         """
-        from .profile_updates import checked_patch
+        from .profile_updates import checked_patch, merge_v2_params
 
         patch = checked_patch(patch, name, version)
         original = self.get(name, from_version)["spec"]
-        spec = {**original, **patch, "name": name, "version": version,
-                "params": {**original.get("params", {}), **patch.get("params", {})}}
+        spec = {**original, **patch, "name": name, "version": version}
+        if original.get('schema_version') == 'envplatform.profile/v2':
+            if 'params' in patch:
+                from .http import RemoteError
+                raise RemoteError('INVALID_PROFILE', 422)
+            before, changes = original.get('spec', {}), patch.get('spec', {})
+            spec['spec'] = {**before, **changes, 'params': merge_v2_params(before.get('params', {}), changes.get('params', {}), spec.get('secret_params', []))}
+        else:
+            spec['params'] = {**original.get('params', {}), **patch.get('params', {})}
         return self.put(spec, secrets=secrets)
 
+    def fork(self, source_name, source_version, *, name, version, patch=None, secrets=None):
+        """Publish a new identity from an authorized source; never change its default."""
+        from .profile_updates import checked_patch, merge_v2_params
+
+        original = self.get(source_name, source_version)['spec']
+        changes = checked_patch({} if patch is None else patch, name, version)
+        result = {**original, **changes, 'name': name, 'version': version}
+        if original.get('schema_version') == 'envplatform.profile/v2':
+            before, updates = original.get('spec', {}), changes.get('spec', {})
+            result['spec'] = {**before, **updates, 'params': merge_v2_params(before.get('params', {}), updates.get('params', {}), result.get('secret_params', []))}
+        else:
+            result['params'] = {**original.get('params', {}), **changes.get('params', {})}
+        return self.put(result, secrets=secrets)
+
     def get(self, name: str, version: str | None = None) -> dict:
         return self._server.get_profile(name, version)
 
@@ -377,7 +399,31 @@ class Profiles:
         """Revoke model access for a scoped immutable secret revision."""
         return self._server.revoke_profile_secret(name, version)
 
-    def import_spec(self, raw: bytes, *, name=None, version=None, secrets=None):
+    def import_spec(self, raw: bytes, *, name=None, version=None, secrets=None, runner=None):
+        import json
+
+        from .profile_updates import read_profile_patch, with_runner
+
+        value = read_profile_patch(raw)
+        if isinstance(value, dict) and value.get('schema_version') == 'envhub.runner/v1':
+            from .http import RemoteError
+
+            definition = value.get('runner')
+            declarations = value.get('params', {})
+            if (not isinstance(definition, dict) or not isinstance(definition.get('name'), str)
+                    or not definition['name'] or not isinstance(declarations, dict)
+                    or any(not isinstance(item, dict) for item in declarations.values())):
+                raise RemoteError('INVALID_PROFILE', 422)
+            if runner is not None and runner.partition('@')[0] != definition['name']:
+                raise RemoteError('INVALID_PROFILE_RUNNER', 422)
+            defaults = {key: declaration['default'] for key, declaration in declarations.items()
+                        if 'default' in declaration}
+            value = {'schema_version': 'envplatform.profile/v2', 'name': name, 'version': version,
+                     'runner': runner if runner is not None else definition['name'] + '@main',
+                     'spec': {'params': defaults, **({'env': value['env']} if 'env' in value else {})}}
+        if runner is not None:
+            value = with_runner(value, runner)
+        raw = json.dumps(value, allow_nan=False, ensure_ascii=False).encode('utf-8')
         options = {} if secrets is None else {"secrets": secrets}
         return self._server.import_profile(raw, name=name, version=version, **options)
 
@@ -454,9 +500,10 @@ class Jobs:
                 body['image'] = validate_image(image)
             validate_public_execution(body)
             return self._server.submit_job(body)
-        if sum(value is not None for value in (dataset, source, task_ref)) != 1:
+        profile_only = all(value is None for value in (dataset, source, task_ref)) and (profile_id is not None or options.get("profile_name") is not None)
+        if sum(value is not None for value in (dataset, source, task_ref)) != 1 and not profile_only:
             raise ValueError("provide exactly one dataset, source or task_ref")
-        if dataset is None and (runner is not None or any(value is not None for value in (task_id, namespace, config, split, revision))):
+        if dataset is None and not profile_only and (runner is not None or any(value is not None for value in (task_id, namespace, config, split, revision))):
             raise ValueError("dataset selection options require a dataset")
         if runner is not None:
             runner = runner_selector(runner)
@@ -464,7 +511,9 @@ class Jobs:
             options["command"] = validate_command(command)
         selection = {key: value for key, value in dict(task_id=task_id, namespace=namespace, config=config,
                                                       split=split, revision=revision).items() if value is not None}
-        if source is not None:
+        if profile_only:
+            source = {"dataset": selection} if selection else {}
+        elif source is not None:
             source = {"task": load_task(source)}
         elif task_ref is not None:
             source = {"task_ref": dict(task_ref)}
@@ -499,10 +548,8 @@ class Jobs:
 
     def submit_inference(self, body: dict):
         """Submit a continuous inference deployment, identified by its Job ID."""
-        if not isinstance(body, dict) or set(body) - {'type', 'request_id', 'spec'} or body.get('type', 'inference') != 'inference':
-            raise ValueError('inference submission requires spec and request_id')
-        if not isinstance(body.get('spec'), dict):
-            raise ValueError('inference submission requires a spec object')
+        from .inference import validate_submission
+        validate_submission(body)
         return self._server.submit_job({'request_id': str(uuid4()), **body, 'type': 'inference'})
 
     def pause(self, job_id):
@@ -535,7 +582,12 @@ class Jobs:
     def stop(self, job_id):
         return self._server.stop_job(job_id)
 
-    def wait(self, job_id, *, timeout=600, poll_interval=.1):
+    def wait(self, job_id, *, timeout=600, poll_interval=.1, max_poll_interval=5):
+        """Poll until terminal; the interval grows 1.5x per poll up to ``max_poll_interval``.
+
+        Jobs that run for tens of minutes (large-model training) would otherwise
+        issue ten status requests a second for the whole wait.
+        """
         if not math.isfinite(timeout) or timeout < 0:
             raise ValueError("timeout must be finite and non-negative")
         if not math.isfinite(poll_interval) or poll_interval <= 0:
@@ -549,6 +601,7 @@ class Jobs:
             if remaining <= 0:
                 raise TimeoutError("job did not reach a terminal state")
             time.sleep(min(poll_interval, remaining))
+            poll_interval = max(poll_interval, min(poll_interval * 1.5, max_poll_interval))
 
 
 class Client:
@@ -591,36 +644,11 @@ class Client:
 
         return TemporaryResources(self, **options)
 
-    def training_service(self, *, temporary_scope_id=None, **options):
-        """Use this EnvLoop connection for training without Tinker credentials/env.
+    def training_service(self, *args, **options):
+        """Removed: raise a pointer to managed Jobs."""
+        from .train import INTERACTIVE_TRAINING_REMOVED
 
-        The platform exchanges its Key for the training protocol's short-lived
-        token. Upstream token refresh follows the same platform URL and the
-        gateway rechecks the underlying subject and credential on every request.
-        """
-        from .training import ServiceClient
-        from .training.credentials import TrainingHttpClient
-
-        if 'http_client' in options:
-            raise ValueError('Client.training_service manages its authenticated HTTP client')
-        if any(name in options for name in ('base_url', 'api_key', 'default_headers')):
-            raise ValueError('Client.training_service manages its connection and credential headers')
-        overrides = options.get('default_headers_overrides') or {}
-        protected_headers = {'authorization', 'x-api-key', 'cookie', 'x-workspace-id',
-                             'x-project-id', 'x-envloop-temporary-scope'}
-        if any(name.lower() in protected_headers for name in overrides):
-            raise ValueError('Client.training_service manages authentication, project and temporary scope headers')
-        transport = self._transport
-        project_id = transport.headers.get("X-Project-ID", "")
-        if 'project_id' in options and options.pop('project_id') != project_id:
-            raise ValueError('Select the training project through Client.remote(project_id=...)')
-        token = transport.request("POST", "/v1/job/tinker/api/v1/auth/token", {})["jwt"]
-        headers = {name: value for name, value in transport.headers.items() if name in {"X-Workspace-ID", "X-Project-ID"}}
-        if temporary_scope_id is not None:
-            headers["X-EnvLoop-Temporary-Scope"] = temporary_scope_id
-        base_url = transport.base + "/v1/job/tinker"
-        return ServiceClient(base_url=base_url, api_key=token, project_id=project_id, default_headers=headers,
-                             http_client=TrainingHttpClient(base_url, transport.headers["Authorization"]), **options)
+        raise RuntimeError(INTERACTIVE_TRAINING_REMOVED)
 
     @classmethod
     def remote(cls, api_url=None, *, timeout=30, api_key=None, workspace_id=None, project_id=None, config=True):

envloop/http.py

@@ -307,22 +307,10 @@ class HttpService:
                           sort_keys=True, separators=(",", ":"), allow_nan=False).encode("utf-8")
 
     def import_profile(self, raw, *, name=None, version=None, secrets=None):
-        def unique_object(pairs):
-            result = {}
-            for key, value in pairs:
-                if key in result:
-                    raise ValueError("duplicate key")
-                result[key] = value
-            return result
+        from .profile_updates import read_profile_patch
 
-        def invalid_constant(value):
-            raise ValueError("non-finite JSON value")
-
-        try:
-            spec = json.loads(raw, object_pairs_hook=unique_object, parse_constant=invalid_constant)
-            if (not isinstance(spec, dict) or (name is not None and spec.get("name") != name)
-                    or (version is not None and spec.get("version") != version)):
-                raise ValueError("Profile name/version mismatch")
-        except (ValueError, UnicodeError, TypeError):
-            raise RemoteError("INVALID_PROFILE", 422) from None
+        spec = read_profile_patch(raw)
+        if (not isinstance(spec, dict) or (name is not None and spec.get("name") != name)
+                or (version is not None and spec.get("version") != version)):
+            raise RemoteError("INVALID_PROFILE", 422)
         return self.put_profile(profile_payload(spec, secrets))

envloop/inference.py

@@ -0,0 +1,35 @@
+"""Public inference intent validation; resolution and admission remain server owned."""
+import re
+
+_FIELDS = {'name', 'runner', 'inputs', 'serving_profile', 'hardware', 'weights_format',
+           'scaling', 'temporary_scope_id'}
+
+
+def validate_submission(body):
+    if (not isinstance(body, dict) or set(body) - {'type', 'request_id', 'spec'}
+            or body.get('type', 'inference') != 'inference'):
+        raise ValueError('inference submission requires spec and request_id')
+    spec = body.get('spec')
+    if not isinstance(spec, dict):
+        raise ValueError('inference submission requires a spec object')
+    if 'request_id' in body and (not isinstance(body['request_id'], str)
+            or not body['request_id'].strip() or len(body['request_id']) > 128):
+        raise ValueError('request_id must be a non-empty string of at most 128 characters')
+    if any(key in spec for key in ('provider', 'executor', 'resolved_runner', 'runtime')):
+        raise ValueError('execution configuration and Runner resolution are owned by the server')
+    if 'runner' not in spec:
+        return  # Explicit legacy compatibility: existing adapter specs still reach the API.
+    if set(spec) - _FIELDS:
+        raise ValueError('fixed-input inference cannot mix legacy or runtime fields')
+    runner = spec['runner']
+    if (not isinstance(runner, str)
+            or not re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._-]*/[A-Za-z0-9][A-Za-z0-9._-]*@[^\s@]+', runner)):
+        raise ValueError('runner requires namespace/name@revision')
+    if any(not isinstance(spec.get(key), str) or not spec[key].strip()
+           for key in ('name', 'serving_profile')):
+        raise ValueError('fixed-input inference requires name and serving_profile')
+    inputs = spec.get('inputs', {})
+    if (not isinstance(inputs, dict) or set(inputs) - {'checkpoint'}
+            or 'checkpoint' in inputs and (not isinstance(inputs['checkpoint'], str)
+            or not inputs['checkpoint'].startswith('envloop://') or not inputs['checkpoint'][10:])):
+        raise ValueError('inputs accepts one Checkpoint ANS URI')

envloop/profile_updates.py

@@ -1,5 +1,6 @@
 """Build new Profile versions without changing the source or its default."""
 import json
+import tomllib
 from collections.abc import Mapping
 
 from .http import RemoteError
@@ -18,13 +19,19 @@ def read_profile_patch(raw):
         raise ValueError
 
     try:
-        return json.loads(raw, object_pairs_hook=unique, parse_constant=invalid_constant)
+        text = raw.decode('utf-8') if isinstance(raw, bytes) else raw
+        try:
+            value = json.loads(text, object_pairs_hook=unique, parse_constant=invalid_constant)
+        except ValueError:
+            value = tomllib.loads(text)
+        json.dumps(value, allow_nan=False)
+        return value
     except (ValueError, UnicodeError, TypeError):
         raise RemoteError("INVALID_PROFILE", 422) from None
 
 
 def checked_patch(patch, name, version):
-    allowed = {"schema_version", "name", "version", "params", "description", "created_for", "secret_params", "runner"}
+    allowed = {"schema_version", "name", "version", "params", "description", "created_for", "secret_params", "agent", "runner", "dataset", "dataset_mode", "task", "tags", "spec"}
 
     def string_keys(value):
         if isinstance(value, Mapping):
@@ -39,7 +46,8 @@ def checked_patch(patch, name, version):
     try:
         if (not isinstance(patch, Mapping) or set(patch) - allowed
                 or patch.get("name", name) != name or patch.get("version", version) != version
-                or not isinstance(patch.get("params", {}), Mapping)):
+                or not isinstance(patch.get("params", {}), Mapping)
+                or not isinstance(patch.get("spec", {}), Mapping)):
             raise ValueError
         # Reject non-finite numbers for SDK input as well as CLI JSON files.
         json.dumps(patch, allow_nan=False)
@@ -49,6 +57,18 @@ def checked_patch(patch, name, version):
     return dict(patch)
 
 
+def merge_v2_params(base, override, secrets=()):
+    """Overlay parameter values using the Runner's case insensitive names."""
+    if not isinstance(base, Mapping) or not isinstance(override, Mapping):
+        raise RemoteError("INVALID_PROFILE", 422)
+    targets = [key.upper() for key in override]
+    if len(set(targets)) != len(targets):
+        raise RemoteError("INVALID_PROFILE", 422)
+    marked = {key.upper(): key for key in secrets}
+    changes = {marked.get(key.upper(), key): item for key, item in override.items()}
+    return {key: item for key, item in base.items() if key.upper() not in targets} | changes
+
+
 def with_runner(value, runner):
     """Keep a file binding and explicit CLI binding unambiguous."""
     if not isinstance(value, Mapping) or value.get('runner', runner) != runner:

envloop/resources.py

@@ -183,10 +183,6 @@ class TemporaryResources:
     def get(self):
         return self.client._transport.request("GET", self.path)
 
-    def training_service(self, **options):
-        self.path  # Fail before any authentication/session if the scope was not entered.
-        return self.client.training_service(temporary_scope_id=self.scope_id, **options)
-
     def retain(self, resources):
         return self.client._transport.request("POST", self.path + "/retain", {"resources": resources})