Enum EventKind 

pub enum EventKind {
    WorkflowStarted {
        task_count: usize,
        generation_id: String,
        workflow_hash: String,
        nika_version: String,
    },
    WorkflowCompleted {
        final_output: Arc<Value>,
        total_duration_ms: u64,
    },
    WorkflowFailed {
        error: String,
        failed_task: Option<Arc<str>>,
    },
    WorkflowAborted {
        reason: String,
        duration_ms: u64,
        running_tasks: Vec<Arc<str>>,
    },
    WorkflowPaused,
    WorkflowResumed,
    TaskScheduled {
        task_id: Arc<str>,
        dependencies: Vec<Arc<str>>,
    },
    TaskStarted {
        task_id: Arc<str>,
        verb: Arc<str>,
        inputs: Value,
    },
    TaskCompleted {
        task_id: Arc<str>,
        output: Arc<Value>,
        duration_ms: u64,
    },
    TaskFailed {
        task_id: Arc<str>,
        error: String,
        duration_ms: u64,
        error_code: Option<String>,
    },
    TaskSkipped {
        task_id: Arc<str>,
        reason: String,
    },
    TemplateResolved {
        task_id: Arc<str>,
        template: String,
        result: String,
    },
    ProviderCalled {
        task_id: Arc<str>,
        provider: String,
        model: String,
        prompt_len: usize,
    },
    ProviderResponded {
        task_id: Arc<str>,
        request_id: Option<String>,
        input_tokens: u64,
        output_tokens: u64,
        cache_read_tokens: u64,
        ttft_ms: Option<u64>,
        finish_reason: String,
        cost_usd: f64,
    },
    ContextAssembled {
        task_id: Arc<str>,
        sources: Vec<ContextSource>,
        excluded: Vec<ExcludedItem>,
        total_tokens: u64,
        budget_used_pct: f32,
        truncated: bool,
    },
    McpInvoke {
        task_id: Arc<str>,
        call_id: String,
        mcp_server: String,
        tool: Option<String>,
        resource: Option<String>,
        params: Option<Value>,
    },
    McpResponse {
        task_id: Arc<str>,
        call_id: String,
        output_len: usize,
        duration_ms: u64,
        cached: bool,
        is_error: bool,
        response: Option<Value>,
    },
    McpConnected {
        server_name: String,
    },
    McpError {
        server_name: String,
        error: String,
    },
    McpRetry {
        task_id: Arc<str>,
        server_name: String,
        operation: String,
        attempt: u32,
        max_attempts: u32,
        error: String,
    },
    AgentStart {
        task_id: Arc<str>,
        max_turns: u32,
        mcp_servers: Vec<String>,
    },
    AgentTurn {
        task_id: Arc<str>,
        turn_index: u32,
        kind: String,
        metadata: Option<AgentTurnMetadata>,
    },
    AgentComplete {
        task_id: Arc<str>,
        turns: u32,
        stop_reason: String,
    },
    AgentSpawned {
        parent_task_id: Arc<str>,
        child_task_id: Arc<str>,
        depth: u32,
    },
    GuardrailPassed {
        task_id: Arc<str>,
        guardrail_type: String,
        description: String,
    },
    GuardrailFailed {
        task_id: Arc<str>,
        guardrail_type: String,
        description: String,
        message: String,
    },
    GuardrailEscalation {
        task_id: Arc<str>,
        guardrail_type: String,
        guardrail_id: String,
        message: String,
        severity: String,
        suggested_action: Option<String>,
    },
    Log {
        level: String,
        message: String,
        task_id: Option<Arc<str>>,
    },
    Custom {
        name: String,
        payload: Value,
        task_id: Option<Arc<str>>,
    },
    ArtifactWritten {
        task_id: Arc<str>,
        path: String,
        size: u64,
        format: String,
        checksum: Option<String>,
    },
    ArtifactFailed {
        task_id: Arc<str>,
        path: String,
        reason: String,
    },
    MediaExtracted {
        task_id: Arc<str>,
        block_count: u32,
        content_types: Vec<String>,
    },
    MediaProcessed {
        task_id: Arc<str>,
        hash: String,
        mime_type: String,
        size_bytes: u64,
    },
    MediaStored {
        task_id: Arc<str>,
        hash: String,
        path: String,
        size_bytes: u64,
        verified: bool,
        deduplicated: bool,
        pipeline_ms: u64,
    },
    MediaStoreFailed {
        task_id: Arc<str>,
        hash: String,
        reason: String,
    },
    MediaIntegrityCheck {
        checked: u64,
        warnings: u64,
    },
    StructuredOutputAttempt {
        task_id: Arc<str>,
        layer: u8,
        layer_name: String,
        attempt: u32,
        success: bool,
        error: Option<String>,
    },
    StructuredOutputSuccess {
        task_id: Arc<str>,
        layer: u8,
        layer_name: String,
        total_attempts: u32,
    },
    VisionContentResolved {
        task_id: Arc<str>,
        image_count: u32,
        total_bytes: u64,
        resolve_ms: u64,
    },
    HttpRequest {
        task_id: Arc<str>,
        method: String,
        url: String,
        has_body: bool,
    },
    HttpResponse {
        task_id: Arc<str>,
        status_code: u16,
        content_type: Option<String>,
        content_length: Option<u64>,
        elapsed_ms: u64,
    },
    MediaCleanup {
        removed: u64,
        bytes_freed: u64,
        dry_run: bool,
    },
    ExecCompleted {
        task_id: Arc<str>,
        exit_code: i32,
        stdout_len: usize,
        stderr_len: usize,
        duration_ms: u64,
    },
    FetchRetry {
        task_id: Arc<str>,
        url: String,
        attempt: u32,
        max_attempts: u32,
        status_code: Option<u16>,
        backoff_ms: u64,
    },
    PolicyBlocked {
        task_id: Arc<str>,
        verb: String,
        policy_type: String,
        reason: String,
    },
    BootPhaseCompleted {
        phase: String,
        success: bool,
        duration_ms: u64,
        warnings: Vec<String>,
    },
    NativeModelLoaded {
        model: String,
        kind: String,
        size_bytes: u64,
        duration_ms: u64,
        is_vision: bool,
    },
    BindingDefaultApplied {
        task_id: Arc<str>,
        alias: String,
        path: String,
        default_value: Value,
    },
    BindingTransformApplied {
        task_id: Arc<str>,
        alias: String,
        transform_chain: String,
    },
    BindingEnvResolved {
        task_id: Arc<str>,
        var_name: String,
        found: bool,
    },
    DecomposeStarted {
        task_id: Arc<str>,
        strategy: String,
    },
    DecomposeCompleted {
        task_id: Arc<str>,
        strategy: String,
        item_count: usize,
        duration_ms: u64,
    },
    ForEachStarted {
        task_id: Arc<str>,
        item_count: usize,
        concurrency: usize,
        fail_fast: bool,
    },
    ForEachCompleted {
        task_id: Arc<str>,
        total: u32,
        succeeded: u32,
        failed: u32,
        skipped: u32,
        duration_ms: u64,
    },
    ProviderInitialized {
        provider: String,
        model: String,
        cached: bool,
    },
    BuiltinToolInvoked {
        task_id: Arc<str>,
        tool_name: String,
        duration_ms: u64,
        success: bool,
    },
    ExtractApplied {
        task_id: Arc<str>,
        mode: String,
        selector: Option<String>,
        input_len: usize,
        output_len: usize,
    },
}

