mostlyright-data 0.25.7__tar.gz → 0.25.8__tar.gz

{mostlyright_data-0.25.7 → mostlyright_data-0.25.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mostlyright-data
-Version: 0.25.7
+Version: 0.25.8
 Summary: Mostly Right hosted CLI for reviewed datasets
 Project-URL: Homepage, https://mostlyright.md/
 Project-URL: Documentation, https://mostlyright.md/docs/guides/cli/

{mostlyright_data-0.25.7 → mostlyright_data-0.25.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mostlyright-data"
-version = "0.25.7"
+version = "0.25.8"
 description = "Mostly Right hosted CLI for reviewed datasets"
 readme = "README.md"
 requires-python = ">=3.11"

{mostlyright_data-0.25.7 → mostlyright_data-0.25.8}/src/mostlyright/data_harness/thin/propose.py

@@ -2275,7 +2275,7 @@ def _dataset_conflict_remedy(refusal: ThinLaneError) -> str | None:
     return (
         "a Dataset of this name already exists in the workspace; if an earlier run of this bundle "
         'registered it, adopt it by id in dataset.json ({"dataset_id": "..."}) -- '
-        "mr-data list names the workspace's datasets -- or choose another name"
+        "mr-data dataset list names the workspace's datasets -- or choose another name"
     )
 
 

{mostlyright_data-0.25.7 → mostlyright_data-0.25.8}/src/mostlyright/data_harness/thin/recipe.py

@@ -51,17 +51,23 @@ from mostlyright.data_harness.thin.recipe_lint import lint_document, lint_refusa
 from mostlyright.data_harness.thin.session import StudioSession, open_studio_session
 from mostlyright.data_harness.thin.transport import ThinLaneError
 from mostlyright.data_harness.thin.v4 import identifier
-from mostlyright.data_harness.thin.v4_datasets import StudioV4DatasetClient, append_cell_body
+from mostlyright.data_harness.thin.v4_datasets import (
+    StudioV4DatasetClient,
+    append_cell_body,
+)
 from mostlyright.data_harness.thin.v4_narrative import v4_cell_receipt
+from mostlyright.data_harness.thin.v4_runs import StudioV4RunClient
+from mostlyright.data_harness.thin.v4_runs import start as start_run
 from mostlyright.data_harness.ux.credentials import resolve_cloud_credentials
 from mostlyright.data_harness.ux.plain_file import PlainFileRefusal, read_plain_file
 
 #: The one-line help both front doors print for this command.
-COMMAND_HELP = "register one recipe document and print the identifiers the server derived"
+COMMAND_HELP = "register one recipe document, or propose a revision that also starts one replay"
 
 REGISTER_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe.v1"
 SHOW_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe-read.v1"
 READINESS_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe-readiness.v1"
+PROPOSE_SCHEMA = f"{THIN_SCHEMA_PREFIX}-recipe-propose.v1"
 
 #: The bound on the document. The same number the authoring lane bounded one of its six documents
 #: by -- four times the contract's own 262144-byte ceiling on a canonical recipe -- rather than a
@@ -126,6 +132,7 @@ UNREFRESHABLE_PLAN_TAIL = (
 #: `mr-data recipe show ID` is how a person says it out loud.
 SHOW = "show"
 READINESS = "readiness"
+PROPOSE = "propose"
 # Studio evaluates the exact persisted admission proof for each recipe revision. Keep this
 # inventory page small enough that a normal production workspace completes each bounded request
 # inside the thin client's request deadline, while preserving the established 40,000-item
@@ -148,15 +155,17 @@ def declare_arguments(parser: argparse.ArgumentParser) -> None:
         metavar="FILE",
         help=(
             "the recipe document to register, as a path to a JSON file; the word `show`, "
-            "followed by a recipe identifier, to read one back; or `readiness` to inventory "
-            "whether current tables may schedule a bounded incremental refresh"
+            "followed by a recipe identifier, to read one back; `readiness` to inventory "
+            "whether current tables may schedule a bounded incremental refresh; or `propose`, "
+            "followed by a recipe document path and `--sources-from RUN_ID`, to register a "
+            "revision and start exactly one retained-input replay (MCP `propose_revision`)"
         ),
     )
     parser.add_argument(
         "recipe_id",
         nargs="?",
         metavar="RECIPE_ID",
-        help="with `show`, the recipe to read back",
+        help="with `show`, the recipe to read back; with `propose`, the recipe document path",
     )
     parser.add_argument(
         "--no-lint",
@@ -171,6 +180,18 @@ def declare_arguments(parser: argparse.ArgumentParser) -> None:
         help="record that the user delegated the brief, in their own words, and register; this "
         "is how `you choose` or `just build it` is written onto the dataset as the answer it is",
     )
+    parser.add_argument(
+        "--sources-from",
+        dest="sources_from_run",
+        metavar="RUN_ID",
+        help="with `propose`, replay the retained raw inputs of this successful run; required, "
+        "and replay never becomes live",
+    )
+    parser.add_argument(
+        "--confirm",
+        action="store_true",
+        help="with `propose`, authorize the projected spend if the replay is held for one",
+    )
 
 
 #: The flags that describe a registration. ``show`` reads one back and neither can mean anything
@@ -181,6 +202,13 @@ _REGISTER_ONLY_FLAGS: tuple[tuple[str, str], ...] = (
     ("delegated", "--delegated"),
 )
 
+#: Flags that belong only to ``propose``. A plain registration (or show/readiness) that carries
+#: one is refused by name rather than silently dropped -- same construction as _REGISTER_ONLY_FLAGS.
+_PROPOSE_ONLY_FLAGS: tuple[tuple[str, str], ...] = (
+    ("sources_from_run", "--sources-from"),
+    ("confirm", "--confirm"),
+)
+
 
 def _session(args: argparse.Namespace) -> StudioSession:
     return open_studio_session(resolve_cloud_credentials())
@@ -1159,6 +1187,163 @@ def readiness(
     }
 
 
+def propose(
+    args: argparse.Namespace,
+    *,
+    client: StudioV4DatasetClient | None = None,
+    run_client: StudioV4RunClient | None = None,
+) -> dict[str, Any]:
+    """``mr-data recipe propose FILE --sources-from RUN``: register + start one replay.
+
+    Mirrors cloud MCP ``propose_revision``: the revision is durable even when the retained-input
+    replay is held for spend confirmation or refused. Validate ``--sources-from`` before
+    registration so a bad run id never leaves an orphan revision. A non-held replay refusal
+    returns ``revision_registered_replay_not_started`` with the immutable coordinates; a held
+    replay returns outer status ``held`` (exit 2) so a script does not treat spend-gate as success.
+    """
+
+    document_path = getattr(args, "recipe_id", None)
+    if not isinstance(document_path, str) or not document_path:
+        raise ThinLaneError(
+            "THIN_REQUEST_INVALID",
+            "mr-data recipe propose needs the recipe document path after the word propose",
+        )
+    sources_raw = getattr(args, "sources_from_run", None)
+    if not isinstance(sources_raw, str) or not sources_raw:
+        raise ThinLaneError(
+            "THIN_REQUEST_INVALID",
+            "mr-data recipe propose needs --sources-from RUN_ID naming the "
+            "retained inputs to replay",
+        )
+    # Validate before register — a bad identifier must not leave a durable revision behind.
+    sources_from = identifier(sources_raw, "source run identifier")
+
+    register_args = argparse.Namespace(**vars(args))
+    register_args.target = document_path
+    register_args.recipe_id = None
+    registration = register(register_args, client=client)
+
+    coordinates = {
+        "recipe_id": registration["recipe_id"],
+        "recipe_digest": registration["recipe_digest"],
+        "dataset_id": registration["dataset_id"],
+        "table_id": registration["table_id"],
+        "source_ids": registration["source_ids"],
+    }
+
+    run_args = argparse.Namespace(
+        recipe=registration["recipe_id"],
+        digest=registration["recipe_digest"],
+        mode="replay",
+        sources_from_run=sources_from,
+        max_rows=None,
+        max_source_bytes=None,
+        window=None,
+        resource_class=None,
+        progressive=False,
+        resume_capture_run_id=None,
+        confirm=bool(getattr(args, "confirm", False)),
+        confirm_held=None,
+        cancel=None,
+        retry=None,
+        approve_full=None,
+    )
+    try:
+        replay = start_run(run_args, client=run_client)
+    except ThinLaneError as refusal:
+        payload: dict[str, Any] = {
+            "schema_version": PROPOSE_SCHEMA,
+            "status": "revision_registered_replay_not_started",
+            "lane": "hosted",
+            **coordinates,
+            "sources_from_run": sources_from,
+            "refusal": {"code": refusal.code, "detail": refusal.detail},
+            "idempotent_by": registration.get("idempotent_by", "recipe_digest"),
+            "brief": registration["brief"],
+            "next": (
+                "The recipe revision was registered, but its retained-input replay did not "
+                "start. Keep these immutable coordinates and correct the replay precondition "
+                "before proposing again."
+            ),
+        }
+        _copy_registration_extras(registration, payload)
+        return payload
+
+    if replay.get("status") == "run_awaiting_confirmation":
+        held: dict[str, Any] = {
+            "schema_version": PROPOSE_SCHEMA,
+            "status": "held",
+            "lane": "hosted",
+            **coordinates,
+            "sources_from_run": sources_from,
+            "mode": "replay",
+            "idempotent_by": registration.get("idempotent_by", "recipe_digest"),
+            "brief": registration["brief"],
+            "replay": replay,
+            "next": (
+                "Show the projected cost to the user, then call "
+                f"`{replay.get('confirm_command', 'mr-data run --confirm …')}` only if they "
+                "agree. The replay produces repair evidence only; no full run is approved."
+            ),
+        }
+        for key in (
+            "run_id",
+            "projected_bytes",
+            "projected_runtime_s",
+            "projected_cost",
+            "confirm_command",
+            "build_scope",
+        ):
+            if key in replay:
+                held[key] = replay[key]
+        if "run_id" in held:
+            held["replay_run_id"] = held["run_id"]
+        _copy_registration_extras(registration, held)
+        return held
+
+    payload = {
+        "schema_version": PROPOSE_SCHEMA,
+        "status": "recipe_proposed",
+        "lane": "hosted",
+        **coordinates,
+        "sources_from_run": sources_from,
+        "replay": replay,
+        "idempotent_by": registration.get("idempotent_by", "recipe_digest"),
+        "brief": registration["brief"],
+    }
+    run_body = replay.get("run") if isinstance(replay.get("run"), Mapping) else None
+    if isinstance(run_body, Mapping) and isinstance(run_body.get("run_id"), str):
+        payload["replay_run_id"] = run_body["run_id"]
+    _copy_registration_extras(registration, payload)
+    return payload
+
+
+def _copy_registration_extras(
+    registration: Mapping[str, Any], payload: dict[str, Any]
+) -> None:
+    """Carry optional register fields onto a propose receipt without inventing them."""
+
+    for key in (
+        "warnings",
+        "columns_without_description",
+        "sources_without_continuation",
+        "delegation_cell",
+    ):
+        if key in registration:
+            payload[key] = registration[key]
+
+
+def propose_exit_code(payload: Mapping[str, Any]) -> int:
+    """Held or failed replay after a durable register is a gate, not a successful propose."""
+
+    status = payload.get("status")
+    if status in {"held", "revision_registered_replay_not_started"}:
+        return 2
+    return 0
+
+
+
+
 def recipe(
     args: argparse.Namespace, *, client: StudioV4DatasetClient | None = None
 ) -> dict[str, Any]:
@@ -1174,7 +1359,7 @@ def recipe(
     if args.target in {SHOW, READINESS}:
         given = [
             flag
-            for destination, flag in _REGISTER_ONLY_FLAGS
+            for destination, flag in (*_REGISTER_ONLY_FLAGS, *_PROPOSE_ONLY_FLAGS)
             if getattr(args, destination, None) not in (None, False)
         ]
         if given:
@@ -1191,12 +1376,25 @@ def recipe(
                 "mr-data recipe readiness takes no recipe identifier",
             )
         return readiness(args, client=client)
+    if args.target == PROPOSE:
+        return propose(args, client=client)
+    propose_only = [
+        flag
+        for destination, flag in _PROPOSE_ONLY_FLAGS
+        if getattr(args, destination, None) not in (None, False)
+    ]
+    if propose_only:
+        raise ThinLaneError(
+            "THIN_REQUEST_INVALID",
+            f"{', '.join(propose_only)} belong to mr-data recipe propose, not to a plain "
+            "registration; say `propose` before the document path, or drop the flag",
+        )
     if args.recipe_id:
         raise ThinLaneError(
             "THIN_REQUEST_INVALID",
             f"mr-data recipe takes one document to register, `show` and a recipe identifier, "
-            f"or `readiness`; "
-            f"{args.target!r} is neither",
+            f"`readiness`, or `propose` and a document path; "
+            f"{args.target!r} is none of those",
         )
     return register(args, client=client)
 
@@ -1210,6 +1408,8 @@ __all__ = [
     "NAMED_UNCONTINUED_SOURCES",
     "NAMED_UNDESCRIBED_COLUMNS",
     "NDJSON_SOURCE_BYTE_CEILING",
+    "PROPOSE",
+    "PROPOSE_SCHEMA",
     "READER_SOURCE_BYTE_CEILING",
     "READINESS",
     "READINESS_PAGE_SIZE",
@@ -1226,6 +1426,7 @@ __all__ = [
     "columns_without_description",
     "continuation_warnings",
     "declare_arguments",
+    "propose",
     "read_document",
     "readiness",
     "recipe",

{mostlyright_data-0.25.7 → mostlyright_data-0.25.8}/src/mostlyright/data_harness/thin/router.py

@@ -131,6 +131,12 @@ HOSTED_SUMMARY = dict(
         ("reader", "ask Studio to normalize reader options for a family and version"),
         ("source", "queue or read one bounded source inspection"),
         ("catalog", "ask the sealed public-source catalogue what might answer a question"),
+        (
+            "public",
+            "read the public dataset catalogue anonymously "
+            "(search, show, tables, schema, sample)",
+        ),
+        ("connected", "list or connect public datasets for this workspace (device key)"),
         ("stream", "record a public wss venue and name the recording a build reads"),
         ("keys", "store a source credential by name, name the stored ones, and withdraw one"),
         ("open", "hand this terminal's session to the browser as a single-use address"),
@@ -152,6 +158,7 @@ HOSTED_SUMMARY = dict(
         ("demote", "ask Studio to withdraw the live pointer from one table or many"),
         ("watch", "stream one run's live progress, resuming across stream cuts"),
         ("download", "bring one run's artifacts back here, each one's digest checked"),
+        ("artifacts", "list what one run sealed, without fetching bytes"),
         ("receipt", "print the record one run sealed about how it was built"),
         ("checks", "report how each check the recipe declared came out for one run"),
         ("note", "write one cell of this run's decision record, or list what is written"),
@@ -263,6 +270,7 @@ def _hosted_parser() -> argparse.ArgumentParser:
     from mostlyright.data_harness.thin import recipe as recipe_module
     from mostlyright.data_harness.thin import (
         v4_artifacts,
+        v4_connected,
         v4_connections,
         v4_dataset_covers,
         v4_datasets,
@@ -299,6 +307,13 @@ def _hosted_parser() -> argparse.ArgumentParser:
 
     v4_catalog.declare_arguments(_add("catalog"))
 
+    from mostlyright.data_harness.thin import v4_public
+
+    v4_public.declare_arguments(_add("public"))
+
+
+    v4_connected.declare_arguments(_add("connected"))
+
     # ------------------------------------------------------------------------------------
     # The source whose bytes do not exist until somebody records them
     # ------------------------------------------------------------------------------------
@@ -404,11 +419,13 @@ def _handlers() -> dict[str, Callable[[argparse.Namespace], dict[str, Any]]]:
         stream_venue,
         v4_artifacts,
         v4_catalog,
+        v4_connected,
         v4_connections,
         v4_dataset_covers,
         v4_datasets,
         v4_handoff,
         v4_narrative,
+        v4_public,
         v4_query,
         v4_reader,
         v4_runs,
@@ -442,6 +459,8 @@ def _handlers() -> dict[str, Callable[[argparse.Namespace], dict[str, Any]]]:
         # around the command rather than around its one verb, because the verb is a
         # positional and the module is where a second one would land.
         "catalog": v4_catalog.catalog,
+        "public": v4_public.public,
+        "connected": v4_connected.connected,
         # The venue lane. One name over eight verbs, because registering a document,
         # admitting it, probing it, capturing it, subscribing to it and reading back what
         # any of those produced are steps of one act -- and eight top-level names would be
@@ -453,6 +472,7 @@ def _handlers() -> dict[str, Callable[[argparse.Namespace], dict[str, Any]]]:
         "watch": v4_stream.watch,
         "status": v4_runs.status,
         "download": v4_artifacts.download,
+        "artifacts": v4_artifacts.artifacts,
         "verify": v4_artifacts.verify,
         "receipt": v4_artifacts.receipt,
         "checks": v4_artifacts.checks,
@@ -488,8 +508,10 @@ def _exit_codes() -> dict[str, Callable[[dict[str, Any]], int]]:
     """
 
     from mostlyright.data_harness.thin import probe as probe_module
+    from mostlyright.data_harness.thin import recipe as recipe_module
     from mostlyright.data_harness.thin import (
         v4_artifacts,
+        v4_connected,
         v4_datasets,
         v4_query,
         v4_runs,
@@ -508,6 +530,8 @@ def _exit_codes() -> dict[str, Callable[[dict[str, Any]], int]]:
         "table": v4_tables.lifecycle_exit_code,
         "demote": v4_tables.lifecycle_exit_code,
         "dataset": v4_datasets.dataset_exit_code,
+        "recipe": recipe_module.propose_exit_code,
+        "connected": v4_connected.connected_exit_code,
     }
 
 

{mostlyright_data-0.25.7 → mostlyright_data-0.25.8}/src/mostlyright/data_harness/thin/session.py

@@ -63,6 +63,10 @@ CLOUD_SESSION_HANDOFF_PATH = "/api/cli/session-handoffs"
 #: this client sends a mode and renders what came back rather than deciding any part of it.
 CLOUD_DATASET_ACCESS_PATH = "/api/cli/datasets/{dataset_id}/access"
 
+# Workspace dataset directory for agents (`mr-data dataset list`), same facts MCP's
+# `list_my_datasets` reads from Cloud's own table.
+CLOUD_DATASETS_LIST_PATH = "/api/cli/datasets"
+
 # Projection repair after a Studio metadata write, without a publication mutation.
 CLOUD_DATASET_IDENTITY_PATH = "/api/cli/datasets/{dataset_id}/identity"
 
@@ -530,6 +534,7 @@ class CloudClient:
 
 __all__ = [
     "CLOUD_APPROVAL_DASHBOARD_PATH",
+    "CLOUD_DATASETS_LIST_PATH",
     "CLOUD_DATASET_ACCESS_PATH",
     "CLOUD_DATASET_DASHBOARD_PATH",
     "CLOUD_DATASET_RUN_QUERY_KEY",

{mostlyright_data-0.25.7 → mostlyright_data-0.25.8}/src/mostlyright/data_harness/thin/v4_artifacts.py

@@ -83,6 +83,7 @@ from mostlyright.data_harness.thin.v4_stream import check_results, terminal_even
 from mostlyright.data_harness.ux.credentials import resolve_cloud_credentials
 
 DOWNLOAD_SCHEMA = f"{THIN_SCHEMA_PREFIX}-v4-download.v1"
+ARTIFACTS_LIST_SCHEMA = f"{THIN_SCHEMA_PREFIX}-v4-artifacts-list.v1"
 RECEIPT_SCHEMA = f"{THIN_SCHEMA_PREFIX}-v4-receipt.v1"
 CHECKS_SCHEMA = f"{THIN_SCHEMA_PREFIX}-v4-checks.v1"
 PEEK_SCHEMA = f"{THIN_SCHEMA_PREFIX}-v4-peek.v1"
@@ -176,6 +177,7 @@ VERSION_KINDS: tuple[str, ...] = ("table_manifest", "table_part")
 #: The one-line help each front door prints, keyed by name so both parsers read one declaration.
 COMMAND_HELP: dict[str, str] = {
     "download": "bring one run's artifacts back to this computer, each one's digest checked",
+    "artifacts": "list what one run sealed, without fetching bytes (MCP run_artifacts)",
     "verify": "check one run's sealed table against its manifest, part by part with --deep",
     "receipt": "print the record one run sealed: its sources, its coverage and its raw snapshot",
     "checks": "report how each check the recipe declared came out for one run",
@@ -185,7 +187,7 @@ COMMAND_HELP: dict[str, str] = {
 #: ``peek`` and ``diff`` are NOT here: both already have a declaration in each front door and an
 #: argument surface a script may be carrying, and this plan re-points their handler rather than
 #: re-declaring them.
-COMMANDS: tuple[str, ...] = ("download", "receipt", "checks")
+COMMANDS: tuple[str, ...] = ("download", "artifacts", "receipt", "checks")
 
 #: ``verify``, mounted on the FRONT DOOR ALONE and deliberately not through :data:`COMMANDS`.
 #:
@@ -350,6 +352,19 @@ def declare_arguments(command: str, parser: argparse.ArgumentParser) -> None:
             "many, never a folder holding some of the table."
         )
         return
+    if command == "artifacts":
+        parser.add_argument(
+            "action",
+            choices=("list",),
+            help="list — name every artifact this run sealed (MCP run_artifacts parity)",
+        )
+        parser.add_argument("run_id", help=_RUN_POSITIONAL)
+        parser.description = (
+            "List what one run sealed — identifiers, kinds, sizes and digests — without fetching "
+            "bytes. Same facts cloud MCP `run_artifacts` returns. Use `mr-data download RUN` when "
+            "you want the bytes themselves."
+        )
+        return
     parser.add_argument("run_id", help=_RUN_POSITIONAL)
 
 
@@ -509,7 +524,10 @@ def _document(
 def _manifest_from_bytes(raw: bytes) -> Any:
     """One sealed manifest, read through the format's own reader."""
 
-    from mostlyright.data_harness.table_manifest import TableManifest, TableManifestError
+    from mostlyright.data_harness.table_manifest import (
+        TableManifest,
+        TableManifestError,
+    )
 
     try:
         return TableManifest.from_bytes(raw)
@@ -538,6 +556,57 @@ def _head(
     }
 
 
+
+_ARTIFACT_LIST_MEMBERS: tuple[str, ...] = (
+    "artifact_id",
+    "kind",
+    "size_bytes",
+    "digest",
+    "media_type",
+)
+
+
+def _artifact_row(row: Mapping[str, Any]) -> dict[str, Any]:
+    """The five members MCP ``run_artifacts`` prints; nothing else leaves this lane."""
+
+    return {member: row[member] for member in _ARTIFACT_LIST_MEMBERS if member in row}
+
+
+def artifacts(
+    args: argparse.Namespace, *, client: StudioV4ArtifactClient | None = None
+) -> dict[str, Any]:
+    """``mr-data artifacts list RUN``: what this run sealed, without fetching bytes.
+
+    MCP ``run_artifacts`` parity. Reuses the same listing client ``download`` already follows,
+    including cursor aggregation, so a run whose artifacts span pages is still reported whole.
+    """
+
+    action = getattr(args, "action", None)
+    if action != "list":
+        raise ThinLaneError(
+            "THIN_REQUEST_INVALID",
+            "mr-data artifacts takes the action `list` followed by a run identifier",
+        )
+    run_id = identifier(args.run_id, "run identifier")
+    selected = client or _client(args)
+    listing = _listing(selected, run_id)
+    rows = [_artifact_row(row) for row in listing]
+    return {
+        "schema_version": ARTIFACTS_LIST_SCHEMA,
+        "status": "artifacts_listed",
+        **_head(selected.session, run_id),
+        "count": len(rows),
+        "complete": True,
+        "artifacts": _numbered("artifact", rows),
+        "next": (
+            "this run has sealed nothing yet; ask mr-data status RUN for its state"
+            if not rows
+            else "mr-data download RUN brings the bytes back; cite each digest"
+        ),
+    }
+
+
+
 # --------------------------------------------------------------------------------------------
 # download
 # --------------------------------------------------------------------------------------------
@@ -1545,6 +1614,7 @@ def _summary(
 
 
 __all__ = [
+    "ARTIFACTS_LIST_SCHEMA",
     "CHECKS_SCHEMA",
     "CHECK_SCOPE_VERSION",
     "COMMANDS",
@@ -1566,6 +1636,7 @@ __all__ = [
     "VERIFY_SCHEMA",
     "VERSION_KINDS",
     "StudioV4ArtifactClient",
+    "artifacts",
     "checks",
     "checks_exit_code",
     "declare_arguments",