Optional technical reference. This material is for developers, integration specialists and platform administrators. For the consultant lesson, read the practical guide.
Preserved from source baseline
d4587c7c0e073e58c2d430342f65ac55dd701bf4; source/static examples retain their stated scope. They are not new runtime verification or required consultant setup steps.
Service Task Execution Runs
Follow one durable service run
An asynchronous service activity has several identities: its actual process instance/token/node, durable work item, service run and numbered attempts. A human task uses a different completion/form contract. Do not exchange their request shapes or interpret a run ID as a generic acceptance receipt for every platform action.
The HTTP worker routes below /api/service-task-runs bind ownership to the authenticated actor. A caller-supplied workerId is not an impersonation mechanism. Every current run/object/workspace check still applies, including permissions on its related process.
| Step | Route | Retain/check |
|---|---|---|
| Claim due work | POST /claim |
Returned run/work-item IDs, current owner and lock duration |
| Renew/release lease | POST /{runId}/renew-lease or /release-lease |
Exact run, admitted actor and supported timing |
| Complete | POST /{runId}/complete |
Actual typed output and authored binding; current actor is rebound |
| Record failure | POST /{runId}/fail |
Safe reason/retryAt and actual attempt/outcome evidence |
| Inspect | GET /{runId}, /{runId}/attempts, /{runId}/logs |
Current status, ordered attempts and permitted logs |
| Timeout recovery | POST /recover-timeouts under its separate permission |
Lease/run recovery, not proof the remote action never occurred |
A run’s retained output may contain executor envelopes that are not automatically projected into business variables. Current catalog validation and declared binding provenance remain authoritative. Successful local persistence is separate from the acceptance of a previously dispatched remote request. Examples below explain actual source contracts; no real workers, providers or timeout recovery were started by the documentation program.
Read run state without confusing it with case completion
The service run state vocabulary is PENDING, PROCESSING, COMPLETED, FAILED, DEAD_LETTER and CANCELLED. A completed service run does not mean its parent business case is complete; the process may next wait for a person or another service. Human TaskStatus and process-instance status are separate contracts.
| Run data | Why an operator/worker needs it | Limit |
|---|---|---|
| Actual run/work item/process/token/node references | Correlate this one activity and its continuation | A client reference is not an access grant |
serviceTaskType, version and implementation |
Resolve the actual selected contract | A catalog label does not qualify a provider |
attempts, maxAttempts, timeout/backoff/policy |
Understand admitted dispatch and recovery | A counter does not establish remote rejection |
lockedBy, lockedUntil, dueAt |
Lease ownership and timing | HTTP ownership is rebound to current actor |
createdAt, updatedAt, completedAt |
Timeline evidence | Wall-clock ordering alone is not causal proof |
variables, configuration, output |
Actual authorized run inputs/result | Do not expose confidential values in support examples |
| Binding provenance | Determines accepted projection into case data | Legacy missing provenance is quarantined, not assumed empty/safe |
The binding provenance field is deliberately not an ordinary public JSON authority field. A run predating trusted binding provenance can carry SERVICE_TASK_OUTPUT_BINDING_PROVENANCE_MISSING; its dispatch/external outcome may be unknown. Do not repair that condition by supplying a made-up boundOutputFields array or blindly redispatching the work. Reconcile the actual external operation and use the responsible owner’s admitted recovery.
Source contracts: run and provenance, run status, completion validation/projection.
Worked examples
Example FLOW-SE-01 — Claim a run as the authenticated worker
Scenario and inputs. An authorized worker identity can claim permitted service work in people-ops. The request’s limit and lock duration are operational choices for its admitted workload. The server binds the owner to the current authenticated actor, so the optional body worker name is not authority. This is a complete claim body.
{
"workerId": "illustrative-label-not-identity",
"limit": 5,
"lockDuration": "PT30S"
}
Procedure. POST to /api/service-task-runs/claim. Retain each actual returned run/work-item identity and current lease state. Renew an appropriate claimed run through /{runId}/renew-lease with its supported lockDuration, or release through /{runId}/release-lease with its availableAt when needed. Read the current run before accepting further work if transport or ownership is uncertain.
Expected result. Only due work admitted for the current workspace/process scope is returned, and its HTTP lease owner is the authenticated actor ID. Another actor cannot become the owner merely by repeating the body label.
Failure and recovery. An expired or foreign lease must be reconciled through the actual queue contract. Do not borrow another worker’s credentials, forge its workerId, or use internal token lease methods as service-run administration. A valid global claim permission still does not waive related process/object admission.
Sources. ServiceTaskRunController.java:68; ServiceTaskRunController.java:78.
Example FLOW-SE-02 — Complete with the service command’s real VariableMap shape
Scenario and inputs. A claimed run belongs to a task whose actual output schema permits a business result named answer. The example illustrates the controller/domain-command envelope; it is not the schema of every document, connector or rule task. Substitute the actual work-item reference and allowed output before use.
{
"workItemId": "actual-work-item-id",
"workerId": "ignored-body-identity",
"output": {
"values": {
"answer": "eligible"
}
}
}
Procedure. POST to /api/service-task-runs/{runId}/complete as the admitted current worker. Inspect the selected run’s catalog output contract and bound-output provenance first. The controller binds runId from the path and current actor/worker from authentication; the service validates output, marks completion and resumes the original process correlation. Read the protected process/run response and the explicitly authored business binding.
Expected result. The real service command uses a VariableMap envelope, unlike the flat output/formData of human task completion. Declared business output is preserved while unbound executor telemetry need not become case data.
Failure and recovery. A successful JSON parse does not prove the arbitrary answer schema applies to the chosen activity. Correct the mapping/type/contract instead of flattening the map, adding reserved names or treating a different run’s ID as this completion’s authority.
Sources. ServiceTaskRunController.java:96; CompleteServiceTaskRunCommand.java:7; DefaultServiceTaskExecutionService.java:47.
Example FLOW-SE-03 — Record a known failure and reconcile an unknown external effect
Scenario and inputs. A worker’s external request was definitively refused, or its response was lost after dispatch. Those outcomes require different decisions even though both can leave a local run unfinished. The worker retains the exact run/attempt and safe correlation evidence without logging credentials or confidential request bodies.
Procedure. Read the current run, attempts and permitted logs. For a known failed request, use the admitted fail operation with a safe reason and supported retryAt if the policy allows another attempt. For an unknown remote outcome, consult the owning connector/provider’s reconciliation evidence before scheduling another consequential dispatch. Keep the original run and attempt linkage rather than creating another business process to repeat it. Timeout recovery has its separate permission and scope.
Expected result. The durable run can represent failure/retry state while preserving attempts and actual outcome evidence. A lease expiry or recovery pass does not certify that the external system rejected or never received the earlier request.
Failure and recovery. Never label UNKNOWN as “failed, safe to retry” solely because the client timed out. Do not expose raw provider errors as public business values, delete the earlier attempt or use a fabricated expectedAttempt/failureEvidence object on the public HTTP contract; those internal failure witnesses have their own trusted producer path.
Sources. ServiceTaskRunController.java:109; ServiceTaskRunController.java:146; FailServiceTaskRunCommand.java:7.
Example FLOW-SE-04 — Diagnose a reserved or undeclared output before advancement
Scenario and inputs. A custom worker returns data that includes an engine-owned name, or the durable run lacks the required output-binding provenance. The author expected a normal business result, but the returned map would otherwise be able to affect runtime-owned state or ambiguous case bindings.
Procedure. Inspect the safe run failure and exact activity output schema. Compare each returned key with declared output fields, permitted open-output behavior and the authored bound-output set. The completion service validates before normal advancement and refuses reserved engine-owned writes; envelope telemetry has separate projection rules. Correct the worker/authoring contract through its responsible owner, then use the original run’s supported recovery rather than bypassing validation.
Expected result. Business outputs remain explicit and the worker cannot write arbitrary process internals. The retained run/attempt records explain why the output was not accepted as a normal continuation.
Failure and recovery. Do not hide an undeclared value inside an untyped nested map or rename it to a token/status field. A local validation failure is not evidence that a previously dispatched remote action did not happen, so reconcile that effect independently before another execution attempt. Preserve the rejected output’s safe diagnostic metadata rather than rewriting history.
Sources. DefaultServiceTaskExecutionService.java:77; DefaultServiceTaskExecutionService.java:102.
Detailed reference
The current PersistentAsyncServiceTaskExecutor validates input before immediate
execution or durable run creation; ServiceTaskRuntimeContractValidator validates
supported strict output/authentication contracts. A catalog declaration or a
successful claim is not proof that every executor/provider is available, nor that
an external effect occurred exactly once. Keep executor-specific trusted-context,
confirmation, retry and reconciliation rules when applying the worker API below.
The service task catalog describes what a workflow can call. Service task runs record each asynchronous execution so workers can process, retry, audit, and resume work safely across multiple platform nodes.
Architecture
flowchart TD
A["BPMN service task"] --> B["XmlDefinedServiceTaskHandler"]
B --> C["PersistentAsyncServiceTaskExecutor"]
C --> T["ServiceTaskRuntimeContractValidator"]
T --> D["Inline Java executor for sync tasks"]
T --> E["service_task_runs for async Java-backed tasks"]
C --> F["StandardServiceTaskExecutor for generic external work"]
F --> G["runtime_work_items"]
F --> H["service_task_runs"]
I["Service-task worker node"] --> J["claimDueByImplementation"]
I --> R["claimDueByServiceTaskTypes"]
K["External worker"] --> L["claimDue or HTTP claim"]
J --> M["service_task_attempts"]
R --> M
L --> M
I --> N["Local Java executor"]
I --> S["Marketplace provider executor"]
N --> U["Validate output contract"]
S --> U
K --> O["External service, connector, RPA, document engine"]
U --> P["complete or fail"]
O --> P
P --> Q["service_task_run_logs"]
Stored Data
service_task_runs stores:
- workflow correlation: process instance, token, node, and work item id
- service identity: type, version, name, and implementation
- execution policy: max attempts, timeout, retry backoff, retry policy id, auth requirement, logging category, and audit flag
- worker lease state: status, attempts, locked by, locked until, due at
- payloads: workflow variables, task configuration, and output JSON
service_task_attempts stores every claimed attempt. A worker creates an
attempt when it claims a run. Completion or failure closes the current attempt.
service_task_run_logs stores structured log events for the run. These are not
a replacement for platform log files; they are workflow-visible execution logs
that can be shown in task history, operations consoles, and audit screens.
Worker Contract
External workers use ServiceTaskRunRepository:
- Call
claimDue(workerId, limit, lockDuration). - Execute the service task using the run configuration and variables.
- Call
markCompleted(runId, workerId, output, completedAt)on success. - Call
markFailed(runId, workerId, reason, retryAt)on failure.
The repository enforces ownership. A worker can only complete or fail a run that it currently owns through an unexpired lock.
In-process platform service-task workers use a narrower claim path:
claimDueByImplementation(workerId, limit, lockDuration, implementations)
This prevents a platform worker from stealing generic standard-work-item
runs that are meant for external document, RPA, connector, or webhook workers.
Only runs whose implementation is backed by a local Java executor are claimed by
the built-in service-task worker.
Marketplace provider-backed tasks use a second narrow claim path:
claimDueByServiceTaskTypes(workerId, limit, lockDuration, serviceTaskTypes)
This is necessary because many marketplace tasks intentionally share
standard-work-item as their implementation template. The worker only claims
the concrete service-task types whose metadata.extensionPoint is supported by
a registered MarketplaceServiceTaskExecutor. A catalog standard-work-item
that declares an extension point and an implementation template, and has no
registered provider for that point, fails closed with
SERVICE_TASK_EXTENSION_PROVIDER_NOT_FOUND. It does not stay pending, does not
create a waiting work item, and is not returned as ready work. For example, a
node with only a document provider completes
service.document.generate.offer.letter and fails
service.agent.run.browser.operator because agent-runtime has no provider.
Most platform code should use ServiceTaskExecutionService instead of calling
the repository directly:
List<ServiceTaskRun> runs = serviceTaskExecutionService.claimDue(
new ClaimServiceTaskRunsCommand("worker-node-1", 10, Duration.ofMinutes(5)));
ProcessInstance instance = serviceTaskExecutionService.complete(
new CompleteServiceTaskRunCommand(
runs.get(0).id(),
null,
"worker-node-1",
new VariableMap(Map.of("documentId", "doc-100")),
completedBy));
complete(...) marks the service run completed and resumes the workflow using
the run's stored process instance id, token id, and node id. This keeps external
workers decoupled from runtime internals. When the service-task definition has
{"enforceRuntimeContracts":true}, completion output is validated against the
definition's outputSchema before the workflow resumes. Invalid output fails
the run instead of completing the process.
Failures are also routed through the same service:
ServiceTaskRun failed = serviceTaskExecutionService.fail(
new FailServiceTaskRunCommand(
runId,
null,
"worker-node-1",
"Document provider timed out.",
Instant.now().plusSeconds(60)));
When the attempt count reaches maxAttempts, the repository moves the run to
DEAD_LETTER.
Timeout Recovery
timeoutSeconds is enforced by timeout recovery, not by the worker thread
itself. This lets long-running workers stay simple while a platform maintenance
node handles stalled attempts consistently.
ServiceTaskRunTimeoutRecoveryService calls:
recoverTimedOut(recoveryWorkerId, limit, Instant.now())
The repository finds PROCESSING runs whose current attempt started more than
timeoutSeconds ago. Each timed-out run is marked FAILED or DEAD_LETTER
according to maxAttempts, its lock is released, the current attempt is closed,
and a structured error log is written. Retryable runs become due again after
their retryBackoffSeconds.
Operators can trigger the same recovery path through the API:
POST /api/service-task-runs/recover-timeouts?recoveryWorkerId=node-a&limit=100
The endpoint requires SERVICE_TASK_RUN_RECOVER_TIMEOUTS. The seeded worker
role has this permission so service-task worker nodes can run maintenance
sweeps without admin credentials.
When platform.node.roles includes service-task-worker, the standard worker
loop runs this recovery sweep automatically before processing due service-task
runs. The sweep uses the node id as the recoveryWorkerId and
platform.worker.batchSize as the maximum number of timed-out rows to recover
per loop. The worker result exposes the recovered count as
serviceTaskTimeoutsRecovered.
Runtime Contracts
ServiceTaskRuntimeContractValidator protects strict service tasks before and
after execution. It is called by PersistentAsyncServiceTaskExecutor for
inline execution and by DefaultServiceTaskRunWorker for durable worker
execution.
Runtime enforcement is opt-in per service task:
<metadata>{"enforceRuntimeContracts":true}</metadata>
When enabled, the runtime checks:
configurationSchemaagainst the service-task configuration.inputSchemaagainst workflow variables.outputSchemaagainst completed executor output.authRequirementagainst the request actor.
The schema vocabulary is deliberately portable across databases and extension
runtimes: string, number, boolean, object, and array. A listed field
is required. A contract violation throws
SERVICE_TASK_RUNTIME_CONTRACT_VIOLATION; missing authentication throws
SERVICE_TASK_AUTHENTICATION_REQUIRED.
In the durable worker path, contract failures are treated like executor or
external worker failures: the run is failed, retried according to its policy,
and moved to DEAD_LETTER when attempts are exhausted. This applies both to
the built-in service-task-worker and to external workers that complete runs
through ServiceTaskExecutionService.
Built-In Service-Task Worker
The platform has an in-process service-task worker for async Java-backed service tasks. Enable it on a worker node with:
platform.node.roles=service-task-worker
platform.worker.autoStart=true
The worker loop calls ServiceTaskRunWorker.runDueServiceTasksOnce(...). Each
run is processed as follows:
- Recover timed-out
PROCESSINGservice-task runs up toplatform.worker.batchSize. - Claim due runs whose implementation has a local Java executor.
- Resolve the XML service-task definition from the catalog.
- Validate strict input and authentication contracts when enabled.
- Execute the matching Java executor with the run's stored variables and configuration.
- Validate strict output contracts when enabled.
- Complete the run and resume the workflow when the executor returns
COMPLETED. - Fail and retry/dead-letter the run when the executor returns
FAILED, violates a strict contract, or throws an exception.
Generic standard-work-item runs are not claimed by this worker unless their
service-task type is backed by a registered marketplace provider. Otherwise,
they remain available through the HTTP API or repository contract for external
workers. Marketplace providers therefore get durable, type-partitioned worker
execution without making the worker claim every generic external work item.
PersistentAsyncServiceTaskExecutor decides whether a task runs inline or is
persisted first:
SYNC_AUTOMATEDtasks still execute inline.- generic
standard-work-itemtasks that do not declare a catalog extension point and implementation template still create external work items. - a catalog
standard-work-itemwith that pair and no registered provider fails closed withSERVICE_TASK_EXTENSION_PROVIDER_NOT_FOUNDand creates neither a pending run nor a waiting work item. - provider-backed async marketplace
standard-work-itemtasks create durable service-task runs and are claimed by service-task type. - async Java-backed tasks create a durable service-task run and wait for a
service-task-worker.
Built-In Document And Office Executor
DocumentOfficeServiceTaskExecutor gives the platform a local Java execution
path for document, PDF, Excel, and validation-style spreadsheet service tasks.
It currently produces deterministic workflow artifacts and metadata:
- document generation returns
documentId,fileId,url,format, and template metadata - PDF conversion/split/merge/transform tasks return
pdfIdorpdfIds - document/PDF extraction tasks return provided text, fields, or table payloads
- Excel creation/update/export tasks return workbook or generated CSV ids
- Excel and Google Sheets validation tasks evaluate simple required-field rules
- XML-only Google Sheets creation/copy/protection/pivot tasks return stable spreadsheet, sheet, protected-range, or pivot ids plus operation metadata
Connector-backed tasks such as service.google.sheets.read,
service.google.sheets.write, service.google.sheets.format, and
service.excel.read stay with the connector executors. Event-backed tasks such
as service.integration.kafka.publish, service.integration.rabbitmq.publish,
and service.queue.publish stay with the event-stream connector executor so
they publish through the durable message outbox. The office executor
deliberately refuses connector-rest, connector-jdbc, and
connector-event-stream definitions so Microsoft/Google API calls and broker
publishes remain governed by connector configuration.
This is the standard Java implementation template for office-style tasks. A future binary document engine can replace the deterministic internals while preserving the same XML service-task definitions and output contracts.
Built-In Calculation And Rules Executor
CalculationRulesServiceTaskExecutor gives the platform a local Java execution
path for calculation, scoring, pricing, tax, SLA, currency, rules, and decision
table service tasks. These tasks are still defined in XML, but they no longer
fall through to generic external work when the configured implementation is
local.
Supported calculation tasks:
service.calculation.formula.evaluateevaluates arithmetic expressions with+,-,*,/, parentheses, and workflow/configuration variables.service.calculation.scorecomputes weighted numeric facts and returns a score plus contribution reasons.service.calculation.pricingcomputes subtotal, discount, taxable amount, tax, and total from cart items.service.calculation.taxcomputes tax amount and total from amount and rate.service.calculation.sla.due-datecomputesdueAtfromstartAt, duration, or priority defaults.service.calculation.currency.convertconverts an amount with an explicit configured rate.
Supported rule tasks:
service.rules.evaluateservice.rules.decision.tableservice.decision.table.evaluate
Rules accept simple row maps with field, operator, value, and result.
The executor supports eq, ne, gt, gte, lt, lte, contains, and
in. A row can also contain a conditions list for AND-style compound
conditions. hitPolicy defaults to FIRST; COLLECT returns all matching
rows.
Example decision table configuration:
{
"hitPolicy": "FIRST",
"facts": {
"amount": 1500,
"country": "SA"
},
"rules": [
{
"id": "small",
"field": "amount",
"operator": "lt",
"value": 1000,
"result": "AUTO_APPROVE"
},
{
"id": "large",
"field": "amount",
"operator": "gte",
"value": 1000,
"result": "APPROVAL_REQUIRED"
}
]
}
This executor is intentionally deterministic and dependency-free. Later, a full rule repository, DMN engine, pricing service, or policy service can be plugged behind the same XML service task types without changing BPMN models.
Built-In Platform Utility Executor
PlatformUtilityServiceTaskExecutor gives the platform a local Java execution
path for broad utility families that should be usable before external systems
are connected. The XML service-task definitions remain the contract, while the
executor returns deterministic workflow outputs for:
- workflow actions such as start, signal, escalation, and timer creation
- data utilities such as lookup, match, dedupe, quality check, write, enrich, and cache warm
- audit and security checks
- file, report, webhook, RPA, and notification artifacts
- JSON utility transforms and waits
Connector-backed tasks still stay with connector executors. For example,
service.data.query remains governed by connector-jdbc, event publish tasks
remain governed by connector-event-stream, and AI tasks remain governed by
ai-gateway. The platform utility executor deliberately refuses those
implementation ids so data, broker, and AI calls keep their own security and
observability boundaries.
Representative outputs:
service.workflow.startreturns a stableprocessInstanceId,processKey, and variables.service.workflow.signalreturns legacy acceptance fields plus a versioned Record receipt with the stable message id, literal signal name, exact target instance, acceptance status, pending consumption status, unknown receiver-completion status, original durable timestamp, and failure category. The versioned contract defaults receiver-not-ready handling toINCIDENT;RETRYrequires a positive maximum delivery age and releases the inbox lease until the same durable message is consumed or expires. Expiry is persisted asexpiresAt, evidenced without consuming a receiver wait, and recorded as an incident after retry stops. An optional literal or Text correlation reference is evaluated from the sender snapshot and carried in the receipt and delivery trace. Missing or cross-workspace targets, receiver-not-ready outcomes, expiry, and terminal targets create incidents on the sending instance. Completed, cancelled, and failed targets retain their original terminal state. Typed payload fields are evaluated from one sender snapshot and carried through the transactional outbox. Receiver events retain only trusted delivery provenance and state, never authored payload values.service.data.quality.checkreturnsscoreandviolationsfrom simple required-field checks.service.data.dedupegroups duplicate records by common business keys such asid,email, orname.service.audit.writereturns anauditEventId, severity, and event payload.service.security.permission.checkreturnsallowedandreason.- file/report/notification/webhook tasks return stable artifact ids that can later be replaced by real storage, reporting, mail, or callback providers.
This executor is a bridge between workflow modeling and full integrations. It lets BPMN models run end to end with useful outputs now, while keeping the same XML service-task types ready for replacement by richer platform services, connectors, or external workers later.
Worker HTTP API
External workers can use the authenticated API instead of embedding Java:
POST /api/service-task-runs/claim
Authorization: Basic ...
Content-Type: application/json
{
"workerId": "document-worker-1",
"limit": 10,
"lockDuration": "PT5M"
}
Complete a claimed run:
POST /api/service-task-runs/{runId}/complete
Content-Type: application/json
{
"workerId": "document-worker-1",
"output": {
"values": {
"documentId": "doc-100",
"url": "https://files.example/doc-100"
}
},
"completedBy": {
"id": "worker",
"type": "USER",
"displayName": "Task Worker"
}
}
Renew a long-running lease before it expires:
POST /api/service-task-runs/{runId}/renew-lease
Content-Type: application/json
{
"workerId": "document-worker-1",
"lockDuration": "PT5M"
}
Release a lease without failing the run when the worker is shutting down or intentionally handing work back to the queue:
POST /api/service-task-runs/{runId}/release-lease
Content-Type: application/json
{
"workerId": "document-worker-1",
"availableAt": "2026-07-02T01:00:00Z"
}
availableAt is optional. When it is omitted, the run becomes immediately
available for another worker. Both lease operations require the same workerId
that currently owns the non-expired lease.
Fail a claimed run:
POST /api/service-task-runs/{runId}/fail
Content-Type: application/json
{
"workerId": "document-worker-1",
"reason": "Document provider timed out.",
"retryAt": "2026-07-02T01:00:00Z"
}
Read run details:
GET /api/service-task-runs/{runId}
GET /api/service-task-runs?processInstanceId={processInstanceId}
GET /api/service-task-runs/{runId}/attempts
GET /api/service-task-runs/{runId}/logs
Required permissions:
SERVICE_TASK_RUN_CLAIMSERVICE_TASK_RUN_COMPLETESERVICE_TASK_RUN_FAILSERVICE_TASK_RUN_VIEWSERVICE_TASK_RUN_LEASE_MANAGE
The built-in worker role receives these permissions in the development
configuration. The root user still has *.
Statuses
PENDING: waiting for a worker.PROCESSING: claimed by a worker.FAILED: failed but can be retried.DEAD_LETTER: failed after all allowed attempts.COMPLETED: finished successfully.CANCELLED: reserved for workflow cancellation handling.
Active-Active Behavior
The JDBC repository claims rows with database locking and SKIP LOCKED, so many
nodes can compete for service work without processing the same run twice. This
matches the timer and message dispatcher patterns used elsewhere in the
platform.
Workers should renew leases for long-running actions such as document generation, PDF conversion, spreadsheet synchronization, connector calls, and AI tool execution. A worker that is stopping cleanly should release the lease so another node can resume the work immediately instead of waiting for timeout recovery.
Service-task worker nodes claim local Java-backed work by implementation and marketplace-provider work by service-task type, so multiple worker pools can coexist. For example, external document workers can claim generic work through the HTTP API while platform nodes claim local Java-backed Fabric, connector, AI Gateway, or marketplace provider runs.
Extension Impact
XML-only service tasks do not need Java changes to participate. When they use
standard-work-item, the platform automatically creates:
- a runtime work item
- a service task run
- an initial run log
Custom Java executors can run inline for synchronous tasks or participate in the
durable worker path for async tasks by using a non-standard implementation id
and registering a matching ServiceTaskExecutor. Marketplace extension
providers can also participate in the durable worker path by registering a
ServiceTaskExtensionProvider; async marketplace runs are then partitioned by
service-task type so unrelated standard-work-item runs are not claimed.