All possible event types (3 levels)

Uses Arc<str> for task_id fields to enable zero-cost cloning.

Variants

WorkflowStarted

Fields

task_count: usize

generation_id: String

Unique generation ID for this execution

workflow_hash: String

Hash of workflow file for cache invalidation

nika_version: String

Nika version

WorkflowCompleted

Fields

final_output: Arc<Value>

total_duration_ms: u64

WorkflowFailed

Fields

error: String

failed_task: Option<Arc<str>>

WorkflowAborted

Workflow was cancelled by user

Fields

reason: String

Reason for abort (e.g., “User cancelled”, “Timeout”)

duration_ms: u64

Duration before abort (ms)

running_tasks: Vec<Arc<str>>

Tasks that were still running when aborted

WorkflowPaused

Workflow execution paused

WorkflowResumed

Workflow execution resumed

TaskScheduled

Fields

task_id: Arc<str>

dependencies: Vec<Arc<str>>

TaskStarted

Task execution begins with resolved inputs from with: block

Fields

task_id: Arc<str>

verb: Arc<str>

Verb type (infer, exec, fetch, invoke, agent)

inputs: Value

Resolved inputs from ResolvedBindings (what the task receives)

TaskCompleted

Fields

task_id: Arc<str>

output: Arc<Value>

