Struct Blueprint 

pub struct Blueprint {
    pub schema_version: Version,
    pub id: String,
    pub flow: Node,
    pub agents: Vec<AgentDef>,
    pub operators: Vec<OperatorDef>,
    pub hints: CompilerHints,
    pub strategy: CompilerStrategy,
    pub metadata: BlueprintMetadata,
    pub spawner_hints: SpawnerHints,
    pub default_agent_kind: AgentKind,
    pub default_operator_kind: Option<OperatorKind>,
}

Unified package of flow.ir + Swarm extension layers. The entry-point type of Swarm.

Fields

schema_version: Version

Schema version (= tied to this crate’s semver). Default = CURRENT_SCHEMA_VERSION. Serialized as a semver string (e.g. "0.1.0").

id: String

Blueprint identifier (= unique key within the caller’s namespace).

flow: Node

Embeds the flow.ir Node verbatim (= keeps flow.ir side unpolluted). Opaque in the JSON Schema (the Node shape is owned by the mlua-flow-ir crate, a separate repo; see its docs for the Node / Expr grammar).

agents: Vec<AgentDef>

Swarm extension layer: agent → backend mapping.

operators: Vec<OperatorDef>

Swarm extension layer: design-time definition of Operator roles (first-class).

AgentDef.spec.operator_ref references an OperatorDef.name (logical role name) in this vec. Embedding runtime-generated IDs such as sid into the BP is forbidden (= collapses the design-time vs runtime boundary). Runtime backend bindings are established via the attach / register path; the BP side holds only logical names.

Every kind = Operator agent must have its spec.operator_ref present in this list — the compiler validates it at compile() time. May be [] only when the Blueprint declares no Operator agents.

hints: CompilerHints

Swarm extension layer: per-agent hints (interpreted by the Compiler).

strategy: CompilerStrategy

Swarm extension layer: Compiler behavior strategy (strict / lenient).

metadata: BlueprintMetadata

Blueprint metadata (description / origin / tags / ttl / version label / alias).

spawner_hints: SpawnerHints

Swarm extension layer: hint keys of the layers to wrap around the SpawnerStack. Resolved by the LayerRegistry at engine bind time (= unregistered keys are silently skipped). Flow / Blueprint do not hold middleware implementations (e.g. MainAIMiddleware) directly; they only declare required capabilities as string keys (= implementations live in the engine-side LayerRegistry).

default_agent_kind: AgentKind

BP-wide default AgentKind (= fallback when AgentDef.kind is omitted). Four-layer cascade: (1) Schema impl Default = Operator, (2) CLI --default-agent-kind, (3) this field (BP JSON literal), (4) AgentDef.kind (per-agent literal). (5) CompilerHints.kind_override allows runtime override. All default resolution flows through this path.

default_operator_kind: Option<OperatorKind>

BP-wide default OperatorKind (= the “BP Global” tier of the 4-tier OperatorKind cascade). None when the Blueprint author does not declare a default; the caller-side resolver then falls through to the hardcoded OperatorKind::default() (Automate).

4-tier cascade (highest to lowest priority)

1. Runtime Agent-level (per-agent override supplied at task-launch time)
2. Runtime Global (the launch-time operator_kind request)
3. BP Agent-level (OperatorDef.kind, resolved via AgentDef.spec.operator_ref)
4. BP Global (this field)
5. Default Fallback (OperatorKind::default() = Automate)

The collapse itself is implemented once on the engine side and consumed per-agent when resolving operator info.

Trait Implementations

impl Clone for Blueprint

fn clone(&self) -> Blueprint

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Blueprint

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Blueprint

fn deserialize<__D>( __deserializer: __D, ) -> Result<Blueprint, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Blueprint

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Blueprint

fn eq(&self, other: &Blueprint) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Blueprint

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Blueprint