sdcmodeler 4.0.0__tar.gz → 4.2.0__tar.gz

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdcmodeler
-Version: 4.0.0
+Version: 4.2.0
 Summary: The modeler's client for SDCStudio: search the catalog, estimate, assemble and publish SDC4 data models, generate applications; a CLI and an MCP server over one client
 Author: Axius SDC, Inc.
 License-Expression: Apache-2.0
@@ -68,11 +68,11 @@ tree = {
     ],
     "clusters": [],
 }
-print(c.estimate(tree, "Vitals"))           # reuse, mint, total_credits, estimate_id; no call that spends
-result = c.assemble("Vitals", tree)         # 500 credits plus the mints
+estimate = c.estimate(tree, "Vitals")       # the server's estimate: reuse, mint, problems, total_credits, wallet, key, estimate_id
+result = c.assemble("Vitals", tree, estimate_id=estimate["estimate_id"])   # 500 credits plus the mints
 ```
 
-Every leaf existing: the server assembles, publishes and generates the package in one call (`result["mode"] == "reuse"`). Some leaves new: the pipeline runs and `result["data_source_ct_id"]` is polled with `c.job_status(...)`.
+Every leaf existing: the server assembles, publishes and generates the package in one call (`result["mode"] == "reuse"`; `published` and `generated` say so). Some leaves new: the pipeline runs and `result["job_ct_id"]` is polled with `c.job_status(...)`, or `c.wait_for_job(...)`, until `completed`, when the job has published and generated as asked and its result carries the model's links. `publish=False` leaves a draft for a person to review. The server refuses a build whose tree changed since the estimate.
 
 A 402 is `InsufficientCredits` with the numbers in credits. A 403 from the key's policy (no `spend` scope, or past its limit) is `KeyPolicyRefused`. The client never funds a wallet; a person does that at the wallet page.
 
@@ -106,8 +106,8 @@ A JSON-RPC 2.0 stdio server, no SDK, the way sdcvalidator and sdcgovernance are
 | `search_components` | the public catalog by label, type and project | no |
 | `list_models`, `get_model` | published models and their artifact routes | no |
 | `estimate_model` | what a tree would reuse, mint and cost; returns `estimate_id` | no |
-| `build_model` | assemble and publish; needs the `estimate_id` the person saw; refuses past the key's limit | yes |
-| `job_status` | the pipeline for a mixed build | no |
+| `build_model` | assemble, publish and generate (or `publish: false` for a draft); needs the `estimate_id` the person saw; refuses past the key's limit | yes |
+| `job_status` | one job by id: status, step, cost so far, the model's links | no |
 | `generate_app` | generate and download the application; needs `confirm_charge`; 1,500 credits the first time, free after | yes |
 | `wallet` | balance in credits and the key's policy | no |
 

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/README.md

@@ -42,11 +42,11 @@ tree = {
     ],
     "clusters": [],
 }
-print(c.estimate(tree, "Vitals"))           # reuse, mint, total_credits, estimate_id; no call that spends
-result = c.assemble("Vitals", tree)         # 500 credits plus the mints
+estimate = c.estimate(tree, "Vitals")       # the server's estimate: reuse, mint, problems, total_credits, wallet, key, estimate_id
+result = c.assemble("Vitals", tree, estimate_id=estimate["estimate_id"])   # 500 credits plus the mints
 ```
 
-Every leaf existing: the server assembles, publishes and generates the package in one call (`result["mode"] == "reuse"`). Some leaves new: the pipeline runs and `result["data_source_ct_id"]` is polled with `c.job_status(...)`.
+Every leaf existing: the server assembles, publishes and generates the package in one call (`result["mode"] == "reuse"`; `published` and `generated` say so). Some leaves new: the pipeline runs and `result["job_ct_id"]` is polled with `c.job_status(...)`, or `c.wait_for_job(...)`, until `completed`, when the job has published and generated as asked and its result carries the model's links. `publish=False` leaves a draft for a person to review. The server refuses a build whose tree changed since the estimate.
 
 A 402 is `InsufficientCredits` with the numbers in credits. A 403 from the key's policy (no `spend` scope, or past its limit) is `KeyPolicyRefused`. The client never funds a wallet; a person does that at the wallet page.
 
@@ -80,8 +80,8 @@ A JSON-RPC 2.0 stdio server, no SDK, the way sdcvalidator and sdcgovernance are
 | `search_components` | the public catalog by label, type and project | no |
 | `list_models`, `get_model` | published models and their artifact routes | no |
 | `estimate_model` | what a tree would reuse, mint and cost; returns `estimate_id` | no |
