Enum GenerationEvent 

pub enum GenerationEvent {
    Started {
        tool_name: String,
        total_tools: usize,
        current_index: usize,
    },
    Thinking {
        thought: String,
    },
    Searching {
        query: String,
    },
    SearchResult {
        tools: Vec<String>,
        count: usize,
    },
    Example {
        example: GeneratedExample,
    },
    Validation {
        valid: bool,
        errors: Vec<String>,
        example_index: usize,
    },
    Progress {
        current: usize,
        total: usize,
        percent: f32,
        message: Option<String>,
    },
    ToolCompleted {
        tool_name: String,
        examples_generated: usize,
        valid_examples: usize,
        duration_ms: u64,
    },
    Completed {
        total_examples: usize,
        total_valid: usize,
        total_tools: usize,
        duration_ms: u64,
    },
    Error {
        message: String,
        recoverable: bool,
        tool_name: Option<String>,
    },
    AgentStep {
        step: AgentStep,
    },
}

Events emitted during AI-powered example generation

These events follow the SSE (Server-Sent Events) format and can be streamed to CLI or MCP clients in real-time.

Variants

Started

Generation process has started for a tool

Fields

tool_name: String

Name of the tool being processed

total_tools: usize

Total number of tools to process

current_index: usize

Current tool index (1-based)

Thinking

LLM is processing/thinking

Fields

thought: String

Current thought/reasoning step

Searching

Performing an intermediate search

Fields

query: String

Search query being executed

SearchResult

Search results received

Fields

tools: Vec<String>

Tool names found

count: usize

Number of results

Example

An example has been generated

Fields

example: GeneratedExample

The generated example

Validation

Validation result for an example

Fields

valid: bool

Whether the example passed validation

errors: Vec<String>

Validation errors (if any)

example_index: usize

Index of the example being validated

Progress

Progress update

Fields

current: usize

Current item being processed

total: usize

Total items to process

percent: f32

Completion percentage (0.0 - 100.0)

message: Option<String>

Optional message

ToolCompleted

Tool generation completed

Fields

tool_name: String

Tool name

examples_generated: usize

Number of examples generated

valid_examples: usize

Number of valid examples

duration_ms: u64

Duration in milliseconds

Completed

All generation completed

Fields

total_examples: usize

Total examples generated across all tools

total_valid: usize

Total valid examples

total_tools: usize

Total tools processed

duration_ms: u64

Total duration in milliseconds

Error

An error occurred

Fields

message: String

Error message

recoverable: bool

Whether the error is recoverable

tool_name: Option<String>

Optional tool name context

AgentStep

Agent reasoning step (for self-ask patterns)

Fields

step: AgentStep

The reasoning step

Implementations

impl GenerationEvent

pub fn started( tool_name: impl Into<String>, total_tools: usize, current_index: usize, ) -> Self

Create a started event

pub fn thinking(thought: impl Into<String>) -> Self

Create a thinking event

pub fn progress(current: usize, total: usize, message: Option<String>) -> Self

Create a progress event

pub fn error(message: impl Into<String>, recoverable: bool) -> Self

Create an error event

pub fn tool_error( message: impl Into<String>, tool_name: impl Into<String>, recoverable: bool, ) -> Self

Create an error event with tool context

pub fn completed( total_examples: usize, total_valid: usize, total_tools: usize, duration: Duration, ) -> Self

Create a completed event

pub fn to_sse_data(&self) -> String

Format as SSE data line

pub fn to_sse(&self) -> String

Format as SSE with event type

Trait Implementations

impl Clone for GenerationEvent

fn clone(&self) -> GenerationEvent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GenerationEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GenerationEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GenerationEvent

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

where __S: Serializer,

Serialize this value into the given Serde serializer.