Skip to main content

Interface: ProcessableStructure

Defined in: packages/core/src/types.ts:423

What Processable.describe() answers.

Node ids in edges, opaque, nodeLabels and sources are the ids this node reports in NodeContext.nodeId — a child's nodeId, or a step that is not a child.

Properties​

children​

children: ProcessableChild[]

Defined in: packages/core/src/types.ts:435

The processables this one composes, each tagged with how it is reached: pipeline(a, b, c) is a series, loop({ body }) a cycle, conditional({ onPass, onFail }) a branch, so a consumer reads the topology off the edge tags.

The live processables, not a projection of them, so a walker asks each the same question. Leaves answer []; so do composites whose children are not processables (recursiveLoop's body is a closure), which is why [] means "nothing to walk", not "nothing happens here".


close?​

optional close?: () => Promise<void>

Defined in: packages/core/src/types.ts:495

Release the host resources this node owns (a CrewSession's interval keeps the event loop alive). Absent on a node that owns none.

Per node, not per tree: a composite does not forward it, and closeAll() walks the composition once and closes whatever declares it, so a new resource-owning primitive is released by every teardown seam the day it declares this. Implementations are idempotent and restartable: closing twice does nothing the second time, and a later process() rebuilds what it needs.

Returns​

Promise<void>


edges?​

optional edges?: readonly object[]

Defined in: packages/core/src/types.ts:441

Wiring between node ids, for the composite whose edges are arbitrary by construction (graph). Absent where composition implies the edges: pipeline(a, b) is a series and loop({ body }) a cycle.


family?​

optional family?: DeclaredFamily

Defined in: packages/core/src/types.ts:483

The family this node was built as a member of, when it was. A baleybotFamily() member answers from its config; processableFamily() adds it to every other member it builds. Read it through declaredFamilyOf(), the one place it is validated.


history?​

optional history?: History

Defined in: packages/core/src/history/history.ts:147

The canonical conversation this node keeps (a bot with keepHistory), for a host that pauses a run and resumes it later from storage.


identity?​

optional identity?: () => NodeIdentity

Defined in: packages/core/src/types.ts:476

What this node is beyond its name and children, for a run's identity (fingerprintProcessable, identifyProcessable): a bot's goal, model and tools, a handle's URL, a step's version. A function because answering can cost (schemas are converted); layout never asks it. Must be stable across processes; never include getId().

Returns​

NodeIdentity


nodeLabels?​

optional nodeLabels?: Readonly<Record<string, string>>

Defined in: packages/core/src/types.ts:450

Display names by node id, where a name differs from the id.


opaque?​

optional opaque?: readonly string[]

Defined in: packages/core/src/types.ts:448

Node ids this composite runs and reports on but cannot hand over as children — a graph's merge point, or a step that is not a Processable. They fire step boundaries, so a consumer joining a run onto the structure needs to know they exist.


place?​

optional place?: string

Defined in: packages/core/src/types.ts:468

Present when this node runs at another place — it implements PlacedProcessable (start()/attach()) — and names that place: the executor of every ExecutionReference its runs carry. That is what resolves a recorded child-run reference to the node that owns it, and what startRun() asks before running a node here.


requirements?​

optional requirements?: readonly keyof ExecutionCapabilities[]

Defined in: packages/core/src/core/durability.ts:125

Guarantees this node needs from the place that runs it: a tool that asks for approval needs approvals, a child run needs childRecovery. requirementsOf() collects them across the composition, so a place refuses a run it cannot hold before any step runs.


sources?​

optional sources?: Readonly<Record<string, string>>

Defined in: packages/core/src/types.ts:452

Source text of the steps written as plain functions, by node id.


tool?​

optional tool?: ProcessableToolDeclaration

Defined in: packages/core/src/types.ts:460

What a model that calls this node as a tool is told: what it does, and the input it takes (a Zod schema or a JSON Schema). A node that declares neither is offered as "Delegate to agent" with an empty object input, under its getName(). The tool layer adds display (see ProcessableToolDeclaration).