-| `build_model` | assemble and publish; needs the `estimate_id` the person saw; refuses past the key's limit | yes |
-| `job_status` | the pipeline for a mixed build | no |
+| `build_model` | assemble, publish and generate (or `publish: false` for a draft); needs the `estimate_id` the person saw; refuses past the key's limit | yes |
+| `job_status` | one job by id: status, step, cost so far, the model's links | no |
 | `generate_app` | generate and download the application; needs `confirm_charge`; 1,500 credits the first time, free after | yes |
 | `wallet` | balance in credits and the key's policy | no |
 

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sdcmodeler"
-version = "4.0.0"
+version = "4.2.0"
 description = "The modeler's client for SDCStudio: search the catalog, estimate, assemble and publish SDC4 data models, generate applications; a CLI and an MCP server over one client"
 license = "Apache-2.0"
 requires-python = ">=3.10"

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/src/sdcmodeler/__init__.py

@@ -17,7 +17,7 @@ servers: sdcvalidator validates, sdcgovernance governs, sdcreader reads,
 sdcmodeler models. It also names the concept SDCStudio already has: every user
 is a Modeler, and the Modeler's projects scope every call.
 """
-__version__ = "4.0.0"
+__version__ = "4.2.0"
 
 from sdcmodeler.client import (  # noqa: E402
     AssemblyRefused,

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/src/sdcmodeler/cli.py

@@ -50,11 +50,22 @@ def build_parser() -> argparse.ArgumentParser:
 
     s = sub.add_parser("build", help="assemble (and, with every leaf existing, publish and generate) a model; spends credits")
     s.add_argument("tree"); s.add_argument("--title", required=True); s.add_argument("--description", default="")
-    s.set_defaults(func=lambda c, a: c.assemble(a.title, _load_tree(a.tree), description=a.description))
-
-    s = sub.add_parser("job", help="status of a mixed build or an upload")
-    s.add_argument("data_source_ct_id")
-    s.set_defaults(func=lambda c, a: c.job_status(a.data_source_ct_id))
+    s.add_argument("--estimate-id", default=None, help="the id `estimate` printed; the server refuses a build whose tree changed since")
+    s.add_argument("--draft", action="store_true", help="do not publish (nothing is generated either)")
+    s.add_argument("--no-generate", action="store_true", help="publish without building the package")
+    s.add_argument("--wait", action="store_true", help="on the mixed path, poll the job until it completes or fails")
+    def _build(c, a):
+        result = c.assemble(a.title, _load_tree(a.tree), description=a.description, estimate_id=a.estimate_id,
+                            publish=not a.draft, generate=not a.no_generate)
+        if a.wait and result.get("mode") == "mixed" and result.get("job_ct_id"):
+            result["job"] = c.wait_for_job(result["job_ct_id"])
+        return result
+    s.set_defaults(func=_build)
+
+    s = sub.add_parser("job", help="one job by id (from build), or every job with --list")
+    s.add_argument("job_ct_id", nargs="?")
+    s.add_argument("--list", action="store_true")
+    s.set_defaults(func=lambda c, a: c.jobs() if a.list or not a.job_ct_id else c.job_status(a.job_ct_id))
 
     s = sub.add_parser("package", help="generate a published model's package and download it")
     s.add_argument("ct_id"); s.add_argument("--dir", default=".")

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/src/sdcmodeler/client.py

@@ -88,6 +88,7 @@ class SDCStudioClient:
         self._http = http or httpx.Client(base_url=self.base_url, headers=headers, timeout=timeout)
         if http is not None and self.api_key and "Authorization" not in http.headers:
             http.headers["Authorization"] = f"Token {self.api_key}"
+        self._default_project_checked = False
 
     def close(self) -> None:
         self._http.close()
@@ -193,25 +194,71 @@ class SDCStudioClient:
 
     # ------------------------------------------------------------------ building
 
-    def estimate(self, tree: dict[str, Any], title: str = "") -> dict[str, Any]:
-        """What the assembly would reuse, mint and cost, computed locally (``sdcmodeler.pricing``)."""
-        return pricing.estimate_tree(tree, title)
+    def estimate(self, tree: dict[str, Any], title: str = "", *, allow_retired: bool = False) -> dict[str, Any]:
+        """
+        What the assembly would reuse, mint and cost.
+
+        With a key, the server's estimate (``POST /api/v1/dmgen/assemble/estimate/``,
+        SDCStudio 4.17.0): every leaf resolved as ``assemble/`` resolves it, problems
+        named, the wallet's and the key's position, and the same ``estimate_id`` the
+        local computation produces. Without a key, or against a deployment older
+        than 4.17.0, the local estimate (``sdcmodeler.pricing``), marked
+        ``"source": "local"``.
+        """
+        local = pricing.estimate_tree(tree, title)
+        if not self.api_key:
+            local["source"] = "local"
+            return local
+        payload: dict[str, Any] = {"title": title, "data": tree}
+        if allow_retired:
+            payload["allow_retired"] = True
+        resp = self._http.post("/api/v1/dmgen/assemble/estimate/", json=payload)
+        if resp.status_code == 404:
+            local["source"] = "local"
+            return local
+        self._raise(resp)
+        server = _body(resp)
+        server["source"] = "server"
+        return server
 
     def assemble(self, title: str, tree: dict[str, Any], *, description: str = "",
-                 contextual: dict | None = None, allow_retired: bool = False) -> dict[str, Any]:
+                 contextual: dict | None = None, allow_retired: bool = False,
+                 estimate_id: str | None = None, publish: bool = True, generate: bool = True) -> dict[str, Any]:
         """
         POST ``/api/v1/dmgen/assemble/``.
 
