cmpnd 0.47.0__tar.gz → 0.49.0__tar.gz

{cmpnd-0.47.0 → cmpnd-0.49.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.47.0
+Version: 0.49.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>

{cmpnd-0.47.0 → cmpnd-0.49.0}/cmpnd/callback.py

@@ -1372,10 +1372,10 @@ class _LMMixin(_CallbackBase):
         if self._active_optimization_run_id is not None or context.get_current_optimization_run_id() is not None:
             span.attributes["optimization.role"] = "rollout"
 
-        # Capture LM kwargs (exclude secrets)
-        lm_kwargs = {
-            k: v for k, v in getattr(instance, "kwargs", {}).items() if k not in {"api_key", "api_base", "api_secret"}
-        }
+        # The usage fields read one named value each out of the raw kwargs. The
+        # span attributes copy only what helpers.SAFE_LM_KWARGS names, because
+        # the kwargs also hold provider credentials.
+        lm_kwargs = getattr(instance, "kwargs", None) or {}
         span.lm_usage = models.LMUsageObservationV1(
             sdk_call_id=call_id,
             model_requested=span.model_name,
@@ -1387,7 +1387,7 @@ class _LMMixin(_CallbackBase):
             {
                 "lm.model_type": getattr(instance, "model_type", "unknown"),
                 "lm.cache": str(getattr(instance, "cache", False)),
-                **{f"lm.{k}": str(v) for k, v in lm_kwargs.items()},
+                **{f"lm.{k}": str(v) for k, v in helpers.safe_lm_kwargs(lm_kwargs).items()},
             }
         )
 

{cmpnd-0.47.0 → cmpnd-0.49.0}/cmpnd/cli/commands/deployments.py

@@ -73,6 +73,12 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
         if name == "wait":
             command.add_argument("--timeout", type=float, default=None, help=TIMEOUT_HELP)
         command.set_defaults(func=handler)
+    cancel = run_sub.add_parser(
+        "cancel",
+        help="Cancel a queued or running deployment run. It settles as failed with error_code cancelled",
+    )
+    cancel.add_argument("id", help="Deployment run ID")
+    cancel.set_defaults(func=handle_runs_cancel)
 
     openapi = sub.add_parser(
         "openapi",
@@ -251,6 +257,16 @@ def handle_runs_wait(client: api_client.ApiClient, args: Any) -> Any:
     return settled
 
 
+def handle_runs_cancel(client: api_client.ApiClient, args: Any) -> Any:
+    """Settle an open run as cancelled and return its header.
+
+    Serve stops dispatching and collecting the run at once. A run already
+    executing on a worker runs on there until its deadline and may spend model
+    calls, but its answer is discarded.
+    """
+    return client.post(f"/api/v1/deployments/runs/{args.id}/cancel")
+
+
 def handle_openapi(client: api_client.ApiClient, args: Any) -> None:
     """Write the deployment's OpenAPI document to stdout.
 

{cmpnd-0.47.0 → cmpnd-0.49.0}/cmpnd/cli/verbs.py

@@ -152,6 +152,7 @@ DOMAIN_VERBS: dict[str, str] = {
     "revoke-invite": "withdraws the open owner invites to an address; bare revoke would read as revoking the org",
     "run": "submits a deployment execution and optionally waits for its retained answer",
     "wait": "polls one accepted run until it settles or the local budget expires",
+    "cancel": "settles an open run as cancelled and keeps its record; delete would read as removing the run",
     "follow": "tails a record until it settles — a list over time rather than a snapshot",
     "select": "marks one candidate as the program's chosen version",
     "refresh": "re-reads a record from the system of record it mirrors; nothing the caller supplies is written",

{cmpnd-0.47.0 → cmpnd-0.49.0}/cmpnd/deployment_runs.py

@@ -100,11 +100,28 @@ class RunSubmissionUncertain(RuntimeError):
         _set_run_id(self, run_id)
 
 
+def _cancel_command(run_id: str) -> str:
+    return f"cmpnd deployments runs cancel {run_id}"
+
+
 class RunWaitTimeout(TimeoutError):
-    """The local budget ran out; the accepted run continues."""
+    """The local budget ran out; the accepted run continues.
 
-    def __init__(self, run_id: str):
-        super().__init__(f"Deployment run {run_id} has not settled. Resume with `{_wait_command(run_id)}`.")
+    ``status`` and ``status_reason`` are the run's last header read, when one
+    arrived: why the run is still open, such as a queued run waiting for a
+    credential or a worker.
+    """
+
+    def __init__(self, run_id: str, *, status: str | None = None, status_reason: str | None = None):
+        state = ""
+        if status:
+            state = f" ({status}: {status_reason})" if status_reason else f" ({status})"
+        super().__init__(
+            f"Deployment run {run_id} has not settled{state}. "
+            f"Resume with `{_wait_command(run_id)}`, or stop it with `{_cancel_command(run_id)}`."
+        )
+        self.status = status
+        self.status_reason = status_reason
         _set_run_id(self, run_id)
 
 
@@ -325,6 +342,9 @@ class _RunClient:
         self.api_key = api_key
         self.client: httpx.Client | None = None
         self.retry_after = 0.0
+        # The last run header a wait read, so a wait that runs out can say why
+        # the run is still open.
+        self.last_header: dict[str, Any] | None = None
 
     def __enter__(self) -> _RunClient:
         self.client = _http.new_client(headers={"X-API-Key": self.api_key})
@@ -444,8 +464,23 @@ class _RunClient:
         """Follow an accepted run until its retained answer is read or the budget ends.
 
         Reads only. A read refused with 401, 403 or 404 raises at once; timeouts,
-        408, 429 and server errors are retried with backoff and jitter.
+        408, 429 and server errors are retried with backoff and jitter. When the
+        budget runs out, the timeout names the run's last status and reason.
         """
+        self.last_header = initial
+        try:
+            return self._follow(run_id, deadline, initial)
+        except RunWaitTimeout:
+            header = self.last_header
+            if header is None:
+                raise
+            reason = header.get("status_reason")
+            raise RunWaitTimeout(
+                run_id, status=header.get("status"), status_reason=reason if isinstance(reason, str) else None
+            ) from None
+
+    def _follow(self, run_id: str, deadline: float | None, initial: dict[str, Any] | None) -> dict[str, Any]:
+        """The wait loop. It records each header it reads in ``last_header``."""
         header = initial
         need_status = header is None
         delay = _FIRST_POLL_DELAY
@@ -455,6 +490,7 @@ class _RunClient:
                 response = self._poll(status_path, deadline, run_id)
                 if response is not None:
                     header = _validate_run(_json(response, "status", run_id), submitted=False)
+                    self.last_header = header
             need_status = True
             if header is not None and header["status"] in _TERMINAL:
                 # The status is settled, so only the answer remains to be read.

{cmpnd-0.47.0 → cmpnd-0.49.0}/cmpnd/helpers.py

@@ -193,3 +193,55 @@ def infer_provider(instance: Any) -> str:
         return "together"
     else:
         return "unknown"
+
+
+# The LM kwargs the SDK may copy off an LM: into an ``lm.*`` span attribute,
+# which every member of the org can read, and into the ``dspy.LM(...)`` line of
+# deployed source. An allow-list, because an LM's kwargs carry provider
+# credentials under names no deny-list keeps up with, such as
+# ``aws_secret_access_key``, ``azure_ad_token``, ``vertex_credentials`` and
+# ``extra_headers``, and ``dspy.LM.dump_state()`` drops only ``api_key``. A
+# worker spends the deployment's sealed credential, so neither copy needs one.
+#
+# It holds what a provider is asked for (a superset of
+# ``optimization.SAMPLING_KEYS``) and the ``dspy.LM`` settings that shape a
+# call, and nothing that names a destination: ``api_base`` and ``base_url``
+# stay out.
+SAFE_LM_KWARGS: frozenset[str] = frozenset(
+    {
+        # Sampling and response shape.
+        "temperature",
+        "max_tokens",
+        "max_completion_tokens",
+        "top_p",
+        "top_k",
+        "n",
+        "stop",
+        "presence_penalty",
+        "frequency_penalty",
+        "seed",
+        "logprobs",
+        "top_logprobs",
+        "reasoning_effort",
+        "thinking",
+        "verbosity",
+        "response_format",
+        "tools",
+        "tool_choice",
+        "parallel_tool_calls",
+        "service_tier",
+        "cache_control_injection_points",
+        # dspy.LM call settings.
+        "cache",
+        "num_retries",
+        "use_developer_role",
+        "rollout_id",
+    }
+)
+
+
+def safe_lm_kwargs(kwargs: Any) -> dict[str, Any]:
+    """The entries of an LM's kwargs or ``dump_state()`` that :data:`SAFE_LM_KWARGS` names."""
+    if not isinstance(kwargs, dict):
+        return {}
+    return {key: value for key, value in kwargs.items() if key in SAFE_LM_KWARGS}

{cmpnd-0.47.0 → cmpnd-0.49.0}/cmpnd/optimization.py

@@ -862,7 +862,12 @@ def optimize(
             in ``config["reflection_model"]``, which is what the server
             establishes this run's reflection credential from, and its sampling in
             ``config["reflection_sampling"]``, which only the reflecting tier
-            reads. An ``api_key``, ``api_base`` or ``base_url`` on it is refused
+            reads. A reflection turn that names no output cap or temperature
+            gets the platform's (a large ``max_tokens`` and ``temperature=1.0``).
+            To send none and let the model's own defaults apply, pass the model
+            name as a string and set those keys to ``None`` in
+            ``config["reflection_sampling"]``, e.g.
+            ``{"max_tokens": None, "temperature": None}``. An ``api_key``, ``api_base`` or ``base_url`` on it is refused
             rather than dropped: the credential a run spends and the endpoint it
             is spent at are both the platform's, so one set here would be
             discarded without a word. The server refuses a gepa run

{cmpnd-0.47.0 → cmpnd-0.49.0}/cmpnd/packaging.py

@@ -30,6 +30,7 @@ from typing import TYPE_CHECKING, Any
 
 import typing_extensions
 
+from . import helpers
 from ._runtime_tools import is_runtime_tool
 
 if TYPE_CHECKING:
@@ -331,17 +332,6 @@ def _get_module_signature(module: dspy.Module) -> dspy.Signature | None:
     return None
 
 
-# Keys to omit when generating a dspy.LM() call
-_LM_SKIP_KEYS: set[str] = {
-    "model",
-    "model_type",
-    "api_key",
-    "api_base",
-    "base_url",
-    "model_list",
-}
-
-
 def _is_user_type(cls: type) -> bool:
     """True if cls is defined by user code, not stdlib/dspy/third-party."""
     mod = getattr(cls, "__module__", "") or ""
@@ -894,18 +884,12 @@ def generate_program_source(
     lm_state = _extract_lm_state(module)
     if lm_state is not None:
         model = lm_state.get("model", "")
-        kwargs_parts = []
-        for key, value in lm_state.items():
-            # Skip credentials/config we never codegen, and any dspy-internal
-            # state marker. dump_state() can emit markers like `_dspy_lm_class`
-            # (popped by load_state, never a real constructor kwarg); forwarding
-            # one into dspy.LM(...) makes litellm reject it as an unknown
-            # argument (a 502 at execute on the dspy versions that emit it).
-            # LM/litellm kwargs are never underscore-prefixed, so the prefix is
-            # a safe discriminator.
-            if key in _LM_SKIP_KEYS or key.startswith("_"):
-                continue
-            kwargs_parts.append(f"{key}={value!r}")
+        # dump_state() keeps every constructor kwarg but api_key, including
+        # cloud credentials, the destination (api_base), and dspy-internal
+        # markers such as `_dspy_lm_class` that litellm rejects as unknown
+        # arguments. The deployed LM names only what helpers.SAFE_LM_KWARGS
+        # allows. The worker supplies the credential and the destination.
+        kwargs_parts = [f"{key}={value!r}" for key, value in helpers.safe_lm_kwargs(lm_state).items()]
         kwargs_str = ", ".join(kwargs_parts)
         if kwargs_str:
             lines.append(f'lm = dspy.LM("{model}", {kwargs_str})')

{cmpnd-0.47.0 → cmpnd-0.49.0}/docs/cli.md

@@ -88,6 +88,9 @@ within the budget.
 
 The budget or Ctrl-C stops the local wait, and an accepted run continues.
 After acceptance the CLI prints `cmpnd deployments runs wait <id>` on stderr.
+A wait that runs out also names the run's last status and `status_reason`,
+such as `queued: execution_authority_unavailable`, and the command that
+cancels it.
 When the submission reply is lost or fails, acceptance is uncertain. The CLI
 then prints `cmpnd deployments runs list --deployment <id>`. Check that list
 before you submit again.
@@ -104,7 +107,13 @@ with `--deployment ID`. It takes these filters:
 Each page reports `total`, the number of matching runs, and `has_more` when another page follows.
 
 `show ID` prints one run, `result ID` reads its retained answer, and
-`wait ID [--timeout SECONDS]` resumes waiting. The run commands' JSON output
+`wait ID [--timeout SECONDS]` resumes waiting. `cancel ID` settles a queued or
+running run as `failed` with `error_code` `cancelled` and prints it. Serve
+stops dispatching and collecting the run at once. A run already executing on a
+worker runs on there until its deadline and may spend model calls, but its
+answer is discarded. A key with `deployments:write` cancels any run, and a key
+with only `deployments:execute` cancels the runs it submitted. Cancelling a run
+that already settled exits nonzero. The run commands' JSON output
 needs no DSPy install.
 
 ### A file deploys as the source you wrote

{cmpnd-0.47.0 → cmpnd-0.49.0}/docs/sdk-instrumentation.md

@@ -407,7 +407,9 @@ lost POST reply or a server `5xx` leaves acceptance uncertain, so the SDK raises
 names the command to list recent runs. Reads that time out or answer `408`,
 `429` or `5xx` are retried with backoff and jitter, honoring `Retry-After`. A
 `401`, `403` or `404` read raises at once. A spent budget raises
-`RunWaitTimeout`, and the accepted run continues. Ctrl-C prints the run ID and
+`RunWaitTimeout`, and the accepted run continues. Its `status` and
+`status_reason` hold the run's last header read, and its message names them
+with the commands that resume the wait and cancel the run. Ctrl-C prints the run ID and
 `cmpnd deployments runs wait <id>` on stderr, or before acceptance the list
 command, and re-raises.
 
@@ -846,6 +848,8 @@ The callback mints `source_observation_id` when the LM call starts and records `
 
 The LM span's `lm.finish_reason` attribute records why the model stopped, in the chat vocabulary serve's truncation warning reads. Each response shape spells it differently. Chat puts it on the first choice and DSPy 3.3's typed `LMResponse` on the first output. The lm15 `Response` a DSPy 3.4 engine returns carries it at the top level and names a tool-call stop `tool_call`, which the SDK records as `tool_calls`. The Responses API reports a `status`, and its `max_output_tokens` cutoff lands as `length`. `_finish_reason` in `python-sdk/cmpnd/callback.py` holds the mapping.
 
+The LM span's other `lm.*` attributes copy only the LM kwargs that `SAFE_LM_KWARGS` in `python-sdk/cmpnd/helpers.py` names. These are the sampling and response-shape settings, such as `temperature` and `reasoning_effort`, and dspy.LM's own call settings, such as `num_retries`. Every member of the org can read a span. An LM's kwargs can also carry provider credentials under names no deny-list keeps up with, such as `aws_secret_access_key`, `azure_ad_token`, `vertex_credentials` and `extra_headers`. So the list names what may be copied, and a kwarg it does not name stays out. It also leaves out `api_base` and `base_url`, which name a destination. The `dspy.LM(...)` line in a programmatic deploy's generated source goes through the same list, because `dspy.LM.dump_state()` drops only `api_key`. The worker supplies the deployment's credential and destination itself.
+
 `provider_cost` stays `None`. DSPy and LiteLLM can attach a calculated cost to history, but that value is not provider evidence. The SDK will populate this field only when an adapter can prove that the provider supplied both the amount and its currency.
 
 ## Field truncation (span inputs/outputs)

{cmpnd-0.47.0 → cmpnd-0.49.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.47.0"
+version = "0.49.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
 requires-python = ">=3.11"

{cmpnd-0.47.0 → cmpnd-0.49.0}/tests/stress/_provider.py

@@ -198,8 +198,8 @@ def deployed_lm_kwargs(**overrides: object) -> dict[str, object]:
     that is where the destination is decided: `deploy` reads the model, the key and the
     ``api_base`` off `dspy.settings.lm` and forwards them so the server can resolve a
     provider. Setting the LM on the *module* does not do it — the packaged program's own
-    LM line comes from there, but `api_base` is stripped out of it (it is in
-    `cmpnd.packaging._LM_SKIP_KEYS`), so a worker pointed by nothing else answers from
+    LM line comes from there, but `api_base` is stripped out of it (it is not in
+    `cmpnd.helpers.SAFE_LM_KWARGS`), so a worker pointed by nothing else answers from
     whatever host it can resolve. Hence `with dspy.context(lm=…): cmpnd.deploy(…)` at the
     call sites here.
     """

{cmpnd-0.47.0 → cmpnd-0.49.0}/tests/test_callback.py

@@ -433,6 +433,51 @@ class TestCallbackLMHandlers:
 
         shutdown_exporter()
 
+    def test_on_lm_start_records_only_allow_listed_lm_kwargs(self):
+        """A provider credential set on the LM never reaches the span.
+
+        The span ships to serve, where every org member can read it, so its
+        ``lm.*`` attributes name what is known to be safe rather than filtering
+        out what is known to be secret.
+        """
+        import json
+
+        import dspy
+
+        from cmpnd.callback import CmpndCallback
+
+        with mock.patch("cmpnd.exporter.ensure_exporter_started", autospec=True):
+            callback = CmpndCallback()
+        lm = dspy.LM(
+            "bedrock/anthropic.claude-3-haiku",
+            temperature=0.2,
+            max_tokens=64,
+            api_key="secret-api-key",
+            api_base="https://secret-host.invalid",
+            aws_access_key_id="secret-access-key-id",
+            aws_secret_access_key="secret-access-key",
+            aws_session_token="secret-session-token",
+            azure_ad_token="secret-azure-token",
+            vertex_credentials='{"private_key": "secret-vertex"}',
+            extra_headers={"Authorization": "Bearer secret-header"},
+            unknown_future_kwarg="secret-unknown",
+        )
+
+        with mock.patch("cmpnd.exporter.get_exporter", autospec=True, return_value=None):
+            callback.on_lm_start(call_id="lm_call_1", instance=lm, inputs={"messages": []})
+
+        span = get_current_span()
+        assert span is not None
+        assert span.attributes["lm.temperature"] == "0.2"
+        assert span.attributes["lm.max_tokens"] == "64"
+        assert "secret" not in json.dumps(span.to_api_dict(), default=str)
+
+    def test_safe_lm_kwargs_cover_the_sampling_an_optimization_forwards(self):
+        """A sampling key an optimization may forward to a provider is one a span may show."""
+        from cmpnd import helpers, optimization
+
+        assert set(optimization.SAMPLING_KEYS) <= helpers.SAFE_LM_KWARGS
+
     @pytest.mark.parametrize("optimization_source", [None, "context", "callback"])
     def test_on_lm_start_creates_span(self, optimization_source):
         """Test on_lm_start creates LM_CALL span."""

{cmpnd-0.47.0 → cmpnd-0.49.0}/tests/test_cli/test_deployment_runs.py

@@ -215,6 +215,51 @@ def test_interrupted_run_names_the_accepted_run(monkeypatch: pytest.MonkeyPatch,
     assert f"cmpnd deployments runs wait {RUN_ID}" in capsys.readouterr().err
 
 
+@pytest.mark.parametrize("verb", [["run", DEPLOYMENT_ID, "{}"], ["deployments", "runs", "wait", RUN_ID]])
+def test_a_wait_that_runs_out_names_why_the_run_is_still_open(monkeypatch: pytest.MonkeyPatch, capsys, verb):
+    from cmpnd import deployment_runs
+
+    clock = iter(float(tick) for tick in range(1000))
+    monkeypatch.setattr(deployment_runs, "_now", lambda: next(clock))
+    monkeypatch.setattr(deployment_runs, "_sleep", lambda _: None)
+    waiting = {**_envelope("queued"), "status_reason": "execution_authority_unavailable"}
+
+    def answer(req):
+        return httpx.Response(202 if req.method == "POST" else 200, json=waiting, request=req)
+
+    with pytest.raises(SystemExit) as caught:
+        _run_cli(monkeypatch, [*verb, "--timeout", "6"], answer)
+    assert caught.value.code != 0
+    err = capsys.readouterr().err
+    assert f"Deployment run {RUN_ID} has not settled" in err
+    assert "queued: execution_authority_unavailable" in err
+    assert f"cmpnd deployments runs wait {RUN_ID}" in err
+    assert f"cmpnd deployments runs cancel {RUN_ID}" in err
+
+
+def test_runs_cancel_posts_the_cancel_and_prints_the_settled_run(monkeypatch: pytest.MonkeyPatch, capsys):
+    seen = []
+    cancelled = {**_envelope("failed"), "error_code": "cancelled"}
+
+    def answer(req):
+        seen.append(req)
+        return httpx.Response(200, json=cancelled, request=req)
+
+    _run_cli(monkeypatch, ["deployments", "runs", "cancel", RUN_ID], answer)
+    assert [(req.method, req.url.path) for req in seen] == [("POST", f"/api/v1/deployments/runs/{RUN_ID}/cancel")]
+    assert json.loads(capsys.readouterr().out)["error_code"] == "cancelled"
+
+
+def test_runs_cancel_of_a_settled_run_exits_nonzero(monkeypatch: pytest.MonkeyPatch, capsys):
+    def answer(req):
+        return httpx.Response(409, json={"error": "deployment run already settled as completed"}, request=req)
+
+    with pytest.raises(SystemExit) as caught:
+        _run_cli(monkeypatch, ["deployments", "runs", "cancel", RUN_ID], answer)
+    assert caught.value.code != 0
+    assert "already settled as completed" in capsys.readouterr().err
+
+
 def test_interrupted_submission_reports_uncertainty(monkeypatch: pytest.MonkeyPatch, capsys):
     def answer(req):
         raise KeyboardInterrupt

{cmpnd-0.47.0 → cmpnd-0.49.0}/tests/test_deploy.py

@@ -528,8 +528,8 @@ class TestLMDestinationForwarding:
 
     A worker calls the model itself, so `deploy()` forwards both halves of the
     destination — `litellm_model` and, when the LM carries one, `lm_api_host` from its
-    ``api_base``. The host cannot ride the packaged program instead: `api_base` is in
-    `packaging._LM_SKIP_KEYS`, so the generated source never mentions it.
+    ``api_base``. The host cannot ride the packaged program instead: `api_base` is not in
+    `helpers.SAFE_LM_KWARGS`, so the generated source never mentions it.
 
     Both come off ``dspy.settings.lm`` **as of the deploy call**, which is the property a
     test that deploys under a different LM than it calls in-process depends on

{cmpnd-0.47.0 → cmpnd-0.49.0}/tests/test_optimize_reflection_lm.py

@@ -189,6 +189,18 @@ def test_the_refusal_fires_even_when_the_lm_would_have_overwritten_it():
         optimization._reflection_config(config, _LM("openai/gpt-4o", top_p=0.9))
 
 
+def test_a_none_in_config_sampling_travels_as_none():
+    """``None`` asks the reflecting tier to drop its own default for that key, so the
+    model's default applies. This layer must carry it rather than filter it out as
+    "unset", which is what it means everywhere an LM's own state is read."""
+    config = {"reflection_sampling": {"max_tokens": None, "temperature": None}}
+    optimization._reflection_config(config, "openai/gpt-4o")
+    assert config == {
+        "reflection_model": "openai/gpt-4o",
+        "reflection_sampling": {"max_tokens": None, "temperature": None},
+    }
+
+
 def test_a_model_name_beside_config_sampling_stays_legal():
     """The string path is the one way left to name sampling through ``config``, so it
     keeps working — a name says nothing about sampling and so contradicts nothing."""

{cmpnd-0.47.0 → cmpnd-0.49.0}/tests/test_packaging_program_source.py

@@ -781,6 +781,41 @@ class TestGenerateProgramSource(unittest.TestCase):
             self.assertIn("groq/llama-3.1-8b-instant", source)
             self.assertIn("dspy.configure(lm=lm)", source)
 
+    def test_lm_config_carries_only_allow_listed_kwargs(self):
+        """A provider credential set on the LM never reaches the deployed source.
+
+        ``dspy.LM.dump_state()`` keeps every constructor kwarg except ``api_key``,
+        so cloud credentials such as ``aws_secret_access_key`` survive into it.
+        The worker spends the deployment's sealed credential, so the source names
+        only kwargs known to be safe and still runs.
+        """
+        lm = dspy.LM(
+            "bedrock/anthropic.claude-3-haiku",
+            temperature=0.5,
+            num_retries=2,
+            api_key="secret-api-key",
+            api_base="https://secret-host.invalid",
+            aws_access_key_id="secret-access-key-id",
+            aws_secret_access_key="secret-access-key",
+            aws_session_token="secret-session-token",
+            azure_ad_token="secret-azure-token",
+            vertex_credentials='{"private_key": "secret-vertex"}',
+            extra_headers={"Authorization": "Bearer secret-header"},
+            unknown_future_kwarg="secret-unknown",
+        )
+        with dspy.context(lm=lm):
+            source = generate_program_source(dspy.Predict("question -> answer"))
+        self.assertNotIn("secret", source)
+        lm_line = next(line for line in source.splitlines() if line.startswith("lm = dspy.LM("))
+        self.assertIn("temperature=0.5", lm_line)
+        self.assertIn("num_retries=2", lm_line)
+        # The rebuilt LM constructs, so the allow-list names only real dspy.LM kwargs.
+        # Only the LM line runs: the source's dspy.configure(lm=lm) would leave this
+        # LM in the shared settings for every later test.
+        namespace: dict[str, typing.Any] = {"dspy": dspy}
+        exec(lm_line, namespace)
+        self.assertEqual(namespace["lm"].kwargs["temperature"], 0.5)
+
 
 class TestProgramStatePackaging(unittest.TestCase):
     """CMP-289: a deployed program must carry its optimized *state* (demos and

{cmpnd-0.47.0 → cmpnd-0.49.0}/uv.lock

@@ -496,7 +496,7 @@ wheels = [
 
 [[package]]
 name = "cmpnd"
-version = "0.47.0"
+version = "0.49.0"
 source = { editable = "." }
 dependencies = [
     { name = "dspy" },