adaptorch-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{adaptorch_cli-0.1.0/src/adaptorch_cli.egg-info → adaptorch_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adaptorch-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: Command-line client for AdaptOrch
 Author: ClassicMate
 License-Expression: LicenseRef-Proprietary
@@ -11,7 +11,7 @@ Project-URL: Documentation, https://adaptorch.com/mcp-docs
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: adaptorch-client<0.2,>=0.1
+Requires-Dist: adaptorch-client<0.2,>=0.1.2
 Dynamic: license-file
 
 # adaptorch-cli
@@ -41,6 +41,22 @@ A git push does not replace a previously published PyPI version.
 
 See [`../../docs/adaptorchctl-usage.ko.md`](../../docs/adaptorchctl-usage.ko.md) for usage.
 
+## Bounded wait exit codes
+
+`adaptorchctl run wait RUN_ID` emits the last observation as JSON. A terminal
+`SUCCEEDED` exits 0, `FAILED` exits 8, and `CANCELLED` exits 9. These codes describe
+run lifecycle, not result correctness or evidence verification.
+
+A `deadline`, `poll_limit`, `unsupported_status`, or unrecognized stop reason exits
+10, even if the last observation looks terminal. Missing or unsupported terminal
+observations also exit 10. This means the observation is inconclusive, not that
+the server-side run failed. Inspect `reason` and retain the JSON; continue with the
+same run ID when appropriate. Waiting never resubmits or cancels a run.
+
+Automation compatibility: `run wait` previously returned 0 for these observations.
+Scripts using `set -e` must now handle nonzero exits. `run get` keeps its existing
+exit-code behavior; submit and cancel still report command success separately.
+
 ## License
 
 Proprietary — Copyright ClassicMate. All rights reserved. See [LICENSE](https://github.com/dmae97/Adaptorch-MCP/blob/main/LICENSE).

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2}/README.md

@@ -25,6 +25,22 @@ A git push does not replace a previously published PyPI version.
 
 See [`../../docs/adaptorchctl-usage.ko.md`](../../docs/adaptorchctl-usage.ko.md) for usage.
 
+## Bounded wait exit codes
+
+`adaptorchctl run wait RUN_ID` emits the last observation as JSON. A terminal
+`SUCCEEDED` exits 0, `FAILED` exits 8, and `CANCELLED` exits 9. These codes describe
+run lifecycle, not result correctness or evidence verification.
+
+A `deadline`, `poll_limit`, `unsupported_status`, or unrecognized stop reason exits
+10, even if the last observation looks terminal. Missing or unsupported terminal
+observations also exit 10. This means the observation is inconclusive, not that
+the server-side run failed. Inspect `reason` and retain the JSON; continue with the
+same run ID when appropriate. Waiting never resubmits or cancels a run.
+
+Automation compatibility: `run wait` previously returned 0 for these observations.
+Scripts using `set -e` must now handle nonzero exits. `run get` keeps its existing
+exit-code behavior; submit and cancel still report command success separately.
+
 ## License
 
 Proprietary — Copyright ClassicMate. All rights reserved. See [LICENSE](https://github.com/dmae97/Adaptorch-MCP/blob/main/LICENSE).

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "adaptorch-cli"
-version = "0.1.0"
+version = "0.1.2"
 description = "Command-line client for AdaptOrch"
 readme = "README.md"
 requires-python = ">=3.11"
 license = "LicenseRef-Proprietary"
 license-files = ["LICENSE"]
 authors = [{ name = "ClassicMate" }]
-dependencies = ["adaptorch-client>=0.1,<0.2"]
+dependencies = ["adaptorch-client>=0.1.2,<0.2"]
 
 [project.urls]
 Homepage = "https://adaptorch.com"

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2}/src/adaptorch_cli/cli.py

@@ -13,6 +13,7 @@ from adaptorch_client import (
     AdaptOrchAPIError,
     AdaptOrchClient,
     ClientConfig,
+    PollPolicy,
     ProviderCredential,
     validate_api_url,
 )
@@ -39,7 +40,10 @@ def _reject_json_constant(_value: str) -> Never:
 
 
 def _finite_float(text: str) -> float:
-    value = float(text)
+    try:
+        value = float(text)
+    except ValueError:
+        _reject_json_constant(text)
     if not math.isfinite(value):
         raise ValueError("non-finite JSON number")
     return value
@@ -97,11 +101,14 @@ def _require_client(api_url: str) -> AdaptOrchClient:
 
 
 def _submission_credential() -> ProviderCredential | None:
-    resolved, _source = config_store.resolve_provider_credential()
+    resolved, source = config_store.resolve_provider_credential()
     if resolved is None:
         return None
     provider, model, key = resolved
-    return ProviderCredential(provider, model, key)
+    auth_type, account_id = config_store.resolve_provider_auth(source)
+    if auth_type is None and account_id is None:
+        return ProviderCredential(provider, model, key)
+    return ProviderCredential(provider, model, key, auth_type=auth_type, account_id=account_id)
 
 
 def _read_secret(prompt: str, *, stdin_flag: bool) -> str:
@@ -241,6 +248,28 @@ def _run_command(
         case "get":
             run_id: str = args.run_id
             return _result_payload(_require_client(api_url).get_run(run_id)), True
+        case "wait":
+            wait_run_id: str = args.run_id
+            timeout_seconds: float = args.timeout
+            interval_seconds: float = args.interval
+            if not math.isfinite(timeout_seconds) or timeout_seconds <= 0:
+                parser.error("--timeout must be finite positive seconds")
+            if not math.isfinite(interval_seconds) or interval_seconds <= 0:
+                parser.error("--interval must be finite positive seconds")
+            wait_result = _require_client(api_url).wait_for_run(
+                wait_run_id,
+                policy=PollPolicy(
+                    timeout_seconds=timeout_seconds, interval_seconds=interval_seconds
+                ),
+            )
+            wait_payload: dict[str, JSONValue] = {
+                "reason": wait_result.reason.value,
+                "polls": wait_result.polls,
+                "elapsed_seconds": wait_result.elapsed_seconds,
+            }
+            if wait_result.run is not None:
+                wait_payload["run"] = wait_result.run.to_payload()
+            return wait_payload, True
         case "cancel":
             cancel_run_id: str = args.run_id
             reason: str | None = args.reason
@@ -318,6 +347,19 @@ def _run_status_exit(payload: JSONMapping) -> int:
     return 0
 
 
+def _wait_status_exit(payload: JSONMapping) -> int:
+    """Map a bounded observation without treating a stopped wait as success."""
+    if payload.get("reason") != "terminal":
+        return 10
+    run = payload.get("run")
+    if not isinstance(run, dict):
+        return 10
+    status = run.get("status")
+    if not isinstance(status, str):
+        return 10
+    return {"succeeded": 0, "failed": 8, "cancelled": 9}.get(status.lower(), 10)
+
+
 def main(argv: Sequence[str] | None = None) -> int:
     parser = build_parser()
     args = parse_args(argv)
@@ -333,6 +375,8 @@ def main(argv: Sequence[str] | None = None) -> int:
         except ValueError:
             print("response contained non-encodable JSON values", file=sys.stderr)
             return 7
+        if args.command == "run" and args.run_command == "wait":
+            return _wait_status_exit(payload)
         return _run_status_exit(payload) if check_run_status else 0
     # pi-lens-ignore: unreachable-except
     except KeyboardInterrupt:

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2}/src/adaptorch_cli/config_store.py

@@ -27,6 +27,8 @@ _PROVIDER_KEY_MAP = {
     "provider.name": "provider",
     "provider.model": "model",
     "provider.api_key": "api_key",
+    "provider.auth_type": "auth_type",
+    "provider.account_id": "account_id",
 }
 _CONFIGURABLE_KEYS = frozenset({"api_url", *_PROVIDER_KEY_MAP})
 
@@ -175,18 +177,50 @@ def resolve_provider_credential() -> tuple[tuple[str, str, str] | None, str]:
     env_provider = os.environ.get("ADAPTORCH_PROVIDER", "").strip()
     env_model = os.environ.get("ADAPTORCH_PROVIDER_MODEL", "").strip()
     env_key = os.environ.get("ADAPTORCH_PROVIDER_API_KEY", "").strip()
-    if env_provider or env_model or env_key:
+    if any(
+        (
+            env_provider,
+            env_model,
+            env_key,
+            os.environ.get("ADAPTORCH_PROVIDER_AUTH_TYPE"),
+            os.environ.get("ADAPTORCH_PROVIDER_ACCOUNT_ID"),
+        )
+    ):
         return (env_provider, env_model, env_key), "env"
     provider_cfg = load_config().get("provider")
     if isinstance(provider_cfg, dict):
         provider = str(provider_cfg.get("provider") or "").strip()
         model = str(provider_cfg.get("model") or "").strip()
         key = str(provider_cfg.get("api_key") or "").strip()
-        if provider or model or key:
+        has_auth_metadata = "auth_type" in provider_cfg or "account_id" in provider_cfg
+        if provider or model or key or has_auth_metadata:
             return (provider, model, key), "config"
     return None, "none"
 
 
+def resolve_provider_auth(source: str) -> tuple[str | None, str | None]:
+    """Read metadata from the same source as the token; never mix identities."""
+    if source == "env":
+        values = (
+            os.environ.get("ADAPTORCH_PROVIDER_AUTH_TYPE"),
+            os.environ.get("ADAPTORCH_PROVIDER_ACCOUNT_ID"),
+        )
+    else:
+        provider = load_config().get("provider")
+        if not isinstance(provider, dict):
+            return None, None
+        values = (provider.get("auth_type"), provider.get("account_id"))
+
+    def optional_text(value: object) -> str | None:
+        if value is None:
+            return None
+        if not isinstance(value, str):
+            raise ValueError("provider authentication metadata must be strings")
+        return value.strip() or None
+
+    return optional_text(values[0]), optional_text(values[1])
+
+
 def mask_secret(value: str | None) -> str | None:
     if not value:
         return None
@@ -209,6 +243,8 @@ def config_view() -> dict[str, Any]:
             "name": provider.get("provider"),
             "model": provider.get("model"),
             "api_key": mask_secret(provider_key if isinstance(provider_key, str) else None),
+            "auth_type": provider.get("auth_type"),
+            "account_id_configured": bool(provider.get("account_id")),
             "source": resolve_provider_credential()[1],
         },
         "config_path": str(config_path()),

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2}/src/adaptorch_cli/parser.py

