User Interaction

User Interaction puts a human in the middle of a task. The node renders a surface — a small UI of its own, on the node, in the task canvas — and what someone does with it drives the task.

The service is named for the category, not for one node. Each interaction kind is a separate version of it, and the two behave very differently:

Version	Mode	Input	Output
ask	Linear	question — the text shown to the person	response — what they typed
inject	Continuous	—	null

Pick the version on the service node like any other.

ask — a question the task waits for

Use it for the steps a workflow cannot decide on its own: an approval, a missing value, a judgement call between two branches.

The node defers rather than blocking: the task stays alive and the node is marked as waiting, indefinitely, until someone answers. Nothing times out on its own — if a task should not wait forever, stop it, or put a continuous-mode timeout path around it.

Answering happens on the node: the question and a reply field are rendered right there in the canvas, and submitting resumes the task from that node. It is answered once — the node completes and the form then says so.

Nothing stays connected for the wait. The service renders the form and exits, so the question survives a redeploy, a restart, and a wait measured in days. The one thing it needs is that some instance of the service is running at the moment somebody presses Send; while none is, the button is withheld and comes back on its own.

The answer is always text. If you need a number, a decision, or structured data, parse the response in a logic node right after — and phrase the question so the expected answer is obvious.

inject — a button that emits a message

inject is a manual trigger: one button, no question, and every press emits a message with the output null. It is what you reach for to kick off a branch by hand — a re-run button, a “go” gate in the middle of a graph, a way to feed a pipeline one item at a time while you watch it.

Two things about it surprise people, and both are by design:

• The node never finishes. It is a continuous node, so it stays RUNNING for the life of the task, waiting to be pressed again. There is no “done” — you stop the task.
• Pressing it twice means two messages, not one confirmation. Each press is its own start, so each press begins its own trace through the graph — which is exactly what the canvas’s trace pager then walks (see Surfaces).

Because the button belongs to the running node, it is pressable only while an instance of the service is running. Stop the service and the button goes quiet until it is back.

Access and setup

Interacting requires update access to the task — being able to watch a task is not enough to answer for it, or to press its buttons.

Unlike Requence Lookup, User Interaction is an ordinary external service: an environment adds it, and its versions, through the normal service UI, once. Future interaction kinds (confirm, select, …) arrive as further versions of the same service.