cmpnd 0.65.0__tar.gz → 0.66.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.65.0
+Version: 0.66.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -526,8 +526,17 @@ for candidate in sdk.list_candidates(best.optimization_run_id):  # read each one
 other = sdk.continue_optimization(best, candidate="ca_...", auto="light")
 ```
 
+`model=` runs the candidate on another student model, and `credential=` names
+the credential that model spends. A loop over models is a model sweep:
+
+```python
+for model in ["openai/gpt-4o-mini", "openai/gpt-4.1-nano"]:
+    swept = sdk.continue_optimization(best, model=model, auto="light")
+    print(model, swept.score)
+```
+
 A refusal raises `cmpnd.OptimizeError`, whose `error_code` says why, such as
-`not_completed` or `unknown_candidate`.
+`not_completed`, `unknown_candidate` or `no_credential`.
 
 ## Command line
 
@@ -654,9 +663,10 @@ global config. Use it as a context manager or as a plain object.
   found. It raises `cmpnd.OptimizeError` or `cmpnd.OptimizeFailed` on failure.
 - `list_candidates(run_id)` returns a run's candidates as dicts, each with its
   `ca_` id, score, parent and instructions.
-- `continue_optimization(run, candidate=None, ...)` runs a new optimization
-  from one candidate of a completed run, with that run's data and a new budget,
-  and returns its best `DeployedProgram`.
+- `continue_optimization(run, candidate=None, model=None, credential=None, ...)`
+  runs a new optimization from one candidate of a completed run, with that
+  run's data and a new budget, optionally on another student model, and returns
+  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.
 - `close()` flushes the client's traces and closes the client. A closed

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

@@ -475,8 +475,17 @@ for candidate in sdk.list_candidates(best.optimization_run_id):  # read each one
 other = sdk.continue_optimization(best, candidate="ca_...", auto="light")
 ```
 
+`model=` runs the candidate on another student model, and `credential=` names
+the credential that model spends. A loop over models is a model sweep:
+
+```python
+for model in ["openai/gpt-4o-mini", "openai/gpt-4.1-nano"]:
+    swept = sdk.continue_optimization(best, model=model, auto="light")
+    print(model, swept.score)
+```
+
 A refusal raises `cmpnd.OptimizeError`, whose `error_code` says why, such as
-`not_completed` or `unknown_candidate`.
+`not_completed`, `unknown_candidate` or `no_credential`.
 
 ## Command line
 
@@ -603,9 +612,10 @@ global config. Use it as a context manager or as a plain object.
   found. It raises `cmpnd.OptimizeError` or `cmpnd.OptimizeFailed` on failure.
 - `list_candidates(run_id)` returns a run's candidates as dicts, each with its
   `ca_` id, score, parent and instructions.
-- `continue_optimization(run, candidate=None, ...)` runs a new optimization
-  from one candidate of a completed run, with that run's data and a new budget,
-  and returns its best `DeployedProgram`.
+- `continue_optimization(run, candidate=None, model=None, credential=None, ...)`
+  runs a new optimization from one candidate of a completed run, with that
+  run's data and a new budget, optionally on another student model, and returns
+  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.
 - `close()` flushes the client's traces and closes the client. A closed

{cmpnd-0.65.0 → cmpnd-0.66.0}/cmpnd/cli/commands/optimizations.py

@@ -93,7 +93,7 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     cont = sub.add_parser(
         "continue",
         help="Run a new optimization from one candidate of a completed run. It reuses that run's data, models "
-        "and credentials, and takes a new budget",
+        "and credentials, and takes a new budget. --model runs the candidate on another student model",
     )
     cont.add_argument("id", help="Completed optimization run ID (op_...)")
     cont.add_argument(
@@ -102,6 +102,19 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         help="The ca_ id of the candidate to start from, as `cmpnd optimizations candidates ID` lists them "
         "(default: the run's best)",
     )
