Struct ChatWorkflow 

pub struct ChatWorkflow {
    pub dag: StableDag<ChatMessage>,
    /* private fields */
}

DAG wrapper for chat conversation.

Every message becomes a node in the DAG with a stable NodeIndex. Sequential edges are auto-created for linear conversation flow.

Fields

dag: StableDag<ChatMessage>

The underlying DAG with stable node indices

Implementations

impl ChatWorkflow

pub fn new() -> Self

Create a new empty ChatWorkflow.

pub fn message_count(&self) -> usize

Get the number of messages in the conversation.

pub fn add_message(&mut self, content: &str, role: Role) -> NodeIndex

Add a message to the conversation DAG. Returns the stable NodeIndex of the new message.

Automatically creates a sequential edge from the previous message to maintain linear conversation flow.

pub fn get_message_by_id(&self, id: &str) -> Option<&ChatMessage>

Get a message by its ID (e.g., “msg-001”).

pub fn get_message_by_index(&self, idx: NodeIndex) -> Option<&ChatMessage>

Get a message by its NodeIndex.

pub fn get_message_by_number(&self, n: u32) -> Option<&ChatMessage>

Get a message by its number (for @N references). @1 returns the first message (msg-001).

pub fn get_index_by_number(&self, n: u32) -> Option<NodeIndex>

Get the NodeIndex by message number.

pub fn current_message_number(&self) -> u32

Get the current message number (for @N references). Returns 0 if no messages have been added.

pub fn last_message(&self) -> Option<&ChatMessage>

Get the most recent message (last added).

pub fn last_message_index(&self) -> Option<NodeIndex>

Get the NodeIndex of the most recent message.

pub fn add_message_parallel(&mut self, content: &str, role: Role) -> NodeIndex

Add a message that is parallel (independent of previous message).

Unlike add_message(), this does NOT create an auto-edge from the previous message. Used for messages starting with // parallel marker.

pub fn add_message_auto(&mut self, content: &str, role: Role) -> NodeIndex

Add a message, automatically detecting if it’s parallel or sequential.

Messages starting with // are parallel (no edge from previous). All other messages get the standard sequential edge.

pub fn get_mentions(&self, idx: NodeIndex) -> Vec<Mention>

Parse @mentions from a message’s content.

Returns all mentions found in the message content.

pub fn resolve_mention( &self, mention: &Mention, ) -> Result<ResolvedMention, MentionResolutionError>

Resolve a mention using this conversation’s message count.

pub fn get_bindings_for_message( &self, idx: NodeIndex, ) -> Result<BindingSpec, MentionResolutionError>

Get BindingSpec for all mentions in a message.

Parses mentions from the message content and converts them to BindingSpec bindings that can be used for DAG edges.

pub fn is_parallel_message(&self, idx: NodeIndex) -> bool

Check if a message has the parallel marker.

Returns true if the message content starts with //.

pub fn add_edges_from_mentions( &mut self, target_idx: NodeIndex, ) -> Result<usize, MentionResolutionError>

Add edges from mentioned messages to the target message.

For each @mention in the target message’s content, creates an edge from the mentioned message(s) to the target. This forms the DAG dependency graph based on explicit references.

Returns the number of edges added.

pub fn add_message_with_mentions( &mut self, content: &str, role: Role, ) -> Result<NodeIndex, MentionResolutionError>

Add a message and create edges from any @mentions in its content.

This combines add_message_auto() with add_edges_from_mentions():

1. Adds the message (parallel if //, sequential otherwise)
2. Creates edges from all @mentioned messages

Returns the NodeIndex of the new message.

pub fn get_dependencies(&self, idx: NodeIndex) -> Vec<NodeIndex>

Get all incoming edges (dependencies) for a message.

Returns the NodeIndices of messages that this message depends on.

pub fn get_dependents(&self, idx: NodeIndex) -> Vec<NodeIndex>

Get all outgoing edges (dependents) for a message.

Returns the NodeIndices of messages that depend on this message.

pub fn all_messages(&self) -> Vec<(NodeIndex, &ChatMessage)>

Iterate over all messages in the workflow.

Returns messages in insertion order (by message number).

pub fn total_messages(&self) -> u32

Get the total message count (for iteration bounds).

pub fn to_yaml(&self) -> String

Export the chat conversation to Nika workflow YAML.

Converts User messages to infer: tasks, preserving @N dependencies as depends_on: entries. Assistant/System/Tool messages are skipped.

Example Output

schema: "nika/workflow@0.12"
provider: claude

tasks:
  - id: msg-002
    infer: "What is Rust?"

  - id: msg-004
    depends_on: [msg-002]
    infer: "@2 Tell me more about safety"

Trait Implementations

impl Default for ChatWorkflow

fn default() -> Self

Returns the “default value” for a type.