Runchat Docs

Every value flowing between nodes has a type. Runchat colour-codes parameters and edges by type so you can see at a glance what kind of data is moving. When you connect parameters of different types, Runchat automatically casts the value, and you’ll see a gradient edge to indicate the cast.

Files and URLs

Images, videos, audio, 3D meshes, PDFs and other binary files are always uploaded to Runchat’s storage and represented as URL strings. This keeps workflow file sizes small and latency low. When you wire a file output into another node, what flows is the URL, not the file content.

Objects

JSON objects are key-value structures used to represent properties of things. Many third-party APIs (language models, YouTube, Maps, etc.) return data as objects, so Runchat works with them natively.

{
  "key": "value",
  "nested": {
    "another": "object"
  }
}

The Object input lets you build keys and values directly, including nested objects.

Lists and arrays

All parameter data is stored internally as an array. When a parameter holds more than one item, the node shows pagination controls so you can step through inputs and outputs. List behaviour (each, all, flatten) is controlled by depth, not by a separate “list” type. See Data Structure for how depth works.

Casting between types

You can connect any two parameters. Runchat casts the value automatically using these rules:

To text: numbers and booleans stringify; messages and contexts extract their text content; images use their flattened URL.
To number: text parses to a number (0 if not parseable); booleans become 1 or 0.
To boolean: text “true” (case-insensitive) becomes true, anything else false.
To object: messages and contexts extract as JSON; images become { imageUrl, layers }; text is parsed as JSON.
To message or context: URL strings become image messages; PDFs become file data.
To URL: extracts the URL from messages or images; text passes through.
To code, markdown or HTML: extracts code blocks or text from messages.

Cast edges render as a gradient between the source and target type colours.

Type reference

The full list of types Runchat understands. Connect any two and casting is automatic.

Text

Colour	Type	Notes
	`string`	Plain text
	`markdown`	Markdown-formatted text

Numbers and logic

Colour	Type	Notes
	`number`	Numeric value, integer or decimal
	`boolean`	True or false

Code and markup

Colour	Type	Notes
	`code`	Source code, any language
	`html`	HTML markup
	`format`	JSON schema or other formatting instructions

Media

Colour	Type	Notes
	`image`	URL string, optionally with layers
	`video`	URL string
	`audio`	URL string
	`mesh`	3D model URL (.glb, .ply, etc.)

Files and identifiers

Colour	Type	Notes
	`file`	Generic file URL
	`pdf`	PDF document URL
	`model`	Generative model identifier

Chat

Colour	Type	Notes
	`message`	A single chat message with role and content
	`context`	A collection of messages

Collections

Colour	Type	Notes
	`object`	JSON object
	`array`	List of items

UI and control

Colour	Type	Notes
	`instruction`	Instructional text passed to an agent
	`select`	A list of choices and the current selection
	`trigger`	Signal to fire a downstream action
	`null`	Absence of a value

Next steps

Data Structure: how depth, “each” and “all” control list behaviour
Data Matching: how Runchat lines up multiple inputs across runs
Connecting Nodes: drawing edges, references, and published parameters

​Files and URLs

​Objects

​Lists and arrays

​Casting between types

​Type reference

​Text

​Numbers and logic

​Code and markup

​Media

​Files and identifiers

​Chat

​Collections

​UI and control

​Next steps