duration_ms: u64

TaskFailed

Fields

task_id: Arc<str>

error: String

duration_ms: u64

error_code: Option<String>

Structured error code (e.g. “NIKA-044”) for programmatic extraction

TaskSkipped

A task was skipped because a dependency failed.

Fields

task_id: Arc<str>

reason: String

The dependency that failed causing the skip

TemplateResolved

Fields

task_id: Arc<str>

template: String

result: String

ProviderCalled

Fields

task_id: Arc<str>

provider: String

model: String

prompt_len: usize

ProviderResponded

Fields

task_id: Arc<str>

request_id: Option<String>

API request ID (for debugging with provider)

input_tokens: u64

Input tokens

output_tokens: u64

Output tokens

cache_read_tokens: u64

Cache read tokens (if any)

ttft_ms: Option<u64>

Time to first token (ms), if known

finish_reason: String

Finish reason

cost_usd: f64

Estimated cost in USD

ContextAssembled

Context assembly event for observability

Fields

task_id: Arc<str>

sources: Vec<ContextSource>

Sources included in context

excluded: Vec<ExcludedItem>

Items excluded (with reasons)

total_tokens: u64

Total tokens in assembled context

budget_used_pct: f32

Budget utilization percentage

truncated: bool

Was context truncated?

McpInvoke

MCP tool call or resource read initiated

Fields

task_id: Arc<str>

call_id: String

Unique call ID for correlating with McpResponse

mcp_server: String

tool: Option<String>

resource: Option<String>

params: Option<Value>

Full params passed to MCP tool (for TUI display)

McpResponse

MCP operation completed

Fields

task_id: Arc<str>

call_id: String

Correlates with McpInvoke.call_id

output_len: usize

duration_ms: u64

Duration of MCP call in milliseconds

cached: bool

Whether response came from cache

is_error: bool

Whether MCP tool returned an error

response: Option<Value>

Full response JSON (for TUI display)

McpConnected

MCP server connection established

Fields

server_name: String

Name of the connected MCP server

McpError

MCP server connection failed

Fields

server_name: String

Name of the MCP server

error: String

Error description

McpRetry

MCP operation retry attempt

Emitted when MCP tool calls fail with connection errors and are retried. Use McpClient::call_tool_with_retry_events() for observable retry tracking. TUI handlers display this event with attempt count and error details.

Fields

task_id: Arc<str>

Task ID initiating the retry

server_name: String

Name of the MCP server

operation: String

Tool or resource being retried

attempt: u32

Current attempt number (1-based)

max_attempts: u32

Max attempts configured

error: String

Error that triggered the retry

AgentStart

Agent loop started

Fields

task_id: Arc<str>

max_turns: u32

mcp_servers: Vec<String>

AgentTurn

Agent turn event with optional metadata

When metadata is present, it contains:

• Response text
• Token usage (input/output/cache)
• Stop reason
• Thinking content (if using streaming API)

Fields

task_id: Arc<str>

turn_index: u32

kind: String

Event kind: “started”, “continue”, “natural_completion”, “explicit_completion”

metadata: Option<AgentTurnMetadata>

Turn metadata including response text, tokens, thinking

AgentComplete

Agent loop completed (reached stop condition or max turns)

Fields

task_id: Arc<str>

turns: u32

stop_reason: String

AgentSpawned

A sub-agent was spawned by a parent agent

Fields

parent_task_id: Arc<str>

ID of the parent task that spawned the child

child_task_id: Arc<str>

ID of the newly spawned child task

depth: u32

Current depth level (1 = root agent spawning first child)

GuardrailPassed

Guardrail check passed

Fields

task_id: Arc<str>

Task ID for correlation

guardrail_type: String

Guardrail type: “length”, “schema”, “regex”

description: String

Human-readable description of the guardrail

GuardrailFailed

Guardrail check failed

Fields

task_id: Arc<str>

Task ID for correlation

guardrail_type: String

Guardrail type: “length”, “schema”, “regex”, “llm”

description: String

Human-readable description of the guardrail

message: String

Error message explaining why it failed

GuardrailEscalation

Guardrail failure requires escalation

Emitted when a guardrail with on_failure: escalate fails. This signals that human intervention or special handling is needed.

Fields

task_id: Arc<str>

Task ID for correlation

guardrail_type: String

Guardrail type: “length”, “schema”, “regex”, “llm”