-        Every leaf existing: the server assembles, publishes and generates
-        synchronously and answers 200 with the model (``mode`` ``"reuse"``).
-        Some leaves new: 202 with ``task_id`` and ``data_source_ct_id`` to poll
-        with ``job_status`` (``mode`` ``"mixed"``; the result is a draft model).
+        Every leaf existing: the server assembles, and with ``publish`` (default)
+        publishes and with ``generate`` (default) builds the package, in one call;
+        200 with the model, ``published``, ``generated`` and ``model_url``
+        (``mode`` ``"reuse"``). Some leaves new: 202 with ``job_ct_id`` (SDCStudio
+        4.17.0) to poll with ``job_status`` (``mode`` ``"mixed"``); when the
+        pipeline completes, the job publishes bottom-up and generates as the flags
+        asked (4.17.2) and its result says ``published`` and ``generated``.
+        ``estimate_id`` is the id of the estimate the person saw; the server
+        refuses a build whose tree no longer matches it (409 ``stale_estimate``,
+        raised as ``AssemblyRefused``).
         """
-        payload: dict[str, Any] = {"title": title, "description": description, "data": tree}
+        # assemble/ needs the Modeler's default project and answers 400 without one;
+        # the PRD's "default project created on first use" (3.1.4) is done here,
+        # once per client, until the server does it.
+        if not self._default_project_checked:
+            self.ensure_default_project()
+            self._default_project_checked = True
+        # The server refuses a blank description ("may not be blank") but accepts its
+        # absence, so an empty one is left out.
+        payload: dict[str, Any] = {"title": title, "data": tree}
+        if description:
+            payload["description"] = description
         if contextual:
             payload["contextual"] = contextual
         if allow_retired:
             payload["allow_retired"] = True
+        if estimate_id:
+            payload["estimate_id"] = estimate_id
+        if not publish:
+            payload["publish"] = False
+        if not generate or not publish:
+            payload["generate"] = False
         resp = self._http.post("/api/v1/dmgen/assemble/", json=payload)
         if resp.status_code == 409:
             raise AssemblyRefused(409, _body(resp), (_body(resp) or {}).get("error", "Assembly refused.") if isinstance(_body(resp), dict) else "Assembly refused.")
@@ -221,16 +268,51 @@ class SDCStudioClient:
         data["mode"] = "mixed" if resp.status_code == 202 else "reuse"
         return data
 
-    def job_status(self, data_source_ct_id: str) -> dict[str, Any]:
-        """The pipeline's status for a mixed assembly or an upload (``status``: uploaded, parsing, parsed, agent_processing, modeling, completed, error, agent_error)."""
+    def job_status(self, job_ct_id: str) -> dict[str, Any]:
+        """
+        The job resource (SDCStudio 4.17.0): ``status`` (queued, running, completed,
+        failed), ``step``, ``cost_credits``, ``result`` with the model's links on
+        completion, ``error`` on failure.
+        """
+        return self._get(f"/api/v1/jobs/{job_ct_id}/")
+
+    def wait_for_job(self, job_ct_id: str, *, timeout: float = 900.0, interval: float = 3.0,
+                     max_interval: float = 20.0) -> dict[str, Any]:
+        """
+        Poll the job until it is ``completed`` or ``failed`` (or ``timeout`` seconds pass).
+
+        Backs off from ``interval`` to ``max_interval``. Returns the last job
+        record; raises ``TimeoutError`` with it attached when time runs out.
+        """
+        import time
+
+        deadline = time.monotonic() + timeout
+        wait = interval
+        while True:
+            job = self.job_status(job_ct_id)
+            if job.get("status") in ("completed", "failed"):
+                return job
+            if time.monotonic() >= deadline:
+                err = TimeoutError(f"Job {job_ct_id} still {job.get('status')} after {timeout:.0f}s")
+                err.job = job  # type: ignore[attr-defined]
+                raise err
+            time.sleep(wait)
+            wait = min(max_interval, wait * 1.5)
+
+    def jobs(self, *, kind: str | None = None, data_source_ct_id: str | None = None) -> dict[str, Any]:
+        """The caller's jobs, newest first; narrowed by ``kind`` or ``data_source_ct_id``."""
+        return self._get("/api/v1/jobs/", kind=kind, data_source=data_source_ct_id)
+
+    def pipeline_status(self, data_source_ct_id: str) -> dict[str, Any]:
+        """The pipeline's own status for a data source, for deployments older than 4.17.0."""
         return self._get(f"/api/v1/uploader/api/data-sources/{data_source_ct_id}/workflow_status/")
 
     def publish_model(self, ct_id: str) -> dict[str, Any]:
         return self._post(f"/api/v1/dmgen/dms/{ct_id}/publish/")
 
