Skip to content

Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.

fix changelog

thomashebrard3693543c6d04
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 847773bd7..77aa3662f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -18,16 +18,6 @@
### Added
-- **Breaking: `JobMetadata` splits its run-constant half into a new `RunMetadata`.** `user_id`, `pipeline_run_id`, `storage_scope` and `request_id` are constant for a whole run; `pipe_code`, `pipe_run_id`, `otel_context` and `content_generation_job_id` change at every step. They sat side by side with nothing saying which was which, so a copy made for a nested pipe had to know, field by field, what to carry through. They are now `job_metadata.run_metadata.*`, and the copy carries one object.
-
- There is deliberately no read-through accessor on `JobMetadata`: one spelling for one fact. Every call site reads the nested path.
-
-- **A pipe's result now carries the job it was produced under.** `PipeOutput.job_metadata` and `TracingAssembly.run_metadata` are set once at the run boundary, so a transport that offloads an oversized result to storage can key it inside the run's own namespace. Both are **private attributes behind properties, not model fields**: `PipeOutput` is on the wire — `pipelex-api` returns it and publishes its schema — so as a field this would have put `user_id`, `request_id` and `otel_context` into a public API's response body and its documented OpenAPI artifact. A transport reads the value by attribute on the live object before serializing, so it never needed to be on the wire at all.
-
- The gap was one-directional and easy to miss: every payload a run sends _in_ carries a `job_metadata` to resolve a scope through, and nothing it sent _back_ did. Under a hosted orchestrator that meant the two largest payloads an ordinary run produces — the pipe output and the tracing assembly, both around 350 KB — were stored outside every prefix the host's erasure cascade deletes, and survived deletion of the run that produced them. The same bytes were also stored a second time, correctly scoped, inside the delivery argument that carries them.
-
- Set at the run boundary and **not** at the ~17 `PipeOutput(...)` construction sites: only the top-level output crosses a transport boundary, and stamping every constructor to serve one of them is the same "remember to add it everywhere" fragility that caused the original bug. Optional throughout — dry runs, signature stubs and tests build outputs with no job in hand — and invisible on the wire, since `serialize_completed_output` names the fields it returns explicitly.
-
- **The `error_type` values a validation verdict can carry are now an enumerable, closed registry**: a `.mthds` bundle that fails validation reports each fault under an `error_type`, and until now there was no way to ask the runtime which faults exist. The values were reachable only by reading raise sites, and the only curated list of them lived outside this repo, in a hand-maintained conformance suite that could silently fall behind. `pipelex/validation_error_types.py` now holds the vocabulary in full and enumerates it as `VALIDATION_ERROR_TYPES`, so a consumer building coverage over the language surface — a test corpus, a client mapping faults onto its own UI — reads the registry instead of collecting strings from whichever diagnostics it happened to have seen. It is a **union of the enums the runtime already raises**, never a second list beside them: the two stage vocabularies plus a new `ValidationResidualErrorType` naming the one residual channel that had no enum of its own and rode an inline string. A member added to any of them is in the registry the moment it is declared. `ValidationErrorItem.error_type` is typed against their union, which is what makes the registry closed rather than merely documented — an unregistered string can no longer be constructed or parsed onto an item — and which publishes the vocabulary into the OpenAPI schema served for `/validate`, where the field was previously an open `string`. **No wire value changed**, including the dry-run residual's `DryRunError`: it keeps the exception-class spelling it has always had, because normalizing it would break every consumer that pins the string and would buy nothing an enumeration does not already give. Membership means a value is reachable on the wire, not that it is worth exercising — the advisory-only warning type and the two `unknown_*` fallbacks are in the registry and a coverage consumer excludes them on its own side, with a reason, rather than pruning the runtime's truth.
- **Closed registry for validation error types**: `VALIDATION_ERROR_TYPES`, in the new `pipelex/validation_error_types.py`, is an enumerable, closed registry of every `error_type` a validation verdict can carry. It is a union of the enums the runtime already raises — `PipeValidationErrorType`, `PipeFactoryErrorType`, and a new `ValidationResidualErrorType` naming the one residual channel that had no enum of its own — so a member added to any of them is in the registry the moment it is declared. A consumer building coverage over the language surface now reads the registry instead of collecting strings from whichever diagnostics it happened to have seen. No wire value changed.
- **The corpus's invalid axis**: the MTHDS Test Corpus now carries an `error.*` tag namespace generated from `VALIDATION_ERROR_TYPES`, plus a focused invalid entry for every tag in it that a `.mthds` bundle can actually produce — each authored to trigger exactly one error, and gated on doing so. Five codes are excluded, each with the measurement behind it: `circular_dependency_error` and `unknown_concept` are unreachable through bundle validation, `optional_force_redundant` is advisory-only and rides the `warnings` array, and the two `unknown_*` fallbacks name the absence of a diagnosis rather than a language fault.