+    cont.add_argument(
+        "--model",
+        default=None,
+        help="The student model the new run spends, as a deploy records it, for example openai/gpt-4o-mini "
+        "(default: the completed run's). Only the program's own model changes",
+    )
+    cont.add_argument(
+        "--credential",
+        metavar="NAME",
+        default=None,
+        help="The provider credential the student model spends (default: the completed run's). "
+        "`cmpnd credentials list` shows the names",
+    )
     # The budget flags are `cmpnd optimize`'s, and the SDK refuses a run with none or two,
     # so both commands answer a missing budget the same way.
     cont.add_argument(
@@ -258,17 +271,23 @@ def handle_continue(client: api_client.ApiClient, args: Any) -> Any:
     """Run a new optimization from one candidate of a completed run, as `cmpnd optimize` runs one.
 
     The new run reuses the completed run's data and configuration and takes a new budget.
-    The command names the candidate it starts from, waits for the run, and prints the
-    best program as `cmpnd optimize` does. `--async` returns the queued run instead.
+    `--model` and `--credential` run the candidate on another student model. The command
+    names the candidate it starts from, waits for the run, and prints the best program as
+    `cmpnd optimize` does. `--async` returns the queued run instead.
     """
     from ... import optimization
 
+    credential_name = args.credential
+    if credential_name is not None:
+        credential_name = top._CredentialLookup(client)(f"--credential {credential_name}", credential_name).name
     cfg = top.sdk_config(client)
     try:
         started = optimization.start_continuation(
             args.id,
             cfg=cfg,
             candidate=args.candidate,
+            model=args.model,
+            credential_name=credential_name,
             max_metric_calls=args.max_metric_calls,
             auto=args.auto,
         )
@@ -289,6 +308,11 @@ def handle_continue(client: api_client.ApiClient, args: Any) -> Any:
         ),
         file=sys.stderr,
     )
+    if args.model is not None or args.credential is not None:
+        print(
+            top._c(f"on {started.get('model')} with the credential {started.get('credential_name')}", "dim"),
+            file=sys.stderr,
+        )
     print(top._c(f"optimizing with {started.get('optimizer')}…", "dim"), file=sys.stderr)
     try:
         result = optimization.wait_for_continuation(started, cfg=cfg)
@@ -301,6 +325,7 @@ def handle_continue(client: api_client.ApiClient, args: Any) -> Any:
             "optimization_id": started.get("optimization_id"),
             "continued_from_run_id": started.get("continued_from_run_id"),
             "continued_from_candidate_id": started.get("continued_from_candidate_id"),
+            **{key: started[key] for key in ("model", "credential_name") if key in started},
         },
     )
     return None

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

@@ -721,6 +721,8 @@ class Client:
         run: Any,
         *,
         candidate: str | None = None,
+        model: str | None = None,
+        credential: credentials.Credential | None = None,
         max_metric_calls: int | None = None,
         auto: str | None = None,
         poll_interval: float = 3.0,
@@ -735,12 +737,27 @@ class Client:
             best = client.optimize_deployment(deployed, ..., max_metric_calls=120)
             better = client.continue_optimization(best, max_metric_calls=120)
 
+        With ``model``, the new run is a model sweep: the candidate runs and optimizes on
+        that student model instead of the completed run's. A loop over models compares
+        them on one task::
+
+            for model in ["openai/gpt-4o-mini", "openai/gpt-4.1-nano"]:
+                swept = client.continue_optimization(best, model=model, auto="light")
+                print(model, swept.score)
+
         Args:
             run: The completed run's ``op_`` id, or the ``DeployedProgram`` an
                 optimization returned.
             candidate: The ``ca_`` id of the candidate to start from, as
                 ``list_candidates`` and ``cmpnd optimizations candidates`` list it. The
                 default is the run's best.
