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.

Rename mistralai-workflows token to mistral-workflows; bump mthds 0.6.0

Louis Choquel8a081d149006
diff --git a/README.md b/README.md
index 496d06190..f6f487a41 100644
--- a/README.md
+++ b/README.md
@@ -533,8 +533,6 @@ Install all extras:
uv pip install "pipelex[anthropic,google,google-genai,mistralai,bedrock,fal,linkup,docling]"
```
-> **Mistral Workflows orchestration** is not a pipelex extra. It runs pipes through the runtime bridge inside Mistral Workflows activities, and ships as a separate private package (`pipelex-mistralai-workflows`) that bundles pipelex — part of Pipelex's [workflow-orchestration offer](https://pipelex.com/products#mistral-workflows). It requires **Python 3.12+**; pipelex itself supports **Python 3.10+**, so only this optional orchestration path needs 3.12.
-
---
**Privacy & Telemetry** — Pipelex Gateway collects only technical data (model names, token counts, latency) — never prompts or business data. If you want to avoid Gateway telemetry, disable `pipelex_gateway` and use your own provider keys or local AI instead. [Learn more](https://docs.pipelex.com/latest/setup/telemetry/)
diff --git a/docs/under-the-hood/orchestrator-plugins.md b/docs/under-the-hood/orchestrator-plugins.md
index 4f00e0ced..e7124418a 100644
--- a/docs/under-the-hood/orchestrator-plugins.md
+++ b/docs/under-the-hood/orchestrator-plugins.md
@@ -7,17 +7,17 @@ description: "How Pipelex dispatches a pipe run by orchestration mode through th
A pipe a host runtime invokes through the runtime bridge runs along **two orthogonal axes**:
-- **`orchestration_mode`** — *which* orchestrator runs the pipe. An **open string token**, not a closed enum: core owns only `"direct"` (in-process); every other token is contributed by the plugin that owns its orchestrator — [`"temporal"`](https://pipelex.com/products#temporal) (durable, on a Temporal worker fleet) by `pipelex-temporal`, [`"mistralai-workflows"`](https://pipelex.com/products#mistral-workflows) (decomposed into Mistral Workflows primitives) by `pipelex-mistralai-workflows`. Both are commercial host-runtime backends, part of Pipelex's [workflow-orchestration offer](https://pipelex.com/products#durable-execution).
+- **`orchestration_mode`** — *which* orchestrator runs the pipe. An **open string token**, not a closed enum: core owns only `"direct"` (in-process); every other token is contributed by the plugin that owns its orchestrator — [`"temporal"`](https://pipelex.com/products#temporal) (durable, on a Temporal worker fleet) by `pipelex-temporal`, [`"mistral-workflows"`](https://pipelex.com/products#mistral-workflows) (decomposed into Mistral Workflows primitives) by `pipelex-mistralai-workflows`. Neither is built into the open-source `pipelex` core: both ship as external, closed-source host-runtime backends, distributed privately rather than on PyPI as part of Pipelex's [workflow-orchestration offer](https://pipelex.com/products#durable-execution).
- **`delivery`** — *whether the caller waits*. A **closed** core `DeliveryMode` enum (`BLOCKING` / `FIRE_AND_FORGET`), set by the endpoint and passed as a parameter to `run`, never received from a caller. An orchestrator honors it per its nature; `supports_fire_and_forget` advertises whether it can do genuine async.
-An **orchestrator** is what knows how to run a pipe under one token. Core names no orchestrator by import or by string. The bridge resolves the orchestrator for the requested token from a registry (keyed by the token `str`) and calls its `run` — `"direct"` is contributed by a core plugin, `"temporal"` by the Temporal plugin, `"mistralai-workflows"` by the external `pipelex-mistralai-workflows` plugin. A lookup miss raises a generic `MissingOrchestratorError` that names no orchestrator. This page documents that seam, the **Orchestrator SPI** a host-runtime plugin compiles against, and how the Temporal plugin is wired.
+An **orchestrator** is what knows how to run a pipe under one token. Core names no orchestrator by import or by string. The bridge resolves the orchestrator for the requested token from a registry (keyed by the token `str`) and calls its `run` — `"direct"` is contributed by a core plugin, `"temporal"` by the Temporal plugin, `"mistral-workflows"` by the external `pipelex-mistralai-workflows` plugin. A lookup miss raises a generic `MissingOrchestratorError` that names no orchestrator. This page documents that seam, the **Orchestrator SPI** a host-runtime plugin compiles against, and how the Temporal plugin is wired.
---
## The seam in one view
```
-run_pipe_via_bridge(input_payload) # pipelex_transport.bridge — closed host-runtime library
+<host-side bridge entry>(input_payload) # closed pipelex-transport library
→ build the PipeJob (boundary decode + library scope + trace_context)
→ orchestrator = get_orchestrator_registry().get_optional(mode=orchestration_mode)
→ if orchestrator is None: raise MissingOrchestratorError(mode) # generic, names no orchestrator
@@ -27,7 +27,7 @@ run_pipe_via_bridge(input_payload) # pipelex_transport.bridge — clo
The registry is built once at boot from whatever the discovered plugins contributed (`build_registrar` → `OrchestratorRegistry` on the hub). There is no `match orchestration_mode:` anywhere in the bridge — the token set is open, so validation is the registry lookup itself; adding a mode's behavior means registering an orchestrator for its token, nothing in core changes.
!!! note "Open seam, closed host-side entry"
- The host-side entry — `run_pipe_via_bridge` / `build_pipe_job_from_input` and the dispatch primitives that decode the boundary payload, scope the per-call library, and deliver results — lives in the **closed `pipelex-transport` library**. Embedding Pipelex into a host runtime (Temporal, Mistral, Airflow, your own) is a Pipelex [commercial capability](https://pipelex.com/products#durable-execution), not an open extension point. What stays **open** is the seam a third-party orchestrator extends: the orchestrator registry, `OrchestratorProtocol`, and the `pipelex.runtime_bridge` modules listed in [The Orchestrator SPI](#the-orchestrator-spi) below.
+ The host-side entry — the bridge entry point and `PipeJob` builder, plus the dispatch primitives that decode the boundary payload, scope the per-call library, and deliver results — lives in the **closed `pipelex-transport` library**. Embedding Pipelex into a host runtime (Temporal, Mistral, Airflow, your own) is a Pipelex [commercial capability](https://pipelex.com/products#durable-execution), not an open extension point. What stays **open** is the seam a third-party orchestrator extends: the orchestrator registry, `OrchestratorProtocol`, and the `pipelex.runtime_bridge` modules listed in [The Orchestrator SPI](#the-orchestrator-spi) below.
---
@@ -87,6 +87,8 @@ This is what lets the public `pipelex-api` base be orchestrator-agnostic and sti
Some orchestrators don't just serve a per-call mode — they reconfigure the whole process to run *as* that runtime (a Temporal worker). Such a plugin **claims process-global hub slots**, but only when the core-owned boot gate names it. `plugins.boot_orchestrator == self.name` means "boot this process as a Temporal-default runtime", not "the Temporal plugin is on". The gate is a backend-agnostic name-match — core names no orchestrator, and `register` reads no config file (the rich orchestrator config self-loads inside the thunks):
+Not every orchestrator goes this far. A per-call-only plugin — `pipelex-mistralai-workflows` is the minimal example — contributes just its `"mistral-workflows"` orchestrator and claims **no** hub slots: its router is installed per workflow invocation by the workflow body itself, so there is no process-global boot slot to claim and it never participates in the boot gate below. The boot-orchestrator machinery in this section applies only to a plugin that boots the process as its runtime (today, `pipelex-temporal`).
+
```python
if registrar.config.plugins.boot_orchestrator == self.name:
registrar.claim_content_generator(_make_temporal_content_generator) # a thunk, not an instance
@@ -98,7 +100,7 @@ if registrar.config.plugins.boot_orchestrator == self.name:
Each `claim_*` takes a **thunk** (a zero-arg factory), never a constructed instance. The thunk runs only at the boot apply-point, so `register` itself imports no `temporalio` — even on a worker. This is the deferred-thunk rule that keeps the import-light invariant intact at boot.
-Because the gate is a name-match, `plugins.boot_orchestrator` must name a plugin that actually registered. After discovery, `Pipelex.setup` rejects a `boot_orchestrator` that no registered plugin carries — a typo or a missing plugin (e.g. `--orchestrator temporal` without `pipelex-temporal` installed) raises `UnknownBootOrchestratorError` instead of silently running in-process: nothing would claim the hub slots, so the process would otherwise fall through to the core defaults and execute on the wrong runtime. The check matches against **plugin names** (the same namespace the gate uses), not the `orchestration_mode` registry — a plugin's name and the token it serves can differ (`pipelex-mistralai-workflows` is named `mistral_native` but serves `mistralai-workflows`). The error names no specific plugin, keeping core decoupled.
+Because the gate is a name-match, `plugins.boot_orchestrator` must name a plugin that actually registered. After discovery, `Pipelex.setup` rejects a `boot_orchestrator` that no registered plugin carries — a typo or a missing plugin (e.g. `--orchestrator temporal` without `pipelex-temporal` installed) raises `UnknownBootOrchestratorError` instead of silently running in-process: nothing would claim the hub slots, so the process would otherwise fall through to the core defaults and execute on the wrong runtime. The check matches against **plugin names** (the same namespace the gate uses), not the `orchestration_mode` registry — a plugin's name and the token(s) it serves are separate namespaces that *may* differ, even where a shipped plugin keeps them identical (`pipelex-temporal` is named `temporal` and serves `temporal`). The error names no specific plugin, keeping core decoupled.
### Injection precedence
@@ -143,7 +145,7 @@ What an out-of-tree orchestrator imports *is* a contract. The SPI is a documente
| Tracing / graph hooks | `trace_events`, `graph_tracer_manager`, `tracing_assembly` (per-step trace/usage events across the boundary) |
!!! warning "Not in the open SPI — the closed `pipelex-transport` layer"
- The host-side bridge entry (`run_pipe_via_bridge`, `build_pipe_job_from_input`), the cross-process dispatch primitives (`delivery`, `pipe_classification`, `submitter_hydration`, `trace_flush`, `scoped_library`, `pipe_run_arg`), and the transport prepare helpers (`prepare_job_for_transport`, `prepare_output_for_transport`) were extracted out of open core into the **closed `pipelex-transport` library**. Embedding Pipelex into a host runtime is a Pipelex commercial capability — Pipelex's own host-runtime plugins (`pipelex-temporal`, `pipelex-mistralai-workflows`) compile against `pipelex-transport`; a third-party out-of-tree orchestrator compiles against the **open** rows above only.
+ The host-side bridge entry point, the cross-process dispatch primitives (boundary delivery, pipe classification, submitter-side hydration, trace flush, scoped-library, and the submit-arg envelope), and the transport-prep helpers were extracted out of open core into the **closed `pipelex-transport` library**. Embedding Pipelex into a host runtime is a Pipelex commercial capability — Pipelex's own host-runtime plugins (`pipelex-temporal`, `pipelex-mistralai-workflows`) compile against `pipelex-transport`; a third-party out-of-tree orchestrator compiles against the **open** rows above only.
---
diff --git a/docs/under-the-hood/pipe-routing-and-execution.md b/docs/under-the-hood/pipe-routing-and-execution.md
index 11e19a828..4e8ed0609 100644
--- a/docs/under-the-hood/pipe-routing-and-execution.md
+++ b/docs/under-the-hood/pipe-routing-and-execution.md
@@ -49,7 +49,7 @@ The `PipeJob` is the universal unit of execution. It carries everything needed t
| `output_name` | `str \| None` | Override for the output variable name |
| `library_crate` | `LibraryCrate \| None` | Serializable library snapshot for distributed execution |
-`PipeJob` is created by `pipeline_run_setup()`, which handles library loading, pipe resolution, working memory initialization, and telemetry setup. For distributed dispatch, `prepare_job_for_transport(pipe_job)` (in the closed `pipelex-transport` library) moves `working_memory` to `working_memory_raw` (deferred hydration) and ensures the crate is attached.
+`PipeJob` is created by `pipeline_run_setup()`, which handles library loading, pipe resolution, working memory initialization, and telemetry setup. For distributed dispatch, a transport-prep step in the closed `pipelex-transport` library moves `working_memory` to `working_memory_raw` (deferred hydration) and ensures the crate is attached.
---
@@ -187,7 +187,7 @@ sequenceDiagram
S->>S: Create PipeJob (crate attached)
Note over S: TemporalPipeRouter.run() (submitter side)
- S->>S: prepare_job_for_transport()<br/>(WM → working_memory_raw)
+ S->>S: transport prep (closed)<br/>(WM → working_memory_raw)
S->>T: Submit WfPipeRouter(PipeJob)
T->>W: Dispatch workflow
@@ -235,7 +235,7 @@ Concrete pipe operators (PipeLLM, PipeCompose, PipeExtract, PipeImgGen) dispatch
Distributed execution introduces three mechanisms that don't exist in direct mode, because the worker is a separate process that shares none of the submitter's library, class registry, or working-memory state. They are backend-neutral; for the full walkthrough see [Runtime Bridge & Transport](./runtime-bridge-and-transport.md). In short:
- **LibraryCrate propagation** — the submitter attaches a serializable snapshot of all pipes and concepts to the `PipeJob`; every worker-side job loads it (idempotently, by fingerprint) so `get_required_pipe()` resolves at every level.
-- **Deferred hydration** — `WorkingMemory` crosses as a raw JSON dict (`working_memory_raw`) on both `PipeJob` inputs and `PipeOutput` return values, avoiding deserialization failures when a receiving process hasn't registered the bundle's dynamic concept classes. The transport-prep helpers (`prepare_job_for_transport`, `prepare_output_for_transport`) live in the closed `pipelex-transport` library; the raw field and the hydration helper stay in open core.
+- **Deferred hydration** — `WorkingMemory` crosses as a raw JSON dict (`working_memory_raw`) on both `PipeJob` inputs and `PipeOutput` return values, avoiding deserialization failures when a receiving process hasn't registered the bundle's dynamic concept classes. The transport-prep helpers live in the closed `pipelex-transport` library; the raw field and the hydration helper stay in open core.
- **Per-call isolation** — each job gets its own `ClassRegistry` (pre-seeded from the global registry) and its own `Library`, scoped via `ContextVar`, so concurrent jobs with conflicting concept names (e.g., two bundles that both define `Result` with different fields) don't cross-contaminate.
!!! warning "Known backend limitation: StuffArtefact in dry-run"
@@ -270,7 +270,7 @@ flowchart TB
end
subgraph Distributed["Distributed Execution (Temporal example)"]
- T1["Submitter router: prepare_job_for_transport()"]
+ T1["Submitter router: transport prep (closed)"]
T2["Kajson serialize PipeJob + crate"]
T3["Host runtime (Temporal Server)"]
T4["Worker: Kajson deserialize"]
diff --git a/docs/under-the-hood/runtime-bridge-and-transport.md b/docs/under-the-hood/runtime-bridge-and-transport.md
index ebf90afb3..f9bc6ec74 100644
--- a/docs/under-the-hood/runtime-bridge-and-transport.md
+++ b/docs/under-the-hood/runtime-bridge-and-transport.md
@@ -110,7 +110,7 @@ The worker-side hydration helper (`pipelex/runtime_bridge/primitives/hydration.p
Because delivery renders from the raw dict (`pipelex/pipe_run/delivery_executor.py` branches on which field is populated), a delivery worker never needs the crate loaded — which is the precondition for true distributed execution. Dynamic concepts lose typed rendering on the delivery worker (a generic field-walking fallback still produces readable JSON/HTML), but the worker stays crate-free.
!!! note "Where the transport prep lives"
- Moving working memory into `working_memory_raw` for a job (`prepare_job_for_transport`), dehydrating a result before return (`prepare_output_for_transport`), and the submitter-side rehydration are part of the **closed `pipelex-transport`** library — they are the cross-process plumbing. The *raw field itself*, `dump_for_transport`, and the worker-side hydration helper stay **open core**, because they are host-agnostic and are also exercised by the open `pipelex-api` runner.
+ Moving working memory into `working_memory_raw` for a job, dehydrating a result before return, and the submitter-side rehydration are part of the **closed `pipelex-transport`** library — they are the cross-process plumbing. The *raw field itself*, `dump_for_transport`, and the worker-side hydration helper stay **open core**, because they are host-agnostic and are also exercised by the open `pipelex-api` runner.
---
@@ -129,20 +129,19 @@ The hub's class-registry and library scoping (`pipelex/hub.py`, `pipelex/librari
## Where open core ends and `pipelex-transport` begins
-The boundary types and the host-agnostic helpers are **open** (MIT, in the `pipelex` distribution). The cross-process *plumbing* that drives a pipe run across the boundary is **closed** (the proprietary `pipelex-transport` library, installed via git+ssh, pinned to an exact core rev). Embedding Pipelex into a host runtime is a commercial capability, so the entry point and dispatch primitives are not an open extension seam.
+The boundary types and the host-agnostic helpers are **open** (MIT, in the `pipelex` distribution):
-| Concern | Open core (`pipelex`) | Closed (`pipelex-transport`) |
-|---|---|---|
-| Boundary DTOs | `PipeJob`, `PipeOutput`, `LibraryCrate`, `runtime_bridge/payloads.py` | — |
-| Serialization | `runtime_bridge/serialization.py` | — |
-| Mode / delivery model | `orchestration_mode`, `DeliveryMode`, the orchestrator registry / SPI | — |
-| Working-memory raw + dump | `working_memory_raw`, `WorkingMemory.dump_for_transport` | — |
-| Worker-side hydration | `runtime_bridge/primitives/hydration.py` | — |
-| Bridge entry point | — | `run_pipe_via_bridge`, `build_pipe_job_from_input` |
-| Transport prep | — | `prepare_job_for_transport`, `prepare_output_for_transport` |
-| Submitter rehydration, delivery, trace flush, scoped-library, pipe classification, submit-arg envelope | — | the dispatch primitives |
+| Concern | Open core (`pipelex`) |
+|---|---|
+| Boundary DTOs | `PipeJob`, `PipeOutput`, `LibraryCrate`, `runtime_bridge/payloads.py` |
+| Serialization | `runtime_bridge/serialization.py` |
+| Mode / delivery model | `orchestration_mode`, `DeliveryMode`, the orchestrator registry / SPI |
+| Working-memory raw + dump | `working_memory_raw`, `WorkingMemory.dump_for_transport` |
+| Worker-side hydration | `runtime_bridge/primitives/hydration.py` |
-A third-party orchestrator compiles against the **open** rows only (the [Orchestrator SPI](./orchestrator-plugins.md#the-orchestrator-spi)); Pipelex's own host-runtime plugins (`pipelex-temporal`, `pipelex-mistralai-workflows`) additionally compile against `pipelex-transport`.
+The cross-process *plumbing* that drives a pipe run across the boundary — the host-side bridge entry point, the transport-prep step, and the dispatch primitives (submitter rehydration, delivery, trace flush, scoped-library, pipe classification, and the submit-arg envelope) — is **closed** (the proprietary `pipelex-transport` library, installed via git+ssh, pinned to an exact core rev). Embedding Pipelex into a host runtime is a commercial capability, not an open extension seam.
+
+A third-party orchestrator compiles against the **open** surface only (the [Orchestrator SPI](./orchestrator-plugins.md#the-orchestrator-spi)); Pipelex's own host-runtime plugins (`pipelex-temporal`, `pipelex-mistralai-workflows`) additionally compile against `pipelex-transport`.
---
diff --git a/pipelex/hub.py b/pipelex/hub.py
index c43daa4dd..d998ddef7 100644
--- a/pipelex/hub.py
+++ b/pipelex/hub.py
@@ -751,7 +751,7 @@ def set_pipe_router(pipe_router: "PipeRouterProtocol") -> None:
"""Override the active pipe router for the current async context.
Used by host runtimes that want controllers to dispatch sub-pipes
- through their own router (e.g. Mistral-native mode swaps in a router
+ through their own router (e.g. Mistral Workflows mode swaps in a router
that turns sub-pipe calls into child workflows / activities). The
override is contextvar-scoped, so concurrent runs on the same hub
don't leak into each other. Pass ``None`` via
diff --git a/pipelex/plugins/orchestrator_registry.py b/pipelex/plugins/orchestrator_registry.py
index 110d17181..25aa040de 100644
--- a/pipelex/plugins/orchestrator_registry.py
+++ b/pipelex/plugins/orchestrator_registry.py
@@ -15,7 +15,7 @@ class OrchestratorProtocol(Protocol):
An orchestrator plugin registers one of these per ``orchestration_mode`` token it
serves (``"direct"`` in core; ``"temporal"`` from ``pipelex-temporal``,
- ``"mistralai-workflows"`` from ``pipelex-mistralai-workflows``). The runtime bridge
+ ``"mistral-workflows"`` from ``pipelex-mistralai-workflows``). The runtime bridge
dispatches by token through the ``OrchestratorRegistry`` instead of branching on a
``match``.
diff --git a/pipelex/runtime_bridge/exceptions.py b/pipelex/runtime_bridge/exceptions.py
index 0a3b4b59d..9d6b4fff4 100644
--- a/pipelex/runtime_bridge/exceptions.py
+++ b/pipelex/runtime_bridge/exceptions.py
@@ -11,7 +11,7 @@ class MissingOrchestratorError(PipelexRuntimeBridgeError):
``orchestration_mode`` is an open token: ``"direct"`` is contributed by core, and every
other token by the plugin that owns its orchestrator (``"temporal"`` →
- ``pipelex-temporal``, ``"mistralai-workflows"`` → ``pipelex-mistralai-workflows``). A
+ ``pipelex-temporal``, ``"mistral-workflows"`` → ``pipelex-mistralai-workflows``). A
lookup miss therefore means *that mode's plugin is not installed* — the message is
generic and names no orchestrator, so core stays fully decoupled from its plugins. The
one special case is ``"direct"``: its orchestrator is core and always present, so a miss
diff --git a/pipelex/runtime_bridge/orchestration_mode.py b/pipelex/runtime_bridge/orchestration_mode.py
index 5e3c86724..ec16cd94f 100644
--- a/pipelex/runtime_bridge/orchestration_mode.py
+++ b/pipelex/runtime_bridge/orchestration_mode.py
@@ -3,7 +3,7 @@
``orchestration_mode`` is an **open string token**, not a closed enum. Core owns
only ``"direct"`` (its single built-in, in-process orchestrator); every other token
is contributed by the plugin that owns the orchestrator — ``pipelex-temporal`` owns
-``"temporal"``, ``pipelex-mistralai-workflows`` owns ``"mistralai-workflows"``. The
+``"temporal"``, ``pipelex-mistralai-workflows`` owns ``"mistral-workflows"``. The
orchestrator/validator registries are keyed by this token and validation is a
registry lookup (*is this mode registered?* → ``MissingOrchestratorError`` on a miss),
never an enum-membership check.
diff --git a/pyproject.toml b/pyproject.toml
index 387cb6085..ef5f77534 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -30,7 +30,7 @@ dependencies = [
"json2html>=1.3.0",
"kajson==0.7.0",
"markdown>=3.6",
- "mthds>=0.5.0",
+ "mthds>=0.6.0",
"networkx>=3.4.2",
"openai>=2.0.0",
"opentelemetry-api",
diff --git a/tests/unit/pipelex/runtime_bridge/test_exceptions_disclosure.py b/tests/unit/pipelex/runtime_bridge/test_exceptions_disclosure.py
index 8f3c84515..37c782600 100644
--- a/tests/unit/pipelex/runtime_bridge/test_exceptions_disclosure.py
+++ b/tests/unit/pipelex/runtime_bridge/test_exceptions_disclosure.py
@@ -5,7 +5,7 @@ from pipelex.runtime_bridge.exceptions import MissingOrchestratorError
class TestRuntimeBridgeExceptionDisclosure:
- @pytest.mark.parametrize("mode", ["temporal", "mistralai-workflows", "acme"])
+ @pytest.mark.parametrize("mode", ["temporal", "mistral-workflows", "acme"])
def test_generic_plugin_hint_survives_strict_disclosure(self, mode: str) -> None:
"""MissingOrchestratorError carries a caller-actionable, plugin-decoupled hint in its message.
diff --git a/tests/unit/pipelex/runtime_bridge/test_missing_bundle_validator_error.py b/tests/unit/pipelex/runtime_bridge/test_missing_bundle_validator_error.py
index a986caf07..cfbb22e94 100644
--- a/tests/unit/pipelex/runtime_bridge/test_missing_bundle_validator_error.py
+++ b/tests/unit/pipelex/runtime_bridge/test_missing_bundle_validator_error.py
@@ -13,7 +13,7 @@ from pipelex.runtime_bridge.orchestration_mode import DIRECT_ORCHESTRATION_MODE
class TestMissingBundleValidatorError:
- @pytest.mark.parametrize("mode", ["temporal", "mistralai-workflows", "acme"])
+ @pytest.mark.parametrize("mode", ["temporal", "mistral-workflows", "acme"])
def test_unregistered_mode_carries_generic_plugin_hint(self, mode: str) -> None:
error = MissingBundleValidatorError(mode=mode)
diff --git a/uv.lock b/uv.lock
index e253065ec..8fa652598 100644
--- a/uv.lock
+++ b/uv.lock
@@ -2673,7 +2673,7 @@ wheels = [
[[package]]
name = "mthds"
-version = "0.5.0"
+version = "0.6.0"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "backports-strenum", marker = "python_full_version < '3.11'" },
@@ -2684,9 +2684,9 @@ dependencies = [
{ name = "tomlkit" },
{ name = "typing-extensions" },
]
-sdist = { url = "https://files.pythonhosted.org/packages/3a/6b/5d706bade53e93466fbe1816d3046b7924c67bfec9859544cbedf21ea4c5/mthds-0.5.0.tar.gz", hash = "sha256:143b4405590d4f78713c442ad55553542d630c374099e9ee02b96823b2a2c426", size = 142082, upload-time = "2026-06-18T20:45:24.601Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/51/d4/64263f35f42dcc0a74bb348e6511e923fe32f99d851955f04673f1cb5d68/mthds-0.6.0.tar.gz", hash = "sha256:8608599345f90b1a6f4a475cc73dc050d9dfd69c4b9245d814b8733fd923dd5b", size = 131133, upload-time = "2026-06-30T12:50:51.744Z" }
wheels = [
- { url = "https://files.pythonhosted.org/packages/ef/47/0af23c995b6859b8809d077185d97de1be93c50f56bfe980daaf7cd9fc2d/mthds-0.5.0-py3-none-any.whl", hash = "sha256:a41a7b5986b65f41b0465372fc4f9180800ad212ed67830d8bb8d6dd457cd220", size = 64413, upload-time = "2026-06-18T20:45:23.277Z" },
+ { url = "https://files.pythonhosted.org/packages/58/f3/4b30d61dbd6b5699954da41908353524b07c388376a0bb164e75196bd6c0/mthds-0.6.0-py3-none-any.whl", hash = "sha256:8faf7ba78e672da7c3693a07872bfd654fcdcff43d0e085a9d340d9920beb2f3", size = 57703, upload-time = "2026-06-30T12:50:50.57Z" },
]
[[package]]
@@ -3856,7 +3856,7 @@ requires-dist = [
{ name = "mkdocs-meta-manager", marker = "extra == 'docs'", specifier = ">=1.1.0" },
{ name = "mkdocs-redirects", marker = "extra == 'docs'", specifier = "==1.2.2" },
{ name = "moto", extras = ["dynamodb", "s3"], marker = "extra == 'dev'", specifier = ">=5.0.0" },
- { name = "mthds", specifier = ">=0.5.0" },
+ { name = "mthds", specifier = ">=0.6.0" },
{ name = "mypy", marker = "extra == 'dev'", specifier = "==1.19.1" },
{ name = "networkx", specifier = ">=3.4.2" },
{ name = "openai", specifier = ">=2.0.0" },