guardrail_id: String

Guardrail ID for identification

message: String

Error message explaining why it failed

severity: String

Severity level: “low”, “medium”, “high”, “critical”

suggested_action: Option<String>

Suggested action (optional)

Log

Log event emitted by nika:log builtin tool

Fields

level: String

Log level: trace, debug, info, warn, error

message: String

Log message

task_id: Option<Arc<str>>

Optional task context

Custom

Custom event emitted by nika:emit builtin tool

Fields

name: String

Event name/type

payload: Value

Event payload (arbitrary JSON)

task_id: Option<Arc<str>>

Optional task context

ArtifactWritten

Artifact successfully written to disk

Fields

task_id: Arc<str>

Task that produced this artifact

path: String

Final resolved path

size: u64

Size in bytes

format: String

Output format (text, json, binary)

checksum: Option<String>

Blake3 checksum from CAS (binary artifacts only)

ArtifactFailed

Artifact write failed

Fields

task_id: Arc<str>

Task that produced this artifact

path: String

Intended path

reason: String

Error reason

MediaExtracted

Media content blocks extracted from MCP tool result

Fields

task_id: Arc<str>

block_count: u32

Number of non-text content blocks found

content_types: Vec<String>

Content types found (e.g., [“image”, “audio”])

MediaProcessed

Single media block processed (decoded + detected)

Fields

task_id: Arc<str>

hash: String

blake3 hash of the decoded content (with “blake3:” prefix)

mime_type: String

Detected MIME type

size_bytes: u64

File size in bytes (decoded)

MediaStored

Media file stored in CAS

Fields

task_id: Arc<str>

hash: String

blake3 hash (with “blake3:” prefix)

path: String

File path in CAS store

size_bytes: u64

File size in bytes

verified: bool

Whether read-back verification passed (or skipped for small files)

deduplicated: bool

Whether this was a dedup hit

pipeline_ms: u64

Pipeline latency in milliseconds (decode -> store)

MediaStoreFailed

Media storage failed

Fields

task_id: Arc<str>

hash: String

blake3 hash (if available, empty string if pre-hash failure)

reason: String

Error description

MediaIntegrityCheck

Media integrity check completed (emitted after all tasks finish)

Fields

checked: u64

Number of media refs checked

warnings: u64

Number of integrity warnings (missing files, size mismatches)

StructuredOutputAttempt

Structured output extraction attempt at a specific layer

Emitted for each layer/retry attempt in the 4-layer defense system:

• Layer 1: rig Extractor (Rust types with JsonSchema)
• Layer 2: Extract + Validate (post-processing)
• Layer 3: Retry with Feedback
• Layer 4: LLM Repair

Fields

task_id: Arc<str>

Task ID for correlation

layer: u8

Layer number (0-4)

layer_name: String

Human-readable layer name (e.g., “tool_injection”, “extract_validate”)

attempt: u32

Attempt number within this layer (1-based)

success: bool

Whether this attempt succeeded

error: Option<String>

Error message if failed

StructuredOutputSuccess

Structured output successfully extracted

Emitted when any layer successfully produces valid output

Fields

task_id: Arc<str>

Task ID for correlation

layer: u8

Layer that succeeded (1-4)

layer_name: String

Human-readable layer name

total_attempts: u32

Total attempts across all layers before success

VisionContentResolved

Vision content parts resolved for multimodal inference.

Emitted when CAS image references in content: are resolved to base64 data before sending to a vision-capable LLM.

Fields

task_id: Arc<str>

Task that triggered vision resolution

image_count: u32

Number of image parts resolved

total_bytes: u64

Total bytes of image data resolved from CAS

resolve_ms: u64

Time to resolve all images (ms)

HttpRequest

HTTP request initiated by fetch: verb

Fields

task_id: Arc<str>

method: String

url: String

has_body: bool

HttpResponse

HTTP response received by fetch: verb

Fields

task_id: Arc<str>

status_code: u16

content_type: Option<String>

content_length: Option<u64>

elapsed_ms: u64

MediaCleanup

Media store cleanup (GC) operation completed

Fields

removed: u64

Number of files removed

bytes_freed: u64

Total bytes freed

dry_run: bool

Whether this was a dry-run (no files actually deleted)

ExecCompleted

Shell command execution completed with exit details

Fields

task_id: Arc<str>

exit_code: i32

Process exit code (0 = success)

