cmpnd 0.66.0__tar.gz → 0.67.0__tar.gz

{cmpnd-0.66.0 → cmpnd-0.67.0}/AGENTS.md

@@ -92,7 +92,7 @@ knowing:
   Run `uv lock` and commit the result. A stale lock makes every `uv` command
   rewrite it.
 - `basedpyright` takes no path argument. A path overrides pyproject's
-  `include`, so `basedpyright cmpnd` skips `tests/e2e` and `tests/stress` and
+  `include`, so `basedpyright cmpnd` skips `tests/e2e` and `tests/real_models` and
   passes changes CI rejects.
 
 **This tree's SDK and CLI run against each live self-host release.**
@@ -234,7 +234,10 @@ first. Its failures name the attribute or class that moved.
 
 To add a verb to both front-ends, add a `Verb(...)` row to `cli/verbs.py`, add
 its `add_parser` call in `top.register()`, and add the entity method or the
-`_make_namespace` function. The parity test fails until all three agree.
+`_make_namespace` function. The parity test fails until all three agree. A
+verb that repeats a namespaced command sets `shortcut_for`, and its help then
+starts with "Shortcut for `cmpnd deployments list`". The parity test checks
+that the named command exists.
 
 When you touch a handler:
 

{cmpnd-0.66.0 → cmpnd-0.67.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.66.0
+Version: 0.67.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -669,6 +669,12 @@ global config. Use it as a context manager or as a plain object.
   its best `DeployedProgram`.
 - `list_traces(**filters)` and `get_trace(trace_id)` read traces with the
   client's credentials. They flush the client's traces first.
+- `list_deployments(status=None, since=None, limit=50, offset=0)` and
+  `get_deployment(deployment_id)` read deployment records, as
+  `cmpnd deployments list` and `show` do.
+- `get_deployment_source(deployment_id, path=None)` returns the program file a
+  deployment stores, as `cmpnd inspect --source` does. A continuation's
+  deployment holds the program the continuation runs.
 - `close()` flushes the client's traces and closes the client. A closed
   client raises `RuntimeError` on every method.
 

{cmpnd-0.66.0 → cmpnd-0.67.0}/README.md

@@ -618,6 +618,12 @@ global config. Use it as a context manager or as a plain object.
   its best `DeployedProgram`.
 - `list_traces(**filters)` and `get_trace(trace_id)` read traces with the
   client's credentials. They flush the client's traces first.
+- `list_deployments(status=None, since=None, limit=50, offset=0)` and
+  `get_deployment(deployment_id)` read deployment records, as
+  `cmpnd deployments list` and `show` do.
+- `get_deployment_source(deployment_id, path=None)` returns the program file a
+  deployment stores, as `cmpnd inspect --source` does. A continuation's
+  deployment holds the program the continuation runs.
 - `close()` flushes the client's traces and closes the client. A closed
   client raises `RuntimeError` on every method.
 

cmpnd-0.67.0/cmpnd/_deployments.py

@@ -0,0 +1,105 @@
+"""Deployment reads behind ``cmpnd.Client``: the record list, one record, its stored source and its typed metadata."""
+
+from __future__ import annotations
+
+import io
+import tokenize
+from typing import Any, Protocol
+
+from . import _http
+from .deployment_metadata import DeploymentMetadataError, DeploymentSignatureResponse
+
+MAX_DEPLOYMENTS_PER_PAGE = 500
+
+
+class _JSONReader(Protocol):
+    def get(self, path: str) -> Any: ...
+
+
+def read_signature(client: _JSONReader, deployment_id: str) -> DeploymentSignatureResponse:
+    """Read one deployment's persisted signature through an existing client."""
+    value = client.get(f"/api/v1/deployments/{deployment_id}/signature")
+    response = DeploymentSignatureResponse.from_dict(value)
+    if response.deployment_id != deployment_id:
+        raise DeploymentMetadataError(
+            f"response deployment_id {response.deployment_id!r} does not match {deployment_id!r}"
+        )
+    return response
+
+
+def get_signature(
+    deployment_id: str,
+    *,
+    api_key: str,
+    endpoint: str,
+    timeout: float | None = None,
+) -> DeploymentSignatureResponse:
+    """Read one deployment's persisted signature with explicit credentials."""
+    client = (
+        _http.ApiClient(api_key, endpoint) if timeout is None else _http.ApiClient(api_key, endpoint, timeout=timeout)
+    )
+    return read_signature(client, deployment_id)
+
+
+def list_deployments(
+    *,
+    status: str | None = None,
+    since: str | None = None,
+    limit: int = 50,
+    offset: int = 0,
+    api_key: str,
+    endpoint: str,
+) -> dict[str, Any]:
+    """List the organization's deployments, newest first.
+
+    Returns ``{"deployments": [...], "has_more": bool, ...}``. ``status`` is one
+    of ``pending``, ``parsing``, ``optimizing``, ``ready`` or ``failed``, and
+    ``since`` is an ISO 8601 timestamp. The route pages by page number, so
+    ``offset`` must be a whole multiple of ``limit``. The route returns at most
+    500 deployments per page, so ``limit`` must not exceed 500.
+    """
+    if limit <= 0:
+        raise _http.ApiError("limit must be positive")
+    if limit > MAX_DEPLOYMENTS_PER_PAGE:
+        raise _http.ApiError(
+            f"limit must not exceed {MAX_DEPLOYMENTS_PER_PAGE}; the deployments route returns at most "
+            f"{MAX_DEPLOYMENTS_PER_PAGE} per page"
+        )
+    if offset < 0:
+        raise _http.ApiError("offset must not be negative")
+    if offset % limit != 0:
+        lower = (offset // limit) * limit
+        raise _http.ApiError(
+            f"offset must be a multiple of limit (the deployments route pages by page number); "
+            f"try offset {lower} or {lower + limit}"
+        )
+    params = {"per_page": str(limit), "page": str(offset // limit + 1)}
+    if status is not None:
+        params["status"] = status
+    if since is not None:
+        params["since"] = since
+    return _http.ApiClient(api_key, endpoint).get("/api/v1/deployments", params=params)
+
+
+def get_deployment(deployment_id: str, *, api_key: str, endpoint: str) -> dict[str, Any]:
+    """Read one deployment's record: its status, program, model and metadata."""
+    return _http.ApiClient(api_key, endpoint).get(f"/api/v1/deployments/{deployment_id}")
+
+
+def get_source(deployment_id: str, *, path: str | None = None, api_key: str, endpoint: str) -> str:
+    """Read one file of a deployment's stored source as text.
+
+    Without ``path`` it reads the program file the stored bundle names. With
+    ``path`` it reads that archive-relative member. It decodes the file with the
+    encoding the file declares in a PEP 263 coding comment, and with UTF-8 when
+    the file declares none.
+    """
+    client = _http.ApiClient(api_key, endpoint)
+    route = f"/api/v1/deployments/{deployment_id}/source"
+    if path is None:
+        path = client.get(route).get("program")
+        if not path:
+            raise _http.ApiError(f"the stored source of deployment {deployment_id} names no program file")
+    raw = client.get_bytes(route, params={"path": path})
+    encoding, _lines = tokenize.detect_encoding(io.BytesIO(raw).readline)
+    return raw.decode(encoding)

{cmpnd-0.66.0 → cmpnd-0.67.0}/cmpnd/cli/__init__.py

@@ -107,7 +107,11 @@ def parse(parser: argparse.ArgumentParser, argv: list[str]) -> argparse.Namespac
 def main() -> None:
     parser = tree_help.TreeHelpParser(
         prog="cmpnd",
-        description="CMPND platform CLI — deploy, run, and inspect DSPy programs.",
+        description=(
+            "CMPND platform CLI — deploy, run, and inspect DSPy programs.\n\n"
+            "The top-level commands are the Docker-style deploy-and-run loop. ps, run and inspect are\n"
+            "shortcuts for deployments list, run and show."
+        ),
         epilog=_EPILOG,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )

{cmpnd-0.66.0 → cmpnd-0.67.0}/cmpnd/cli/commands/provider_credentials.py

@@ -5,7 +5,7 @@ platform spend on your behalf when a program of yours runs?
 
     cmpnd credentials create --name luna-exec --preset lunaroute       # a model provider
     cmpnd credentials create --kind mcp --server URL --name n …         # an MCP tool server
-    cmpnd credentials list
+    cmpnd credentials list --text
     cmpnd credentials protocols luna-exec --add system_one
     cmpnd credentials default luna-exec
     cmpnd credentials delete --name luna-exec --force
@@ -70,7 +70,7 @@ import sys
 from argparse import ArgumentParser, _SubParsersAction
 from typing import Any
 
-from .. import api_client, deprecation
+from .. import api_client, deprecation, views
 
 #: The placements the platform's credentialed egress can compose a credential into.
 #: Closed set, and the same three strings `cmpnd.mcp_tools`'s auth shapes record.
@@ -156,7 +156,7 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     deprecation.alias(sub, "add", "create", func=handle_create, configure=_seal_args)
 
     listing = sub.add_parser("list", help="Show your org's credentials, their protocols and the default")
-    listing.add_argument("--json", action="store_true", help="Emit the raw JSON instead of the rendering")
+    views.add_text_flag(listing)
     listing.set_defaults(func=handle_list)
 
     protocols = sub.add_parser(
@@ -393,7 +393,7 @@ def handle_list(client: api_client.ApiClient, args: Any) -> Any:
     # Metadata only: the platform's projection carries no key material, not even its
     # length, so there is nothing here to redact.
     payload = client.get(_ROOT)
-    if getattr(args, "json", False) or not isinstance(payload, dict):
+    if not getattr(args, "text", False) or not isinstance(payload, dict):
         return payload
     credentials = [c for c in payload.get("credentials") or [] if isinstance(c, dict)]
     default = payload.get("default")

{cmpnd-0.66.0 → cmpnd-0.67.0}/cmpnd/cli/commands/tool_servers.py

@@ -6,8 +6,8 @@ agreed those declarations may reach. A server here carries the credential it is
 with, and the allow-list of tools on it a deploy is permitted to name.
 
     cmpnd tool-servers create --url https://mcp.exa.ai/mcp --credential exa-prod
-    cmpnd tool-servers list
-    cmpnd tool-servers show <server_id>
+    cmpnd tool-servers list --text
+    cmpnd tool-servers show <server_id> --text
     cmpnd tool-servers allow <server_id> web_search_exa
     cmpnd tool-servers deny <server_id> --all
     cmpnd tool-servers refresh <server_id>
@@ -48,7 +48,7 @@ import json
 from argparse import ArgumentParser, _SubParsersAction
 from typing import Any
 
-from .. import api_client
+from .. import api_client, views
 from . import provider_credentials
 
 _ROOT = "/api/v1/org/tool-servers"
@@ -66,7 +66,7 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     create.set_defaults(func=handle_create)
 
     listing = sub.add_parser("list", help="Show the tool servers your org has registered")
-    listing.add_argument("--json", action="store_true", help="Emit the raw JSON instead of the rendering")
+    views.add_text_flag(listing)
     listing.set_defaults(func=handle_list)
 
     show = sub.add_parser("show", help="Show one server, its credential, and its tools")
@@ -74,9 +74,9 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     show.add_argument(
         "--schemas",
         action="store_true",
-        help="Also print each tool's reduced argument schema — the shape the platform will enforce",
+        help="With --text, also print each tool's reduced argument schema — the shape the platform will enforce",
     )
-    show.add_argument("--json", action="store_true", help="Emit the raw JSON instead of the rendering")
+    views.add_text_flag(show)
     show.set_defaults(func=handle_show)
 
     for verb, effect in (
@@ -232,7 +232,7 @@ def handle_create(client: api_client.ApiClient, args: Any) -> Any:
 
 def handle_list(client: api_client.ApiClient, args: Any) -> Any:
     payload = client.get(_ROOT)
-    if getattr(args, "json", False):
+    if not getattr(args, "text", False):
         return payload
     servers = _servers(payload)
     if not servers:
@@ -246,13 +246,13 @@ def handle_list(client: api_client.ApiClient, args: Any) -> Any:
             f"{str(server.get('id', '')).ljust(14)} {str(server.get('name') or '').ljust(16)} "
             f"{server.get('url', '')}  [{server.get('credential_name') or 'no credential'}]"
         )
-    print("Read one server's tools and its allow-list with `cmpnd tool-servers show <server_id>`.")
+    print("Read one server's tools and its allow-list with `cmpnd tool-servers show <server_id> --text`.")
     return None
 
 
 def handle_show(client: api_client.ApiClient, args: Any) -> Any:
     server = client.get(f"{_ROOT}/{args.server_id}")
-    if getattr(args, "json", False):
+    if not getattr(args, "text", False):
         return server
     _render_server(server if isinstance(server, dict) else {}, schemas=getattr(args, "schemas", False))
     return None
@@ -283,7 +283,7 @@ def _grant(client: api_client.ApiClient, args: Any, verb: str) -> Any:
     if not getattr(args, "all", False) and not tools:
         raise SystemExit(
             f"`tool-servers {verb}` needs at least one tool name, or --all. Run "
-            f"`cmpnd tool-servers show {args.server_id}` to see what this server lists."
+            f"`cmpnd tool-servers show {args.server_id} --text` to see what this server lists."
         )
     body: dict[str, Any] = {"all": True} if getattr(args, "all", False) else {"tools": tools}
     server = client.post(f"{_ROOT}/{args.server_id}/{verb}", json=body)

{cmpnd-0.66.0 → cmpnd-0.67.0}/cmpnd/cli/commands/top.py

@@ -1301,10 +1301,22 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     def _handler(name: str) -> Any:
         return verbs.by_name(name).handler
 
+    # A verb that repeats a namespaced command says so first, from its VERBS
+    # row, so `cmpnd -h` tells a shortcut from a separate feature.
+    def _help(name: str, text: str = "") -> str:
+        shortcut_for = verbs.by_name(name).shortcut_for
+        if not shortcut_for:
+            return text
+        prefix = f"Shortcut for `cmpnd {shortcut_for}`"
+        return f"{prefix}; {text}" if text else prefix
+
     ps = subparsers.add_parser(
         "ps",
-        help="List deployments (Docker-style)",
-        description="List deployments belonging to the calling org, newest first.",
+        help=_help("ps", "renders a table"),
+        description=(
+            "List deployments belonging to the calling org, newest first. Shortcut for "
+            "`cmpnd deployments list` that renders a table; --json prints the same response."
+        ),
         epilog="Examples:\n  cmpnd ps\n  cmpnd ps --status ready --json\n",
         formatter_class=raw,
     )
@@ -1352,8 +1364,11 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
     insp = subparsers.add_parser(
         "inspect",
-        help="Full JSON for a deployment",
-        description="Print the full deployment record as JSON. Equivalent to `cmpnd status <id> --json`.",
+        help=_help("inspect", "--source prints the stored program"),
+        description=(
+            "Print the full deployment record as JSON, as `cmpnd deployments show` does. "
+            "--source prints the deployment's stored program file instead."
+        ),
         formatter_class=raw,
     )
     insp.add_argument("id")
@@ -1396,8 +1411,11 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
 
     rn = subparsers.add_parser(
         "run",
-        help="Run a deployment with a JSON input body",
-        description="Submit one durable run to a ready deployment and wait for its result.",
+        help=_help("run"),
+        description=(
+            "Submit one durable run to a ready deployment and wait for its result. "
+            "Shortcut for `cmpnd deployments run`."
+        ),
         epilog=(
             "Examples:\n"
             '  cmpnd run d_a1b2c3d4 \'{"question": "what is dspy?"}\'\n'

{cmpnd-0.66.0 → cmpnd-0.67.0}/cmpnd/cli/verbs.py

@@ -41,7 +41,9 @@ class Verb:
     ``deploy(path)``); ``"entity"`` binds it as a method on
     ``shell_entity`` (e.g. ``deps.d_xxx.status()``). ``shell_method``
     defaults to ``name`` and gives the registry a single hook to rename
-    a method without the hint helpers going stale.
+    a method without the hint helpers going stale. ``shortcut_for`` names the
+    namespaced command a verb repeats, such as ``"deployments list"`` for
+    ``ps``. Its CLI help starts with "Shortcut for `cmpnd deployments list`".
     """
 
     name: str
@@ -49,6 +51,7 @@ class Verb:
     shell_kind: Literal["top_level", "entity"]
     shell_entity: str | None = None
     shell_method: str | None = None
+    shortcut_for: str | None = None
 
     def __post_init__(self) -> None:
         if self.shell_kind == "entity" and not self.shell_entity:
@@ -65,13 +68,13 @@ class Verb:
 # functions (`_shell_method`, `register`), never at module scope.
 # Module-scope binding also makes the table trivially inspectable.
 _VERBS: tuple["Verb", ...] = (
-    Verb("ps", commands.top.cmd_ps, "top_level"),
+    Verb("ps", commands.top.cmd_ps, "top_level", shortcut_for="deployments list"),
     Verb("deploy", commands.top.cmd_deploy, "top_level"),
     Verb("optimize", commands.top.cmd_optimize, "top_level"),
     Verb("status", commands.top.cmd_status, "entity", "Deployment"),
     Verb("logs", commands.top.cmd_logs, "entity", "Deployment"),
-    Verb("inspect", commands.top.cmd_inspect, "entity", "Deployment"),
-    Verb("run", commands.top.cmd_run, "entity", "Deployment"),
+    Verb("inspect", commands.top.cmd_inspect, "entity", "Deployment", shortcut_for="deployments show"),
+    Verb("run", commands.top.cmd_run, "entity", "Deployment", shortcut_for="deployments run"),
     Verb("schema", commands.top.cmd_schema, "entity", "Deployment"),
     Verb("sample", commands.top.cmd_sample, "entity", "Deployment"),
 )

cmpnd-0.67.0/cmpnd/cli/views.py

@@ -0,0 +1,25 @@
+"""The output rule for namespaced commands.
+
+A namespaced read, such as `cmpnd traces show` or `cmpnd tool-servers list`, prints
+the platform's JSON by default, and a human view is an opt-in flag: `--tree` and
+`--timeline` on `traces show`, `--text` on the reads below. An action command may
+print a short result instead and take `--json` for the whole answer, as
+`cmpnd programs create` prints the id. The top-level commands (`cmpnd ps`,
+`cmpnd status`) are the human loop: they render text and take `--json`.
+`tests/test_cli/test_parity.py` refuses a namespaced read that offers `--json`.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+
+def add_text_flag(parser: argparse.ArgumentParser) -> None:
+    """Give a namespaced read the opt-in `--text` view.
+
+    Some reads rendered text by default and took `--json` before the CLI settled on
+    the rule, so `--json` stays accepted and hidden, and a script that passes it
+    keeps working.
+    """
+    parser.add_argument("--text", action="store_true", help="Render for a person instead of printing JSON")
+    parser.add_argument("--json", action="store_true", help=argparse.SUPPRESS)

{cmpnd-0.66.0 → cmpnd-0.67.0}/cmpnd/client.py

@@ -836,6 +836,47 @@ class Client:
 
         return optimization.list_candidates(run_id, cfg=self._config)
 
+    def list_deployments(
+        self, *, status: str | None = None, since: str | None = None, limit: int = 50, offset: int = 0
+    ) -> list[dict[str, Any]]:
+        """The organization's deployments, newest first.
+
+        Returns the list itself, not the response envelope. ``status`` is one of
+        ``pending``, ``parsing``, ``optimizing``, ``ready`` or ``failed``, and
+        ``since`` is an ISO 8601 timestamp. ``offset`` must be a whole multiple of
+        ``limit``, because the route pages by page number. ``limit`` must not
+        exceed 500, the most deployments the route returns per page.
+        """
+        self._check_active()
+        page = _deployments.list_deployments(
+            status=status,
+            since=since,
+            limit=limit,
+            offset=offset,
+            api_key=self._config.api_key,
+            endpoint=self._config.endpoint,
+        )
+        return page.get("deployments", [])
+
+    def get_deployment(self, deployment_id: str) -> dict[str, Any]:
+        """Fetch one deployment's record: its status, program, model and metadata."""
+        self._check_active()
+        return _deployments.get_deployment(deployment_id, api_key=self._config.api_key, endpoint=self._config.endpoint)
+
+    def get_deployment_source(self, deployment_id: str, path: str | None = None) -> str:
+        """Read the program source a deployment stores, as text.
+
+        Without ``path`` it returns the program file the deployment runs. A
+        continuation's deployment holds the chosen candidate's program, so this
+        reads what the continuation runs. ``path`` names another archive-relative
+        file of the stored bundle. The file decodes with the encoding its PEP 263
+        coding comment declares, and with UTF-8 when it declares none.
+        """
+        self._check_active()
+        return _deployments.get_source(
+            deployment_id, path=path, api_key=self._config.api_key, endpoint=self._config.endpoint
+        )
+
     def get_deployment_signature(self, deployment_id: str) -> DeploymentSignatureResponse:
         """Fetch one deployment's persisted artifact metadata."""
         self._check_active()

{cmpnd-0.66.0 → cmpnd-0.67.0}/cmpnd/deployment.py

@@ -345,7 +345,7 @@ def _resolve_mcp_tool_references(client: httpx.Client, config, references: list[
                 f"your organization's registry holds no tool named {reference.tool_name!r} on "
                 f"{reference.server_url}, so this deploy cannot pin the schema its calls would be "
                 "validated against. Read what the registry does hold with "
-                f"`cmpnd tool-servers show {server_id}`, and if the server has grown the tool since it "
+                f"`cmpnd tool-servers show {server_id} --text`, and if the server has grown the tool since it "
                 f"was registered, `cmpnd tool-servers refresh {server_id}` re-reads its listing."
             )
         pinned[(reference.server_url, reference.tool_name)] = mcp_servers.PinnedTool(

{cmpnd-0.66.0 → cmpnd-0.67.0}/docs/cli.md

@@ -154,11 +154,28 @@ release without the warning, set `CMPND_NO_UPGRADE_WARNING=1`. In code,
 `warnings.filterwarnings("ignore", category=cmpnd.UpgradeRequiredWarning)`
 does the same.
 
+## Output of namespaced and top-level commands
+
+A namespaced read, such as `cmpnd traces show`, `cmpnd deployments list` or
+`cmpnd tool-servers list`, prints the API's JSON by default, so a script can
+pipe it to `jq`. A human view is an opt-in flag: `--tree` and `--timeline` on
+`traces show`, and `--text` on `tool-servers list`, `tool-servers show` and
+`credentials list`. Those three accept `--json` as well, so older scripts keep
+working. An action command may print a short result and take `--json` for the
+whole answer: `cmpnd programs create` prints the new id, and
+`cmpnd optimizations continue` prints the best deployment. The top-level
+commands below are the human loop: they render text and take `--json`.
+`cmpnd/cli/views.py` states the rule, and `tests/test_cli/test_parity.py`
+refuses a namespaced read that offers `--json`.
+
 ## Deploy flow (Docker-style)
 
 These commands print human-readable output by default. Each takes `--json` for
 a stable, scriptable shape. A deployment ID may be any unambiguous prefix,
-such as `d_a1b2c3d4`.
+such as `d_a1b2c3d4`. Three of them are shortcuts, and their help says so:
+`cmpnd ps` repeats `cmpnd deployments list`, `cmpnd run` repeats
+`cmpnd deployments run`, and `cmpnd inspect` repeats `cmpnd deployments show`.
+`Verb.shortcut_for` in `cmpnd/cli/verbs.py` declares each one.
 
 - `cmpnd deploy <source.py|-> PROGRAM_NAME [--entrypoint ATTRIBUTE]
   [--source-root DIR] [--include PATH ...] [--run <json>] [--metadata <json>]`
@@ -560,10 +577,10 @@ cmpnd credentials create --name luna-exec --preset lunaroute < key.txt
 op read 'op://vault/openai/key' | cmpnd credentials create --name openai --preset openai
 ```
 
-`cmpnd credentials list` shows each credential's protocols, whether its host
-implies them, its address and the org's default. A member sees the scheme and
-host of the address, and an owner sees the whole of it. `--json` prints the
-listing as the API returns it.
+`cmpnd credentials list` prints the listing as the API returns it: each
+credential's protocols, whether its host implies them, its address and the
+org's default. `--text` renders it for a person. A member sees the scheme and
+host of the address, and an owner sees the whole of it.
 
 `cmpnd credentials protocols NAME` shows a credential's protocols. `--add` and
 `--remove` start from them, whether stated or implied by the host, and `--set`
@@ -620,18 +637,19 @@ server, the credential it uses and the allow-list of tools a deploy may name.
 
 ```bash
 cmpnd tool-servers create --url https://mcp.exa.ai/mcp --credential exa-prod [--name exa]
-cmpnd tool-servers list
-cmpnd tool-servers show <server_id> [--schemas]
+cmpnd tool-servers list [--text]
+cmpnd tool-servers show <server_id> [--text [--schemas]]
 cmpnd tool-servers refresh <server_id>
 cmpnd tool-servers delete <server_id> --force
 ```
 
 `create` registers the server and has the platform list its tools. The
 platform contacts the server, and the CLI never does. `refresh` lists the
-tools again after a vendor changes them. `show` prints each tool with its
-allow-list state and a one-line description. `--schemas` adds the reduced
-argument schema the platform enforces. Every command takes `--json` for the
-raw payload.
+tools again after a vendor changes them. `list` and `show` print the API's
+JSON. With `--text`, `show` prints each tool with its allow-list state and a
+one-line description, and `--schemas` adds the reduced argument schema the
+platform enforces. `create`, `allow`, `deny` and `refresh` render the server
+as it now stands, and `--json` prints the raw payload instead.
 
 When the platform cannot list a server's tools because of the server itself,
 `create` and `refresh` fail with a `424` that names the URL, the credential and
@@ -881,7 +899,7 @@ creator after the creator leaves. The customer then:
    same name, and `cmpnd credentials create --kind mcp --server URL
    --name NAME` with the same server and name, replace the sealed keys in
    place. The tool server and the deployment keep pointing at them.
-3. Runs `cmpnd tool-servers show SERVER_ID` and
+3. Runs `cmpnd tool-servers show SERVER_ID --text` and
    `cmpnd tool-servers refresh SERVER_ID` to read the tools and allow-list
    under the new key.
 4. Runs `cmpnd ps`, `cmpnd sample ID` and `cmpnd run ID '<json>'`. The

{cmpnd-0.66.0 → cmpnd-0.67.0}/docs/client.md

@@ -211,8 +211,13 @@ methods:
 
 - Traces: `sdk.list_traces(**filters)` and `sdk.get_trace(trace_id)`. The
   `program=` filter takes a program name or a `p_` id.
-- Deployments: `sdk.get_deployment_signature(deployment_id)` returns the
-  selected artifact's typed metadata. It reads no worker status or executions.
+- Deployments: `sdk.list_deployments(status=..., since=..., limit=...,
+  offset=...)` lists the organization's deployments, newest first.
+  `sdk.get_deployment(deployment_id)` returns one deployment's record.
+  `sdk.get_deployment_source(deployment_id, path=None)` returns the program
+  file the deployment stores, or the archive-relative file `path` names.
+  `sdk.get_deployment_signature(deployment_id)` returns the selected
+  artifact's typed metadata. It reads no worker status or executions.
 - Assessments, in development behind `CMPND_CLI_DEV=1`:
   `sdk.create_assessment(trace_id, conclusion=..., body=...,
   annotations=...)`, `sdk.list_assessments(program=... | trace_id=...,

{cmpnd-0.66.0 → cmpnd-0.67.0}/pyproject.toml

@@ -5,7 +5,7 @@ name = "cmpnd"
 # it's new) — no git tags. Bump with `uv version --bump {minor,patch}` or by
 # hand. Runtime `cmpnd.__version__` reads installed metadata, so it tracks
 # this automatically. See docs/plans/2026-07-02-sdk-pypi-tag-free-publish.md.
-version = "0.66.0"
+version = "0.67.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -261,7 +261,7 @@ select = ["E", "F", "I", "W"]
 # attributes cmpnd reads. We co-maintain dspy, so the stubs stay in
 # sync with the real package by hand. See stubs/dspy/__init__.pyi.
 [tool.basedpyright]
-# `cmpnd` is the SDK source (strict bar). `tests/stress` and all of `tests/e2e`
+# `cmpnd` is the SDK source (strict bar). `tests/real_models` and all of `tests/e2e`
 # are checked too, with relaxed rules in the executionEnvironments below — so a
 # stale `cmpnd.*` reference in a test (PR #163 shipped a
 # `cmpnd.identity.program_hash_for_sig` that crashed at runtime; see CMP-154)
@@ -275,7 +275,7 @@ select = ["E", "F", "I", "W"]
 # the exporter's private counters and monkeypatch its methods, so a rename in the
 # transport turns a rig into a lie rather than an error. It typechecks clean with
 # no relaxations, so it gets no executionEnvironment of its own.
-include = ["cmpnd", "ingest/cmpnd_ingest", "examples", "tests/stress", "tests/e2e", "tests/load"]
+include = ["cmpnd", "ingest/cmpnd_ingest", "examples", "tests/real_models", "tests/e2e", "tests/load"]
 stubPath = "stubs"
 pythonVersion = "3.11"
 reportAny = false
@@ -304,9 +304,9 @@ root = "examples"
 reportArgumentType = false
 
 # Test files inherit every rule above and relax a few more. These overrides
-# apply only to files under tests/stress; `cmpnd` source keeps the strict bar.
+# apply only to files under tests/real_models; `cmpnd` source keeps the strict bar.
 [[tool.basedpyright.executionEnvironments]]
-root = "tests/stress"
+root = "tests/real_models"
 # DSPy dynamic-API noise: e.g. dspy.Predict("q -> a") is read as a `callbacks`
 # argument. These two rules are what make a full tests/ scope unviable
 # (~850 false positives); reportAttributeAccessIssue stays on.

{cmpnd-0.66.0 → cmpnd-0.67.0}/scripts/capture_review_run.py

@@ -6,7 +6,7 @@ review app. The fixture is a list of `{"kind", "payload"}` items — one per SDK
 exporter HTTP call — captured by hooking `cmpnd.exporter_http._send_json` (the single
 chokepoint every export POST routes through) while running the exact committee
 GEPA optimization the stress suite runs
-(`tests/stress/test_optimize_client_committee.py` → `tests/e2e/committee_task`):
+(`tests/real_models/test_optimize_client_committee.py` → `tests/e2e/committee_task`):
 a weak Bedrock student + a Bedrock reflection LM over the vendored committee
 subset. Capturing a *real* run (rather than fabricating payloads) keeps the seed
 faithful — real prompts, token counts, span trees, and now the GEPA optimizer

cmpnd-0.67.0/scripts/release-gate.sh

@@ -0,0 +1,11 @@
+#!/usr/bin/env bash
+# CI dependency: .github/workflows/release-staging.yml and release-prod.yml.
+#
+# The release gate that calls no model: it ingests one trace into the
+# just-released stack and searches for it. A provider outage cannot fail it, so
+# it can block a merge.
+set -euo pipefail
+
+uv run --extra dev python -m pytest \
+  tests/real_models/test_trace_search.py \
+  -v -rs

cmpnd-0.67.0/scripts/release-real-models.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# CI dependency: .github/workflows/release-staging.yml and release-prod.yml.
+#
+# The real-model suite: tests that call real providers against a released stack.
+# It blocks no merge. The release gate (release-gate.sh) runs test_trace_search.py,
+# which calls no model, so this script leaves it out.
+set -euo pipefail
+
+uv run --extra dev python -m pytest \
+  tests/real_models/ \
+  --ignore=tests/real_models/test_trace_search.py \
+  -m "forall_workers or worker_independent" \
+  -v -rs \
+  --reruns 2 --reruns-delay 120 \
+  --only-rerun "RetryableProviderError"

{cmpnd-0.66.0 → cmpnd-0.67.0}/scripts/seed_review_run.py

@@ -2,7 +2,7 @@
 """Replay a captured real optimization run into a review app each deploy.
 
 A live GEPA against a review app (real third-party inference) is the stress suite's
-job (tests/stress/test_optimize_client_committee.py). For per-deploy review data we
+job (tests/real_models/test_optimize_client_committee.py). For per-deploy review data we
 instead replay a **captured real run** (real emails, token counts, span trees,
 datasets) from `fixtures/review_run.json.gz` — the exact SDK export payloads of one
 real run — so every review app is born with a realistic optimization + its traces