Skip to content
threadle

Prompt, converter, Data & output

Most graphs start with text, reshape it, and land it somewhere. These nodes cover that spine. Plus ◇ Data when you need a typed constant or coerce step.

✎ Prompt

Section titled “✎ Prompt”

A pure source: free text out, no input handle.

Type in the node body. At run time threadle substitutes {{param:name}} from the workflow’s ≔ params, then validates the result against the node’s declared value type.

The header dropdown picks that type. A typed primitive:

TypeAccepts
textanything (default)
int^[+-]?\d+$
floatany finite number
booltrue / false / 1 / 0
jsonmust JSON.parse

A mismatch fails the node: prompt is typed int but not an int: "…".

Types also gate wiring. A source may feed a target when the types match, when the target is text, or when int widens to float. Anything else is refused at connect time.

{{param:…}} placeholders that name no declared param are left visible rather than blanked.

⇄ Text → Prompt

Section titled “⇄ Text → Prompt”

The converter wraps inbound text in a template. It requires an input. An unwired converter is a loose end.

Multiple inbound wires are joined with a blank line before templating. {{param:…}} is substituted in the template too.

TemplateResult
contains {{input}}every {{input}} replaced with the joined text
non-empty, no {{input}}template + blank line + input (append)
emptyinput passes through unchanged

New converters are dropped with {{input}} already in the box.

Review this diff and list only blocking problems:


{{input}}

◇ Data

Section titled “◇ Data”

A typed constant (or coerce step) on the text lane. 1 in · 1 out.

  • Pick a type on the card: string · int · float · bool · json.
  • With no inbound wire, the value typed on the card is emitted as-is.
  • With an inbound wire, the upstream text is coerced to that type at run time (JSON fences unwrapped, bools normalized). A failed coerce fails the node instead of poisoning downstream.
  • Inspector: edit type/value, format JSON, copy, clear.
  • Does not require an inbound wire for readiness. The card value alone is enough.

Typical uses with custom nodes:

agent ──▶ ◇ Data(json) ──▶ ⌁ sum-numbers ──▶ ⇤ Output
✎ Prompt(int) ──▶ ◇ Data(int) ──▶ ⌁ fibonacci ──▶ ⇤ Output

(You can also type the Prompt itself as int / json and skip Data.)

⇤ Output

Section titled “⇤ Output”

A sink for results. It stores the text on the node (content), so a finished graph still shows its answers after a reload.

  • Render mode. auto · text · markdown · html · svg. auto sniffs the content: a leading <svg, a leading <!doctype html> / <html>, the first fenced block that looks like SVG or HTML, markdown syntax, else plain text. The detected mode shows as a badge next to the title.
  • HTML renders inside a sandbox="" iframe. SVG renders inline.
  • Resizable. Drag the corners when selected. The size persists on the node.
  • ❐ copies captured content to the clipboard (card header and inspector). Brief ✓ feedback on success.
  • ↻ pulls text from whatever is wired in (session last message, upstream prompt/knot, …) without running the graph.
  • ⌫ clears captured content / preview on the card. The same ⌫ clear entry appears on the node’s right-click menu.
  • On ▶ Run, Output (and Data) nodes that are fed by a wire are cleared first so stale captures don’t linger while the new run fills them. Constant Data cards with no inbound wire are left alone.
  • 1 in · multi out. Output re-emits its text, so you can fan it out to several downstream nodes. Captured text is capped at 200,000 chars.

Output refuses a few inbound types on purpose. prompt, skill, rules and context cannot wire straight into it. Output is for results. Convert first, or route through an agent.

Wiring example

Section titled “Wiring example”
✎ Prompt ──▶ ⇄ Text → Prompt ──▶ ⟨/⟩ Agent ──▶ ⇤ Output
 "auth.ts"      "Review this…"      claude          markdown

The prompt supplies the raw subject, the converter turns it into an instruction, the agent runs it through a provider CLI, and the output captures the reply.

Drop a Merge in front of the output to merge several branches, or an Iterator in front of the agent to run it once per line.

Section titled “Related”