cmpnd 0.40.1__tar.gz → 0.42.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: cmpnd
-Version: 0.40.1
+Version: 0.42.0
 Summary: DSPy observability and deployment SDK for cmpnd
 Project-URL: Homepage, https://cmpnd.ai
 Author-email: cmpnd <hello@cmpnd.ai>
@@ -10,13 +10,13 @@ Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 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-Python: >=3.11
 Requires-Dist: dspy>=3.1.3
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: ipython>=8.20
@@ -27,10 +27,11 @@ 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: numpy>=1.26; (python_version < '3.11') and extra == 'dev'
-Requires-Dist: numpy>=2.3; (python_version >= '3.11') and extra == 'dev'
+Requires-Dist: litellm; extra == 'dev'
+Requires-Dist: numpy>=2.3; extra == 'dev'
 Requires-Dist: pandas>=2.2; extra == 'dev'
 Requires-Dist: pillow>=10.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
@@ -40,7 +41,7 @@ Requires-Dist: pytest>=8.0; extra == 'dev'
 Requires-Dist: ruff>=0.4.0; extra == 'dev'
 Requires-Dist: twine>=7.0; extra == 'dev'
 Provides-Extra: fake-provider
-Requires-Dist: cmpnd-fake-provider; (python_version >= '3.11') and extra == 'fake-provider'
+Requires-Dist: cmpnd-fake-provider; extra == 'fake-provider'
 Provides-Extra: images
 Requires-Dist: pillow>=10.0; extra == 'images'
 Provides-Extra: mcp
@@ -161,7 +162,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.42.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.42.0}/cmpnd/cli/commands/top.py

@@ -83,8 +83,7 @@ def _parse_iso(ts: str | None) -> datetime | None:
     if not ts:
         return None
     try:
-        # Rails serializes with "Z"; Python <3.11 parsed via fromisoformat needed +00:00
-        return datetime.fromisoformat(ts.replace("Z", "+00:00"))
+        return datetime.fromisoformat(ts)
     except (ValueError, TypeError):
         return None
 