+            model: The student model the new run spends, as a deploy records it, for
+                example ``"openai/gpt-4o-mini"``. The default is the completed run's.
+                Only the program's own model changes: a predictor with its own LM, the
+                run's ``lms`` and the reflection model stay as the completed run had
+                them.
+            credential: The credential the student model spends, from
+                ``cmpnd.credentials.get(NAME)``. The default is the completed run's.
             max_metric_calls: The budget as a ceiling on metric calls. Pass this or
                 ``auto``, exactly one.
             auto: The budget as ``"light"``, ``"medium"`` or ``"heavy"``.
@@ -754,11 +771,15 @@ class Client:
         Raises:
             ValueError: No budget or two budgets, or a ``DeployedProgram`` that no
                 optimization produced.
+            TypeError: ``credential`` is a string. Look a credential up with
+                ``cmpnd.credentials.get``.
             OptimizeError: The platform refused the continuation. Its ``error_code``
-                says why, for example ``not_completed`` or ``unknown_candidate``.
+                says why, for example ``not_completed``, ``unknown_candidate`` or
+                ``no_credential``.
             OptimizeFailed: The new run transitioned to ``status="failed"``.
         """
         self._check_active()
+        credential_name = credentials.name_of(credential, "cmpnd.Client.continue_optimization(credential=)")
         from . import execution, optimization
 
         run_id = run.optimization_run_id if isinstance(run, execution.DeployedProgram) else run
@@ -770,6 +791,8 @@ class Client:
             run_id,
             cfg=self._config,
             candidate=candidate,
+            model=model,
+            credential_name=credential_name,
             max_metric_calls=max_metric_calls,
             auto=auto,
             poll_interval=poll_interval,

{cmpnd-0.65.0 → cmpnd-0.66.0}/cmpnd/optimization.py

@@ -978,20 +978,28 @@ def start_continuation(
     *,
     cfg: configuration.Config,
     candidate: str | None = None,
+    model: str | None = None,
+    credential_name: str | None = None,
     max_metric_calls: int | None = None,
     auto: str | None = None,
 ) -> dict[str, Any]:
     """Start a run from one candidate of the completed run ``run_id``, and return serve's answer.
 
     The answer names the new run (``optimization_id``), its deployment and optimizer, the
-    run and ``ca_`` candidate it continues, and the candidate's score and instructions.
-    Serve deploys the candidate and reuses the parent's evaluation data and configuration,
-    so the request carries only the candidate and the budget, and nothing is uploaded.
+    run and ``ca_`` candidate it continues, the candidate's score and instructions, and
+    the ``model`` and ``credential_name`` the run spends. Serve deploys the candidate and
+    reuses the parent's evaluation data and configuration, so the request carries only
+    the candidate, the budget and an optional student model and credential, and nothing
+    is uploaded.
     """
     body: dict[str, Any] = {}
     _apply_budget(body, max_metric_calls=max_metric_calls, auto=auto, config_budgets=False)
     if candidate is not None:
         body["candidate_id"] = candidate
+    if model is not None:
+        body["model"] = model
+    if credential_name is not None:
+        body["credential_name"] = credential_name
     headers = {"X-API-Key": cfg.api_key, "Content-Type": "application/json"}
     what = f"continue optimization {run_id}"
     with _http.new_client(timeout=_HTTP_TIMEOUT_SECONDS) as client:
@@ -1052,6 +1060,8 @@ def continue_optimization(
     *,
     cfg: configuration.Config,
     candidate: str | None = None,
+    model: str | None = None,
+    credential_name: str | None = None,
     max_metric_calls: int | None = None,
     auto: str | None = None,
     poll_interval: float = 3.0,
@@ -1061,7 +1071,15 @@ def continue_optimization(
 
     ``cmpnd.Client.continue_optimization`` calls this and documents the arguments.
     """