stdout_len: usize

Length of stdout in bytes

stderr_len: usize

Length of stderr in bytes

duration_ms: u64

Execution duration in milliseconds

FetchRetry

Fetch retry attempt (mirrors McpRetry pattern)

Fields

task_id: Arc<str>

url: String

URL being fetched

attempt: u32

Current attempt number (1-based)

max_attempts: u32

Max attempts configured

status_code: Option<u16>

HTTP status code that triggered retry (if any)

backoff_ms: u64

Backoff delay before this attempt in ms

PolicyBlocked

Security policy blocked an operation

Fields

task_id: Arc<str>

verb: String

Verb that was blocked (exec, fetch, invoke)

policy_type: String

Policy type that triggered block (command_blocklist, host_blocklist, ssrf, etc.)

reason: String

Human-readable reason for the block

BootPhaseCompleted

Boot phase completed (one per phase during startup)

Fields

phase: String

Phase name: “config_discovery”, “config_validation”, “memory_loading”, “secrets_loading”, “mcp_startup”, “provider_validation”, “ready”

success: bool

Whether the phase succeeded

duration_ms: u64

Phase duration in milliseconds

warnings: Vec<String>

Warnings produced during this phase

NativeModelLoaded

Native (local) model loaded successfully

Fields

model: String

Model identifier (file path for GGUF, HF ID for HuggingFace)

kind: String

Model kind: “gguf” or “huggingface”

size_bytes: u64

Model file size in bytes (0 for HuggingFace downloads)

duration_ms: u64

Load duration in milliseconds

is_vision: bool

Whether model has vision capabilities

BindingDefaultApplied

Binding default value applied (via ?? operator)

Fields

task_id: Arc<str>

alias: String

Alias name in with: block

path: String

Original binding path that was null/missing

default_value: Value

Default value that was used

BindingTransformApplied

Binding transform chain applied (e.g., |upper|trim|sort)

Fields

task_id: Arc<str>

alias: String

Alias name

transform_chain: String

Transform expression (e.g., “upper | trim”)

BindingEnvResolved

Environment variable resolved via $env.VAR_NAME binding

Fields

task_id: Arc<str>

var_name: String

Environment variable name

found: bool

Whether the env var was found

DecomposeStarted

Decompose modifier expansion started

Fields

task_id: Arc<str>

strategy: String

Strategy: “semantic”, “static”, “nested”

DecomposeCompleted

Decompose modifier expansion completed

Fields

task_id: Arc<str>

strategy: String

Strategy used

item_count: usize

Number of items produced

duration_ms: u64

Expansion duration in milliseconds

ForEachStarted

for_each iteration batch started

Fields

task_id: Arc<str>

item_count: usize

Number of items to iterate over

concurrency: usize

Concurrency level (1 = sequential)

fail_fast: bool

Whether fail_fast is enabled

ForEachCompleted

for_each iteration batch completed with aggregated results

Fields

task_id: Arc<str>

total: u32

Total iterations attempted

succeeded: u32

Successful iterations

failed: u32

Failed iterations (errors)

skipped: u32

Skipped iterations (cancelled by fail_fast)

duration_ms: u64

Total duration across all iterations (ms)

ProviderInitialized

Provider initialized (first use, cache miss)

Fields

provider: String

Provider name (anthropic, openai, mistral, etc.)

model: String

Default model for this provider

cached: bool

Whether this was served from cache

BuiltinToolInvoked

Builtin tool invoked by agent (nika:read, nika:write, etc.)

Fields

task_id: Arc<str>

tool_name: String

Tool name: “nika:read”, “nika:write”, etc.

duration_ms: u64

Call duration in milliseconds

success: bool

Whether the call succeeded

ExtractApplied

Extraction mode applied to fetch response

Fields

task_id: Arc<str>

mode: String

Extract mode: “css”, “jq”, “text”, “markdown”, “llm_txt”

selector: Option<String>

CSS/jq selector used (if any)

input_len: usize

Input body length (bytes)

output_len: usize

Output length after extraction (bytes)

Implementations

impl EventKind

pub fn task_id(&self) -> Option<&str>

Extract task_id if event is task-related

pub fn is_workflow_event(&self) -> bool

Check if this is a workflow-level event

Trait Implementations

impl Clone for EventKind

fn clone(&self) -> EventKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for EventKind

fn eq(&self, other: &EventKind) -> 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 EventKind

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 EventKind