-    def generate_package(self, ct_id: str) -> dict[str, Any]:
-        """Build the published model's package (free; synchronous)."""
-        return self._post(f"/api/v1/dmgen/dms/{ct_id}/generate/")
+    def generate_package(self, ct_id: str, *, as_job: bool = False) -> dict[str, Any]:
+        """Build the published model's package (free). ``as_job`` answers a job to poll instead of waiting (4.17.0)."""
+        return self._post(f"/api/v1/dmgen/dms/{ct_id}/generate/", {"async": True} if as_job else {})
 
     def download_package(self, ct_id: str, dest_dir: str | Path) -> Path:
         content, name = self._fetch_bytes(f"/api/v1/dmgen/dms/{ct_id}/download_package/")
@@ -239,11 +321,14 @@ class SDCStudioClient:
         path.write_bytes(content)
         return path
 
-    def generate_app(self, ct_id: str, profile: str = "lightweight") -> dict[str, Any]:
-        """Generate the application (free; synchronous). ``profile`` is ``lightweight`` or ``enterprise``."""
+    def generate_app(self, ct_id: str, profile: str = "lightweight", *, as_job: bool = False) -> dict[str, Any]:
+        """Generate the application (free). ``profile`` is ``lightweight`` or ``enterprise``; ``as_job`` answers a job to poll (4.17.0)."""
         if profile not in ("lightweight", "enterprise"):
             raise ValueError("profile must be 'lightweight' or 'enterprise'")
