Connection tags are visual representations of the data available from connected blocks, providing an easy way to reference data between blocks and outputs from previous blocks in your workflow.
What Are Connection Tags?
Connection tags are interactive elements that appear when blocks are connected. They represent the data that can flow from one block to another and allow you to:
- Visualize available data from source blocks
- Reference specific data fields in destination blocks
- Create dynamic data flows between blocks
Connection tags make it easy to see what data is available from previous blocks and use it in your current block without having to remember complex data structures.
Using Connection Tags
There are two primary ways to use connection tags in your workflows:
Drag and Drop
Click on a connection tag and drag it into input fields of destination blocks. A dropdown will appear showing available values.
- Hover over a connection tag to see available data
- Click and drag the tag to an input field
- Select the specific data field from the dropdown
- The reference is inserted automatically
Angle Bracket Syntax
Type < in input fields to see a dropdown of available connection values
from previous blocks.
- Click in any input field where you want to use connected data
Type
<to trigger the connection dropdown- Browse and select the data you want to reference
- Continue typing or select from the dropdown to complete the reference
Tag Syntax
Connection tags use a simple syntax to reference data:
<blockName.path.to.data>Where:
blockNameis the name of the source blockpath.to.datais the path to the specific data field
For example:
<agent1.content>- References the content field from a block with ID "agent1"<api2.data.users[0].name>- References the name of the first user in the users array from the data field of a block with ID "api2"
Tags resolve in every field except the literal fields of a Judgment or Laya Decision block: Instructions, option descriptions, level descriptions, and Ask Several questions. A tag in one of those fields is not resolved, and the run fails before anything is sent to TypeSafe or Laya. Put references in the block's State field.
Loop and Parallel References
Blocks inside a Loop or Parallel block can reference the container's iteration state with the reserved loop and parallel prefixes. SteelEngine resolves these prefixes before block references, so they work without a connection from the container:
| Reference | Value |
|---|---|
<loop.index> | Zero-based iteration number (<loop.iteration> is an alias) |
<loop.currentItem> | The current item in a ForEach loop (<loop.item> is an alias) |
<loop.items> | The whole collection a ForEach loop iterates over |
<loop.results> | The loop's collected outputs, for blocks that run after the loop (<loop.result> is an alias) |
<parallel.index> | Zero-based branch number |
<parallel.currentItem> | The item assigned to this branch when distributing a collection |
<parallel.items> | The whole distributed collection |
<parallel.results> | The parallel block's collected outputs, for blocks that run after it (<parallel.result> is an alias) |
The bare prefix resolves to the innermost container around the current block. To target a specific container, use its block name instead of the prefix, for example <myLoop.index>. Iteration fields (index, currentItem, items) only resolve inside the named container. From outside it, the raw <myLoop.index> text stays in the field. results is the exception. You read it after the container finishes. Count-based loops and parallels have no currentItem or items, so those references also stay unresolved. An unknown property such as <loop.foo> fails the block with an error that lists the available fields. See Loop and Parallel for the shape of each results entry.
References Inside Parallel Windows
Inside a loop within a Parallel Window, <parallel.currentItem> identifies the window item and <loop.currentItem> identifies the current element of the innermost loop. Named loop references can read an enclosing loop's iteration context. Each window item has its own loop state and outputs.
Read a loop's result or results only after that loop finishes. Blocks inside it cannot read its incomplete aggregate. A loop's collection is evaluated before the loop starts, so <loop.items> in that collection must refer to an enclosing loop. While and Do While conditions can read their own loop's current context.
Dynamic Tag References
Connection tags are evaluated at runtime, which means:
- They always reference the most current data
- They can be used in expressions and combined with static text
- They can be nested within other data structures
Examples
// Reference in text
"The user's name is <userBlock.name>"
// Reference in JSON
{
"userName": "<userBlock.name>",
"orderTotal": <apiBlock.data.total>
}
// Reference in code
const greeting = "Hello, <userBlock.name>!";
const total = <apiBlock.data.total> * 1.1; // Add 10% taxWhen using connection tags in numeric contexts, make sure the referenced data is actually a number to avoid type conversion issues.