@@ -33,6 +33,28 @@ def _add_run_commands(parent: argparse._SubParsersAction[argparse.ArgumentParser
     get = commands.add_parser("get", help="Get a run")
     get.add_argument("run_id")
 
+    wait = commands.add_parser(
+        "wait",
+        help=(
+            "Read an existing run until it reaches a terminal status — the "
+            "CLI's form of the MCP resume_run_id contract. It never submits "
+            "another run; use it after an uncertain submit response."
+        ),
+    )
+    wait.add_argument("run_id")
+    wait.add_argument(
+        "--timeout",
+        type=float,
+        default=120.0,
+        help="Seconds to keep polling before stopping (default: 120)",
+    )
+    wait.add_argument(
+        "--interval",
+        type=float,
+        default=1.0,
+        help="Seconds between status reads (default: 1)",
+    )
+
     cancel = commands.add_parser("cancel", help="Cancel a run")
     cancel.add_argument("run_id")
     cancel.add_argument("--reason")
@@ -76,7 +98,7 @@ def build_parser() -> argparse.ArgumentParser:
     config_commands.add_parser("get", help="Show the merged configuration (secrets masked)")
     config_set = config_commands.add_parser(
         "set",
-        help="Set api_url, provider.name, provider.model, or provider.api_key",
+        help="Set api_url or provider.name/model/api_key/auth_type/account_id",
     )
     config_set.add_argument("key")
     config_set.add_argument("value", nargs="?")

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2/src/adaptorch_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: adaptorch-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: Command-line client for AdaptOrch
 Author: ClassicMate
 License-Expression: LicenseRef-Proprietary
@@ -11,7 +11,7 @@ Project-URL: Documentation, https://adaptorch.com/mcp-docs
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: adaptorch-client<0.2,>=0.1
+Requires-Dist: adaptorch-client<0.2,>=0.1.2
 Dynamic: license-file
 
 # adaptorch-cli
@@ -41,6 +41,22 @@ A git push does not replace a previously published PyPI version.
 
 See [`../../docs/adaptorchctl-usage.ko.md`](../../docs/adaptorchctl-usage.ko.md) for usage.
 
+## Bounded wait exit codes
+
+`adaptorchctl run wait RUN_ID` emits the last observation as JSON. A terminal
+`SUCCEEDED` exits 0, `FAILED` exits 8, and `CANCELLED` exits 9. These codes describe
+run lifecycle, not result correctness or evidence verification.
+
+A `deadline`, `poll_limit`, `unsupported_status`, or unrecognized stop reason exits
+10, even if the last observation looks terminal. Missing or unsupported terminal
+observations also exit 10. This means the observation is inconclusive, not that
+the server-side run failed. Inspect `reason` and retain the JSON; continue with the
+same run ID when appropriate. Waiting never resubmits or cancels a run.
+
+Automation compatibility: `run wait` previously returned 0 for these observations.
+Scripts using `set -e` must now handle nonzero exits. `run get` keeps its existing
+exit-code behavior; submit and cancel still report command success separately.
+
 ## License
 
 Proprietary — Copyright ClassicMate. All rights reserved. See [LICENSE](https://github.com/dmae97/Adaptorch-MCP/blob/main/LICENSE).

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2}/src/adaptorch_cli.egg-info/SOURCES.txt

@@ -16,4 +16,6 @@ src/adaptorch_cli.egg-info/top_level.txt
 tests/test_cli_boundary.py
 tests/test_cli_commands.py
 tests/test_cli_integration.py
-tests/test_cli_login_config.py
+tests/test_cli_login_config.py
+tests/test_cli_oauth.py
+tests/test_cli_wait_exit_codes.py

adaptorch_cli-0.1.2/src/adaptorch_cli.egg-info/requires.txt

@@ -0,0 +1 @@
+adaptorch-client<0.2,>=0.1.2

{adaptorch_cli-0.1.0 → adaptorch_cli-0.1.2}/tests/test_cli_commands.py

@@ -118,6 +118,43 @@ def test_run_get_prints_client_json(run_cli: CliRunner) -> None:
     assert _json_stdout(result.stdout) == {"id": "run-1", "status": "RUNNING"}
 
 
+def test_run_wait_reads_until_terminal_without_resubmitting(run_cli: CliRunner) -> None:
+    result = run_cli(
+        [
+            "--output",
+            "json",
+            "run",
+            "wait",
+            "run-1",
+            "--timeout",
+            "5",
+            "--interval",
+            "0.5",
+        ]
+    )
+
+    assert result.returncode == 0
+    assert _json_stdout(result.stdout) == {
+        "reason": "terminal",
+        "polls": 1,
+        "elapsed_seconds": 0.01,
+        "run": {"id": "run-1", "status": "SUCCEEDED"},
+    }
+    calls = [json.loads(line) for line in result.client_log.splitlines()]
+    assert calls[-1] == {
+        "args": ["run-1"],
+        "kwargs": {"interval_seconds": 0.5, "timeout_seconds": 5.0},
+        "method": "wait_for_run",
+    }
+
+
+def test_run_wait_rejects_non_positive_bounds(run_cli: CliRunner) -> None:
+    result = run_cli(["--output", "json", "run", "wait", "run-1", "--timeout", "0"])
+
+    assert result.returncode != 0
+    assert result.client_log.count("wait_for_run") == 0
+
+
 def test_run_cancel_prints_client_json(run_cli: CliRunner) -> None:
     result = run_cli(["--output", "json", "run", "cancel", "run-1"])
 

adaptorch_cli-0.1.2/tests/test_cli_oauth.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from adaptorch_cli import cli, config_store
+
+
+@pytest.fixture(autouse=True)
+def isolated_config(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setenv("ADAPTORCH_CONFIG_DIR", str(tmp_path))
+    for name in (
+        "ADAPTORCH_PROVIDER",
+        "ADAPTORCH_PROVIDER_MODEL",
+        "ADAPTORCH_PROVIDER_API_KEY",
+        "ADAPTORCH_PROVIDER_AUTH_TYPE",
+        "ADAPTORCH_PROVIDER_ACCOUNT_ID",
+    ):
+        monkeypatch.delenv(name, raising=False)
+
+
+def test_cli_resolves_oauth_from_environment_without_persisting_token(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    for name, value in {
+        "ADAPTORCH_PROVIDER": "openai_codex",
+        "ADAPTORCH_PROVIDER_MODEL": "gpt-5-codex",
+        "ADAPTORCH_PROVIDER_API_KEY": "synthetic-oauth-token",
+        "ADAPTORCH_PROVIDER_AUTH_TYPE": "oauth",
+        "ADAPTORCH_PROVIDER_ACCOUNT_ID": "caller-account",
+    }.items():
+        monkeypatch.setenv(name, value)
+    credential = cli._submission_credential()
+    assert credential is not None
+    assert credential.headers["X-Provider-Auth-Type"] == "oauth"
+    assert credential.headers["X-Provider-Account-Id"] == "caller-account"
+    assert not config_store.config_path().exists()
+
+
+def test_cli_environment_credential_never_borrows_account_from_config(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    config_store.save_config(
+        {
+            "provider": {
+                "provider": "openai_codex",
+                "model": "gpt-5-codex",
+                "api_key": "old-token",
+                "auth_type": "oauth",
+                "account_id": "old-account",
+            }
+        }
+    )
+    monkeypatch.setenv("ADAPTORCH_PROVIDER", "openai_codex")
+    monkeypatch.setenv("ADAPTORCH_PROVIDER_MODEL", "gpt-5-codex")
+    monkeypatch.setenv("ADAPTORCH_PROVIDER_API_KEY", "new-token")
+    credential = cli._submission_credential()
+    assert credential is not None
+    assert credential.account_id is None
+    assert credential.api_key == "new-token"
+
+
+def test_cli_oauth_config_keys_and_view_are_safe() -> None:
+    config_store.set_config_value("provider.name", "openai_codex")
+    config_store.set_config_value("provider.model", "gpt-5-codex")
+    config_store.set_config_value("provider.api_key", "synthetic-oauth-token")
+    config_store.set_config_value("provider.auth_type", "oauth")
+    config_store.set_config_value("provider.account_id", "caller-account")
+    credential = cli._submission_credential()
+    assert credential is not None and credential.account_id == "caller-account"
+    view = json.dumps(config_store.config_view())
+    assert "synthetic-oauth-token" not in view
+    assert "caller-account" not in view
+    assert config_store.config_view()["provider"]["account_id_configured"] is True

adaptorch_cli-0.1.2/tests/test_cli_wait_exit_codes.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+from adaptorch_client import AdaptOrchClient, ClientConfig, PollPolicy, Run, RunPollResult, polling
+from adaptorch_client import client as client_module
+from adaptorch_client.transport import HTTPTransport, RequestSpec
+from cli_test_support import CliRunner
+
+from adaptorch_cli import cli
+
+
+@pytest.mark.parametrize(
+    ("reason", "status", "expected"),
+    [
+        ("terminal", "SUCCEEDED", 0),
+        ("terminal", "sUcCeEdEd", 0),
+        ("terminal", "FAILED", 8),
+        ("terminal", "failed", 8),
+        ("terminal", "CANCELLED", 9),
+        ("terminal", "cancelled", 9),
+        ("deadline", "RUNNING", 10),
+        ("deadline", "SUCCEEDED", 10),
+        ("deadline", "FAILED", 10),
+        ("poll_limit", "RUNNING", 10),
+        ("unsupported_status", "INCONCLUSIVE", 10),
+        ("unsupported_status", "FUTURE_STATUS", 10),
+        ("future_reason", "SUCCEEDED", 10),
+        ("terminal", "RUNNING", 10),
+        ("terminal", "FUTURE_STATUS", 10),
+    ],
+)
+def test_wait_exit_preserves_observation_and_never_resubmits(
+    run_cli: CliRunner,
+    monkeypatch: pytest.MonkeyPatch,
+    reason: str,
+    status: str,
+    expected: int,
+) -> None:
+    monkeypatch.setenv("FAKE_WAIT_REASON", reason)
+    monkeypatch.setenv("FAKE_RUN_STATUS", status)
+    result = run_cli(["run", "wait", "run-1"])
+
+    assert result.returncode == expected
+    assert json.loads(result.stdout) == {
+        "reason": reason,
+        "polls": 1,
+        "elapsed_seconds": 0.01,
+        "run": {"id": "run-1", "status": status},
+    }
+    assert result.stdout.count("\n") == 1
+    assert result.stderr == ""
+    methods = [json.loads(line)["method"] for line in result.client_log.splitlines()]
+    assert methods == ["init", "wait_for_run"]
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        {},
+        {"reason": None, "run": {"status": "SUCCEEDED"}},
+        {"reason": 1, "run": {"status": "SUCCEEDED"}},
+        {"reason": "future_reason", "run": {"status": "SUCCEEDED"}},
+        {"reason": "terminal"},
+        {"reason": "terminal", "run": None},
+        {"reason": "terminal", "run": []},
+        {"reason": "terminal", "run": {}},
+        {"reason": "terminal", "run": {"status": None}},
+        {"reason": "terminal", "run": {"status": 1}},
+        {"reason": "terminal", "run": {"status": ""}},
+        {"reason": "terminal", "run": {"data": {"status": "SUCCEEDED"}}},
+        {"reason": "deadline"},
+        {"reason": "poll_limit"},
+        {"reason": "unsupported_status"},
+    ],
+)
+def test_wait_unknown_or_missing_observation_is_inconclusive(
+    payload: cli.JSONMapping,
+) -> None:
+    assert cli._wait_status_exit(payload) == 10
+
+
+def test_wait_lifecycle_does_not_claim_result_correctness() -> None:
+    assert cli._wait_status_exit(
+        {"reason": "terminal", "run": {"status": "SUCCEEDED", "result_status": "FAILED"}}
+    ) == 0
+
+
+def test_wait_does_not_reinterpret_server_cancellation_encoding() -> None:
+    assert cli._wait_status_exit(
+        {"reason": "terminal", "run": {"status": "FAILED", "error_class": "CANCELLED"}}
+    ) == 8
+
+
+@pytest.mark.parametrize(
+    ("status", "reason", "expected", "timeout", "latency", "count"),
+    [
+        ("SUCCEEDED", "terminal", 0, "5", 0.0, 1),
+        ("FAILED", "terminal", 8, "5", 0.0, 1),
+        ("CANCELLED", "terminal", 9, "5", 0.0, 1),
+        ("RUNNING", "deadline", 10, "0.5", 0.0, 1),
+        ("RUNNING", "poll_limit", 10, "200", 0.0, 100),
+        ("NEW_STATUS", "unsupported_status", 10, "5", 0.0, 1),
+        ("INCONCLUSIVE", "unsupported_status", 10, "5", 0.0, 1),
+        ("SUCCEEDED", "deadline", 10, "0.5", 0.5, 1),
+    ],
+)
+def test_wait_uses_real_sdk_polling_without_writing_or_resubmitting(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    status: str,
+    reason: str,
+    expected: int,
+    timeout: str,
+    latency: float,
+    count: int,
+) -> None:
+    elapsed = 0.0
+    requests: list[RequestSpec] = []
+
+    def clock() -> float:
+        return elapsed
+
+    def sleep(duration: float) -> None:
+        nonlocal elapsed
+        elapsed += duration
+
+    def request(_transport: HTTPTransport, spec: RequestSpec) -> cli.JSONMapping:
+        nonlocal elapsed
+        requests.append(spec)
+        elapsed += latency
+        return {"run_id": "run-1", "status": status}
+
+    def poll(fetch: Callable[[float], Run], policy: PollPolicy) -> RunPollResult:
+        return polling.wait_for_run(fetch, policy, clock=clock, sleep=sleep)
+
+    client = AdaptOrchClient(ClientConfig("https://api.example.test", "ado_test"))
+    monkeypatch.setenv("ADAPTORCH_CONFIG_DIR", str(tmp_path / "isolated-config"))
+    monkeypatch.setattr(cli, "_require_client", lambda _api_url: client)
+    monkeypatch.setattr(HTTPTransport, "request", request)
+    monkeypatch.setattr(client_module, "poll_run", poll)
+
+    code = cli.main(["run", "wait", "run-1", "--timeout", timeout, "--interval", "1"])
+
+    captured = capsys.readouterr()
+    assert code == expected
+    assert json.loads(captured.out) == {
+        "reason": reason,
+        "polls": count,
+        "elapsed_seconds": elapsed,
+        "run": {"run_id": "run-1", "status": status},
+    }
+    assert captured.out.count("\n") == 1
+    assert captured.err == ""
+    assert len(requests) == count
+    assert all((spec.method, spec.path) == ("GET", "/v1/runs/run-1") for spec in requests)
+    assert all(spec.payload is None and spec.provider_credential is None for spec in requests)
+
+
+@pytest.mark.parametrize(
+    ("status", "expected"),
+    [("SUCCEEDED", 0), ("RUNNING", 0), ("NEW_STATUS", 0), ("FAILED", 8), ("CANCELLED", 9)],
+)
+def test_get_retains_its_mapping_with_additive_wait_like_fields(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+    status: str,
+    expected: int,
+) -> None:
+    payload: cli.JSONMapping = {"run_id": "run-1", "status": status, "reason": "deadline"}
+    monkeypatch.setenv("ADAPTORCH_CONFIG_DIR", str(tmp_path / "isolated-config"))
+    monkeypatch.setattr(cli, "_execute", lambda *_args: (payload, True))
+
+    assert cli.main(["run", "get", "run-1"]) == expected
+    captured = capsys.readouterr()
+    assert json.loads(captured.out) == payload
+    assert captured.err == ""

adaptorch_cli-0.1.0/src/adaptorch_cli.egg-info/requires.txt

@@ -1 +0,0 @@
-adaptorch-client<0.2,>=0.1