-        return self._post(f"/api/v1/dmgen/dms/{ct_id}/generate_app/", {"profile": profile})
+        payload: dict[str, Any] = {"profile": profile}
+        if as_job:
+            payload["async"] = True
+        return self._post(f"/api/v1/dmgen/dms/{ct_id}/generate_app/", payload)
 
     def download_app(self, ct_id: str, dest_dir: str | Path, profile: str = "lightweight") -> tuple[Path, bool | None]:
         """

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/src/sdcmodeler/mcp_server.py

@@ -125,11 +125,13 @@ TOOLS: list[dict[str, Any]] = [
         "name": "build_model",
         "description": (
             "Assemble and publish the model the person estimated and approved. Needs the estimate_id "
-            "from estimate_model for the same title and tree; refuses otherwise, and refuses when the "
-            "estimate exceeds what the key may still spend. Spends credits: 500 for the model plus "
-            "100 per minted component. With every leaf existing the model is published and its "
-            "package generated at once (result has ct_id and artifacts); with new leaves the "
-            "pipeline runs and the result has a data_source_ct_id to poll with job_status. A 402 "
+            "from estimate_model for the same title and tree; refuses otherwise, the server refuses a stale "
+            "one too, and refuses when the estimate exceeds what the key may still spend. Spends credits: "
+            "500 for the model plus 100 per minted component or new cluster. With every leaf existing the "
+            "model is published and its package generated at once (result has ct_id and artifacts); with "
+            "new leaves the pipeline runs and the result has a job_ct_id to poll with job_status; when the "
+            "job completes it has published and generated as asked and carries the model's links. publish "
+            "false leaves a draft for a person to review. A 402 "
             "means the wallet needs funding at the wallet page; report it and stop."
         ),
         "inputSchema": {
@@ -140,14 +142,20 @@ TOOLS: list[dict[str, Any]] = [
                 "tree": {"type": "object"},
                 "description": {"type": "string", "default": ""},
                 "contextual": {"type": "object", "description": "Optional contextual component references (audit, attestation, party, subject, provider, participation, protocol, workflow, acs)."},
+                "publish": {"type": "boolean", "default": True, "description": "Publish the clusters and the model (false leaves a draft for a person to review)."},
+                "generate": {"type": "boolean", "default": True, "description": "Build the package after publishing (needs publish)."},
             },
             "required": ["estimate_id", "title", "tree"],
         },
     },
     {
         "name": "job_status",
-        "description": "The pipeline status of a mixed build (data_source_ct_id from build_model): uploaded, parsing, parsed, agent_processing, modeling, completed, error, agent_error. Free.",
-        "inputSchema": {"type": "object", "properties": {"data_source_ct_id": {"type": "string"}}, "required": ["data_source_ct_id"]},
+        "description": (
+            "One job (job_ct_id from build_model): status queued, running, completed or failed; step; "
+            "cost_credits so far; on completion the model's links (dm_ct_id, catalog_url, package_url); "
+            "on failure the reason. Poll every few seconds, backing off. Free."
+        ),
+        "inputSchema": {"type": "object", "properties": {"job_ct_id": {"type": "string"}}, "required": ["job_ct_id"]},
     },
     {
         "name": "generate_app",
@@ -218,11 +226,16 @@ def _handle_estimate_model(args: dict) -> Any:
     tree = _object(args, "tree", required=True)
     estimate = get_client().estimate(tree, _string(args, "title", required=True))
     _estimates[estimate["estimate_id"]] = estimate
-    policy = _policy_or_none()
-    if policy and policy.get("spend_limit_credits") is not None:
-        remaining = max(0, policy["spend_limit_credits"] - policy.get("spent_credits", 0))
-        estimate["key_remaining_credits"] = remaining
-        estimate["within_key_limit"] = estimate["total_credits"] <= remaining
+    key = estimate.get("key") if estimate.get("source") == "server" else None
+    if key and key.get("remaining_credits") is not None:
+        estimate["key_remaining_credits"] = key["remaining_credits"]
+        estimate["within_key_limit"] = bool(key.get("within_limit"))
+    else:
+        policy = _policy_or_none()
+        if policy and policy.get("spend_limit_credits") is not None:
+            remaining = max(0, policy["spend_limit_credits"] - policy.get("spent_credits", 0))
+            estimate["key_remaining_credits"] = remaining
+            estimate["within_key_limit"] = estimate["total_credits"] <= remaining
     return estimate
 
 
@@ -246,21 +259,35 @@ def _handle_build_model(args: dict) -> Any:
         )
     if current["problems"]:
         raise ValueError("The tree has problems: " + "; ".join(current["problems"]))
-    policy = _policy_or_none()
-    if policy and policy.get("spend_limit_credits") is not None:
-        remaining = max(0, policy["spend_limit_credits"] - policy.get("spent_credits", 0))
-        if current["total_credits"] > remaining:
-            raise ValueError(
-                f"This key may still spend {remaining} credits and the build needs {current['total_credits']}. "
-                "Ask the person for a key with a higher limit, or to run the build themselves."
-            )
-    result = get_client().assemble(title, tree, description=_string(args, "description"), contextual=_object(args, "contextual"))
+    remaining = None
+    if current.get("source") == "server" and (current.get("key") or {}).get("remaining_credits") is not None:
+        remaining = current["key"]["remaining_credits"]
+    else:
+        policy = _policy_or_none()
+        if policy and policy.get("spend_limit_credits") is not None:
+            remaining = max(0, policy["spend_limit_credits"] - policy.get("spent_credits", 0))
+    if remaining is not None and current["total_credits"] > remaining:
+        raise ValueError(
+            f"This key may still spend {remaining} credits and the build needs {current['total_credits']}. "
+            "Ask the person for a key with a higher limit, or to run the build themselves."
+        )
+    publish = bool(args.get("publish", True))
+    generate = bool(args.get("generate", True)) and publish
+    result = get_client().assemble(title, tree, description=_string(args, "description"),
+                                   contextual=_object(args, "contextual"), estimate_id=estimate_id,
+                                   publish=publish, generate=generate)
     result["estimate"] = current
+    result["requested"] = {"publish": publish, "generate": generate}
+    if result.get("mode") == "mixed":
+        result["next"] = (
+            f"Poll job_status with job_ct_id {result.get('job_ct_id')} until completed; its result then says "
+            "published and generated and carries the model's links."
+        )
     return result
 
 
 def _handle_job_status(args: dict) -> Any:
-    return get_client().job_status(_string(args, "data_source_ct_id", required=True))
+    return get_client().job_status(_string(args, "job_ct_id", required=True))
 
 
 def _handle_generate_app(args: dict) -> Any:

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/src/sdcmodeler.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdcmodeler
-Version: 4.0.0
+Version: 4.2.0
 Summary: The modeler's client for SDCStudio: search the catalog, estimate, assemble and publish SDC4 data models, generate applications; a CLI and an MCP server over one client
 Author: Axius SDC, Inc.
 License-Expression: Apache-2.0
@@ -68,11 +68,11 @@ tree = {
     ],
     "clusters": [],
 }
-print(c.estimate(tree, "Vitals"))           # reuse, mint, total_credits, estimate_id; no call that spends
-result = c.assemble("Vitals", tree)         # 500 credits plus the mints
+estimate = c.estimate(tree, "Vitals")       # the server's estimate: reuse, mint, problems, total_credits, wallet, key, estimate_id
+result = c.assemble("Vitals", tree, estimate_id=estimate["estimate_id"])   # 500 credits plus the mints
 ```
 
-Every leaf existing: the server assembles, publishes and generates the package in one call (`result["mode"] == "reuse"`). Some leaves new: the pipeline runs and `result["data_source_ct_id"]` is polled with `c.job_status(...)`.
+Every leaf existing: the server assembles, publishes and generates the package in one call (`result["mode"] == "reuse"`; `published` and `generated` say so). Some leaves new: the pipeline runs and `result["job_ct_id"]` is polled with `c.job_status(...)`, or `c.wait_for_job(...)`, until `completed`, when the job has published and generated as asked and its result carries the model's links. `publish=False` leaves a draft for a person to review. The server refuses a build whose tree changed since the estimate.
 
 A 402 is `InsufficientCredits` with the numbers in credits. A 403 from the key's policy (no `spend` scope, or past its limit) is `KeyPolicyRefused`. The client never funds a wallet; a person does that at the wallet page.
 
@@ -106,8 +106,8 @@ A JSON-RPC 2.0 stdio server, no SDK, the way sdcvalidator and sdcgovernance are
 | `search_components` | the public catalog by label, type and project | no |
 | `list_models`, `get_model` | published models and their artifact routes | no |
 | `estimate_model` | what a tree would reuse, mint and cost; returns `estimate_id` | no |
-| `build_model` | assemble and publish; needs the `estimate_id` the person saw; refuses past the key's limit | yes |
-| `job_status` | the pipeline for a mixed build | no |
+| `build_model` | assemble, publish and generate (or `publish: false` for a draft); needs the `estimate_id` the person saw; refuses past the key's limit | yes |
+| `job_status` | one job by id: status, step, cost so far, the model's links | no |
 | `generate_app` | generate and download the application; needs `confirm_charge`; 1,500 credits the first time, free after | yes |
 | `wallet` | balance in credits and the key's policy | no |
 

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/tests/test_client.py

@@ -41,10 +41,13 @@ def test_artifact_download_streams_bytes_on_a_local_deployment(fake, tmp_path):
 
 
 def test_assemble_reuse_is_sync_and_mixed_is_async(fake):
+    fake.on("GET", "/api/v1/auth/modeler/", body={"project_ct_id": "p1"})
     fake.on("POST", "/api/v1/dmgen/assemble/", body={"ct_id": "m1", "title": "Vitals", "artifacts": {"xsd": "/api/v1/catalog/dm/m1/xsd/"}})
     r = fake.client().assemble("Vitals", TREE, description="d")
     assert r["mode"] == "reuse" and r["ct_id"] == "m1"
     assert body_of(fake.calls[-1]) == {"title": "Vitals", "description": "d", "data": TREE}
+    fake.client().assemble("Vitals", TREE)
+    assert "description" not in body_of(fake.calls[-1]), "the server refuses a blank description; an empty one is left out"
     fake.on("POST", "/api/v1/dmgen/assemble/", status=202, body={"status": "processing", "task_id": "t", "data_source_ct_id": "ds1", "estimated_cost_credits": 600, "new_components": 1})
     r = fake.client().assemble("Vitals", TREE)
     assert r["mode"] == "mixed" and r["data_source_ct_id"] == "ds1"
@@ -69,6 +72,35 @@ def test_the_three_refusals_are_typed(fake):
     assert e.value.status == 500
 
 
+def test_estimate_is_the_servers_with_a_key_and_local_without(fake):
+    server = {"estimate_id": "abc", "total_credits": 700, "mode": "mixed", "reuse": [], "mint": [], "problems": [],
+              "wallet": {"balance_credits": 10, "can_pay": False}, "key": {"remaining_credits": 5000, "within_limit": True}}
+    fake.on("POST", "/api/v1/dmgen/assemble/estimate/", body=server)
+    e = fake.client().estimate(TREE, "Vitals")
+    assert e["source"] == "server" and e["total_credits"] == 700 and body_of(fake.calls[-1]) == {"title": "Vitals", "data": TREE}
+    e = fake.client(api_key=None).estimate(TREE, "Vitals")
+    assert e["source"] == "local" and e["total_credits"] == 500
+    fake.on("POST", "/api/v1/dmgen/assemble/estimate/", status=404, body={"detail": "Not found."})
+    assert fake.client().estimate(TREE, "Vitals")["source"] == "local", "a deployment older than 4.17.0"
+
+
+def test_assemble_sends_the_estimate_id_and_a_stale_one_is_refused(fake):
+    fake.on("POST", "/api/v1/dmgen/assemble/", body={"ct_id": "m1"})
+    fake.client().assemble("Vitals", TREE, estimate_id="abc123def456")
+    assert body_of(fake.calls[-1])["estimate_id"] == "abc123def456"
+    fake.on("POST", "/api/v1/dmgen/assemble/", status=409, body={"error": "estimate_id does not match", "error_type": "stale_estimate"})
+    with pytest.raises(AssemblyRefused, match="does not match"):
+        fake.client().assemble("Vitals", TREE, estimate_id="stale")
+
+
+def test_job_status_and_jobs_use_the_job_resource(fake):
+    fake.on("GET", "/api/v1/jobs/j1/", body={"ct_id": "j1", "status": "completed", "result": {"dm_ct_id": "m1"}})
+    fake.on("GET", "/api/v1/jobs/", body={"count": 1, "results": [{"ct_id": "j1"}]})
+    c = fake.client()
+    assert c.job_status("j1")["status"] == "completed"
+    assert c.jobs(kind="assemble")["count"] == 1 and dict(fake.calls[-1].url.params) == {"kind": "assemble"}
+
+
 def test_key_policy_finds_this_keys_own_row(fake):
     fake.on("GET", "/api/v1/auth/api-tokens/", body={"tokens": [
         {"prefix": "sdcs_bbbbbbb", "scopes": ["read"], "spend_limit_credits": None},
@@ -93,3 +125,40 @@ def test_download_app_reports_the_servers_charge(fake, tmp_path):
     assert path.name == "app.zip" and charged is False
     with pytest.raises(ValueError):
         fake.client().generate_app("m1", "huge")
+
+
+def test_assemble_creates_the_default_project_once_when_the_modeler_has_none(fake):
+    fake.on("GET", "/api/v1/auth/modeler/", body={"project_ct_id": None, "projects": []})
+    fake.on("POST", "/api/v1/dmgen/projects/", status=201, body={"ct_id": "p1", "name": "Agent models"})
+    fake.on("PATCH", "/api/v1/auth/modeler/update/", body={"project_ct_id": "p1"})
+    fake.on("POST", "/api/v1/dmgen/assemble/", body={"ct_id": "m1"})
+    c = fake.client()
+    c.assemble("A", TREE)
+    c.assemble("B", TREE)
+    assert [r.url.path for r in fake.calls] == [
+        "/api/v1/auth/modeler/", "/api/v1/dmgen/projects/", "/api/v1/auth/modeler/update/",
+        "/api/v1/dmgen/assemble/", "/api/v1/dmgen/assemble/",
+    ]
+
+
+def test_assemble_sends_the_flags_only_when_they_differ_from_the_default(fake):
+    fake.on("POST", "/api/v1/dmgen/assemble/", body={"ct_id": "m1", "published": True, "generated": True})
+    c = fake.client()
+    c.assemble("A", TREE)
+    assert "publish" not in body_of(fake.calls[-1]) and "generate" not in body_of(fake.calls[-1])
+    c.assemble("B", TREE, publish=False)
+    assert body_of(fake.calls[-1])["publish"] is False and body_of(fake.calls[-1])["generate"] is False
+    c.assemble("C", TREE, generate=False)
+    assert "publish" not in body_of(fake.calls[-1]) and body_of(fake.calls[-1])["generate"] is False
+
+
+def test_wait_for_job_polls_until_terminal(fake, monkeypatch):
+    states = iter([{"status": "queued"}, {"status": "running", "step": "modeling"}, {"status": "completed", "result": {"published": True}}])
+    fake.on("GET", "/api/v1/jobs/j1/", body=lambda request: next(states))
+    monkeypatch.setattr("time.sleep", lambda s: None)
+    job = fake.client().wait_for_job("j1", interval=0.01)
+    assert job["status"] == "completed" and job["result"]["published"] is True
+    fake.on("GET", "/api/v1/jobs/j2/", body={"status": "running"})
+    with pytest.raises(TimeoutError) as exc:
+        fake.client().wait_for_job("j2", timeout=0, interval=0.01)
+    assert exc.value.job["status"] == "running"

{sdcmodeler-4.0.0 → sdcmodeler-4.2.0}/tests/test_mcp_server.py

@@ -22,6 +22,16 @@ def call(name, arguments):
 @pytest.fixture(autouse=True)
 def bound(fake, tmp_path):
     fake.on("GET", "/api/v1/auth/api-tokens/", body={"tokens": [{"prefix": KEY[:12], "scopes": ["read", "build", "spend"], "spend_limit_credits": 1000, "spent_credits": 300}]})
+    # The server's estimate (4.17.0) for TREE: 500 + 100, the key at 700 remaining.
+    from sdcmodeler.pricing import estimate_tree
+
+    def server_estimate(request):
+        body = json.loads(request.content)
+        local = estimate_tree(body["data"], body["title"])
+        return {**local, "wallet": {"balance_credits": 10000, "can_pay": True},
+                "key": {"remaining_credits": 700, "within_limit": local["total_credits"] <= 700}}
+
+    fake.on("POST", "/api/v1/dmgen/assemble/estimate/", body=server_estimate)
     mcp_server.configure(fake.client(), output_dir=tmp_path)
     return fake
 
@@ -45,10 +55,17 @@ def test_build_needs_the_estimate_the_person_saw(bound):
     assert "exact title and tree" in err
     built, _ = call("build_model", {"estimate_id": est["estimate_id"], "title": "Vitals", "tree": TREE})
     assert built["mode"] == "mixed" and built["estimate"]["estimate_id"] == est["estimate_id"]
+    assert built["estimate"]["source"] == "server"
+    assert json.loads([c for c in bound.calls if c.url.path.endswith("/assemble/")][-1].content)["estimate_id"] == est["estimate_id"]
 
 
 def test_build_stops_at_the_keys_limit(bound):
-    bound.on("GET", "/api/v1/auth/api-tokens/", body={"tokens": [{"prefix": KEY[:12], "scopes": ["read", "build", "spend"], "spend_limit_credits": 1000, "spent_credits": 500}]})
+    def server_estimate(request):
+        from sdcmodeler.pricing import estimate_tree
+        body = json.loads(request.content)
+        local = estimate_tree(body["data"], body["title"])
+        return {**local, "wallet": {"balance_credits": 10000, "can_pay": True}, "key": {"remaining_credits": 500, "within_limit": False}}
+    bound.on("POST", "/api/v1/dmgen/assemble/estimate/", body=server_estimate)
     est, _ = call("estimate_model", {"title": "Vitals", "tree": TREE})
     assert est["within_key_limit"] is False
     _, err = call("build_model", {"estimate_id": est["estimate_id"], "title": "Vitals", "tree": TREE})
@@ -82,3 +99,18 @@ def test_malformed_input_is_answered_not_fatal():
     assert mcp_server._handle_request({"jsonrpc": "2.0", "method": "notifications/initialized"}) is None
     _, err = call("estimate_model", {"title": "t", "tree": "not an object"})
     assert "must be an object" in err
+
+
+def test_job_status_takes_the_job_id(bound):
+    bound.on("GET", "/api/v1/jobs/j1/", body={"ct_id": "j1", "status": "running", "step": "modeling", "cost_credits": 100})
+    out, _ = call("job_status", {"job_ct_id": "j1"})
+    assert out["step"] == "modeling"
+
+
+def test_build_model_passes_the_flags_and_names_what_to_poll(bound):
+    bound.on("POST", "/api/v1/dmgen/assemble/", status=202, body={"status": "processing", "job_ct_id": "j9", "data_source_ct_id": "ds"})
+    est, _ = call("estimate_model", {"title": "Vitals", "tree": TREE})
+    built, _ = call("build_model", {"estimate_id": est["estimate_id"], "title": "Vitals", "tree": TREE, "generate": False})
+    sent = json.loads([c for c in bound.calls if c.url.path.endswith("/assemble/")][-1].content)
+    assert sent["generate"] is False and "publish" not in sent
+    assert built["requested"] == {"publish": True, "generate": False} and "j9" in built["next"]