-    started = start_continuation(run_id, cfg=cfg, candidate=candidate, max_metric_calls=max_metric_calls, auto=auto)
+    started = start_continuation(
+        run_id,
+        cfg=cfg,
+        candidate=candidate,
+        model=model,
+        credential_name=credential_name,
+        max_metric_calls=max_metric_calls,
+        auto=auto,
+    )
     return wait_for_continuation(started, cfg=cfg, poll_interval=poll_interval, timeout=timeout)
 
 

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

@@ -759,12 +759,19 @@ so nothing is uploaded.
   candidate's instructions.
 - `--candidate CANDIDATE_ID` names the candidate by its `ca_` id. The default is
   the run's best.
+- `--model MODEL` runs the candidate on another student model, as a deploy
+  records it, such as `openai/gpt-4o-mini`. This is a model sweep. Only the
+  program's own model changes. A predictor with its own LM, the run's named LMs
+  and the reflection model stay as the completed run had them.
+- `--credential NAME` names the credential the student model spends. The
+  default is the completed run's. The command looks the name up before it
+  starts the run, as `cmpnd optimize` does.
 - The command runs the optimization as `cmpnd optimize` does. It names the
   candidate it starts from on stderr, with its score and the start of its
   instructions, then waits. It prints the best deployment's id on stdout and
   its score on stderr. `--json` prints `best_deployment_id` and `best_score`,
-  with the new run's `optimization_id` and the run and candidate it continued
-  from.
+  with the new run's `optimization_id`, the run and candidate it continued
+  from, and the `model` and `credential_name` it spends.
 - `--async` prints the queued run as JSON and returns at once. Follow it with
   `cmpnd optimizations show NEW_RUN_ID`, which shows `continued_from_run_id` and
   `continued_from_candidate_id`. Showing the completed run lists its
@@ -773,11 +780,12 @@ so nothing is uploaded.
   refused with a reason.
 
 In Python, `cmpnd.Client.list_candidates(run_id)` returns the candidates as
-dicts, and `cmpnd.Client.continue_optimization(run, candidate=None,
-max_metric_calls=None, auto=None)` runs the continuation and returns its best
-`DeployedProgram`, as `optimize_deployment` does. `run` is an `op_` id or the
-`DeployedProgram` an optimization returned, whose `optimization_run_id` names
-its run. `candidate` is a `ca_` id.
+dicts, and `cmpnd.Client.continue_optimization(run, candidate=None, model=None,
+credential=None, max_metric_calls=None, auto=None)` runs the continuation and
+returns its best `DeployedProgram`, as `optimize_deployment` does. `run` is an
+`op_` id or the `DeployedProgram` an optimization returned, whose
+`optimization_run_id` names its run. `candidate` is a `ca_` id. `model` is a
+model string, and `credential` is a `cmpnd.credentials.get(NAME)` result.
 
 An org's plan may cap how many hosted optimizations run at once. A run started
 over the cap waits in serve's queue and starts when one of the org's runs

