Inflow.aiDocs

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:

  1. Call claimDue(workerId, limit, lockDuration).
  2. Execute the service task using the run configuration and variables.
  3. Call markCompleted(runId, workerId, output, completedAt) on success.
  4. 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:

  • configurationSchema against the service-task configuration.
  • inputSchema against workflow variables.
  • outputSchema against completed executor output.
  • authRequirement against 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:

  1. Recover timed-out PROCESSING service-task runs up to platform.worker.batchSize.
  2. Claim due runs whose implementation has a local Java executor.
  3. Resolve the XML service-task definition from the catalog.
  4. Validate strict input and authentication contracts when enabled.
  5. Execute the matching Java executor with the run's stored variables and configuration.
  6. Validate strict output contracts when enabled.
  7. Complete the run and resume the workflow when the executor returns COMPLETED.
  8. 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_AUTOMATED tasks still execute inline.
  • generic standard-work-item tasks that do not declare a catalog extension point and implementation template still create external work items.
  • a catalog standard-work-item with that pair and no registered provider fails closed with SERVICE_TASK_EXTENSION_PROVIDER_NOT_FOUND and creates neither a pending run nor a waiting work item.
  • provider-backed async marketplace standard-work-item tasks 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 pdfId or pdfIds
  • 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.evaluate evaluates arithmetic expressions with +, -, *, /, parentheses, and workflow/configuration variables.
  • service.calculation.score computes weighted numeric facts and returns a score plus contribution reasons.
  • service.calculation.pricing computes subtotal, discount, taxable amount, tax, and total from cart items.
  • service.calculation.tax computes tax amount and total from amount and rate.
  • service.calculation.sla.due-date computes dueAt from startAt, duration, or priority defaults.
  • service.calculation.currency.convert converts an amount with an explicit configured rate.

Supported rule tasks:

  • service.rules.evaluate
  • service.rules.decision.table
  • service.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.start returns a stable processInstanceId, processKey, and variables.
  • service.workflow.signal returns 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 to INCIDENT; RETRY requires a positive maximum delivery age and releases the inbox lease until the same durable message is consumed or expires. Expiry is persisted as expiresAt, 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.check returns score and violations from simple required-field checks.
  • service.data.dedupe groups duplicate records by common business keys such as id, email, or name.
  • service.audit.write returns an auditEventId, severity, and event payload.
  • service.security.permission.check returns allowed and reason.
  • 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_CLAIM
  • SERVICE_TASK_RUN_COMPLETE
  • SERVICE_TASK_RUN_FAIL
  • SERVICE_TASK_RUN_VIEW
  • SERVICE_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.

Try “document generation”, “integrations” or “first form”.