Repository navigation
Releases
v2.42.1
Patch release with the fixes shown in the new video series, EventConductor in N minutes.
Fixed
- Console: the Operations tab appears with the first manual operation on a running process — no reload needed.
- Console: a process page redrawn after an operation keeps its header (back arrow, button order) exactly as on a fresh load.
- Console: a styled 403 page for browsers the console refuses (API endpoints keep their plain 401/403).
- Console: truthful audit copy — the operation dialogs say the reason is recorded "together with who did it" (it reads
anonymouswithout a login), not "with your name". - Examples: an unpaid balance is never released automatically (
examples/video-seriesbalance-reminder): the deadline sends a final notice, then a grace period, then the front desk decides. - Docs: deadlines route to a person, not to a cancellation in the scheduling examples.
v2.42.0
Changed
- Breaking for custom webhook providers:
io.mateu.workflow.webhook.WebhookProvideris nowWebhookDeliveryProvider, so the webhook gateway can be embedded beside the engine. Rename the interface in your own providers.
Added
compensate: trueon anEND— compensation on a business decision. An END withcompensate: truecancels whatever is still running and undoes every completed compensable step, newest first (a forEach's completed iterations once each), and the process endsCOMPENSATED. Compensation is the mechanism; who decides to trigger it is your business rule. Checked by the engine,eventconductor:validate, the JSON schema and the editor.- The hotel booking tells a realistic story: the guest decides. In the workshop, the examples and the docs, a sold-out room no longer cancels the rest: the process keeps what was booked, offers alternatives, waits for the guest (reminder, then front desk) and compensates only if the guest — or the front desk — cancels.
examples/video-series— every step type running (timers, messages, FORK/JOIN, CHOICE, PUBLISH_EVENT, REPLY, schedules, triggers, webhook, AGENT on a demo runtime), a scripted MCP client and an observability profile (Prometheus, Grafana, Jaeger).- Docs: Secure by default.
- Diagram minimap folds away; the workshop console has the forms task inbox.
Fixed
- Engine: an XOR join fed from a CHOICE's default branch now goes on; an XOR join with
compensateLosershas exactly one winner; no false "2 outgoing flows" warning foronTimeoutStepId; definitions are imported before the web server starts (no 404 right after boot);eventconductor:validateno longer warns about$defs/deprecated. - Console: labelled compensation rows (
Room 101, notitem 0), an Attempts column, timeout routes drawn as such, loop passes, USER_TASK cards without internal variables, click-to-pin cards, the minimap no longer covers nodes, the task inbox's Run button is visible, the graph re-fits when its container resizes. - Mateu 3.0-beta.67: cached page layouts are kept per app and build (no "not allowed" toast after another app ran on the same port).
- IDE plugins (0.2.5): graph edits no longer rewrite the whole file (comments and quoting are kept); Run Workflow is offered for
*.ec.yaml.
Docs
*.ec.yamlis the recommended name for a workflow definition (.ecand plain YAML/JSON stay supported).
v2.41.0
Added — test kit
- Workflow coverage. Every
@EventConductorTestrecords which steps ran and which routes were taken (CHOICE branches, guarded links, timeout routes, compensations, loop-backs) and writestarget/eventconductor-coverage/coverage.txt+coverage.json. (#653) - Scenarios as data. Describe a test case in YAML/JSON — variables, stubbed tasks/HTTP/LLM/agents, follow-up actions, expected end state — and run a directory of them with
@ParameterizedTest @ScenarioSource("src/test/scenarios"). (#653) eventconductor:verify. One Maven goal: validate + check-migration + optional coverage floors (minStepCoverage,minBranchCoverage), all problems reported at once. CI becomesmvn -B verify -Deventconductor.migration.from=origin/main. (#653)- Compensation, iteration and escalation assertions:
hasCompensatedInOrder(...),iterations("rooms").hasOnlyFailed("Room 102"),iteration(ref).wasCompensated()… — iterations are named by index,forEach.labelor item in failure messages. (#652) - Per-iteration HTTP stubs:
whenHttpCall("book").whenItemHas("number", "102"),.whenIteration(1),.whenRequest(...). (#652) - LLM stubs are checked against the step's
responseSchema(LLM_STUB_INVALID);thenInvalidAnswer(text)stubs a bad model answer on purpose. (#652)
Fixed
- Every classpath
workflows/directory is read — asrc/test/resources/workflowsno longer hidessrc/main/resources/workflows. When the same id is in two roots the first on the classpath wins (test before main), with a warning if they differ. (#651) - Re-importing an identical definition (e.g. from Git after the classpath import) no longer records a new version. (#651)
- LLM
base-urland/v1:openaiaccepts a URL with or without/v1(and a pasted…/chat/completions);anthropictolerates a trailing/v1. Documented per provider. (#651) whenTask(stepId)matches USER_TASKs and other built-in steps by step id —whenTask("approve")used to match nothing. (#652)- Console: consistently English (
workflow.ui.localeto change it); the process list hides forEach child runs by default and has a Business key column; the parent's Errors tab shows why a child failed; the toolbar refreshes after Complete step; kebab-case page URLs (/workflow/batch-operations) redirect to the real pages; the forEach badge on the graph is no longer clipped. (#654)
Docs
- Workshop pages are now schema-checked like the rest of the docs; the workshop's CI uses
eventconductor:verifyand ships coverage-driven scenarios.
v2.40.0
Fixed
forms-enginenext to an embedded engine. Addingforms-engineto a@WorkflowEmbeddedApplication(or under the workflow-test kit) no longer fails with "HumanTaskEvents required a bean of type StreamBridge". In embedded mode USER_TASKs with aformIdare now served by the forms engine in process — fetch, claim and complete through/forms/api/tasks— and the reply goes straight to the engine. Kafka mode is unchanged. New switch:forms.embedded.serve-user-tasks(#648)forms.directory-import.*/forms.git-import.*were silently ignored when the workflow engine shared the application (embedded apps andorchestrator-standalone-app): both engines shipped a class with the same name. (#648)- Inline PROCESS bodies under
forEachlost the item and the business key.${room.number}rendered as null and${businessKey}was the child's ownparent:<id>key. Templates and guards now see the item and index as objects, and${businessKey}inside an inline body is the business key of the process that owns it. The child's real key (search, correlation, locks) is unchanged. Adds migrationV62(two nullable columns). (#649)
Docs
- Hands-on workshop: build the hotel-booking saga end to end, debug it, call an AI agent, and put a test gate in your pipeline — https://eventconductor.mateu.io/workshop/
- Why a process engine instead of hand-written orchestration — https://eventconductor.mateu.io/guides/why-a-process-engine/
- New promo video on the home page — https://youtu.be/QZhz7KwSfUk
Full changelog: v2.39.0...v2.40.0
v2.39.0
Upgrading
- Database migration V60 adds
step_execution.item_label(Flyway applies it on start). - Behaviour changes in compensation, both fixing work that was left undone:
- a compensable step (or forEach iteration) that completes after the engine cancelled it is now compensated instead of ignored;
- a child process the engine cuts short (parent rollback,
failFast,compensateLosers,compensateAbandoned) now rolls back its completed steps. Cancelling a process by hand still does not roll back.
- New definition fields are omitted when unset, so existing definitions keep their version hash.
Added
-
Edit inline PROCESS bodies in the graph editor. Double-click an inline PROCESS (or Edit ▸ in its panel) and its body becomes the graph being edited, with every tool — palette, links, panel, delete; a breadcrumb shows the path and Esc / ↩ Back returns to the level above, at the arrangement and zoom it was left. Bodies nest. Edits are written back into the step's
steps, so the host still receives the whole definition. A PROCESS panel switches between naming a child (childWorkflowDefinitionId) and writing it in line (a fresh body is a START and an END; the side switched away from is kept for the session). -
Panel fields for the new flags:
forEach.onIterationFailureandforEach.label, Compensate losers on an XOR join and Compensate abandoned on an END — each with the messageeventconductor:validatewould give when the combination is refused. The Mateu step form showscompensateLosersonly on an XOR join. -
VS Code execution view: double-click opens child runs. The view links the child processes on its current page into the graph, so a double-click on a PROCESS node, an iteration card or a lane header (
ec-open-process) navigates to that run. -
A forEach opens into its iterations on the process graph. In a process view, double-click a forEach node: it expands into one card per iteration (item index, coloured by state, the error and attempt on hover), fanning out of the same incoming and outgoing edges; double-click again to collapse. Up to 20 cards are drawn, the rest as "+N more"; the overlay lists up to 100 (
iterations.items, also onGET /workflow/api/processes/{id}/graph). -
Double-click a PROCESS node to open its child run. The graph fires
ec-open-processwith{processId, stepId, itemIndex?}, and the admin console navigates to that process; in an expanded forEach over PROCESS, each iteration opens its own child. The definition editor and the definition view are unchanged. -
Inline PROCESS bodies open into lanes on the graph. Double-click a PROCESS step written in line (
steps:): in a process view it opens into one lane per run — per forEach iteration, headed by itsforEach.label("Hab. 101") and state, or the one child run — with the body's steps inside coloured by how they stand in that run; double-click a lane's header to open its child process. In a read-only definition view the body opens once, as declared. Up to 20 lanes are drawn, the rest as "+N more"; the body states of those child runs are read in one batched query (StepExecutionRepository.findByProcessIds). Expanded forEach iteration cards show the iteration's label too. In the editor the node reads⚙ inline · N steps. -
Inline PROCESS bodies. A PROCESS step can write its child workflow in line, under
steps:, instead of naming one withchildWorkflowDefinitionId(exactly one of the two). It runs exactly as a named child — with aforEach, one child process per item: a dynamic fork whose branches are written where they are used. The body becomes the definition<workflow>.<step>, built from the parent's snapshot when a child starts: versioned with the parent, inheriting its sensitive variables, required scopes/roles and tags, and impossible to start on its own. It is validated as a workflow of its own, at load and byeventconductor:validate, with its problems located (booking.rooms: …). -
forEach.onIterationFailure:failFast(the default, as before),continue(the other iterations run on and the step completes,outputelements becoming{status, value | error}) orcompensateAll(all run, then any failure fails the step and compensates every completed iteration; needscompletion: all). Acompletioncondition can readfailedIterations. -
forEach.label: a JEXL expression, evaluated once per iteration over its item, that names it —reserve · Hab. 101in the Steps tab instead ofitem 2, anditemLabelin the REST and MCP step views (migration V60). A label that fails to evaluate leaves the iteration unnamed; it never fails it. -
compensateLosers: trueon anXORjoin abandons the branches it does not go on with: their waiting or running steps are cancelled and their completed compensable steps compensated, newest first. Without it the other branches run on, as before. -
compensateAbandoned: trueon anENDalso compensates what the branches it cuts short completed in time. -
Both are cleanup compensations: they do not move the process status or trigger a rollback, and one that fails is an incident in the Errors tab, not a failure of the process. Validated by the engine and
eventconductor:validate(compensateLosersonly on anXORjoin,compensateAbandonedonly on anEND); absent orfalsethey are left out of the JSON, so existing definitions keep their version hash.
Fixed
-
Memory mode: a worker answering inline inside a fan-out could leave a sibling branch open in a completed process. In memory mode a save acts on its events at once, so an embedded worker that answers on the dispatching thread drove the process on in the middle of the step-over that started it. When that branch ran to END — an
XORwinner, aCHOICErouting to END — the END cancelled the sibling branch the FORK had not saved yet, and the step-over then saved its own stale copy of that branch over the cancellation: it stayedPENDINGin aCOMPLETEDprocess. A step-over's writes now all land before any of their consequences run, the ordering the outbox already gives JPA mode (DeferredEvents). JPA and Kafka modes are unchanged. -
Dark theme: the forEach/repeat/loop/timeout chips no longer glare as pastel pills, and the step panel's text follows the theme in hosts that do not set a body colour (IDE webviews).
-
A forEach iteration whose work finished after the engine cancelled it was never compensated. When a forEach failed fast (or stopped because the process failed), the iterations still at a worker, or running a child process, were cancelled. But cancelling races with the work: a worker that had already made the booking, or a child process that had already completed, reported COMPLETED after the cancellation, and that report was dropped as stale. The iteration stayed CANCELLED, the saga never undid it, and the booking was left behind in the target system.
- That late COMPLETED is now kept as a completed run, with what it reported, when its step declares a compensation. Late answers for steps without a compensation are still ignored.
- The rollback undoes it whenever it lands. Before the rollback reaches its step, it is included as usual. While that step's compensation is running, it waits for that run and then gets a new one. After the process was already
COMPENSATED, the process goes back toERROR, runs a new pass of the compensation over just that iteration, and endsCOMPENSATEDagain. - A compensation container now records the iterations it undoes (
unitsin its scope), so a later run covers only what is still to undo. A run started by an earlier engine counts as covering every iteration that had completed when it started.
-
A step on a parallel branch whose work finished after the engine cancelled it was never compensated either. The same race outside a forEach: the rollback, once done, cancels what is still running on the other branches, and an
ENDcancels the branches it cuts short. A worker that had already booked, or a child process that had already completed, reportedCOMPLETEDafterwards and the report was dropped.- That late
COMPLETEDis now kept (with what it reported, on the run) when the step declares a compensation, and undone: by the rollback in a failed process (a new pass if it had already finished), and by a cleanup compensation in one that completed. Late answers for steps without a compensation, or for a process an operator cancelled, are still ignored.
- That late
-
A child process the engine cut short was cancelled, not undone. When a
PROCESSstep's child was still running and the engine cancelled the step — the parent rolling back, aforEachoverPROCESSfailing fast, anXORjoin withcompensateLosersor anENDwithcompensateAbandonedabandoning the branch — the child was only cancelled (or, during a rollback, left running until the rollback ended). Whatever it had already done (a room held, not yet confirmed) stayed in the target system.- Such a child is now rolled back: its in-flight work is cancelled, its completed compensable steps are compensated newest first (including steps that complete after being cancelled), and it ends
COMPENSATED— orCOMPENSATION_FAILED— also when it had nothing to undo. Its own running children follow, recursively. - The parent's rollback waits for those children: it ends
COMPENSATEDonce they have,COMPENSATION_FAILEDif one could not finish undoing. A rolling-back parent now stops a running child as soon as its rollback starts, rather than at its end. - Undone once: a child still running undoes its own steps (the parent's
PROCESSstep staysCANCELLED, so itscompensationStepIddoes not run); a child that already completed is undone by thatcompensationStepId, and left alone. - Unchanged: an operator's cancel (console, REST, MCP) cancels the children without rolling anything...
- Such a child is now rolled back: its in-flight work is cancelled, its completed compensable steps are compensated newest first (including steps that complete after being cancelled), and it ends
v2.38.1
The Docker images of 2.38.0 were never published: the release's image scan stopped them. Use this version.
Security
snappy-java1.1.10.9, for CVE-2026-108106 and CVE-2026-93451 (high, denial of service on malformed compressed input). It arrives throughkafka-clients.guava33.7.2 in the rules app, for CVE-2026-102554 (high).
v2.38.0
Debounce gets a ceiling, what happened to one flow-control key can be looked up, and Mateu moves to 3.0-beta.52.
Added
startPolicy.maxWait. A ceiling on a debounce: however often a key keeps changing, its start waits at most this long after the first one. Equal todebounce, the window is fixed and counted from the first start.- Following a flow-control key. Receipts record the rendered key:
GET /workflow/api/events/received?flowKey=,listReceivedEventsand a filter on Received events list what happened to one key (migration V59). - What a debounce folded, on the process. A process started by a debounce gets
flowControlFoldedStartsandflowControlFirstStartAt.
Fixed
- A flow-control key that could not be released stopped every other key's release, since the pass stopped at the first failure and always began with the oldest.
- With
memorypersistence, a failed release lost the waiting start. The store now undoes a failed key as the database does.
Changed
- Mateu 3.0-beta.52, on the engine, apps and testbenches (from 3.0-alpha.411).
demo/shellstays on 3.0-beta.51, since its sign-in uses@KeycloakSecured, which beta.52 removes. (#613) - The Forms and Rules consoles no longer redirect the browser to a Keycloak host of their own. Their
@KeycloakSecurednamed a host that was not the deployment's and is gone with the annotation. Access is enforced by each app'sSecurityConfig, or by whatever sits in front of it. (#613)
Documentation
- The flow-control guide said a crash could lose a start. With
jpaand a broker it cannot: it stays waiting, or is sent twice and collapses. It also gains a recipe for keeping an entity's changes without losing any.
v2.37.0
A gauge of the open incidents, so an integration can be watched and alerted on from a dashboard.
Added
eventconductor.incidents.opengauge. How many processes are stopped on an incident right now, per definition. It is the backlog of the incidents view, for dashboards and alerts.eventconductor.process.erroredonly counts failures as they happen.- Counted every
workflow.incidents.gauge-interval-ms(60 s by default;0turns it off). - Cluster-wide: every pod reports the same figure, so alert on
max()across replicas. - The observability reference now suggests four alerts for an event-driven integration: dead-lettered events, open incidents, a degraded destination, and a silent producer. (#588)
Helm chart 0.2.10 (appVersion 2.37.0).
v2.36.0
The graph editor's Step Properties panel now covers every property of a step: what is a scalar or a list can be edited in place, and what is a structured block gets a read-only summary ("Edit … in the YAML") (#484, #585). The panel is the same component in the console and in the VS Code and IntelliJ plugins.
Added
- Every step property in the panel (#484).
- Topic can be set on every step dispatched to a worker (ACTION, DYNAMIC, USER_TASK, RULE, HTTP_CALL, LLM_CALL, PUBLISH_EVENT), with its default topic as the placeholder.
- Per-type fields:
- ACTION: task contract.
- WAIT_FOR_MESSAGE and SEND_MESSAGE: correlation expression.
- SEND_MESSAGE: message variables.
- TIMER: duration and until variable.
- PROCESS: output variables.
- LOCK and UNLOCK: lock name and key.
- REPLY: reply template (read-only).
- A collapsible Advanced section, open when something in it is set, with the run cap, the required scopes and roles, and any deprecated fields the definition still carries.
- Node captions describe every step type.
- USER_TASK assignment and escalation (#585).
- Assignee, candidate users and groups, priority, due and follow-up dates; each value may be a
${...}template. - The escalation list as a read-only summary in firing order, e.g.
PT48H reassign → ops · P3D escalate → manual-review.
- Assignee, candidate users and groups, priority, due and follow-up dates; each value may be a
- Sensitive outputs (#585): any step that writes variables can declare its
outputVariablesand mark themsensitiveOutputsunder Advanced.
Upgrade notes
- None: editor-only changes, with no engine, schema or API change.
v2.35.0
The orchestration core no longer performs actions. HTTP_CALL, LLM_CALL and now PUBLISH_EVENT are tasks served by built-in workers, and those workers ship inside the orchestrator. A definition that calls an API, asks a model or publishes an event no longer needs a worker deployment (#581, #582).
Upgrade notes
- Hand-written
EmbeddedTaskExecutor? It must now servepublish-event@1as well. Otherwise PUBLISH_EVENT steps stay PENDING. Apps that useworker-embedded, and the test kit, need nothing:worker-embeddedbringsworker-events. - Already running
http-worker/llm-workeron Kafka?- With the Helm chart, nothing to do: an enabled
httpWorker/llmWorkerkeeps its topic and the orchestrator's own worker is switched off. - Elsewhere, keep one consumer per topic: take the topic out of the orchestrator's
BUILTIN_WORKER_TOPICSand setworkflow.http.enabled=false/workflow.llm.enabled=falseon it, or retire the standalone worker. - To move a topic onto the orchestrator, roll out once with
BUILTIN_WORKERS_START_OFFSET=latest, or the retained tasks run again.
- With the Helm chart, nothing to do: an enabled
- New topic
event-publications. It is auto-created whereauto-create-topicsis on; otherwise provision it.
Changed
- PUBLISH_EVENT is a task (
publish-event@1).- The engine still renders and validates the event when the step starts: a bad destination or template still fails the step at once.
- The task is dispatched through the outbox, and the worker sends the event:
- Kafka: a CloudEvent on the destination's topic, carrying the trace headers.
- Embedded: the application's
ExternalEventPublisher, then the loopback.
- Delivery is still at-least-once, with the same stable
ce_id. - The step completes after the send, with the retries, timeouts and incidents of any worker step.
workflow.default-step-timeout-msnow applies to it. __eventis sealed like__httpwhen the process has sensitive variables.
- The standalone
http-worker/llm-workerimages are optional. Use them to keep egress and its secrets out of the orchestrator's pods.apps/docker-compose.ymlno longer starts anhttp-worker. check-migration: PUBLISH_EVENT is no longer counted as instantaneous.
Added
- Built-in workers in the orchestrator image.
- Serves
http-calls,llm-callsandevent-publicationsin consumer grouporchestrator-builtin-workers. - Configured under
workflow.http.*/workflow.llm.*(Anthropic and OpenAI providers included) andworkflow.events.destinations. - Helm:
orchestrator.builtinWorkers.{httpAllowedHosts, existingSecret, startOffset}.
- Serves
worker-events: the publish-event task, withworkflow.events.worker.enabled/.topic.builtin-workers(pom): every built-in worker in one dependency next to an embedded engine.- DIST-39: the orchestrator alone runs HTTP_CALL and PUBLISH_EVENT over Kafka.
Design: BUILTIN-WORKERS-PLAN.md (#580).