{cmpnd-0.65.0 → cmpnd-0.66.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.65.0"
+version = "0.66.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.65.0 → cmpnd-0.66.0}/tests/e2e/test_optimize_continuation.py

@@ -6,6 +6,10 @@ observable on fake models: the seed scores 0.0 and gepa's first proposal, "Answe
 word `correct`.", scores 1.0 (``fake-provider/README.md``). So a continuation's own first
 candidate shows which candidate seeded it: it holds that candidate's text and its score.
 
+A model sweep is a continuation on another student model. fake-provider's model
+``cmpnd-fake/deaf`` skips the instruction rule, so the proposal that scores 1.0 on the
+parent's model scores 0.0 on it, which shows the student model changed.
+
 The parent runs once per module. Each test continues from it.
 """
 
@@ -25,6 +29,9 @@ pytestmark = [pytest.mark.e2e, needs_an_optimizer]
 # Room for the seed's evaluation on the valset and one proposal with its evaluation.
 BUDGET_METRIC_CALLS = 30
 
+#: fake-provider's model that answers the filler whatever the instruction says.
+DEAF_MODEL = f"{fake_lm.PROVIDER}/deaf"
+
 
 @pytest.fixture(scope="module")
 def parent():
@@ -54,19 +61,22 @@ def _idx(candidate: dict[str, Any]) -> int:
     return candidate["idx"]
 
 
-def _continue(run_id: str, candidate: dict[str, Any]) -> tuple[str, list[dict[str, Any]]]:
-    """Continue ``run_id`` from ``candidate`` and wait; return the new run and its candidates."""
+def _continue(
+    run_id: str, candidate: dict[str, Any], model: str | None = None
+) -> tuple[cmpnd.DeployedProgram, list[dict[str, Any]]]:
+    """Continue ``run_id`` from ``candidate`` and wait; return the new run's best program and its candidates."""
     with platform_client() as client:
         result = client.continue_optimization(
             run_id,
             candidate=candidate["candidate_id"],
+            model=model,
             max_metric_calls=BUDGET_METRIC_CALLS,
             poll_interval=2.0,
             timeout=300.0,
         )
         assert isinstance(result, cmpnd.DeployedProgram)
         assert result.optimization_run_id and result.optimization_run_id != run_id
-        return result.optimization_run_id, client.list_candidates(result.optimization_run_id)
+        return result, client.list_candidates(result.optimization_run_id)
 
 
 class TestTheParentRun:
@@ -81,7 +91,8 @@ class TestTheParentRun:
 class TestContinuingFromACandidate:
     def test_a_continuation_from_the_proposal_starts_from_its_text_and_score(self, parent, server_client):
         run_id, _, proposal = parent
-        child, candidates = _continue(run_id, proposal)
+        result, candidates = _continue(run_id, proposal)
+        child = result.optimization_run_id
 
         # The continuation's own seed is the proposal, and a perfect seed leaves gepa
         # nothing to propose.
@@ -101,6 +112,19 @@ class TestContinuingFromACandidate:
         assert (first["instructions"], first["aggregate_score"]) == (seed["instructions"], 0.0)
 
 
+class TestAModelSweep:
+    def test_a_sweep_runs_the_candidate_on_the_named_model(self, parent, server_client):
+        run_id, _, proposal = parent
+        result, candidates = _continue(run_id, proposal, model=DEAF_MODEL)
+
+        # The proposal's text scores 1.0 on the parent's model and 0.0 on the deaf one.
+        first = min(candidates, key=_idx)
+        assert (first["instructions"], first["aggregate_score"]) == (proposal["instructions"], 0.0)
+        assert server_client.get_deployment(result.deployment_id)["litellm_model"] == DEAF_MODEL
+        detail = server_client.get_optimization(result.optimization_run_id)
+        assert detail["continued_from_candidate_id"] == proposal["candidate_id"]
+
+
 class TestARefusedContinuationStartsNothing:
     @pytest.mark.parametrize(
         "candidate",
@@ -114,6 +138,12 @@ class TestARefusedContinuationStartsNothing:
         assert raised.value.error_code == "unknown_candidate"
         assert run_id in str(raised.value)
 
+    def test_an_empty_model_is_refused(self, parent):
+        run_id, _, _ = parent
+        with platform_client() as client, pytest.raises(cmpnd.OptimizeError) as raised:
+            client.continue_optimization(run_id, model=" ", max_metric_calls=BUDGET_METRIC_CALLS)
+        assert raised.value.error_code == "invalid_model"
+
     def test_a_run_that_does_not_exist_is_refused(self):
         with platform_client() as client, pytest.raises(cmpnd.OptimizeError) as raised:
             client.continue_optimization("op_AAAAAAAAAAAA", max_metric_calls=BUDGET_METRIC_CALLS)

{cmpnd-0.65.0 → cmpnd-0.66.0}/tests/stress/test_optimize_continuation.py

@@ -1,14 +1,16 @@
-"""Stress: continue a completed optimization from its best candidate, on real models.
+"""Stress: continue a completed optimization from its best candidate onto another model.
 
 The real-model twin of ``tests/e2e/test_optimize_continuation.py``. It runs the same task,
 ``continuation_task``, whose gold answer to every question is the word ``correct``. A real
 reflector can learn that rule only from the metric's feedback, so its proposals score
 above the seed. The test optimizes a deployment, picks the best candidate from
-``list_candidates``, and continues the completed run from it with a new budget.
+``list_candidates``, and continues the completed run from it with a new budget on another
+student model. That continuation is a model sweep. It names no credential, so it keeps
+the parent's.
 
-The assertions are about the platform, and the scores are logged. A continuation starts
-from the chosen candidate's instructions, completes, and records where it came from.
-Real models do not repeat their scores exactly, so no score is asserted.
+The assertions are about the platform, and the scores are logged. A sweep starts from the
+chosen candidate's instructions, runs on the named model, completes, and records where it
+came from. Real models do not repeat their scores exactly, so no score is asserted.
 
 Env (stress convention, as ``test_optimize_loop_wasm.py``):
   - PLATFORM_API_KEY: cmpnd server API key, an org owner's or one with ``credentials:write``
@@ -41,6 +43,9 @@ LM_KEY = _provider.LM_KEY
 # student, and a reflector whose output ceiling fits a reflection turn.
 STUDENT = _provider.deployed_model("student", committee_task.STUDENT_3B)
 REFLECTION = _provider.deployed_model("reflection", "bedrock/us.anthropic.claude-haiku-4-5-20251001-v1:0")
+# The model the sweep moves the chosen candidate onto: the stress lane's fast model, from
+# the same provider as the student, so the parent's credential serves it.
+SWEPT = _provider.deployed_model("stress", "bedrock/us.amazon.nova-micro-v1:0")
 
 # Room for the seed's evaluation on the six-question valset and a few proposals, in each
 # of the two runs.
@@ -60,9 +65,9 @@ def _client() -> cmpnd.Client:
     return cmpnd.Client(api_key=PLATFORM_API_KEY, endpoint=PLATFORM_ENDPOINT)
 
 
-def _optimization(run_id: str) -> dict[str, Any]:
+def _read(path: str) -> dict[str, Any]:
     resp = httpx.get(
-        f"{PLATFORM_ENDPOINT}/api/v1/optimizations/{run_id}",
+        f"{PLATFORM_ENDPOINT}/api/v1/{path}",
         headers={"X-API-Key": PLATFORM_API_KEY or ""},
         timeout=60.0,
     )
@@ -70,6 +75,10 @@ def _optimization(run_id: str) -> dict[str, Any]:
     return resp.json()
 
 
+def _optimization(run_id: str) -> dict[str, Any]:
+    return _read(f"optimizations/{run_id}")
+
+
 def _describe(candidates: list[dict[str, Any]]) -> str:
     return "; ".join(
         f"{c['candidate_id']} #{c['idx']} {c['aggregate_score']:.3f} {c['instructions']}" for c in candidates
@@ -85,11 +94,11 @@ def _idx(candidate: dict[str, Any]) -> int:
 
 
 class TestContinuationOnRealModels:
-    def test_a_continuation_starts_from_the_best_candidate_and_records_it(self):
-        with tolerate_external_outage("continuation of a gepa run (real LM)"):
+    def test_a_sweep_starts_from_the_best_candidate_on_the_named_model_and_records_it(self):
+        with tolerate_external_outage("model sweep of a gepa run (real LM)"):
             # The student and the reflector may name different providers, so each prefix
             # gets its own credential. The program's LM carries neither a key nor a base.
-            _provider.seal_deployed_credential(STUDENT, REFLECTION)
+            _provider.seal_deployed_credential(STUDENT, REFLECTION, SWEPT)
             lm = dspy.LM(STUDENT, temperature=0.0, max_tokens=400, cache=False)
             program = cmpnd.Program(
                 f"test_optimize_continuation-{uuid.uuid4().hex[:8]}",
@@ -120,6 +129,7 @@ class TestContinuationOnRealModels:
                 result = client.continue_optimization(
                     parent,
                     candidate=chosen["candidate_id"],
+                    model=SWEPT,
                     max_metric_calls=BUDGET_METRIC_CALLS,
                     poll_interval=5.0,
                     timeout=1800.0,
@@ -146,8 +156,12 @@ class TestContinuationOnRealModels:
             max(c["aggregate_score"] for c in child_candidates),
         )
 
-        # The lineage reads both ways.
+        # The sweep ran on the named model, and its best deployment records it.
         detail = _optimization(child)
+        assert detail["model_name"] == SWEPT, f"sweep {child} ran on {detail['model_name']}, not {SWEPT}"
+        assert _read(f"deployments/{result.deployment_id}")["litellm_model"] == SWEPT
+
+        # The lineage reads both ways.
         assert (detail["status"], detail["continued_from_run_id"], detail["continued_from_candidate_id"]) == (
             "completed",
             parent,

{cmpnd-0.65.0 → cmpnd-0.66.0}/tests/test_cli/test_optimizations.py

@@ -8,6 +8,7 @@ from unittest import mock
 
 import pytest
 
+import cmpnd
 from cmpnd.cli.api_client import CliError
 from cmpnd.cli.commands import optimizations
 from cmpnd.cli.commands.optimizations import (
@@ -218,11 +219,11 @@ def _client_with_account(mock_client):
 class TestOptimizationsContinue:
     """`continue` runs an optimization as `cmpnd optimize` does: it waits, and prints the same result."""
 
-    def _run(self, mock_client, argv):
+    def _run(self, mock_client, argv, started=_STARTED):
         args = _build_parser().parse_args(["optimizations", "continue", "op_abc", *argv])
         assert args.func is handle_continue
         with (
-            mock.patch("cmpnd.optimization.start_continuation", autospec=True, return_value=_STARTED) as m_start,
+            mock.patch("cmpnd.optimization.start_continuation", autospec=True, return_value=started) as m_start,
             mock.patch("cmpnd.optimization.wait_for_continuation", autospec=True, return_value=_Result()) as m_wait,
         ):
             returned = handle_continue(_client_with_account(mock_client), args)
@@ -254,6 +255,49 @@ class TestOptimizationsContinue:
             "continued_from_candidate_id": "ca_U0IdawjhyJbz",
         }
 
+    def test_a_sweep_names_its_model_and_looks_up_its_credential(self, mock_client, capsys):
+        """`--model` makes the continuation a sweep, and `--credential` is looked up as `optimize` looks it up."""
+        bedrock = cmpnd.credentials._mint("bedrock", ("converse",), "https://bedrock-runtime.us-east-1.amazonaws.com")
+        swept = {**_STARTED, "model": "bedrock/us.amazon.nova-micro-v1:0", "credential_name": "bedrock"}
+        with mock.patch("cmpnd.credentials.get", autospec=True, return_value=bedrock) as m_get:
+            _, m_start, _ = self._run(
+                mock_client,
+                [
+                    "--model",
+                    "bedrock/us.amazon.nova-micro-v1:0",
+                    "--credential",
+                    "bedrock",
+                    "--auto",
+                    "light",
+                    "--json",
+                ],
+                started=swept,
+            )
+        assert m_get.call_args.args == ("bedrock",)
+        kwargs = m_start.call_args.kwargs
+        assert (kwargs["model"], kwargs["credential_name"]) == ("bedrock/us.amazon.nova-micro-v1:0", "bedrock")
+        out, err = capsys.readouterr()
+        assert "on bedrock/us.amazon.nova-micro-v1:0 with the credential bedrock" in err
+        summary = json.loads(out)
+        assert (summary["model"], summary["credential_name"]) == ("bedrock/us.amazon.nova-micro-v1:0", "bedrock")
+
+    def test_a_continuation_with_no_model_sends_none(self, mock_client):
+        _, m_start, _ = self._run(mock_client, ["--auto", "light"])
+        assert (m_start.call_args.kwargs["model"], m_start.call_args.kwargs["credential_name"]) == (None, None)
+
+    def test_an_unknown_credential_is_refused_before_the_continuation(self, mock_client):
+        args = _build_parser().parse_args(
+            ["optimizations", "continue", "op_abc", "--credential", "bedrok", "--auto", "light"]
+        )
+        missing = cmpnd.credentials.CredentialNotFound("bedrok", ["bedrock"], "bedrock")
+        with (
+            mock.patch("cmpnd.credentials.get", autospec=True, side_effect=missing),
+            mock.patch("cmpnd.optimization.start_continuation", autospec=True) as m_start,
+            pytest.raises(CliError, match="--credential bedrok"),
+        ):
+            handle_continue(_client_with_account(mock_client), args)
+        m_start.assert_not_called()
+
     def test_async_returns_the_queued_run_without_waiting(self, mock_client):
         returned, m_start, m_wait = self._run(mock_client, ["--auto", "light", "--async"])
         assert returned == _STARTED

{cmpnd-0.65.0 → cmpnd-0.66.0}/tests/test_optimize.py

@@ -1265,6 +1265,41 @@ class TestContinueOptimization:
         (request,) = wire.sent("POST")
         assert request.url.path == "/api/v1/optimizations/op_parent/continue"
 
+    def test_a_sweep_posts_its_model_and_credential(self, wire):
+        """A sweep is a continuation that names the student model and the credential it spends."""
+        wire.answer(
+            "POST", 201, {**self._ANSWER, "model": "bedrock/us.amazon.nova-micro-v1:0", "credential_name": "bedrock"}
+        )
+        wire.answer("GET", 200, self._DONE)
+        bedrock = cmpnd.credentials._mint("bedrock", ("converse",), "https://bedrock-runtime.us-east-1.amazonaws.com")
+
+        with _no_sleep():
+            _sdk().continue_optimization(
+                "op_parent", model="bedrock/us.amazon.nova-micro-v1:0", credential=bedrock, max_metric_calls=30
+            )
+        (request,) = wire.sent("POST")
+        assert json.loads(request.content) == {
+            "max_metric_calls": 30,
+            "model": "bedrock/us.amazon.nova-micro-v1:0",
+            "credential_name": "bedrock",
+        }
+
+    def test_a_sweep_with_a_model_alone_sends_no_credential(self, wire):
+        wire.answer("POST", 201, self._ANSWER)
+
+        cfg = cmpnd.configuration.Config(api_key="ct_client", endpoint="http://client.test")
+        optimization.start_continuation("op_parent", cfg=cfg, model="openai/gpt-4o-mini", auto="light")
+        (request,) = wire.sent("POST")
+        assert json.loads(request.content) == {"auto": "light", "model": "openai/gpt-4o-mini"}
+
+    def test_a_sweep_refuses_a_credential_named_by_a_string(self, mock_httpx):
+        client = _client(mock_httpx)
+        with pytest.raises(TypeError, match="cmpnd.credentials.get"):
+            _sdk().continue_optimization(
+                "op_parent", model="openai/gpt-4o-mini", credential="openai", max_metric_calls=10
+            )  # type: ignore[arg-type]
+        assert client.post.call_count == 0
+
     def test_a_listed_candidate_is_named_by_its_id(self, wire):
         wire.answer("GET", 200, self._CANDIDATES)
         wire.answer("POST", 201, self._ANSWER)

{cmpnd-0.65.0 → cmpnd-0.66.0}/uv.lock

@@ -505,7 +505,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.65.0"
+version = "0.66.0"
 source = { editable = "." }
 default-groups = ["dspy-3-4-1"]
 dependencies = [