cmpnd 0.40.1__tar.gz → 0.41.0__tar.gz

{cmpnd-0.40.1 → cmpnd-0.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.40.1
+Version: 0.41.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
 Requires-Dist: dspy>=3.1.3
@@ -27,8 +28,10 @@ Requires-Dist: xxhash>=3.0.0
 Provides-Extra: dev
 Requires-Dist: basedpyright>=1.39; extra == 'dev'
 Requires-Dist: boto3>=1.34; extra == 'dev'
+Requires-Dist: gepa; extra == 'dev'
 Requires-Dist: hypothesis>=6.100; extra == 'dev'
 Requires-Dist: jsonschema>=4.0; extra == 'dev'
+Requires-Dist: litellm; extra == 'dev'
 Requires-Dist: numpy>=1.26; (python_version < '3.11') and extra == 'dev'
 Requires-Dist: numpy>=2.3; (python_version >= '3.11') and extra == 'dev'
 Requires-Dist: pandas>=2.2; extra == 'dev'
@@ -161,7 +164,7 @@ cmpnd.deploy(
     metric=None,       # optional: a metric callable, packaged for optimization
     timeout=300,       # optional: seconds to wait for the parser after the upload
     metadata=None,     # optional: a JSON-serializable dict, at most 64 KiB, stored with the deployment
-    program_id="p_…",  # required unless configured: the program the deployment belongs to
+    program_id="p_…",  # the program the deployment belongs to; serve requires it after self-host 2026-001
 )
 ```
 

{cmpnd-0.40.1 → cmpnd-0.41.0}/README.md

@@ -111,7 +111,7 @@ cmpnd.deploy(
     metric=None,       # optional: a metric callable, packaged for optimization
     timeout=300,       # optional: seconds to wait for the parser after the upload
     metadata=None,     # optional: a JSON-serializable dict, at most 64 KiB, stored with the deployment
-    program_id="p_…",  # required unless configured: the program the deployment belongs to
+    program_id="p_…",  # the program the deployment belongs to; serve requires it after self-host 2026-001
 )
 ```
 

{cmpnd-0.40.1 → cmpnd-0.41.0}/cmpnd/cli/commands/top.py

@@ -811,11 +811,12 @@ def _parse_deploy_metadata(raw: str | None) -> dict[str, Any] | None:
         raise api_client.CliError(f"--metadata is invalid: {exc}")
 
 
-def _program_id_arg(value: str | None, *, required: bool) -> str | None:
+def _program_id_arg(value: str | None) -> str | None:
     """The program id a deploy or optimize names: ``--program-id``, else ``CMPND_PROGRAM_ID``.
 
-    Checked here, before a file is staged, so a missing or mistyped id is a usage
-    error naming the flag rather than a refusal after work was done.
+    Checked here, before a file is staged, so a mistyped id is a usage error naming
+    its source rather than a refusal after work was done. serve decides whether a
+    deployment needs an id, so a missing one is not refused here.
     """
     from ... import identity
 
@@ -823,12 +824,6 @@ def _program_id_arg(value: str | None, *, required: bool) -> str | None:
     if value is None and os.environ.get("CMPND_PROGRAM_ID"):
         value, source = os.environ["CMPND_PROGRAM_ID"], "CMPND_PROGRAM_ID"
     if value is None:
-        if required:
-            raise api_client.CliError(
-                "--program-id is required: a deployment always names its program. "
-                "Create one with `cmpnd programs create`, then pass --program-id p_… "
-                "(or set CMPND_PROGRAM_ID)."
-            )
         return None
     try:
         return identity.validate_program_id(value, source=source)
@@ -855,9 +850,7 @@ def cmd_deploy(client: api_client.ApiClient, args: Any) -> None:
 
     from ... import authored, configuration, deployment
 
-    # Refused before the file is staged or anything is sent: a deployment always
-    # names its program, and the server would refuse the create anyway.
-    program_id = _program_id_arg(getattr(args, "program_id", None), required=True)
+    program_id = _program_id_arg(getattr(args, "program_id", None))
     configuration.configure(api_key=client._api_key, endpoint=client._endpoint, program_id=program_id)
     try:
         if args.source == "-" or args.source is None:
@@ -881,7 +874,10 @@ def cmd_deploy(client: api_client.ApiClient, args: Any) -> None:
 
     metadata = _parse_deploy_metadata(getattr(args, "metadata", None))
     print(_c("deploying…", "dim"), file=sys.stderr)
-    deployed = deployment.deploy_bundle(prepared.bundle, prepared.facts, metadata=metadata, program_id=program_id)
+    try:
+        deployed = deployment.deploy_bundle(prepared.bundle, prepared.facts, metadata=metadata, program_id=program_id)
+    except ValueError as exc:
+        raise api_client.CliError(str(exc)) from exc
 
     deployment_id = deployed.deployment_id
     print(deployment_id)
@@ -946,9 +942,7 @@ def cmd_optimize(client: api_client.ApiClient, args: Any) -> Any:
     from ... import authored, configuration, optimization
 
     deployment_id = getattr(args, "deployment_id", None)
-    # Required only when the file's program is deployed here; a reused deployment
-    # already names its program.
-    program_id = _program_id_arg(getattr(args, "program_id", None), required=deployment_id is None)
+    program_id = _program_id_arg(getattr(args, "program_id", None))
     configuration.configure(api_key=client._api_key, endpoint=client._endpoint, program_id=program_id)
     try:
         if args.source == "-" or args.source is None:
@@ -1266,7 +1260,7 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         dest="program_id",
         default=None,
         help="Program id (p_…) the deployment belongs to, from `cmpnd programs create`. "
-        "Required; defaults to CMPND_PROGRAM_ID",
+        "Defaults to CMPND_PROGRAM_ID. Required by every serve after self-host release 2026-001",
     )
     dp.add_argument(
         "--entrypoint",
@@ -1351,8 +1345,8 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         dest="program_id",
         default=None,
         help="Program id (p_…) being optimized, from `cmpnd programs create`; defaults to "
-        "CMPND_PROGRAM_ID. Required when the file's program is deployed here, optional "
-        "with --deployment-id",
+        "CMPND_PROGRAM_ID. Required by every serve after self-host release 2026-001 when "
+        "the file's program is deployed here, optional with --deployment-id",
     )
     opt.add_argument(
         "--reflection-model",

{cmpnd-0.40.1 → cmpnd-0.41.0}/cmpnd/cli/shell.py

@@ -490,8 +490,8 @@ def _make_namespace(client: api_client.ApiClient, endpoint: str) -> dict[str, An
         """Deploy authored Python from a file or ``"-"`` for stdin.
 
         ``program_id`` (``p_…``, from ``cmpnd programs create``) names the program
-        the deployment belongs to; it defaults to ``CMPND_PROGRAM_ID`` and one of
-        the two is required. A fresh child imports the staged bundle. The shell
+        the deployment belongs to; it defaults to ``CMPND_PROGRAM_ID``. serve
+        decides whether a deployment needs one. A fresh child imports the staged bundle. The shell
         does not execute the file in its own process. Returns the
         new Deployment entity so you can chain ``.watch()`` / ``.run({...})``
         directly; also invalidates ``deps`` so the new deployment shows up
@@ -499,7 +499,7 @@ def _make_namespace(client: api_client.ApiClient, endpoint: str) -> dict[str, An
         """
         from .. import authored, configuration, deployment
 
-        declared = commands.top._program_id_arg(program_id, required=True)
+        declared = commands.top._program_id_arg(program_id)
         configuration.configure(api_key=client._api_key, endpoint=client._endpoint, program_id=declared)
         if source in ("-", None):
             prepared = authored.prepare_stdin(

{cmpnd-0.40.1 → cmpnd-0.41.0}/cmpnd/deployment.py

@@ -346,21 +346,35 @@ def _resolve_mcp_tool_references(client: httpx.Client, config, references: list[
 
 
 MISSING_PROGRAM_ID = (
-    "deploying needs a program id: pass program_id= (`cmpnd deploy --program-id`), or set "
+    "this server requires a program id: pass program_id= (`cmpnd deploy --program-id`), or set "
     "cmpnd.configure(program_id=...) or CMPND_PROGRAM_ID. Create one with `cmpnd programs create`."
 )
 
+# The error serve answers, with a 400, to a create that names no program. A serve
+# from before program ids accepts the create instead. serve pins this prefix in
+# deploymentsapi.missingProgramIDError.
+_SERVE_MISSING_PROGRAM_ID = "program_id is required"
 
-def require_program_id(explicit: str | None, config: configuration.Config) -> str:
+
+def declared_program_id(explicit: str | None, config: configuration.Config) -> str | None:
     """The program a deployment is created under: the explicit id, else the configured one.
 
-    A deployment always names its program, so a missing id is refused here, before
-    anything is packaged or sent, rather than by the server after a create.
+    A declared id is checked for shape before anything is packaged or sent. serve
+    decides whether a deployment needs an id, so a missing one is not refused here.
     """
     chosen = explicit if explicit is not None else config.program_id
-    if chosen is None:
-        raise ValueError(MISSING_PROGRAM_ID)
-    return identity.validate_program_id(chosen)
+    return identity.validate_program_id(chosen) if chosen is not None else None
+
+
+def _refused_for_missing_program_id(response: httpx.Response, deploy_body: dict[str, Any]) -> bool:
+    """Whether serve refused a create that named no program because it needs one."""
+    if response.status_code != 400 or "program_id" in deploy_body:
+        return False
+    try:
+        error = response.json().get("error")
+    except (ValueError, AttributeError):
+        return False
+    return isinstance(error, str) and error.startswith(_SERVE_MISSING_PROGRAM_ID)
 
 
 def deploy(module, metric=None, timeout=300, metadata=None, *, program_id=None):
@@ -387,22 +401,24 @@ def deploy(module, metric=None, timeout=300, metadata=None, *, program_id=None):
             with string keys, within 64 KiB. Read it back via the deployment
             record (``cmpnd.status`` / the deployment GET API).
         program_id: The program (``p_…``) the deployment belongs to, as
-            ``cmpnd programs create`` printed it. Required: when omitted, the
-            configured id (``cmpnd.configure(program_id=...)`` or
-            ``CMPND_PROGRAM_ID``) is used, and with neither the deploy is
-            refused before anything is packaged.
+            ``cmpnd programs create`` printed it. When omitted, the configured
+            id (``cmpnd.configure(program_id=...)`` or ``CMPND_PROGRAM_ID``) is
+            used. With neither, the create names no program, and serve decides:
+            every serve with program ids refuses it, and a serve from before
+            them, such as self-host release 2026-001, accepts it.
 
     Returns:
         A DeployedProgram that can be called with the same inputs as the
         original module. Has a .deployment_id attribute and str() returns it.
 
     Raises:
-        ValueError: If no program id is given or configured, or it is malformed.
+        ValueError: If the program id is malformed, or if serve requires one and
+            none was given or configured.
         RuntimeError: If cmpnd is not configured, or if deployment fails.
         TimeoutError: If the program isn't ready within timeout seconds.
     """
     config = configuration.require_config()
-    declared_program_id = require_program_id(program_id, config)
+    program = declared_program_id(program_id, config)
 
     # Resolve the program's MCP tool references against the org's registry, before
     # anything is packaged and before a deployment row exists. A program with no MCP
@@ -423,12 +439,15 @@ def deploy(module, metric=None, timeout=300, metadata=None, *, program_id=None):
     program_signature_hash = identity.compute_program_hash(module) or 0
 
     deploy_body: dict[str, Any] = {
-        "program_id": declared_program_id,
         "program_signature_hash": identity.format_signature_hash(program_signature_hash),
         # Declare the ZIP's exact length so the server can size-bound the upload
         # slot and reject an oversized deploy before signing it (Slice E).
         "declared_content_length": len(zip_bytes),
     }
+    # Left off when undeclared, so a serve from before program ids reads the body it
+    # always read and a newer serve answers with its own refusal.
+    if program is not None:
+        deploy_body["program_id"] = program
     # Carry the caller's metadata blob (validated and made jsonb-storable at the
     # call site) as a reserved top-level body key, committed with the deployment
     # record server-side.
@@ -496,13 +515,14 @@ def deploy_bundle(
 ) -> execution.DeployedProgram:
     """Upload a checked authored-source bundle without packaging a live module.
 
-    ``program_id`` is required as it is for :func:`deploy`: the explicit id, else
-    the configured one, else a ``ValueError`` before anything is sent.
+    ``program_id`` works as it does for :func:`deploy`: the explicit id, else the
+    configured one, else none, and serve decides whether a deployment needs one.
     """
     config = configuration.require_config()
-    declared_program_id = require_program_id(program_id, config)
+    program = declared_program_id(program_id, config)
     deploy_body = facts.deploy_body()
-    deploy_body["program_id"] = declared_program_id
+    if program is not None:
+        deploy_body["program_id"] = program
     deploy_body["source_format"] = "authored"
     deploy_body["declared_content_length"] = len(zip_bytes)
     if metadata is not None:
@@ -531,6 +551,8 @@ def _deploy_prepared(
             may_resend_with_no_answer=retry.never_left_the_client,
             may_resend_after_answer=lambda _: False,
         )
+        if _refused_for_missing_program_id(created, deploy_body):
+            raise ValueError(MISSING_PROGRAM_ID)
         _raise_http_error(created, "create deployment")
         answer = created.json()
         deployment_id = answer["deployment_id"]

{cmpnd-0.40.1 → cmpnd-0.41.0}/cmpnd/optimization.py

@@ -38,7 +38,7 @@ from typing import TYPE_CHECKING, Any, Callable, cast
 import httpx
 from httpx import HTTPError
 
-from . import _deployments, _http, authored, configuration, deployment, execution, identity, packaging, retry
+from . import _deployments, _http, authored, configuration, deployment, execution, packaging, retry
 from .deployment_metadata import DeploymentMetadataError, DeploymentSignatureResponse
 
 if TYPE_CHECKING:
@@ -831,10 +831,11 @@ def optimize(
         deployment_id: Skip the initial deploy by reusing an existing ready
             deployment as program A.
         program_id: The program (``p_…``) being optimized. Defaults to the
-            configured id. Required when the program is deployed here (no
-            ``deployment_id``), because a deployment always names its program;
-            optional otherwise, since the deployment already names one. Sent on
-            the first optimize step, the one that optimizes your deployment.
+            configured id. When the program is deployed here (no
+            ``deployment_id``), the deploy carries it, and serve decides whether
+            that deploy needs one. A reused deployment already names its program.
+            Sent on the first optimize step, the one that optimizes your
+            deployment.
         reflection_lm: **Required** — the model that proposes new instructions.
             The search is only as good as it is, so this is a strong model,
             typically not the one being optimized. Pass the ``dspy.LM`` you would
@@ -925,7 +926,7 @@ def optimize(
     _apply_budget(config, max_metric_calls=max_metric_calls, auto=auto)
 
     cfg = configuration.require_config()
-    program_id = _declared_program_id(program_id, cfg, deploys=deployment_id is None)
+    program_id = deployment.declared_program_id(program_id, cfg)
 
     from . import lm_configuration
 
@@ -957,19 +958,6 @@ def optimize(
     return _deployed_program(best_deployment_id, cfg, score=best_score)
 
 
-def _declared_program_id(explicit: str | None, cfg: configuration.Config, *, deploys: bool) -> str | None:
-    """The program an optimization names: the explicit id, else the configured one.
-
-    Required when this call deploys the program, since a deployment always names its
-    program, and refused before anything is sent. Optional when an existing
-    deployment is reused, because that deployment already names one.
-    """
-    if deploys:
-        return deployment.require_program_id(explicit, cfg)
-    chosen = explicit if explicit is not None else cfg.program_id
-    return identity.validate_program_id(chosen) if chosen is not None else None
-
-
 def _run_steps(
     cfg: configuration.Config,
     bundle: bytes,
@@ -1094,8 +1082,8 @@ def optimize_authored(
     one directory on the executor, so a path they disagree about is refused, and it is
     worth refusing here where both files are in reach.
 
-    ``program_id`` is :func:`optimize`'s: required when the file's program is deployed
-    here, optional when ``deployment_id`` names the program.
+    ``program_id`` is :func:`optimize`'s: the deploy of the file's program carries it,
+    and serve decides whether that deploy needs one.
     """
     check_optimizer(optimizer)
     config = dict(config or {})
@@ -1111,7 +1099,7 @@ def optimize_authored(
     _apply_budget(config, max_metric_calls=max_metric_calls, auto=auto)
 
     cfg = configuration.require_config()
-    program_id = _declared_program_id(program_id, cfg, deploys=prepared.program_bundle is not None)
+    program_id = deployment.declared_program_id(program_id, cfg)
 
     facts = prepared.facts.program
     if prepared.program_bundle is not None:

{cmpnd-0.40.1 → cmpnd-0.41.0}/cmpnd/programs.py

@@ -19,6 +19,11 @@ from . import _http, configuration
 
 DEFAULT_ENDPOINT = "https://platform.cmpnd.ai"
 
+# Self-host release 2026-001 answers a programs create with 405, because it routes
+# GET requests under /api/v1/programs/ and has no create. Every newer serve accepts
+# the create, so on this one route a 405 means a serve from before program ids.
+UNSUPPORTED_STATUS = 405
+
 
 def create(
     name: str | None = None,
@@ -61,7 +66,18 @@ def send_create(
         body["name"] = name
     if optimized_from_run_id is not None:
         body["optimized_from_run_id"] = optimized_from_run_id
-    return client.post("/api/v1/programs", json=body)
+    try:
+        return client.post("/api/v1/programs", json=body)
+    except _http.ApiError as exc:
+        if exc.status_code == UNSUPPORTED_STATUS:
+            raise _http.ApiError(
+                "This server does not support program ids. A serve from before program ids, such as "
+                "self-host release 2026-001, deploys without one: run `cmpnd deploy` without "
+                f"--program-id.\n  {exc}",
+                exc.exit_code,
+                status_code=exc.status_code,
+            ) from exc
+        raise
 
 
 def _client(api_key: str | None, endpoint: str | None) -> _http.ApiClient:

{cmpnd-0.40.1 → cmpnd-0.41.0}/docs/cli.md

@@ -19,10 +19,15 @@ PROGRAM_ID=$(cmpnd programs create --name triage)
 ```
 
 The command reports what it created on stderr, and `--json` prints the whole
-registry row instead. `cmpnd deploy` requires the id. `cmpnd optimize` takes
-it as `--program-id` too. It is required when the command deploys the file's
-program first, and optional with `--deployment-id`, because that deployment
-already names its program. Each call creates a new program. The command never
+registry row instead. `cmpnd deploy` takes the id as `--program-id`, and so
+does `cmpnd optimize` when it deploys the file's program first. With
+`--deployment-id`, the id is optional because that deployment already names its
+program. The CLI checks a given id's shape and leaves the requirement to serve.
+Every serve after self-host release 2026-001 refuses a deploy with no id, and
+the CLI then names `--program-id` and `cmpnd programs create`. Self-host release
+2026-001 has no program ids, so a deploy there omits `--program-id`, and
+`cmpnd programs create` reports that the server does not support them. Each
+call creates a new program. The command never
 retries, because a second send would create a second program.
 `cmpnd.programs.create(name=...)` makes the same call from Python and returns
 the row.

{cmpnd-0.40.1 → cmpnd-0.41.0}/docs/sdk-instrumentation.md

@@ -757,11 +757,14 @@ the key is left off the wire rather than sent as `null`, so an undeclared trace
 it did before ids existed. The finalize body carries no id, because it restates no
 creation field.
 
-A deployment always names its program. `deploy()` and `deploy_bundle()` take
-`program_id=` and fall back to the configured id; with neither they raise `ValueError`
-before anything is packaged or sent (`deployment.require_program_id`). `optimize()` and
-`optimize_authored()` need the id only when they deploy the program themselves. A reused
-`deployment_id` already names its program, so the id is optional there. Later steps
+`deploy()` and `deploy_bundle()` take `program_id=` and fall back to the configured id
+(`deployment.declared_program_id`). A given id is checked for shape before anything is
+packaged or sent. With no id the create body leaves the key off, and serve decides.
+Every serve after self-host release 2026-001 refuses that create with a `400`, which the
+SDK raises as `ValueError` naming `cmpnd programs create`. Self-host release 2026-001
+has no program ids and accepts it. `optimize()` and `optimize_authored()` pass the id to
+the deploy when they deploy the program themselves. A reused `deployment_id` already
+names its program, so the id is optional there. Later steps
 optimize a result deployment the platform created and whose program it allocated, so
 the caller's id rides only the steps on the caller's own deployment.
 

{cmpnd-0.40.1 → cmpnd-0.41.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.40.1"
+version = "0.41.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -24,6 +24,7 @@ classifiers = [
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
     "Topic :: Software Development :: Libraries :: Python Modules",
 ]
 
@@ -95,6 +96,12 @@ dev = [
     "ruff>=0.4.0",
     "basedpyright>=1.39",
     "jsonschema>=4.0",
+    # The tests import litellm (tests/e2e/fake_lm.py and the modules that reuse it) and
+    # gepa directly. dspy 3.4.1 installs both only below Python 3.15, because both declare
+    # requires-python <3.15. uv ignores that upper bound, so the 3.15 test leg still
+    # installs them.
+    "litellm",
+    "gepa",
     # litellm's bedrock/ provider imports boto3 in-process, so the client-side
     # Bedrock stress tests (committee twins) need it in the test env.
     "boto3>=1.34",

cmpnd-0.41.0/scripts/check-pip-install.sh

@@ -0,0 +1,34 @@
+#!/usr/bin/env bash
+# Install cmpnd with pip's own resolver and check that the installed package
+# imports and instruments DSPy. Called by .github/workflows/ci-sdk.yml (the
+# sdk-test leg for Python 3.15).
+#
+# `pip install cmpnd` is the install PyPI advertises. pip honours the
+# requires-python upper bounds that uv ignores, so this check fails when no
+# dspy release admits the Python version. PYO3_USE_ABI3_FORWARD_COMPATIBILITY
+# is set to 0, so an extension without a wheel for this Python fails the
+# install and does not build from source.
+#
+# Usage: scripts/check-pip-install.sh <python-version> <dspy-version>
+#   e.g. scripts/check-pip-install.sh 3.15 3.4.1
+set -euo pipefail
+
+if [ "$#" -ne 2 ]; then
+    echo "usage: $0 <python-version> <dspy-version>" >&2
+    exit 2
+fi
+python_version=$1
+dspy_version=$2
+
+sdk_dir=$(cd "$(dirname "$0")/.." && pwd)
+venv_dir=$(mktemp -d)
+trap 'rm -rf "$venv_dir"' EXIT
+
+uv venv --seed --python "$python_version" "$venv_dir"
+PYO3_USE_ABI3_FORWARD_COMPATIBILITY=0 \
+    "$venv_dir/bin/python" -m pip install "$sdk_dir" "dspy==$dspy_version"
+
+# -I keeps the checkout off sys.path, so the import reads the installed
+# package and not the source tree.
+cd "$venv_dir"
+"$venv_dir/bin/python" -I -c "import cmpnd; cmpnd.configure(api_key='ci'); cmpnd.auto_instrument(); print('cmpnd', cmpnd.__file__)"

{cmpnd-0.40.1 → cmpnd-0.41.0}/tests/test_cli/test_shell.py

@@ -639,17 +639,23 @@ class TestDeployHelper:
         prepare.assert_called_once()
         assert deploy.call_args.kwargs["program_id"] == "p_0123456789Ab"
 
-    def test_a_deploy_without_a_program_id_stages_nothing(self, tmp_path, monkeypatch):
-        from cmpnd import authored
+    def test_a_deploy_without_a_program_id_sends_none(self, tmp_path, monkeypatch):
+        from cmpnd import authored, deployment
 
         monkeypatch.delenv("CMPND_PROGRAM_ID", raising=False)
         ns = self._ns(tmp_path, monkeypatch)
-        prepare = mock.Mock()
+        prepare = mock.create_autospec(authored.prepare_file)
+        prepare.return_value = mock.Mock(bundle=b"zip", facts=authored.ProgramFacts.minimal())
         monkeypatch.setattr(authored, "prepare_file", prepare)
+        deploy = mock.create_autospec(deployment.deploy_bundle)
+        deploy.return_value = mock.Mock(deployment_id="dep-1")
+        monkeypatch.setattr(deployment, "deploy_bundle", deploy)
+        client = ns["client"]
+        monkeypatch.setattr(client, "get", lambda _path: {"deployment_id": "dep-1", "status": "ready"})
+
+        ns["deploy"](str(tmp_path / "program.py"))
 
-        with pytest.raises(shell.api_client.CliError, match="cmpnd programs create"):
-            ns["deploy"](str(tmp_path / "program.py"))
-        prepare.assert_not_called()
+        assert deploy.call_args.kwargs["program_id"] is None
 
 
 class TestReplFallback:

{cmpnd-0.40.1 → cmpnd-0.41.0}/tests/test_cli/test_top.py

@@ -758,7 +758,7 @@ def _deploy_args(source: str, program_id: str | None = PROGRAM_ID) -> argparse.N
 
 
 class TestDeployNamesItsProgram:
-    """`cmpnd deploy` refuses without a program id before staging or sending anything."""
+    """`cmpnd deploy` checks a program id's shape and leaves the requirement to serve."""
 
     def _stubs(self, monkeypatch):
         from cmpnd import deployment
@@ -771,17 +771,27 @@ class TestDeployNamesItsProgram:
         monkeypatch.setattr(deployment, "deploy_bundle", deploy)
         return prepare_file, prepare_stdin, deploy
 
-    def test_a_missing_id_is_a_usage_error_naming_the_flag_and_the_create_command(self, monkeypatch):
-        prepare_file, prepare_stdin, deploy = self._stubs(monkeypatch)
+    def test_a_missing_id_deploys_without_one(self, monkeypatch):
+        prepare_file, _, deploy = self._stubs(monkeypatch)
+        prepare_file.return_value = mock.Mock(bundle=b"zip", facts=authored.ProgramFacts.minimal())
+        deploy.return_value = _DeployedStub("d_0123456789ab")
+
+        top.cmd_deploy(_fake_client(), _deploy_args("program.py", program_id=None))
+
+        assert deploy.call_args.kwargs["program_id"] is None
+
+    def test_a_serve_refusal_for_a_missing_id_names_the_flag_and_the_create_command(self, monkeypatch):
+        from cmpnd import deployment
+
+        prepare_file, _, deploy = self._stubs(monkeypatch)
+        prepare_file.return_value = mock.Mock(bundle=b"zip", facts=authored.ProgramFacts.minimal())
+        deploy.side_effect = ValueError(deployment.MISSING_PROGRAM_ID)
 
         with pytest.raises(CliError) as refused:
             top.cmd_deploy(_fake_client(), _deploy_args("program.py", program_id=None))
 
         assert "--program-id" in str(refused.value)
         assert "cmpnd programs create" in str(refused.value)
-        prepare_file.assert_not_called()
-        prepare_stdin.assert_not_called()
-        deploy.assert_not_called()
 
     def test_a_malformed_id_is_refused_before_staging(self, monkeypatch):
         prepare_file, _, deploy = self._stubs(monkeypatch)
@@ -808,17 +818,16 @@ class TestDeployNamesItsProgram:
 
 
 class TestOptimizeNamesItsProgram:
-    def test_a_file_that_deploys_its_program_needs_an_id_before_staging(self, monkeypatch):
+    def test_a_file_that_deploys_its_program_without_an_id_sends_none(self, monkeypatch):
         monkeypatch.setattr("sys.stdin", _stdin(_OPTIMIZE_FILE))
         args = _parse_optimize(["optimize", "gepa", "-"])
         with (
-            mock.patch("cmpnd.authored.prepare_optimize_stdin", autospec=True) as m_stage,
-            mock.patch("cmpnd.optimization.optimize_authored", autospec=True) as m_opt,
-            pytest.raises(CliError, match="cmpnd programs create"),
+            mock.patch("cmpnd.configuration.configure", autospec=True),
+            mock.patch("cmpnd.authored.prepare_optimize_stdin", autospec=True, return_value=_prepared()),
+            mock.patch("cmpnd.optimization.optimize_authored", autospec=True, return_value=_FakeResult()) as m_opt,
         ):
             top.cmd_optimize(_fake_client(), args)
-        m_stage.assert_not_called()
-        m_opt.assert_not_called()
+        assert m_opt.call_args.kwargs["program_id"] is None
 
     def test_the_id_reaches_the_loop(self, monkeypatch):
         monkeypatch.setattr("sys.stdin", _stdin(_OPTIMIZE_FILE))