pipelex-api 0.71.1__tar.gz → 0.72.0__tar.gz

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pipelex-api
-Version: 0.71.1
+Version: 0.72.0
 Summary: Pipelex API
 Project-URL: Homepage, https://pipelex.com
 Project-URL: Repository, https://github.com/Pipelex/pipelex
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Python: <3.15,>=3.11
 Requires-Dist: fastapi<0.142,>=0.118.0
-Requires-Dist: pipelex[anthropic,bedrock,fal,google,google-genai,mistralai]==0.71.1
+Requires-Dist: pipelex[anthropic,bedrock,fal,google,google-genai,mistralai]==0.72.0
 Requires-Dist: pyjwt>=2.10.1
 Requires-Dist: uvicorn>=0.37.0
 Provides-Extra: dev
@@ -49,7 +49,7 @@ Description-Content-Type: text/markdown
 
   <h2 align="center">Pipelex API</h2>
 
-The official REST API server for building and executing Pipelex pipelines. Deploy your pipelines as HTTP endpoints and integrate them into any application or workflow.
+The official REST API server for validating and executing Pipelex pipelines. Deploy your pipelines as HTTP endpoints and integrate them into any application or workflow.
 
   <div>
     <a href="https://docs.pipelex.com/latest/api-server/"><strong>API Documentation</strong></a> -
