cmpnd 0.3.0__tar.gz → 0.4.1__tar.gz

{cmpnd-0.3.0 → cmpnd-0.4.1}/CLAUDE.md

@@ -35,7 +35,7 @@ uv run ruff format --check .             # format check
 - `cmpnd/callback.py` - DSPy instrumentation, signature extraction
 - `cmpnd/optimizers/tracker.py` - Optimization tracking
 - `cmpnd/packaging.py` - Source ZIP generation for deploy (ported from deploy/local_cmpnd.py)
-- `cmpnd/deployment.py` - `deploy()` function: SDK -> Rails -> AWS deploy stack
+- `cmpnd/deployment.py` - `deploy()` function: SDK -> serve -> AWS deploy stack
 
 ## Reflector ↔ DSPy compatibility
 

{cmpnd-0.3.0 → cmpnd-0.4.1}/PKG-INFO

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

{cmpnd-0.3.0 → cmpnd-0.4.1}/cmpnd/__init__.py

@@ -129,4 +129,11 @@ def auto_instrument() -> CmpndCallback:
 
     _gepa_patch.patch_gepa()
 
+    # Persist the compiled-from lineage tag across state-only save/load so a
+    # continued optimization still stamps compiled_from_run_id after a disk
+    # reload / process restart (CMP-444).
+    from . import _program_patch
+
+    _program_patch.patch_program_state()
+
     return callback

{cmpnd-0.3.0 → cmpnd-0.4.1}/cmpnd/_gepa_patch.py

@@ -144,7 +144,9 @@ def patch_gepa() -> None:
 
         except Exception as e:
             if callback is not None:  # pyright: ignore[reportUnnecessaryComparison]
-                callback._tracker.set_error(e)
+                # Flush a terminal 'failed', not just in-memory state — else the
+                # running row start() sent lingers forever (CMP-414).
+                callback._tracker.finalize_error(e)
             raise
 
         finally:

cmpnd-0.4.1/cmpnd/_program_patch.py