@@ -811,11 +810,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 +823,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 +849,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 +873,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 +941,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 +1259,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 +1344,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.42.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(
@@ -644,7 +644,7 @@ def _enable_readline(namespace: dict[str, Any]) -> None:
 def _launch_repl(namespace: dict[str, Any], banner: str) -> None:
     """Prefer IPython (Jedi completion, history, multi-line); fall back to stdlib."""
     try:
-        from IPython import start_ipython  # pyright: ignore[reportAttributeAccessIssue]
+        from IPython import start_ipython
         from traitlets.config import Config
     except ImportError:
         import code

{cmpnd-0.40.1 → cmpnd-0.42.0}/cmpnd/cli/trace_render.py

@@ -194,8 +194,8 @@ _TS_RE = re.compile(r"^(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})(\.\d+)?(Z|[+-]\d{2}
 
 def _parse_ts(value: Any) -> datetime.datetime | None:
     """Parse an RFC3339 timestamp tolerantly. Server emits nanosecond (9-digit)
-    fractions that datetime.fromisoformat rejects, so truncate the fraction to
-    microseconds and normalize a trailing Z. Returns None on anything unparsable
+    fractions, so truncate the fraction to microseconds, the precision datetime
+    holds, and normalize a trailing Z. Returns None on anything unparsable
     — the caller degrades (offset 0) rather than crashing."""
     if not isinstance(value, str):
         return None

{cmpnd-0.40.1 → cmpnd-0.42.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.42.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.42.0}/cmpnd/packaging.py

@@ -460,8 +460,8 @@ def _collect_inlined_base_imports(
     if typing_extensions.is_typeddict(ann_type):
         # A TypedDict subclass reports `dict` as its base — the name its source
         # actually spells survives only in the text. Use typing_extensions for
-        # the bare spelling because Pydantic requires it on Python 3.10 and
-        # 3.11. Import both modules to cover either qualified spelling.
+        # the bare spelling because Pydantic requires it on Python 3.11.
+        # Import both modules to cover either qualified spelling.
         imports.add(ImportEntry("typing_extensions", "TypedDict"))
         imports.add(ImportEntry("typing_extensions"))
         imports.add(ImportEntry("typing"))

{cmpnd-0.40.1 → cmpnd-0.42.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.42.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.42.0}/docs/sdk-instrumentation.md

@@ -444,7 +444,7 @@ base written inside a function belongs to no module's globals, so a bare name
 falls back to the runtime base at that position. A `TypedDict` subclass is the
 one base read off the class rather than the text, because it reports `dict`:
 `typing_extensions` supplies the name, which is what pydantic requires on Python
-3.10 and 3.11.
+3.11.
 
 Two shapes refuse the package rather than deploying a program that raises
 `NameError` on its first call, which is well after deploy reported it ready:
@@ -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.42.0}/ingest/pyproject.toml

@@ -11,7 +11,7 @@ description = "The cmpnd ingest transport: the HTTP client that pushes traces, o
 readme = "README.md"
 # `cmpnd`'s floor: these modules ship inside its wheel, so they must import on
 # every Python it supports.
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = {text = "MIT"}
 authors = [
     {name = "cmpnd", email = "hello@cmpnd.ai"}

{cmpnd-0.40.1 → cmpnd-0.42.0}/pyproject.toml

@@ -5,10 +5,10 @@ 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.42.0"
 description = "DSPy observability and deployment SDK for cmpnd"
 readme = "README.md"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 license = {text = "MIT"}
 authors = [
     {name = "cmpnd", email = "hello@cmpnd.ai"}
@@ -19,11 +19,11 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "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",
 ]
 
@@ -46,7 +46,7 @@ dependencies = [
     "pydantic>=2.0",
     # Detects TypedDicts from both typing and typing_extensions, and supplies
     # the spelling Pydantic requires when generated programs run on Python
-    # 3.10 or 3.11.
+    # 3.11.
     "typing-extensions>=4.1.0",
     # Still required, and still the fast path — but `cmpnd/ir/xxh64.py` no
     # longer *needs* it: it falls back to a pure-Python xxh64 that the tests
@@ -56,9 +56,8 @@ dependencies = [
     # install should have it.
     "xxhash>=3.0.0",
     # Powers the interactive `cmpnd` shell (Jedi completion, multi-line,
-    # history search, syntax highlighting). No upper cap: pip/uv resolves
-    # 8.x on Python 3.10 and 9.x on 3.11+. The shell falls back to stdlib
-    # `code.interact` + rlcompleter if IPython somehow can't import.
+    # history search, syntax highlighting). No upper cap. The shell falls back
+    # to stdlib `code.interact` + rlcompleter if IPython somehow can't import.
     "ipython>=8.20",
 ]
 
@@ -95,16 +94,20 @@ 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",
     # test_reflector_smoke.py builds numpy fixtures. dspy <=3.2.x required numpy
     # unconditionally so it rode in transitively; dspy 3.3.0 moved numpy behind a
     # `numpy` extra, so declare it directly as the test dependency it always was.
-    # numpy 2.3 dropped Python 3.10 and is the first release with cp314 wheels. Split the
-    # requirement so the >=3.10 lock keeps 2.2.x for 3.10 only and 3.11+ installs from wheels.
-    "numpy>=1.26; python_version < '3.11'",
-    "numpy>=2.3; python_version >= '3.11'",
+    # numpy 2.3 is the first release with cp314 wheels.
+    "numpy>=2.3",
     # tests/e2e/test_deploy_pandas.py deploys a program and a metric that import pandas,
     # because the worker's kernel ships it. The SDK reads a function's imports from the
     # live module before packaging it, so pandas has to be importable on the client.
@@ -124,12 +127,8 @@ dev = [
 # integration stack points programs at. Carried as an SDK extra so a single
 # `uv run --project python-sdk --extra fake-provider` brings up the SDK and the
 # provider together — no separate venv to forget about.
-#
-# It targets python >=3.11, so the marker is gated: without it, resolution for
-# the (3.10-supporting) SDK fails. The extra is dev-only and we always run it on
-# 3.11+ (bin/setup uses 3.11).
 fake-provider = [
-    "cmpnd-fake-provider; python_version >= '3.11'",
+    "cmpnd-fake-provider",
 ]
 
 [tool.uv.sources]
@@ -224,7 +223,7 @@ markers = [
 
 [tool.ruff]
 line-length = 120
-target-version = "py310"
+target-version = "py311"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "W"]
@@ -256,7 +255,7 @@ select = ["E", "F", "I", "W"]
 # no relaxations, so it gets no executionEnvironment of its own.
 include = ["cmpnd", "ingest/cmpnd_ingest", "examples", "tests/stress", "tests/e2e", "tests/load"]
 stubPath = "stubs"
-pythonVersion = "3.10"
+pythonVersion = "3.11"
 reportAny = false
 reportExplicitAny = false
 reportUnknownMemberType = false

cmpnd-0.42.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__)"