@@ -83,7 +83,7 @@ The official REST API server for building and executing Pipelex pipelines. Deplo
 
 The **Pipelex API Server** is a FastAPI-based REST API that allows you to execute [Pipelex](https://github.com/Pipelex/pipelex) pipelines via HTTP requests. Deploy your pipelines as HTTP endpoints and integrate them into any application or workflow.
 
-It is the source-available reference implementation of the **[MTHDS Protocol](https://mthds.ai)** — the minimal HTTP contract every MTHDS runner implements (`POST /execute`, `POST /start`, `POST /validate`, `GET /models`, `GET /version`). The contracts nest: **MTHDS Protocol ⊂ Pipelex API (this server) ⊂ Pipelex hosted API**. This server adds the build tooling extensions (`/build/*`) on top of the protocol; the hosted API at `api.pipelex.com/v1` adds durable runs, the method catalog, and account management on top of this server — same shapes throughout. All routes live under the `/v1` base path; the committed contract is [`pipelex-api.openapi.yaml`](https://github.com/Pipelex/pipelex/blob/main/docs/api-server/openapi/pipelex-api.openapi.yaml).
+It is the source-available reference implementation of the **[MTHDS Protocol](https://mthds.ai)** — the minimal HTTP contract every MTHDS runner implements (`POST /execute`, `POST /start`, `POST /validate`, `GET /models`, `GET /version`). The contracts nest: **MTHDS Protocol ⊂ Pipelex API (this server) ⊂ Pipelex hosted API**. This server adds the tooling extensions (`/resolve`, `/codegen`, `/pipe-io`, `/lint`, `/format`) on top of the protocol; the hosted API at `api.pipelex.com/v1` adds durable runs, the method catalog, and account management on top of this server — same shapes throughout. All routes live under the `/v1` base path; the committed contract is [`pipelex-api.openapi.yaml`](https://github.com/Pipelex/pipelex/blob/main/docs/api-server/openapi/pipelex-api.openapi.yaml).
 
 # 🚀 Quick Start with Docker
 
@@ -165,7 +165,8 @@ The full reference for this API server is part of the Pipelex documentation, und
 - [Overview](https://docs.pipelex.com/latest/api-server/) — endpoints, authentication, deployment
 - [Pipe Run](https://docs.pipelex.com/latest/api-server/pipe-run/) — `/execute`, `/start`, every input shape
 - [Pipe Validate](https://docs.pipelex.com/latest/api-server/pipe-validate/) — `/validate`
-- [Pipe Builder](https://docs.pipelex.com/latest/api-server/pipe-builder/) — `/build/inputs`, `/build/output`, `/build/runner`
+- [Pipe I/O](https://docs.pipelex.com/latest/api-server/pipe-io/) — `/pipe-io`
+- [Resolve & Codegen](https://docs.pipelex.com/latest/api-server/codegen/) — `/resolve`, `/codegen`
 - [Configuration](https://docs.pipelex.com/latest/api-server/configuration/) — env vars, mounting your own `.pipelex/` config
 
 For broader Pipelex documentation (MTHDS language, concepts, pipe types, the Gateway): **[https://docs.pipelex.com/](https://docs.pipelex.com/)**

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/README.md

@@ -3,7 +3,7 @@
 
   <h2 align="center">Pipelex API</h2>
 
-The official REST API server for building and executing Pipelex pipelines. Deploy your pipelines as HTTP endpoints and integrate them into any application or workflow.
+The official REST API server for validating and executing Pipelex pipelines. Deploy your pipelines as HTTP endpoints and integrate them into any application or workflow.
 
   <div>
     <a href="https://docs.pipelex.com/latest/api-server/"><strong>API Documentation</strong></a> -
@@ -37,7 +37,7 @@ The official REST API server for building and executing Pipelex pipelines. Deplo
 
 The **Pipelex API Server** is a FastAPI-based REST API that allows you to execute [Pipelex](https://github.com/Pipelex/pipelex) pipelines via HTTP requests. Deploy your pipelines as HTTP endpoints and integrate them into any application or workflow.
 
-It is the source-available reference implementation of the **[MTHDS Protocol](https://mthds.ai)** — the minimal HTTP contract every MTHDS runner implements (`POST /execute`, `POST /start`, `POST /validate`, `GET /models`, `GET /version`). The contracts nest: **MTHDS Protocol ⊂ Pipelex API (this server) ⊂ Pipelex hosted API**. This server adds the build tooling extensions (`/build/*`) on top of the protocol; the hosted API at `api.pipelex.com/v1` adds durable runs, the method catalog, and account management on top of this server — same shapes throughout. All routes live under the `/v1` base path; the committed contract is [`pipelex-api.openapi.yaml`](https://github.com/Pipelex/pipelex/blob/main/docs/api-server/openapi/pipelex-api.openapi.yaml).
+It is the source-available reference implementation of the **[MTHDS Protocol](https://mthds.ai)** — the minimal HTTP contract every MTHDS runner implements (`POST /execute`, `POST /start`, `POST /validate`, `GET /models`, `GET /version`). The contracts nest: **MTHDS Protocol ⊂ Pipelex API (this server) ⊂ Pipelex hosted API**. This server adds the tooling extensions (`/resolve`, `/codegen`, `/pipe-io`, `/lint`, `/format`) on top of the protocol; the hosted API at `api.pipelex.com/v1` adds durable runs, the method catalog, and account management on top of this server — same shapes throughout. All routes live under the `/v1` base path; the committed contract is [`pipelex-api.openapi.yaml`](https://github.com/Pipelex/pipelex/blob/main/docs/api-server/openapi/pipelex-api.openapi.yaml).
 
 # 🚀 Quick Start with Docker
 
@@ -119,7 +119,8 @@ The full reference for this API server is part of the Pipelex documentation, und
 - [Overview](https://docs.pipelex.com/latest/api-server/) — endpoints, authentication, deployment
 - [Pipe Run](https://docs.pipelex.com/latest/api-server/pipe-run/) — `/execute`, `/start`, every input shape
 - [Pipe Validate](https://docs.pipelex.com/latest/api-server/pipe-validate/) — `/validate`
-- [Pipe Builder](https://docs.pipelex.com/latest/api-server/pipe-builder/) — `/build/inputs`, `/build/output`, `/build/runner`
+- [Pipe I/O](https://docs.pipelex.com/latest/api-server/pipe-io/) — `/pipe-io`
+- [Resolve & Codegen](https://docs.pipelex.com/latest/api-server/codegen/) — `/resolve`, `/codegen`
 - [Configuration](https://docs.pipelex.com/latest/api-server/configuration/) — env vars, mounting your own `.pipelex/` config
 
 For broader Pipelex documentation (MTHDS language, concepts, pipe types, the Gateway): **[https://docs.pipelex.com/](https://docs.pipelex.com/)**

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/limits.py

@@ -24,7 +24,6 @@ MAX_METHOD_REF_LEN = 512  # `method_ref` selector strings; a fixed schema bound,
 MAX_JSON_NESTING_DEPTH = 128
 DEFAULT_MAX_CALLBACK_URLS = 5
 DEFAULT_MAX_CALLBACK_URL_LEN = 2048
-DEFAULT_MAX_AGENT_SPEC_KIB = 256  # 256 KiB for JSON concept/pipe specs
 DEFAULT_MAX_BUNDLE_FILES = 128  # entries in a materialized method bundle (.mthds + .py + requirements.txt)
 DEFAULT_MAX_BUNDLE_TOTAL_KIB = 8 * 1024  # 8 MiB decompressed across the whole bundle (zip-bomb guard)
 DEFAULT_MAX_METHOD_CACHE_CLONES = 64  # cached method-package clones (one per resolved commit SHA)
@@ -57,8 +56,6 @@ MAX_PIPE_CODE_LEN = _read_positive_int("MAX_PIPE_CODE_LEN", DEFAULT_MAX_PIPE_COD
 MAX_CALLBACK_URLS = _read_positive_int("MAX_CALLBACK_URLS", DEFAULT_MAX_CALLBACK_URLS)
 MAX_CALLBACK_URL_LEN = _read_positive_int("MAX_CALLBACK_URL_LEN", DEFAULT_MAX_CALLBACK_URL_LEN)
 
-MAX_AGENT_SPEC_BYTES = _read_positive_int("MAX_AGENT_SPEC_KIB", DEFAULT_MAX_AGENT_SPEC_KIB) * 1024
-
 MAX_BUNDLE_FILES = _read_positive_int("MAX_BUNDLE_FILES", DEFAULT_MAX_BUNDLE_FILES)
 MAX_BUNDLE_TOTAL_BYTES = _read_positive_int("MAX_BUNDLE_TOTAL_KIB", DEFAULT_MAX_BUNDLE_TOTAL_KIB) * 1024
 

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/main.py

@@ -150,7 +150,7 @@ fastapi_app = PipelexFastAPI(
         f"This server implements the [MTHDS Protocol](https://mthds.ai) v{PROTOCOL_VERSION} "
         "(`POST /execute`, `POST /start`, `POST /validate`, `GET /models`, `GET /version` — "
         "marked `x-mthds-protocol: true`) plus the Pipelex API extensions: resolve and codegen "
-        "(`/resolve`, `/codegen`), build tooling (`/build/*`), and editor tooling (`/lint`, `/format`). "
+        "(`/resolve`, `/codegen`), the pipe I/O route (`/pipe-io`), and editor tooling (`/lint`, `/format`). "
         "Contract layering: MTHDS Protocol ⊂ Pipelex API (this server) ⊂ Pipelex hosted API. "
         "All endpoints are served under the `/v1` base path; "
         "every error is an RFC 7807 `application/problem+json` problem document, documented per "

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/method_source.py

@@ -13,10 +13,10 @@ manifest-identity package location, the bounds, and the structures check all liv
   `mthds_sources`, so diagnostics carry true per-file labels), and only the non-`.mthds`
   files are materialized into a temporary `library_dirs` entry — exactly the split the
   method-bundle transport uses, so a fetched package runs the same proven path.
-- The tooling routes (`/resolve`, `/codegen`, `/build/*`) use
+- The tooling routes (`/resolve`, `/codegen`, `/pipe-io`) use
   :func:`fetch_method_mthds_files`: only the `.mthds` files, as `files[]` items, paired with
-  the manifest's `main_pipe` so the per-pipe projections default their selector exactly as a
-  run does. No Python ever loads there, so the execution-locus gate does not apply.
+  the manifest's `main_pipe` so the per-pipe route defaults its selector exactly as a run
+  does. No Python ever loads there, so the execution-locus gate does not apply.
 
 The security gate (packaging invariant 7 — execution locus decides): `.mthds` content is
 data, always acceptable. On a deployment that is NOT sandbox-hosted, a fetched package

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/openapi_responses.py

@@ -82,7 +82,7 @@ class ProblemDocument(BaseModel):
         description=(
             "Structured per-error diagnostics, carried by a `ValidateBundleError`. Each item may carry a `suggested_fix`. "
             "Retained under `ERROR_DISCLOSURE=strict` — it describes the caller's own bundle, not server internals. "
-            "On `/validate`, `/resolve`, `/codegen` and `/build/*` an invalid bundle is a **200** verdict instead, so the "
+            "On `/validate`, `/resolve`, `/codegen` and `/pipe-io` an invalid bundle is a **200** verdict instead, so the "
             "items ride the response body there rather than a problem document."
         ),
     )

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/routes/pipelex/__init__.py

@@ -1,7 +1,6 @@
 from fastapi import APIRouter
 
 from .agent import router as agent_router
-from .build import router as build_router
 from .codegen import router as codegen_router
 from .pipe_io import router as pipe_io_router
 from .pipeline import router as pipeline_router
@@ -11,7 +10,6 @@ from .validate import router as validate_router
 
 router = APIRouter()
 
-router.include_router(build_router)
 router.include_router(pipeline_router)
 router.include_router(validate_router)
 router.include_router(resolve_router)

pipelex_api-0.72.0/pipelex_api/routes/pipelex/agent/__init__.py

@@ -0,0 +1,7 @@
+from fastapi import APIRouter
+
+from .models import router as models_router
+
+router = APIRouter()
+
+router.include_router(models_router)

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/routes/pipelex/agent/models.py

@@ -18,7 +18,7 @@ async def get_models(
     request: Request,
     model_type: Annotated[
         str | None,
-        Query(alias="type", description="Filter by model category: llm, extract, img_gen, search. Single value (protocol arity)."),
+        Query(alias="type", description="Filter by model category: llm, extract, img_gen, search, judgment. Single value (protocol arity)."),
     ] = None,
 ) -> PipelexModelDeck:
     """List the model deck this runner can route to (MTHDS Protocol `GET /models`).

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/routes/pipelex/codegen.py

@@ -32,8 +32,8 @@ class CodegenRouteKind(StrEnum):
     Membership follows the **trust chain**: a kind is served here exactly when its artifacts are
     stamped and locked, so a client can write them verbatim and pass the offline `codegen check` —
     the promise this route's valid arm makes by carrying a `lock`. Input templates are user-editable
-    scaffolds, never stamped or locked, so they cannot make that promise; they ride
-    `POST /build/inputs` instead and `inputs` is therefore not a kind here. Future per-pipe kinds
+    scaffolds, never stamped or locked, so they cannot make that promise: a client projects one from
+    the input form `POST /pipe-io` serves, and `inputs` is therefore not a kind here. Future per-pipe kinds
     (`docs`, `tools`, `tests`) do emit tracked artifacts, so they join this enum and select their
     pipe via `pipe_ref`. An unknown kind is a request-shape 422 listing the served set.
     """

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/routes/pipelex/crate_ops.py

@@ -1,4 +1,4 @@
-"""Shared crate-resolution plumbing for the `/resolve`, `/codegen`, `/pipe-io` and `/build/*` routes.
+"""Shared crate-resolution plumbing for the `/resolve`, `/codegen` and `/pipe-io` routes.
 
 They all select a closure the same way (inline `files[]` XOR `method_ref`), resolve it through the
 same engine core (`pipelex.pipeline.resolve_bundle.resolve_crate_from_contents`), and speak the same
@@ -8,10 +8,8 @@ This module holds the pieces they share so the envelopes cannot drift.
 
 The invalid arm here is the *crate* verdict: it deliberately omits `/validate`'s runnability facts
 (`pending_signatures`, `is_runnable`) — resolution is static (no dry-run sweep, matching
-`pipelex resolve`), so runnability is not part of its vocabulary. The per-pipe projections
-(`/build/{inputs,output}`) ride that same static core: a template is a read of the pipe's *declared*
-IO, so a valid verdict there says the closure is structurally sound, never that the pipe runs.
-`/build/runner` is the exception — it needs the dry-run sweep, so it keeps `validate_bundle`.
+`pipelex resolve`), so runnability is not part of its vocabulary. The per-pipe route (`/pipe-io`)
+rides that same static core: it reads the selected pipe's *declared* IO with no dry-run sweep.
 """
 
 from enum import StrEnum
@@ -87,15 +85,14 @@ class SelectedFiles(NamedTuple):
 def selected_files(request_data: MthdsFilesRequest) -> SelectedFiles:
     """The files the closure selector names: inline `files[]`, or an address `method_ref`'s package.
 
-    Shared by every route on the `files[]` envelope — including `/build/runner`, which cannot use
-    `resolve_requested_crate` (it needs `validate_bundle`'s dry-run sweep) but owes the caller the
-    same answer on every selector.
+    Every route on the `files[]` envelope reaches it through `resolve_requested_crate`, so they all
+    give the same answer on every selector.
 
     An **address-form** `method_ref` (`github.com/<owner>/<repo>[/<selector>][@<tag>]`) resolves
     through the same fetch path the run routes use: the package's `.mthds` files come back as
     `files[]` items with their real relative paths as per-file sources, and the manifest's
-    `main_pipe` rides beside them so the per-pipe projections can default their selector the way
-    a run by address does. Only `.mthds` data travels — the package's Python (if any) never loads
+    `main_pipe` rides beside them so the per-pipe route can default its selector the way a run
+    by address does. Only `.mthds` data travels — the package's Python (if any) never loads
     on these routes. The **registry form** (any non-address reference) stays reserved and keeps
     its 501 until the packaging program's registry phase.
 
@@ -159,10 +156,10 @@ def resolve_requested_crate(request_data: MthdsFilesRequest) -> ResolvedClosure:
 
 
 class RequestedPipe(NamedTuple):
-    """The pipe a per-pipe projection was asked for: its resolved qualified ref and the live pipe."""
+    """The pipe a per-pipe route was asked for: its resolved qualified ref and the live pipe."""
 
     ref: str
-    """The qualified `domain.pipe_code` actually projected — always qualified, whatever the request spelled."""
+    """The qualified `domain.pipe_code` actually selected — always qualified, whatever the request spelled."""
 
     pipe: PipeAbstract
     """The live pipe, read from the library `resolve_requested_crate` left loaded + current."""
@@ -197,7 +194,7 @@ class _SelectorOrigin(StrEnum):
 
 
 def resolve_requested_pipe(crate: LibraryCrate, *, pipe_ref: str | None, manifest_main_pipe: str | None) -> RequestedPipe:
-    """Select the pipe a per-pipe projection targets, defaulting to the manifest's, then the closure's, `main_pipe`.
+    """Select the pipe a per-pipe route targets, defaulting to the manifest's, then the closure's, `main_pipe`.
 
     The request's `pipe_ref` wins; omitted, the default chain (`select_default_pipe`) decides. Every
     failed selection — an unknown ref, an ambiguous one, a chain that finds no entry pipe or several —

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/routes/pipelex/validate.py

@@ -166,13 +166,13 @@ def _effective_default_pipe_ref(report: PipelexValidationReport, *, manifest_mai
     The run routes' precedence, minus the request selector `/validate` does not have
     (`pipeline.py`: `pipe_code or fetched.main_pipe`, then the batch's primary blueprint via
     `select_primary_blueprint`): a fetched package's manifest `main_pipe` wins, and only when there
-    is none does the closure's own declaration decide. The per-pipe tooling routes apply that same
+    is none does the closure's own declaration decide. The per-pipe tooling route applies that same
     chain in `crate_ops.resolve_requested_pipe`, so a caller reading this field and a caller omitting
-    `pipe_ref` on `/build/*` are told about the same pipe wherever `/build/*` defaults at all — see
+    `pipe_ref` on `/pipe-io` are told about the same pipe wherever `/pipe-io` defaults at all — see
     the one case below where it refuses to.
 
-    It deliberately states the RUN default, not the build routes' stricter one: a closure whose
-    domains each declare a `main_pipe` is refused by `/build/*` but runs happily — `execute` and
+    It deliberately states the RUN default, not the per-pipe route's stricter one: a closure whose
+    domains each declare a `main_pipe` is refused by `/pipe-io` but runs happily — `execute` and
     `start` take the first declaring blueprint — so reporting `null` for it would make a consumer
     refuse to prepare a method the server would run. The report's `bundle_blueprint` IS that first
     declaring blueprint (`build_validation_report` selects it through the same
@@ -374,10 +374,11 @@ async def validate_mthds(request: Request, request_data: ValidateRequest) -> JSO
         # so it is never rendered as `is_valid: false` (that verdict is about MTHDS content).
         with fetched_method_source(request_data.method_ref) as fetched:
             validated_contents = fetched.mthds_contents
-            # The manifest's declared entry pipe outranks the closure's own in the run/build default
-            # chain, so it must reach `default_pipe_ref` — the report itself is manifest-blind — and
-            # the graph arm, which would otherwise draw the primary blueprint's `main_pipe`: a
-            # different pipe when the two disagree, and no graph at all when the bundles declare none.
+            # The manifest's declared entry pipe outranks the closure's own in the default chain the
+            # run routes and `/pipe-io` share, so it must reach `default_pipe_ref` — the report itself
+            # is manifest-blind — and the graph arm, which would otherwise draw the primary blueprint's
+            # `main_pipe`: a different pipe when the two disagree, and no graph at all when the bundles
+            # declare none.
             # The bare code is passed as is, so the graph arm resolves it exactly as the run does.
             manifest_main_pipe = fetched.main_pipe
             verdict = await ApiRunner(

{pipelex_api-0.71.1 → pipelex_api-0.72.0}/pipelex_api/schemas/models.py

@@ -283,7 +283,7 @@ _CALLER_ANALYTICS_GROUPS_DESCRIPTION = (
 class CallerAnalyticsGroupsMixin(BaseModel):
     """The optional `analytics_groups` of a request whose work is done for a caller without being a run.
 
-    `/validate` and `/build/runner` dry-run the submitted pipes, and the runtime attributes that
+    `/validate` dry-runs the submitted pipes, and the runtime attributes that
     telemetry to the caller it is handed (`pipelex.system.caller_identity.CallerIdentity`). The user
     comes from the trusted auth layer, as on a run; the groups come from the body, as on a run, and are
     refused at the wire with the runtime's own rules.
@@ -569,15 +569,17 @@ class MthdsFilesRequest(BaseModel):
 
 
 class MthdsPipeRequest(MthdsFilesRequest):
-    """Shared base for the per-pipe `/build/*` projections: the closure selector plus a pipe selector.
+    """The base of a per-pipe route's request (`/pipe-io`): the closure selector plus a pipe selector.
 
     The pipe selector is the **qualified** ref `domain.pipe_code`, mirroring `pipelex codegen inputs
     --pipe`. It is optional, and an omitted selector defaults with the run routes' precedence: on a
     `method_ref` request, to the fetched package manifest's `main_pipe` (the package author's declared
     entry pipe); otherwise to the closure's declared `main_pipe`, which is what a single-bundle caller
     almost always wants. A closure that declares no `main_pipe` — or several, across domains — cannot
-    be defaulted from its own declarations, so an omitted selector is a request-shape 422 there when
-    no manifest `main_pipe` settles it (the same two arms the CLI rejects on).
+    be defaulted from its own declarations, so when no manifest `main_pipe` settles it a route that
+    needs one pipe refuses the omitted selector with an input 422, `EntryPipeNotFoundError` or
+    `EntryPipeAmbiguousError` (`crate_ops.resolve_requested_pipe`), never the request-shape
+    `ValidationError` of a malformed body.
     """
 
     pipe_ref: str | None = Field(
@@ -585,9 +587,9 @@ class MthdsPipeRequest(MthdsFilesRequest):
         min_length=1,
         max_length=MAX_PIPE_CODE_LEN,
         description=(
-            "Qualified pipe ref (`domain.pipe_code`) to project. Optional — defaults to the fetched package manifest's "
+            "Qualified pipe ref (`domain.pipe_code`) to select. Optional — defaults to the fetched package manifest's "
             "`main_pipe` on a `method_ref` request, else to the closure's declared `main_pipe`; a closure declaring none, "
-            "or several, with no manifest `main_pipe` to settle it, requires it explicitly."
+            "or several, with no manifest `main_pipe` to settle it, requires it unless `all_pipes` is set."
         ),
     )
 
@@ -596,8 +598,8 @@ ALLOW_SIGNATURES_DESCRIPTION = (
     "When true, the validation sweep tolerates unimplemented pipe signatures instead of rejecting the "
     "bundle (signatures dry-run trivially by minting a mock). Defaults to false (strict)."
 )
-"""Shared by the two routes that still run the dry-run sweep (`/validate`, `/build/runner`) — the flag only
-parameterizes that sweep, so the static `/build/{inputs,output}` projections do not accept it."""
+"""Used by `/validate`, the one route that runs the dry-run sweep: the flag only parameterizes that sweep,
+so the static crate routes do not accept it."""
 
 
 class MthdsContentsRequest(BaseModel):
@@ -606,7 +608,7 @@ class MthdsContentsRequest(BaseModel):
     This is the flat-list envelope. `/validate` uses it through this class (its `ValidateRequest`
     subclass adds a parallel `mthds_sources` for per-file source labels), and the run routes
     `/execute` and `/start` carry the same `mthds_contents` field independently on `RunRequest`.
-    The newer Pipelex-API extension routes (`/resolve`, `/codegen`, `/build/*`) use
+    The newer Pipelex-API extension routes (`/resolve`, `/codegen`, `/pipe-io`) use
     `MthdsFilesRequest` instead (`files[]` pairing each content with its `source`, XOR a
     `method_ref`), which folds the source label into each entry. `/validate` keeps the flat-list
     shape deliberately: it is an MTHDS Protocol route, so changing its inline envelope is a

pipelex_api-0.71.1/pipelex_api/routes/pipelex/agent/__init__.py

@@ -1,11 +0,0 @@
-from fastapi import APIRouter
-
-from .concept import router as concept_router
-from .models import router as models_router
-from .pipe_spec import router as pipe_spec_router
-
-router = APIRouter()
-
-router.include_router(models_router)
-router.include_router(concept_router)
-router.include_router(pipe_spec_router)

pipelex_api-0.71.1/pipelex_api/routes/pipelex/agent/concept.py

@@ -1,60 +0,0 @@
-"""Concept endpoint — convert JSON concept spec to TOML."""
-
-import json
-from typing import Any
-
-from fastapi import APIRouter
-from pipelex.builder.operations.concept_ops import concept_spec_to_toml, parse_concept_spec
-from pydantic import BaseModel, Field, ValidationError, field_validator
-
-from pipelex_api.errors import raise_validation_error
-from pipelex_api.json_body import JsonBodyRoute
-from pipelex_api.limits import MAX_AGENT_SPEC_BYTES
-
-router = APIRouter(tags=["agent"], route_class=JsonBodyRoute)
-
-
-class BuildConceptRequest(BaseModel):
-    spec: dict[str, Any] = Field(..., description="JSON concept specification.")
-
-    @field_validator("spec")
-    @classmethod
-    def _bound_spec_size(cls, value: dict[str, Any]) -> dict[str, Any]:
-        if len(json.dumps(value).encode("utf-8")) > MAX_AGENT_SPEC_BYTES:
-            msg = f"spec exceeds {MAX_AGENT_SPEC_BYTES // 1024} KiB limit"
-            raise ValueError(msg)
-        return value
-
-
-class BuildConceptResponse(BaseModel):
-    success: bool = Field(default=True, description="Whether the operation was successful")
-    concept_code: str = Field(..., description="The concept code that was generated")
-    toml: str = Field(..., description="Generated TOML content for the concept")
-
-
-@router.post("/build/concept")
-async def build_concept(request_data: BuildConceptRequest) -> BuildConceptResponse:
-    """Convert a JSON concept spec to TOML format.
-
-    A malformed spec surfaces as a Pydantic `ValidationError` — an API-owned
-    422. Pipelex domain failures propagate untouched to the global
-    `PipelexError` handler in `pipelex_api.exception_handlers`.
-
-    A malformed shape — a non-mapping `structure` (`{"structure": "string"}`)
-    or a `structure` field that is neither a string nor a mapping
-    (`{"structure": {"f": 42}}`) — is refused by `parse_concept_spec` itself
-    with a typed `ConceptSpecError`, which that same handler answers. Nothing
-    broader is caught here: a bare exception from pipelex is the signal of a
-    real programming bug, and a route-level catch would mask it.
-    """
-    try:
-        concept_spec = parse_concept_spec(request_data.spec)
-        toml_content = concept_spec_to_toml(concept_spec)
-
-        return BuildConceptResponse(
-            success=True,
-            concept_code=concept_spec.concept_code,
-            toml=toml_content,
-        )
-    except ValidationError as exc:
-        raise_validation_error(message=str(exc))

pipelex_api-0.71.1/pipelex_api/routes/pipelex/agent/pipe_spec.py

@@ -1,59 +0,0 @@
-"""Pipe spec endpoint — convert JSON pipe spec to TOML."""
-
-import json
-from typing import Any
-
-from fastapi import APIRouter
-from pipelex.builder.operations.pipe_ops import parse_pipe_spec, pipe_spec_to_toml
-from pydantic import BaseModel, Field, ValidationError, field_validator
-
-from pipelex_api.errors import raise_validation_error
-from pipelex_api.json_body import JsonBodyRoute
-from pipelex_api.limits import MAX_AGENT_SPEC_BYTES
-
-router = APIRouter(tags=["agent"], route_class=JsonBodyRoute)
-
-
-class BuildPipeSpecRequest(BaseModel):
-    pipe_type: str = Field(..., min_length=1, max_length=128, description="The pipe type (e.g. PipeLLM, PipeSequence, etc.).")
-    spec: dict[str, Any] = Field(..., description="JSON pipe specification.")
-
-    @field_validator("spec")
-    @classmethod
-    def _bound_spec_size(cls, value: dict[str, Any]) -> dict[str, Any]:
-        if len(json.dumps(value).encode("utf-8")) > MAX_AGENT_SPEC_BYTES:
-            msg = f"spec exceeds {MAX_AGENT_SPEC_BYTES // 1024} KiB limit"
-            raise ValueError(msg)
-        return value
-
-
-class BuildPipeSpecResponse(BaseModel):
-    success: bool = Field(default=True, description="Whether the operation was successful")
-    pipe_code: str = Field(..., description="The pipe code that was generated")
-    pipe_type: str = Field(..., description="The pipe type")
-    toml: str = Field(..., description="Generated TOML content for the pipe")
-
-
-@router.post("/build/pipe-spec")
-async def build_pipe_spec(request_data: BuildPipeSpecRequest) -> BuildPipeSpecResponse:
-    """Convert a JSON pipe spec to TOML format.
-
-    Two caller-mistake paths surface as a 422 here: a `ValidationError` from
-    Pydantic when the spec shape doesn't match the chosen pipe type, and a
-    `ValueError` from `parse_pipe_spec` when `pipe_type` is not one of the
-    known pipe types (documented in `parse_pipe_spec`'s docstring; raised at
-    exactly one site). Pipelex domain failures propagate untouched to the
-    global `PipelexError` handler in `pipelex_api.exception_handlers`.
-    """
-    try:
-        pipe_spec = parse_pipe_spec(request_data.spec, pipe_type=request_data.pipe_type)
-        toml_content = pipe_spec_to_toml(pipe_spec)
-
-        return BuildPipeSpecResponse(
-            success=True,
-            pipe_code=pipe_spec.pipe_code,
-            pipe_type=request_data.pipe_type,
-            toml=toml_content,
-        )
-    except (ValidationError, ValueError) as exc:
-        raise_validation_error(message=str(exc))

pipelex_api-0.71.1/pipelex_api/routes/pipelex/build/__init__.py

@@ -1,11 +0,0 @@
-from fastapi import APIRouter
-
-from .inputs import router as inputs_router
-from .output import router as output_router
-from .runner import router as runner_router
-
-router = APIRouter()
-
-router.include_router(inputs_router)
-router.include_router(output_router)
-router.include_router(runner_router)

pipelex_api-0.71.1/pipelex_api/routes/pipelex/build/inputs.py

@@ -1,192 +0,0 @@
-import json
-from typing import Annotated, Any, Literal, Self, Union
-
-from fastapi import APIRouter
-from fastapi.responses import JSONResponse
-from pipelex.core.pipes.inputs.exceptions import NoInputsRequiredError
-from pipelex.pipe_machinery.rendering.input_renderer import InputsTemplateFormat, render_inputs, render_inputs_toml
-from pipelex.pipeline.exceptions import ValidateBundleError
-from pydantic import BaseModel, Field, model_validator
-
-from pipelex_api.json_body import JsonBodyRoute
-from pipelex_api.openapi_responses import PROBLEM_404_METHOD_PACKAGE, PROBLEM_501_METHOD_REF
-from pipelex_api.routes.pipelex.crate_ops import (
-    CrateInvalidReport,
-    RequestedPipe,
-    invalid_crate_report_response,
-    resolve_requested_crate,
-    resolve_requested_pipe,
-    teardown_current_library,
-)
-from pipelex_api.schemas.models import MthdsPipeRequest
-
-router = APIRouter(tags=["build"], route_class=JsonBodyRoute)
-
-INPUTS_GENERATED_MESSAGE = "Inputs template generated successfully"
-NO_INPUTS_MESSAGE = "This pipe declares no inputs — the template is empty."
-
-
-class BuildInputsRequest(MthdsPipeRequest):
-    """The inputs-template request: the shared closure + pipe selectors, plus the two rendering axes.
-
-    Both axes mirror `pipelex codegen inputs` exactly — `--format` and `--explicit` — and every
-    combination of them is served, as on the CLI.
-    """
-
-    format: InputsTemplateFormat = Field(
-        default=InputsTemplateFormat.JSON,
-        description="Template encoding. `json` returns the parsed template in `inputs`; `toml` returns the raw text in `inputs_toml`.",
-    )
-    explicit: bool = Field(
-        default=False,
-        description=(
-            "When true, emit the ceremonial `{concept, content}` envelope for every input. Defaults to false — the light, "
-            "signature-driven shape that smart inputs accepts (a bare string for a Text input, and so on)."
-        ),
-    )
-
-
-class BuildInputsValidReport(BaseModel):
-    """The 200 **valid** arm: the example inputs template for the requested pipe.
-
-    The template rides **one of two fields, chosen by `format`** — `inputs` (parsed object) for
-    `json`, `inputs_toml` (raw text) for `toml`. TOML cannot be carried as a parsed object without
-    losing what makes it worth asking for (its concept comments and key order), and the JSON case
-    must stay a real object, since that is what the deploy dialog and the SDKs consume. So the two
-    are separate, honestly-typed fields, and the unused one is omitted from the body entirely.
-
-    A pipe that declares no inputs is a *valid* verdict, not an error (the CLI likewise exits 0):
-    the template is simply empty, and `message` says so.
-    """
-
-    is_valid: Literal[True] = True
-    pipe_ref: str = Field(..., description="The qualified pipe the template was generated for — the resolved selector.")
-    requested_pipe_ref: str | None = Field(
-        default=None,
-        description=(
-            "The `pipe_ref` as submitted. Absent when it was omitted and defaulted — to the fetched package manifest's "
-            "`main_pipe` on a `method_ref` request, else to the closure's declared `main_pipe`."
-        ),
-    )
-    format: InputsTemplateFormat = Field(..., description="The template encoding (echo of the request).")
-    explicit: bool = Field(..., description="Whether the ceremonial envelope shape was emitted (echo of the request).")
-    inputs: dict[str, Any] | None = Field(
-        default=None,
-        description="The parsed inputs template — present exactly when `format` is `json`.",
-    )
-    inputs_toml: str | None = Field(
-        default=None,
-        description="The inputs template as TOML text — present exactly when `format` is `toml`.",
-    )
-    message: str = Field(default=INPUTS_GENERATED_MESSAGE, description="Status message")
-
-    @model_validator(mode="after")
-    def _template_field_matches_format(self) -> Self:
-        # The invariant the two-field shape exists to keep: the caller can read the field its own
-        # `format` names, without probing. A route bug that set the other one would be a silent
-        # contract break, so it fails loudly here instead.
-        match self.format:
-            case InputsTemplateFormat.JSON:
-                if self.inputs is None or self.inputs_toml is not None:
-                    msg = "format='json' must carry `inputs` and no `inputs_toml`"
-                    raise ValueError(msg)
-            case InputsTemplateFormat.TOML:
-                if self.inputs_toml is None or self.inputs is not None:
-                    msg = "format='toml' must carry `inputs_toml` and no `inputs`"
-                    raise ValueError(msg)
-        return self
-
-
-# Discriminated 200 response union: the `/validate` discipline — the verdict rides `is_valid`, never
-# the HTTP status.
-BuildInputsResponse = Annotated[Union[BuildInputsValidReport, CrateInvalidReport], Field(discriminator="is_valid")]
-
-
-def _render_report(*, requested: BuildInputsRequest, requested_pipe: RequestedPipe) -> BuildInputsValidReport:
-    """Render the requested pipe's declared inputs into the valid arm, on the `format` axis.
-
-    A pipe with no inputs raises `NoInputsRequiredError` out of the engine renderers. That is not a
-    failure — it is the honest answer "run this with nothing" — so it lands on the valid arm as an
-    empty template, mirroring the CLI's exit-0.
-    """
-    inputs: dict[str, Any] | None = None
-    inputs_toml: str | None = None
-    message: str = INPUTS_GENERATED_MESSAGE
-    match requested.format:
-        case InputsTemplateFormat.JSON:
-            try:
-                inputs = json.loads(render_inputs(requested_pipe.pipe, explicit=requested.explicit))
-            except NoInputsRequiredError:
-                inputs = {}
-                message = NO_INPUTS_MESSAGE
-        case InputsTemplateFormat.TOML:
-            try:
-                inputs_toml = render_inputs_toml(requested_pipe.pipe, explicit=requested.explicit)
-            except NoInputsRequiredError:
-                inputs_toml = ""
-                message = NO_INPUTS_MESSAGE
-    return BuildInputsValidReport(
-        pipe_ref=requested_pipe.ref,
-        requested_pipe_ref=requested.pipe_ref,
-        format=requested.format,
-        explicit=requested.explicit,
-        inputs=inputs,
-        inputs_toml=inputs_toml,
-        message=message,
-    )
-
-
-@router.post(
-    "/build/inputs",
-    response_model=BuildInputsResponse,
-    # On top of the composite router's shared 401/413/422/500: the `method_ref` closure selector the
-    # envelope accepts but no server-side method registry resolves yet (shared with /resolve, /codegen).
-    responses={404: PROBLEM_404_METHOD_PACKAGE, 501: PROBLEM_501_METHOD_REF},
-)
-async def build_inputs(request_data: BuildInputsRequest) -> JSONResponse:
-    """Generate an example inputs template for a pipe (the inputs projection, per pipe).
-
-    Rides the **same static core** as `POST /resolve` and `POST /codegen`: the closure is resolved to
-    its normalized crate, the requested pipe is read live from the library that leaves loaded, and its
-    *declared* inputs are rendered — the exact projection `pipelex codegen inputs` writes, on both of
-    its axes (`format`, `explicit`).
-
-    Static is the point: a template is a read of the pipe's declared IO, so there is **no dry-run
-    sweep** here (that is `/validate`'s vocabulary, and `/build/runner`'s need). A valid verdict says
-    the closure is structurally sound and the template matches what the pipe declares — it is *not* a
-    promise the pipe runs. Ask `/validate` for that.
-
-    This projection is deliberately **not** a `/codegen` kind: the templates are user-editable
-    scaffolds, never stamped or locked, so they cannot ride the trust chain `/codegen`'s valid arm
-    promises (see `CodegenRouteKind`).
-
-    Response contract (the `/validate` discipline):
-
-    - **Valid verdict (200, `is_valid: true`):** the template, in `inputs` or `inputs_toml` per `format`.
-    - **Invalid verdict (200, `is_valid: false`):** the closure could not be parsed, loaded, or
-      validated — `validation_errors[]` from pipelex's one shared builder; no template exists.
-    - **No verdict (non-2xx):** a selection refusal — an unknown pipe ref, or an omitted `pipe_ref` that
-      nothing defaults (no fetched-manifest `main_pipe`, and a closure declaring no — or several —
-      `main_pipe`) — is an input 422 whose `error_type` is `EntryPipeNotFoundError` or
-      `EntryPipeAmbiguousError`; a malformed closure selector is a request-shape 422 problem+json; a
-      registry-form `method_ref` is a 501 until server-side method-registry resolution exists.
-
-    An omitted `pipe_ref` defaults the way a run by address does: to the fetched package manifest's
-    `main_pipe` on a `method_ref` request, else to the closure's own declared `main_pipe`.
-    """
-    try:
-        resolved = resolve_requested_crate(request_data)
-    except ValidateBundleError as validate_error:
-        return invalid_crate_report_response(validate_error.to_error_report())
-    try:
-        requested_pipe = resolve_requested_pipe(
-            resolved.crate,
-            pipe_ref=request_data.pipe_ref,
-            manifest_main_pipe=resolved.manifest_main_pipe,
-        )
-        report = _render_report(requested=request_data, requested_pipe=requested_pipe)
-        # exclude_none drops the template field the `format` did not select (and an absent
-        # `requested_pipe_ref`), so exactly the fields the caller's own request implies are present.
-        return JSONResponse(content=report.model_dump(mode="json", by_alias=True, exclude_none=True))
-    finally:
-        teardown_current_library()

pipelex_api-0.71.1/pipelex_api/routes/pipelex/build/output.py

@@ -1,163 +0,0 @@
-import json
-from typing import Annotated, Any, Literal, Self, Union
-
-from fastapi import APIRouter
-from fastapi.responses import JSONResponse
-from pipelex.core.concepts.concept_representation_generator import ConceptRepresentationFormat
-from pipelex.pipe_machinery.rendering.output_renderer import render_output
-from pipelex.pipeline.exceptions import ValidateBundleError
-from pydantic import BaseModel, Field, model_validator
-
-from pipelex_api.errors import raise_validation_error
-from pipelex_api.json_body import JsonBodyRoute
-from pipelex_api.openapi_responses import PROBLEM_404_METHOD_PACKAGE, PROBLEM_501_METHOD_REF
-from pipelex_api.routes.pipelex.crate_ops import (
-    CrateInvalidReport,
-    RequestedPipe,
-    invalid_crate_report_response,
-    resolve_requested_crate,
-    resolve_requested_pipe,
-    teardown_current_library,
-)
-from pipelex_api.schemas.models import MthdsPipeRequest
-
-router = APIRouter(tags=["build"], route_class=JsonBodyRoute)
-
-
-class BuildOutputRequest(MthdsPipeRequest):
-    """The output-representation request: the shared closure + pipe selectors, plus the format axis."""
-
-    format: ConceptRepresentationFormat = Field(
-        default=ConceptRepresentationFormat.SCHEMA,
-        description=(
-            "Representation to render. `schema` (JSON Schema) and `json` (example value) return a parsed object in "
-            "`output`; `python` returns Python source in `output_python`."
-        ),
-    )
-
-
-class BuildOutputValidReport(BaseModel):
-    """The 200 **valid** arm: the example output representation for the requested pipe.
-
-    The representation rides **one of two fields, chosen by `format`**, for the same reason
-    `/build/inputs` splits `inputs` / `inputs_toml`: `schema` and `json` are objects, `python` is
-    source text. (Before this split the route parsed *every* format as JSON, so `format=python` was a
-    hard 500 — it fed Python source to `json.loads`.)
-    """
-
-    is_valid: Literal[True] = True
-    pipe_ref: str = Field(..., description="The qualified pipe the representation was generated for — the resolved selector.")
-    requested_pipe_ref: str | None = Field(
-        default=None,
-        description=(
-            "The `pipe_ref` as submitted. Absent when it was omitted and defaulted — to the fetched package manifest's "
-            "`main_pipe` on a `method_ref` request, else to the closure's declared `main_pipe`."
-        ),
-    )
-    format: ConceptRepresentationFormat = Field(..., description="The representation format (echo of the request).")
-    output: dict[str, Any] | None = Field(
-        default=None,
-        description="The parsed output representation — present exactly when `format` is `schema` or `json`.",
-    )
-    output_python: str | None = Field(
-        default=None,
-        description="The output representation as Python source — present exactly when `format` is `python`.",
-    )
-    message: str = Field(default="Output representation generated successfully", description="Status message")
-
-    @model_validator(mode="after")
-    def _representation_field_matches_format(self) -> Self:
-        # Same invariant as `/build/inputs`: the caller reads the field its own `format` names.
-        match self.format:
-            case ConceptRepresentationFormat.SCHEMA | ConceptRepresentationFormat.JSON:
-                if self.output is None or self.output_python is not None:
-                    msg = "format='schema'/'json' must carry `output` and no `output_python`"
-                    raise ValueError(msg)
-            case ConceptRepresentationFormat.PYTHON:
-                if self.output_python is None or self.output is not None:
-                    msg = "format='python' must carry `output_python` and no `output`"
-                    raise ValueError(msg)
-        return self
-
-
-# Discriminated 200 response union: the `/validate` discipline — the verdict rides `is_valid`, never
-# the HTTP status.
-BuildOutputResponse = Annotated[Union[BuildOutputValidReport, CrateInvalidReport], Field(discriminator="is_valid")]
-
-
-def _render_report(*, requested: BuildOutputRequest, requested_pipe: RequestedPipe) -> BuildOutputValidReport:
-    """Render the requested pipe's declared output into the valid arm, on the `format` axis.
-
-    `render_output` raises a bare `ValueError` (documented in its docstring) when the pipe's output is
-    `native.Anything` and no concrete option can be determined — a fact about the *requested pipe*,
-    not about the closure, so it is a no-verdict 422 rather than an invalid-crate verdict.
-    """
-    output: dict[str, Any] | None = None
-    output_python: str | None = None
-    try:
-        rendered = render_output(requested_pipe.pipe, output_format=requested.format)
-    except ValueError as exc:
-        raise_validation_error(f"Cannot render the output representation of pipe '{requested_pipe.ref}': {exc}")
-    match requested.format:
-        case ConceptRepresentationFormat.SCHEMA | ConceptRepresentationFormat.JSON:
-            output = json.loads(rendered)
-        case ConceptRepresentationFormat.PYTHON:
-            output_python = rendered
-    return BuildOutputValidReport(
-        pipe_ref=requested_pipe.ref,
-        requested_pipe_ref=requested.pipe_ref,
-        format=requested.format,
-        output=output,
-        output_python=output_python,
-    )
-
-
-@router.post(
-    "/build/output",
-    response_model=BuildOutputResponse,
-    # On top of the composite router's shared 401/413/422/500: the `method_ref` closure selector the
-    # envelope accepts but no server-side method registry resolves yet (shared with /resolve, /codegen).
-    responses={404: PROBLEM_404_METHOD_PACKAGE, 501: PROBLEM_501_METHOD_REF},
-)
-async def build_output(request_data: BuildOutputRequest) -> JSONResponse:
-    """Generate an example output representation for a pipe (the output projection, per pipe).
-
-    Rides the **same static core** as `POST /resolve`, `POST /codegen` and `POST /build/inputs`: the
-    closure is resolved to its normalized crate, the requested pipe is read live from the library that
-    leaves loaded, and its *declared* output is rendered.
-
-    Static is the point: the representation is a read of the pipe's declared IO, so there is **no
-    dry-run sweep** here. A valid verdict says the closure is structurally sound and the shape matches
-    what the pipe declares — it is *not* a promise the pipe runs. Ask `/validate` for that.
-
-    Response contract (the `/validate` discipline):
-
-    - **Valid verdict (200, `is_valid: true`):** the representation, in `output` or `output_python` per `format`.
-    - **Invalid verdict (200, `is_valid: false`):** the closure could not be parsed, loaded, or
-      validated — `validation_errors[]`; no representation exists.
-    - **No verdict (non-2xx):** a selection refusal — an unknown pipe ref, or an omitted `pipe_ref` that
-      nothing defaults (no fetched-manifest `main_pipe`, and a closure declaring no — or several —
-      `main_pipe`) — is an input 422 whose `error_type` is `EntryPipeNotFoundError` or
-      `EntryPipeAmbiguousError`; a pipe whose `native.Anything` output has no determinable shape, or a
-      malformed closure selector, is a request-shape 422 problem+json; a registry-form `method_ref` is a 501 until server-side
-      method-registry resolution exists.
-
-    An omitted `pipe_ref` defaults the way a run by address does: to the fetched package manifest's
-    `main_pipe` on a `method_ref` request, else to the closure's own declared `main_pipe`.
-    """
-    try:
-        resolved = resolve_requested_crate(request_data)
-    except ValidateBundleError as validate_error:
-        return invalid_crate_report_response(validate_error.to_error_report())
-    try:
-        requested_pipe = resolve_requested_pipe(
-            resolved.crate,
-            pipe_ref=request_data.pipe_ref,
-            manifest_main_pipe=resolved.manifest_main_pipe,
-        )
-        report = _render_report(requested=request_data, requested_pipe=requested_pipe)
-        # exclude_none drops the representation field the `format` did not select (and an absent
-        # `requested_pipe_ref`), so exactly the fields the caller's own request implies are present.
-        return JSONResponse(content=report.model_dump(mode="json", by_alias=True, exclude_none=True))
-    finally:
-        teardown_current_library()

pipelex_api-0.71.1/pipelex_api/routes/pipelex/build/runner.py

@@ -1,236 +0,0 @@
-from typing import Annotated, Literal, Union
-
-from fastapi import APIRouter, Request
-from fastapi.responses import JSONResponse
-from mthds.package.manifest.schema import MTHDS_STANDARD_VERSION
-from pipelex.base_exceptions import PipelexUnexpectedError
-from pipelex.builder.runner_code import generate_runner_code
-from pipelex.codegen.emission import build_stamped_projection
-from pipelex.codegen.emitters.naming import runtime_to_emitted_class_names
-from pipelex.codegen.emitters.target import CodegenKind, CodegenTarget
-from pipelex.codegen.emitters.types_emitter import emit_types
-from pipelex.codegen.lock import CODEGEN_LOCK_FILENAME
-from pipelex.codegen.resolved_concepts import resolve_concepts_from_crate
-from pipelex.core.pipes.variable_multiplicity import parse_concept_with_multiplicity
-from pipelex.interpreter_hub import get_current_library_id_or_none, get_library_manager
-from pipelex.libraries.crate_normalization import normalize_crate
-from pipelex.libraries.pipe.exceptions import EntryPipeNotFoundError, PipeNotFoundError
-from pipelex.mthds_parsing.pipelex_bundle_blueprint import PipelexBundleBlueprint
-from pipelex.pipeline.bundle_validator import DryRunOutput, DryRunStatus
-from pipelex.pipeline.exceptions import ValidateBundleError
-from pipelex.pipeline.validate_bundle import validate_bundle
-from pipelex.system.caller_identity import CallerIdentity
-from pipelex.tools.misc.package_utils import get_package_version
-from pipelex.tools.typing.pydantic_utils import empty_list_factory_of
-from pydantic import BaseModel, Field
-
-from pipelex_api.errors import raise_validation_error
-from pipelex_api.json_body import JsonBodyRoute
-from pipelex_api.openapi_responses import PROBLEM_404_METHOD_PACKAGE, PROBLEM_501_METHOD_REF
-from pipelex_api.routes.pipelex.crate_ops import (
-    CrateInvalidReport,
-    GeneratedArtifact,
-    invalid_crate_report_response,
-    resolve_requested_pipe,
-    selected_files,
-    teardown_current_library,
-)
-from pipelex_api.routes.pipelex.pipeline import get_request_user_id
-from pipelex_api.schemas.models import ALLOW_SIGNATURES_DESCRIPTION, CallerAnalyticsGroupsMixin, MthdsPipeRequest
-
-router = APIRouter(tags=["build"], route_class=JsonBodyRoute)
-
-
-class BuildRunnerRequest(MthdsPipeRequest, CallerAnalyticsGroupsMixin):
-    """The runner-script request: the shared closure + pipe selectors, plus the sweep's `allow_signatures`.
-
-    Alone among the `/build/*` projections this route keeps `allow_signatures`, because alone among
-    them it still runs the dry-run sweep — the flag only ever parameterized that sweep.
-    """
-
-    allow_signatures: bool = Field(default=False, description=ALLOW_SIGNATURES_DESCRIPTION)
-
-
-class RunnerStructures(BaseModel):
-    """The typed-structures projection the runner script imports from (`from structures.structures import ...`).
-
-    The same stamped `python-structures` artifacts + `codegen.lock` a local `pipelex build runner`
-    scaffolds into `<output>/structures/` — write `artifacts` and the lock under `directory` and
-    the returned `python_code` runs against them, with the offline `codegen check` passing there.
-    """
-
-    directory: str = Field(default="structures", description="Directory (relative to the runner script) to write the artifacts and lock into.")
-    artifacts: list[GeneratedArtifact] = Field(
-        default_factory=empty_list_factory_of(GeneratedArtifact),
-        description="The stamped generated files (paths relative to `directory`).",
-    )
-    lock: str = Field(..., description="The lock content (TOML) tracking the artifact set — write verbatim inside `directory`.")
-    lock_filename: str = Field(default=CODEGEN_LOCK_FILENAME, description="Filename the lock content must be written as.")
-
-
-class BuildRunnerValidReport(BaseModel):
-    """The 200 **valid** arm: the runner script plus the structures projection it imports from."""
-
-    is_valid: Literal[True] = True
-    pipe_ref: str = Field(..., description="The qualified pipe the runner was generated for — the resolved selector.")
-    requested_pipe_ref: str | None = Field(
-        default=None,
-        description=(
-            "The `pipe_ref` as submitted. Absent when it was omitted and defaulted — to the fetched package manifest's "
-            "`main_pipe` on a `method_ref` request, else to the closure's declared `main_pipe`."
-        ),
-    )
-    python_code: str = Field(..., description="Generated Python script for running the pipeline, imports spelled with the emitted class names.")
-    structures: RunnerStructures = Field(..., description="The typed-structures projection the script imports from.")
-    message: str = Field(default="Runner code generated successfully", description="Status message")
-
-
-# Discriminated 200 response union: the `/validate` discipline — the verdict rides `is_valid`,
-# never the HTTP status (breaking change from the previous `success`-bool body + 422-on-invalid).
-BuildRunnerResponse = Annotated[Union[BuildRunnerValidReport, CrateInvalidReport], Field(discriminator="is_valid")]
-
-
-def _reject_if_requested_pipe_skipped(sweep_result: dict[str, DryRunOutput], *, pipe_ref: str) -> None:
-    """Reject when the *requested* pipe was SKIPPED (its cross-package dependency is unresolved).
-
-    `validate_pipes` records a pipe SKIPPED — rather than failing the whole sweep — when a controller
-    references a sub-pipe in a package not included in the request (the cross-package tolerance shared
-    with `/validate`). For a code-generation endpoint that is a footgun: `generate_runner_code` reads
-    only the pipe's own inputs/output and never resolves sub-pipes, so it would happily emit runner
-    code for a pipeline that cannot actually run. A SKIPPED requested pipe is a no-verdict condition
-    (its dependency closure is absent from the request, so nothing could be diagnosed) → request-shape
-    422; unrelated SKIPPED pipes elsewhere in the bundle stay tolerated.
-    """
-    for output in sweep_result.values():
-        if pipe_ref != output.pipe_ref:
-            continue
-        match output.status:
-            case DryRunStatus.SKIPPED:
-                detail = output.error_message or "its dependencies could not be resolved"
-                raise_validation_error(f"Cannot generate runner code for pipe '{pipe_ref}': {detail}")
-            case DryRunStatus.SUCCESS | DryRunStatus.FAILURE:
-                return
-
-
-def _output_is_list(blueprints: list[PipelexBundleBlueprint], *, pipe_ref: str) -> bool:
-    """Whether the requested pipe's declared output carries a list multiplicity marker (mirrors the CLI).
-
-    Matched on the **qualified** ref. A blueprint's `pipe` map is keyed by bare code, so scanning by
-    bare code alone would return the first blueprint declaring that code — which in a multi-domain
-    closure can be a *different* pipe that merely shares the name, and whose multiplicity may differ.
-    The runner would then be generated with the wrong output handling. Compare the owning domain too.
-    """
-    domain_code, _, pipe_code = pipe_ref.rpartition(".")
-    for blueprint in blueprints:
-        if blueprint.domain != domain_code or not blueprint.pipe or pipe_code not in blueprint.pipe:
-            continue
-        output_parse = parse_concept_with_multiplicity(blueprint.pipe[pipe_code].output)
-        return output_parse.multiplicity is not None
-    return False
-
-
-@router.post(
-    "/build/runner",
-    response_model=BuildRunnerResponse,
-    # On top of the composite router's shared 401/413/422/500: the `method_ref` closure selector the
-    # envelope accepts but no server-side method registry resolves yet (shared with /resolve, /codegen).
-    responses={404: PROBLEM_404_METHOD_PACKAGE, 501: PROBLEM_501_METHOD_REF},
-)
-async def build_runner(request: Request, request_data: BuildRunnerRequest) -> JSONResponse:
-    """Generate a Python runner script for a pipe, riding the codegen types projection.
-
-    The one `/build/*` projection that is **not** static: a runner script is a promise the pipe can
-    actually run, so this route keeps the dry-run sweep its siblings dropped (and with it
-    `allow_signatures`, which only ever parameterized that sweep). `validate_bundle` opens a single
-    library, loads the closure, sweeps, and on success leaves the library loaded + current; on failure
-    it tears it down itself. On the success path the crate is read from that library, the
-    `python-structures` projection is emitted and stamped, and the runner script is generated with the
-    **emitted** class names — the same flow as a local `pipelex build runner`.
-
-    The sweep is scoped to the requested pipe, so unrelated broken siblings do not block a good pipe.
-    When `pipe_ref` is omitted the scope is not settled before the closure loads, so the whole closure
-    is swept and the pipe then defaults the way a run by address does — to the fetched package
-    manifest's `main_pipe` on a `method_ref` request, else to the closure's own declared `main_pipe` —
-    a stricter verdict, and the honest one for a caller who did not say which pipe they meant.
-
-    Response contract (the `/validate` discipline): an invalid closure — including a failed dry-run of
-    the requested pipe — is a produced verdict: a **200** `is_valid: false` with the structured
-    `validation_errors[]`. Non-2xx is reserved for no-verdict conditions: a selection refusal (an
-    unknown pipe ref, an omitted `pipe_ref` that nothing defaults — no fetched-manifest `main_pipe`,
-    and a closure declaring no, or several, `main_pipe`), an input 422 whose `error_type` is
-    `EntryPipeNotFoundError` or `EntryPipeAmbiguousError`; a request-shape 422 for a requested pipe
-    whose cross-package dependencies are absent from the request; a 501 for a registry-form `method_ref`, auth, server
-    fault — RFC 7807 via the global handlers.
-    """
-    library_manager = get_library_manager()
-    selection = selected_files(request_data)
-
-    try:
-        # If this raises, validate_bundle has already torn down its own library — nothing to clean up here.
-        validate_result = await validate_bundle(
-            mthds_contents=[item.content for item in selection.files],
-            mthds_sources=[item.source for item in selection.files],
-            allow_signatures=request_data.allow_signatures,
-            dry_run_pipe_codes=[request_data.pipe_ref] if request_data.pipe_ref else None,
-            # The sweep is done for the caller, so its dry runs and `pipe_dry_run` event name them.
-            caller_identity=CallerIdentity.make_from_host(user_id=get_request_user_id(request), extras=request_data.analytics_groups),
-        )
-    except ValidateBundleError as validate_error:
-        return invalid_crate_report_response(validate_error.to_error_report())
-    except PipeNotFoundError as exc:
-        # The engine deliberately lets this one through untranslated (see `translate_to_validate_bundle_error`)
-        # so the caller can own it: a pipe ref naming nothing in the closure is an input 422, not an
-        # invalid-closure verdict — nothing about the closure is wrong. It is re-raised as the entry-lookup
-        # class the slice miss already is, so its `error_type` matches `resolve_requested_pipe`'s refusals.
-        msg = f"Pipe '{request_data.pipe_ref}' not found in the submitted closure: {exc}"
-        raise EntryPipeNotFoundError(msg) from exc
-
-    # Success: validate_bundle left its library loaded + current. Build everything from it, then own its teardown.
-    library_id = get_current_library_id_or_none()
-    try:
-        crate = library_manager.get_crate(library_id) if library_id else None
-        if crate is None:
-            # Unreachable after a successful in-memory validate (the blueprints were accumulated),
-            # so a None crate is an internal invariant break — a server fault (5xx), never a
-            # caller-facing verdict (mirrors resolve_crate_from_contents's identical guard).
-            msg = "library crate unavailable after a successful bundle load"
-            raise PipelexUnexpectedError(msg)
-        normalized_crate = normalize_crate(crate, mthds_version=MTHDS_STANDARD_VERSION)
-        requested_pipe = resolve_requested_pipe(
-            normalized_crate,
-            pipe_ref=request_data.pipe_ref,
-            manifest_main_pipe=selection.manifest_main_pipe,
-        )
-
-        # The sweep tolerates a cross-package unresolved dependency by recording the pipe SKIPPED
-        # instead of failing. Don't hand back runner code for the *requested* pipe in that state.
-        _reject_if_requested_pipe_skipped(validate_result.dry_run_result, pipe_ref=requested_pipe.ref)
-
-        emitted = emit_types(normalized_crate, target=CodegenTarget.PYTHON_STRUCTURES)
-        projection = build_stamped_projection(
-            emitted,
-            crate_fingerprint=normalized_crate.fingerprint,
-            engine_version=get_package_version(),
-            kind=CodegenKind.TYPES,
-            target=CodegenTarget.PYTHON_STRUCTURES,
-        )
-        class_name_overrides = runtime_to_emitted_class_names(resolve_concepts_from_crate(normalized_crate))
-
-        python_code = generate_runner_code(
-            pipe=requested_pipe.pipe,
-            output_multiplicity=_output_is_list(validate_result.blueprints, pipe_ref=requested_pipe.ref),
-            class_name_overrides=class_name_overrides,
-        )
-
-        report = BuildRunnerValidReport(
-            pipe_ref=requested_pipe.ref,
-            requested_pipe_ref=request_data.pipe_ref,
-            python_code=python_code,
-            structures=RunnerStructures(
-                artifacts=[GeneratedArtifact(path=stamped.filename, content=stamped.content) for stamped in projection.files],
-                lock=projection.lock_content,
-            ),
-        )
-        return JSONResponse(content=report.model_dump(mode="json", by_alias=True, exclude_none=True))
-    finally:
-        teardown_current_library()