@@ -0,0 +1,112 @@
+"""Persist the compiled-from lineage tag across DSPy's state-only save/load.
+
+GEPA tags a compiled program with ``result._optimization_run_id`` (see
+``cmpnd/optimizers/gepa.py`` and ``cmpnd/_gepa_patch.py``); a subsequent
+``compile()`` starting from that program reads the tag back in
+``tracker.enrich_from_program`` and sends it as ``compiled_from_run_id``, which
+is how the cross-run lineage chain (Go breadcrumb bar) is built.
+
+That tag is a plain instance attribute. DSPy's state-only save path
+(``module.save("p.json")`` / ``.pkl`` with ``save_program=False``) serializes
+**only named parameters** — ``BaseModule.dump_state`` returns
+``{name: param.dump_state()}`` and ``load_state`` iterates only parameter names
+— so the tag is dropped on both ends of a disk round-trip and the lineage
+silently vanishes across a save/load or process restart. (``save_program=True``
+cloudpickles the whole instance and already preserves it; the gap is exclusively
+the state-only path, which is the one DSPy steers users toward.)
+
+DSPy exposes no extension point for out-of-band instance state (no
+``get_extra_state`` / attribute allowlist; ``metadata`` is DSPy-owned). Rather
+than change DSPy upstream (CMP-444 decision), ``patch_program_state()`` wraps
+``dump_state`` / ``load_state`` on the two classes that define them — the
+composite ``Module`` path and the bare ``Predict`` path — to round-trip the tag
+under a namespaced carrier key. Installed lazily from
+``cmpnd.auto_instrument()`` alongside ``patch_gepa()``.
+
+The carrier is a single reserved top-level key (the same shape DSPy itself uses
+for its sibling ``metadata`` key). Stock ``Module.load_state`` ignores it (it
+reads only parameter names); ``Predict.load_state`` ``setattr``s every key, so
+the ``Predict`` wrapper strips the carrier after restoring the attribute so it
+doesn't leak onto the instance.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# Reserved top-level key carrying cmpnd's out-of-band program state. Namespaced
+# so it can't collide with a DSPy named-parameter path.
+_LINEAGE_KEY = "_cmpnd"
+_RUN_ID_FIELD = "optimization_run_id"
+
+_patched = False
+
+
+def _inject(state: Any, module: Any) -> Any:
+    """Add the lineage carrier to a dumped state dict when the module is tagged."""
+    run_id = getattr(module, "_optimization_run_id", None)
+    if run_id is not None and isinstance(state, dict):
+        state[_LINEAGE_KEY] = {_RUN_ID_FIELD: str(run_id)}
+    return state
+
+
+def _restore(state: Any, module: Any) -> None:
+    """Re-attach ``_optimization_run_id`` from a loaded state dict's carrier."""
+    if not isinstance(state, dict):
+        return
+    carrier = state.get(_LINEAGE_KEY)
+    if isinstance(carrier, dict) and carrier.get(_RUN_ID_FIELD):
+        module._optimization_run_id = str(carrier[_RUN_ID_FIELD])
+
+
+# The wrappers forward *args/**kwargs verbatim rather than naming dump_state's
+# json_mode / load_state's allow_unsafe_lm_state: those signatures differ across
+# DSPy versions (allow_unsafe_lm_state was added after 3.1.x), and the patch is
+# installed process-wide, so it must be transparent to every caller and version.
+def _wrap_dump(orig):
+    def dump_state(self, *args, **kwargs):
+        return _inject(orig(self, *args, **kwargs), self)
+
+    return dump_state
+
+
+def _wrap_load(orig, *, strip: bool):
+    def load_state(self, state, *args, **kwargs):
+        _restore(state, self)
+        # Predict.load_state setattrs every non-excluded key; drop the carrier
+        # so it doesn't land as a stray `_cmpnd` attribute. Module.load_state
+        # reads only parameter names, so it needs no strip.
+        if strip and isinstance(state, dict) and _LINEAGE_KEY in state:
+            state = {k: v for k, v in state.items() if k != _LINEAGE_KEY}
+        return orig(self, state, *args, **kwargs)
+
+    return load_state
+
+
+def patch_program_state() -> None:
+    """Wrap dump_state/load_state so the lineage tag survives a disk reload.
+
+    Idempotent (a module-level flag guards against double-patching); a no-op
+    when dspy isn't installed.
+    """
+    global _patched
+    if _patched:
+        return
+
+    try:
+        import dspy
+    except ImportError:
+        return
+
+    # Composite programs (dspy.Module subclasses, ChainOfThought, …) inherit
+    # dump_state/load_state from BaseModule; patching on dspy.Module covers every
+    # composite. A bare Predict program overrides both, so patch that path too.
+    # The methods are swapped via getattr/setattr rather than direct attribute
+    # assignment because dspy.*.load_state types as Unknown to basedpyright (its
+    # body imports the untyped dspy.predict.predict) — reflection keeps the swap
+    # off the type checker's attribute-access path across every DSPy version.
+    for cls, strip in ((dspy.Module, False), (dspy.Predict, True)):
+        setattr(cls, "dump_state", _wrap_dump(getattr(cls, "dump_state")))
+        setattr(cls, "load_state", _wrap_load(getattr(cls, "load_state"), strip=strip))
+
+    _patched = True

{cmpnd-0.3.0 → cmpnd-0.4.1}/cmpnd/callback.py

@@ -747,18 +747,20 @@ class _LMMixin(_CallbackBase):
 
         context.pop_span()
 
-        # If this LM call has no trace context but we're in an optimization,
-        # accumulate token usage for the optimization cost computation.
-        # This captures GEPA reflection LM calls which run outside traced program flow.
+        # An LM call with no active trace context, made while an optimization is
+        # running, is GEPA optimizer machinery — an LM call outside any program
+        # rollout. Two phases produce these: reflection (the instructor proposing
+        # new instructions, between evaluations) and metric (an LLM-as-judge /
+        # semantic metric scoring outputs, during evaluation). Rather than drop
+        # them, wrap each in its own trace linked to the optimization run so it
+        # shows up alongside the student traces (CMP-485). serve's
+        # TracedTokensForRun then accounts for their cost from the span, so these
+        # must NOT also be added to _orphaned_lm_usage / untraced_lm_usage — that
+        # would double-count them in the optimization total.
         current_trace = context.get_current_trace()
         if current_trace is None and self._active_optimization_run_id is not None:
-            model_name = span.model_name or "unknown"
-            if model_name not in self._orphaned_lm_usage:
-                self._orphaned_lm_usage[model_name] = {"prompt_tokens": 0, "completion_tokens": 0}
-            self._orphaned_lm_usage[model_name]["prompt_tokens"] += span.prompt_tokens or 0
-            self._orphaned_lm_usage[model_name]["completion_tokens"] += span.completion_tokens or 0
-            logger.debug(f"Orphaned LM usage ({model_name}): +{span.prompt_tokens}p/{span.completion_tokens}c tokens")
-            return  # Don't export orphaned spans (no trace to attach to)
+            self._emit_optimization_lm_trace(span)
+            return  # handled as a standalone GEPA-process trace
 
         # Track span by trace_id for metric aggregation (LM spans have token info!)
         if span.trace_id:
@@ -772,6 +774,64 @@ class _LMMixin(_CallbackBase):
             if exp:
                 exp.export_span(span)
 
+    def _emit_optimization_lm_trace(self, span: models.SpanBuilder) -> None:
+        """Wrap an LM call the GEPA optimizer made outside a program rollout in
+        its own trace, linked to the active optimization run.
+
+        Two phases produce such calls, on different models:
+          - "reflection": GEPA's instruction proposer (the reflection LM), run in
+            the optimize loop between evaluations.
+          - "metric": an LLM-as-judge / semantic metric (the student LM or a
+            separate judge LM), run during candidate evaluation after the program
+            trace has already closed.
+
+        We distinguish them by `_active_eval_run` — set only while DSPy Evaluate
+        is running — instead of assuming every untraced call is reflection (that
+        would mislabel judge calls). The trace is named with the umbrella "GEPA";
+        the specific model stays on the span's model_name, and `gepa.phase`
+        carries the distinction (CMP-485). Each becomes a standalone one-span
+        trace so the prompt, response, tokens and cost are visible alongside the
+        student traces instead of being reduced to an aggregate token count.
+        """
+        run_id = self._active_optimization_run_id
+        if not run_id:
+            return
+
+        phase = "metric" if self._active_eval_run is not None else "reflection"
+        span.attributes["gepa.phase"] = phase
+
+        trace = models.TraceBuilder(
+            trace_id=span.trace_id or uuid4(),
+            start_time=span.start_time,
+            end_time=span.end_time,
+            program_name="GEPA",
+        )
+        # A metric-phase call can start while DSPy's Evaluate span is still on the
+        # context stack, so on_lm_start stamped this span with a parent_span_id for
+        # a span that isn't in this standalone one-span trace. This span IS the
+        # trace's root, so force it parentless and pin it to this trace so tree/root
+        # reconstruction works (CMP-485, Greptile P1).
+        span.parent_span_id = None
+        span.trace_id = trace.trace_id
+        trace.signature_name = span.model_name or phase
+        trace.status = span.status
+        trace.optimization_run_id = run_id
+        trace.tags["optimization_phase"] = phase
+
+        # Single-span trace: roll the span's usage up onto the trace so the
+        # traces list shows tokens/cost without a separate aggregation pass.
+        trace.prompt_tokens = span.prompt_tokens or 0
+        trace.completion_tokens = span.completion_tokens or 0
+        trace.total_tokens = span.total_tokens or 0
+        trace.total_cost = span.cost or 0.0
+        trace.span_count = 1
+
+        exp = exporter.get_exporter()
+        if exp:
+            exp.export_trace_stats(trace)  # stats tier (never dropped)
+            trace._batch_spans = [span]
+            exp.export_trace(trace)
+
 
 class _AdapterMixin(_CallbackBase):
     """DSPy adapter callbacks (format/parse start/end)."""

{cmpnd-0.3.0 → cmpnd-0.4.1}/cmpnd/cli/api_client.py

@@ -49,6 +49,12 @@ class ApiClient:
     def post(self, path: str, json: dict[str, Any] | None = None) -> Any:
         return self._request("POST", path, json=json)
 
+    def patch(self, path: str, json: dict[str, Any] | None = None) -> Any:
+        return self._request("PATCH", path, json=json)
+
+    def put(self, path: str, json: dict[str, Any] | None = None) -> Any:
+        return self._request("PUT", path, json=json)
+
     def delete(self, path: str) -> Any:
         return self._request("DELETE", path)
 
@@ -77,6 +83,10 @@ class ApiClient:
                     response = client.get(url, params=params)
                 elif method == "DELETE":
                     response = client.delete(url)
+                elif method == "PATCH":
+                    response = client.patch(url, json=json)
+                elif method == "PUT":
+                    response = client.put(url, json=json)
                 else:
                     response = client.post(url, json=json)
         except httpx.ConnectError:

cmpnd-0.4.1/cmpnd/cli/commands/admin.py

@@ -0,0 +1,274 @@
+"""Platform-operator commands, hidden behind CMPND_CLI_ADMIN=1.
+
+`cmpnd admin org create|set-owner|list|get|set-limit|set-github-login|elect-owner`
+is the closed-beta org bootstrap and steward surface (CMP-126/CMP-278/CMP-472):
+stand up a shared org with its GitHub auto-join key, anoint its first owner,
+adjust its member cap or GitHub link, and grant ownership from the election
+queue. `cmpnd admin user …` is the operator's user-lifecycle surface (list,
+inspect, create, approve/reject the pending-signup queue, promote/demote admin,
+disable/enable, reset a password, and manage a user's API-key scopes). `cmpnd
+admin feature-flags …` reads and toggles the server's runtime flags. These hit
+/api/v1/admin/* and require an API key carrying the admin:* scopes — the server
+is the real authority. The CMPND_CLI_ADMIN env gate (mirroring CMPND_CLI_DEV)
+only keeps these out of customers' --help; it grants nothing.
+"""
+
+from __future__ import annotations
+
+from argparse import ArgumentParser, _SubParsersAction
+from typing import Any
+
+from .. import api_client
+
+
+def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser("admin", help="Platform-operator commands (CMPND_CLI_ADMIN)")
+    sub = parser.add_subparsers(dest="action")
+
+    _register_org(sub)
+    _register_user(sub)
+    _register_feature_flags(sub)
+
+
+def _register_org(sub: _SubParsersAction[ArgumentParser]) -> None:
+    org = sub.add_parser("org", help="Organization bootstrap")
+    osub = org.add_subparsers(dest="org_action")
+
+    create = osub.add_parser("create", help="Create an organization")
+    create.add_argument("name", help="Organization name")
+    create.add_argument(
+        "--github-login",
+        dest="github_login",
+        default="",
+        help="GitHub org login for OAuth auto-join (optional)",
+    )
+    create.set_defaults(func=handle_org_create)
+
+    set_owner = osub.add_parser("set-owner", help="Make an existing user the org's owner")
+    set_owner.add_argument("org_id", help="Organization id")
+    set_owner.add_argument("email", help="Owner email (must already be a provisioned user)")
+    set_owner.set_defaults(func=handle_org_set_owner)
+
+    ls = osub.add_parser("list", help="List organizations")
+    ls.set_defaults(func=handle_org_list)
+
+    get = osub.add_parser("get", help="Show one organization")
+    get.add_argument("org_id", help="Organization id")
+    get.set_defaults(func=handle_org_get)
+
+    set_limit = osub.add_parser("set-limit", help="Set an org's member cap")
+    set_limit.add_argument("org_id", help="Organization id")
+    set_limit.add_argument("max", type=int, help="Maximum members")
+    set_limit.set_defaults(func=handle_org_set_limit)
+
+    set_github_login = osub.add_parser("set-github-login", help="Set (or clear) an org's GitHub login")
+    set_github_login.add_argument("org_id", help="Organization id")
+    set_github_login.add_argument("login", help='GitHub org login (pass "" to unlink)')
+    set_github_login.set_defaults(func=handle_org_set_github_login)
+
+    elect_owner = osub.add_parser("elect-owner", help="Grant ownership from the election queue")
+    elect_owner.add_argument("github_login", help="The org's GitHub login")
+    elect_owner.add_argument("user_id", help="User id to make owner")
+    elect_owner.set_defaults(func=handle_org_elect_owner)
+
+
+def _register_user(sub: _SubParsersAction[ArgumentParser]) -> None:
+    user = sub.add_parser("user", help="User lifecycle management")
+    usub = user.add_subparsers(dest="user_action")
+
+    ls = usub.add_parser("list", help="List users")
+    ls.set_defaults(func=handle_user_list)
+
+    get = usub.add_parser("get", help="Show one user")
+    get.add_argument("id", help="User id")
+    get.set_defaults(func=handle_user_get)
+
+    create = usub.add_parser("create", help="Provision a user")
+    create.add_argument("email", help="User email")
+    create.add_argument("--name", default="", help="Display name (optional)")
+    create.add_argument("--org-id", dest="org_id", default="", help="Org to place the user in (optional)")
+    create.add_argument("--password", default="", help="Initial password (optional)")
+    create.add_argument("--admin", dest="admin", action="store_true", help="Grant platform-admin")
+    create.set_defaults(func=handle_user_create)
+
+    approve = usub.add_parser("approve", help="Approve a pending signup")
+    approve.add_argument("id", help="User id")
+    approve.set_defaults(func=handle_user_approve)
+
+    promote = usub.add_parser("promote", help="Grant platform-admin")
+    promote.add_argument("id", help="User id")
+    promote.set_defaults(func=handle_user_promote)
+
+    demote = usub.add_parser("demote", help="Revoke platform-admin")
+    demote.add_argument("id", help="User id")
+    demote.set_defaults(func=handle_user_demote)
+
+    reject = usub.add_parser("reject", help="Decline a pending signup")
+    reject.add_argument("id", help="User id")
+    reject.add_argument("--org-id", dest="org_id", required=True, help="Org the pending signup belongs to")
+    reject.set_defaults(func=handle_user_reject)
+
+    disable = usub.add_parser("disable", help="Disable a user")
+    disable.add_argument("id", help="User id")
+    disable.set_defaults(func=handle_user_disable)
+
+    enable = usub.add_parser("enable", help="Re-enable a user")
+    enable.add_argument("id", help="User id")
+    enable.set_defaults(func=handle_user_enable)
+
+    reset_password = usub.add_parser("reset-password", help="Set a user's password")
+    reset_password.add_argument("id", help="User id")
+    reset_password.add_argument("--password", required=True, help="New password")
+    reset_password.set_defaults(func=handle_user_reset_password)
+
+    keys = usub.add_parser("keys", help="List a user's API keys")
+    keys.add_argument("id", help="User id")
+    keys.set_defaults(func=handle_user_keys)
+
+    set_scopes = usub.add_parser("set-scopes", help="Replace an API key's scopes")
+    set_scopes.add_argument("id", help="User id")
+    set_scopes.add_argument("key_id", help="API key id")
+    set_scopes.add_argument(
+        "--scope",
+        dest="scopes",
+        action="append",
+        required=True,
+        help="A scope to grant (repeat for multiple)",
+    )
+    set_scopes.set_defaults(func=handle_user_set_scopes)
+
+
+def _register_feature_flags(sub: _SubParsersAction[ArgumentParser]) -> None:
+    ff = sub.add_parser("feature-flags", help="Runtime feature flags")
+    ffsub = ff.add_subparsers(dest="ff_action")
+
+    ls = ffsub.add_parser("list", help="List feature flags")
+    ls.set_defaults(func=handle_feature_flags_list)
+
+    set_flag = ffsub.add_parser("set", help="Enable (or, with --disabled, disable) a flag")
+    set_flag.add_argument("name", help="Flag name")
+    set_flag.add_argument("--disabled", action="store_true", help="Disable the flag (default is enable)")
+    set_flag.set_defaults(func=handle_feature_flags_set)
+
+
+# --- org handlers ---------------------------------------------------------
+
+
+def handle_org_create(client: api_client.ApiClient, args: Any) -> Any:
+    return client.post(
+        "/api/v1/admin/organizations",
+        json={"name": args.name, "github_login": args.github_login},
+    )
+
+
+def handle_org_set_owner(client: api_client.ApiClient, args: Any) -> Any:
+    # 204 No Content → post() returns None; synthesize a confirmation.
+    client.post(f"/api/v1/admin/organizations/{args.org_id}/owner", json={"email": args.email})
+    return {"org_id": args.org_id, "owner": args.email}
+
+
+def handle_org_list(client: api_client.ApiClient, _args: Any) -> Any:
+    return client.get("/api/v1/admin/organizations")
+
+
+def handle_org_get(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get(f"/api/v1/admin/organizations/{args.org_id}")
+
+
+def handle_org_set_limit(client: api_client.ApiClient, args: Any) -> Any:
+    return client.patch(f"/api/v1/admin/organizations/{args.org_id}", json={"max_members": args.max})
+
+
+def handle_org_set_github_login(client: api_client.ApiClient, args: Any) -> Any:
+    # An empty login unlinks the org from GitHub auto-join; pass it through
+    # verbatim so the server can distinguish "clear" from "unchanged".
+    return client.patch(f"/api/v1/admin/organizations/{args.org_id}", json={"github_login": args.login})
+
+
+def handle_org_elect_owner(client: api_client.ApiClient, args: Any) -> Any:
+    # 204 No Content → post() returns None; synthesize a confirmation.
+    client.post(
+        "/api/v1/admin/organizations/elect-owner",
+        json={"github_login": args.github_login, "user_id": args.user_id},
+    )
+    return {"elected": args.user_id, "github_login": args.github_login}
+
+
+# --- user handlers --------------------------------------------------------
+
+
+def handle_user_list(client: api_client.ApiClient, _args: Any) -> Any:
+    return client.get("/api/v1/admin/users")
+
+
+def handle_user_get(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get(f"/api/v1/admin/users/{args.id}")
+
+
+def handle_user_create(client: api_client.ApiClient, args: Any) -> Any:
+    # email/name/org_id/is_admin are always sent; password is only included
+    # when supplied so the server keeps its own default (e.g. no local login).
+    body = {
+        "email": args.email,
+        "name": args.name,
+        "org_id": args.org_id,
+        "is_admin": args.admin,
+    }
+    if args.password:
+        body["password"] = args.password
+    return client.post("/api/v1/admin/users", json=body)
+
+
+def handle_user_approve(client: api_client.ApiClient, args: Any) -> Any:
+    return client.patch(f"/api/v1/admin/users/{args.id}", json={"is_approved": True})
+
+
+def handle_user_promote(client: api_client.ApiClient, args: Any) -> Any:
+    return client.patch(f"/api/v1/admin/users/{args.id}", json={"is_admin": True})
+
+
+def handle_user_demote(client: api_client.ApiClient, args: Any) -> Any:
+    return client.patch(f"/api/v1/admin/users/{args.id}", json={"is_admin": False})
+
+
+def handle_user_reject(client: api_client.ApiClient, args: Any) -> Any:
+    # 204 No Content → post() returns None; synthesize a confirmation.
+    client.post(f"/api/v1/admin/users/{args.id}/reject", json={"org_id": args.org_id})
+    return {"rejected": args.id}
+
+
+def handle_user_disable(client: api_client.ApiClient, args: Any) -> Any:
+    client.post(f"/api/v1/admin/users/{args.id}/disable")
+    return {"disabled": args.id}
+
+
+def handle_user_enable(client: api_client.ApiClient, args: Any) -> Any:
+    client.post(f"/api/v1/admin/users/{args.id}/enable")
+    return {"enabled": args.id}
+
+
+def handle_user_reset_password(client: api_client.ApiClient, args: Any) -> Any:
+    client.post(f"/api/v1/admin/users/{args.id}/reset-password", json={"password": args.password})
+    return {"password_reset": args.id}
+
+
+def handle_user_keys(client: api_client.ApiClient, args: Any) -> Any:
+    return client.get(f"/api/v1/admin/users/{args.id}/keys")
+
+
+def handle_user_set_scopes(client: api_client.ApiClient, args: Any) -> Any:
+    return client.put(
+        f"/api/v1/admin/users/{args.id}/keys/{args.key_id}/scopes",
+        json={"scopes": args.scopes},
+    )
+
+
+# --- feature-flag handlers ------------------------------------------------
+
+
+def handle_feature_flags_list(client: api_client.ApiClient, _args: Any) -> Any:
+    return client.get("/api/v1/admin/feature-flags")
+
+
+def handle_feature_flags_set(client: api_client.ApiClient, args: Any) -> Any:
+    return client.put(f"/api/v1/admin/feature-flags/{args.name}", json={"enabled": not args.disabled})

{cmpnd-0.3.0 → cmpnd-0.4.1}/cmpnd/cli/commands/org.py

@@ -15,6 +15,13 @@ hit /api/v1/org/ownership-requests and are self-scoped to the calling key's
 user — no owner check (a platform admin grants ownership from the election
 queue; the request is just recorded intent).
 
+`cmpnd org keys list|create|revoke` is your own API-key surface (CMP-472):
+list the keys you've minted, mint a new scoped key (the response carries the
+one-time token — the server stores only its hash), and revoke one. These hit
+/api/v1/org/keys and are self-scoped to the calling key's user — you only ever
+see and manage your own keys, bound to your active org (the non-interactive
+alternative to the `cmpnd login` loopback).
+
 Always registered (no env gate); the server is the authority.
 """
 
@@ -66,6 +73,27 @@ def register(subparsers: _SubParsersAction[ArgumentParser]) -> None:
     withdraw.add_argument("github_login", help="The org's GitHub login (e.g. acme)")
     withdraw.set_defaults(func=handle_withdraw_ownership)
 
+    keys = sub.add_parser("keys", help="Manage your organization's API keys")
+    ksub = keys.add_subparsers(dest="keys_action")
+
+    keys_list = ksub.add_parser("list", help="List the org's API keys")
+    keys_list.set_defaults(func=handle_keys_list)
+
+    keys_create = ksub.add_parser("create", help="Mint a new scoped API key")
+    keys_create.add_argument("name", help="A label for the key")
+    keys_create.add_argument(
+        "--scope",
+        dest="scopes",
+        action="append",
+        required=True,
+        help="A scope to grant (repeat for multiple)",
+    )
+    keys_create.set_defaults(func=handle_keys_create)
+
+    keys_revoke = ksub.add_parser("revoke", help="Revoke an API key")
+    keys_revoke.add_argument("key_id", help="API key id (from `org keys list`)")
+    keys_revoke.set_defaults(func=handle_keys_revoke)
+
 
 def handle_members_pending(client: api_client.ApiClient, _args: Any) -> Any:
     return client.get("/api/v1/org/members/pending")
@@ -113,3 +141,19 @@ def handle_ownership_requests(client: api_client.ApiClient, _args: Any) -> Any:
 def handle_withdraw_ownership(client: api_client.ApiClient, args: Any) -> Any:
     client.post(f"/api/v1/org/ownership-requests/{args.github_login}/withdraw")
     return {"withdrawn": args.github_login}
+
+
+def handle_keys_list(client: api_client.ApiClient, _args: Any) -> Any:
+    return client.get("/api/v1/org/keys")
+
+
+def handle_keys_create(client: api_client.ApiClient, args: Any) -> Any:
+    # The response carries the one-time key token — the server stores only its
+    # hash, so this is the single moment it's shown. Pass it straight through.
+    return client.post("/api/v1/org/keys", json={"name": args.name, "scopes": args.scopes})
+
+
+def handle_keys_revoke(client: api_client.ApiClient, args: Any) -> Any:
+    # 204 No Content → delete() returns None; synthesize a confirmation.
+    client.delete(f"/api/v1/org/keys/{args.key_id}")
+    return {"revoked": args.key_id}

{cmpnd-0.3.0 → cmpnd-0.4.1}/cmpnd/deployment.py

@@ -72,7 +72,7 @@ def _raise_http_error(response: httpx.Response, action: str) -> None:
 class DeployFailed(RuntimeError):
     """Raised when a deployment transitions to ``status=failed``.
 
-    Carries the structured failure detail Rails persists when the parser
+    Carries the structured failure detail the server persists when the parser
     writes a failure marker. ``failure_phase`` is one of a closed set of
     pipeline-stage names (e.g. ``unpack_zip``, ``signature_extraction``,
     ``lm_load``); ``failure_reason`` is a constant template synthesized
@@ -86,7 +86,7 @@ class DeployFailed(RuntimeError):
     parser Lambda's CloudWatch group.
 
     Both fields are ``None`` when the server didn't return structured
-    detail (older deployments or older Rails versions).
+    detail (older deployments or older server versions).
 
     Subclasses ``RuntimeError`` so existing ``except RuntimeError`` callers
     keep working.
@@ -117,7 +117,7 @@ class DeployFailed(RuntimeError):
 def deploy(module, metric=None, timeout=300, metadata=None):
     """Deploy a DSPy module via the Cmpnd platform.
 
-    Packages the module into a source ZIP, uploads it through Rails to the
+    Packages the module into a source ZIP, uploads it through the platform API to the
     deploy stack, and polls until the program is parsed and ready.
 
     Args:
@@ -192,18 +192,18 @@ def deploy(module, metric=None, timeout=300, metadata=None):
         if lm_kwargs.get("api_base"):
             deploy_body["lm_api_host"] = lm_kwargs["api_base"]
 
-    # Client for Rails API calls (JSON)
-    rails_headers = {
+    # Client for platform API calls (JSON)
+    api_headers = {
         "X-API-Key": config.api_key,
         "Content-Type": "application/json",
     }
 
     with httpx.Client(timeout=30.0) as client:
-        # Step 1: Create deployment via Rails
+        # Step 1: Create deployment via the platform API
         create_resp = client.post(
             f"{config.endpoint}/api/v1/deployments",
             json=deploy_body,
-            headers=rails_headers,
+            headers=api_headers,
         )
         _raise_http_error(create_resp, "create deployment")
         data = create_resp.json()
@@ -241,7 +241,7 @@ def deploy(module, metric=None, timeout=300, metadata=None):
 
             poll_resp = client.get(
                 f"{config.endpoint}/api/v1/deployments/{deployment_id}",
-                headers=rails_headers,
+                headers=api_headers,
             )
             _raise_http_error(poll_resp, "poll deployment status")
             status_data = poll_resp.json()