oris-runtime 0.61.0

An agentic workflow runtime and programmable AI execution system in Rust: stateful graphs, agents, tools, and multi-step execution.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

use std::collections::HashMap;

use serde::{Deserialize, Serialize};
use serde_json::Value;

use crate::schemas::StreamData;

/// Metadata for message streaming events
///
/// Contains information about the LLM invocation and graph node
/// where the message chunk was generated.
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct MessageMetadata {
    /// The name of the graph node where the LLM was invoked
    pub graph_node: String,

    /// Tags associated with the LLM invocation (if any)
    pub tags: Vec<String>,

    /// Additional metadata about the LLM invocation
    #[serde(flatten)]
    pub extra: HashMap<String, Value>,
}

impl MessageMetadata {
    /// Create a new MessageMetadata
    pub fn new(node: impl Into<String>) -> Self {
        Self {
            graph_node: node.into(),
            tags: Vec::new(),
            extra: HashMap::new(),
        }
    }

    /// Create with tags
    pub fn with_tags(node: impl Into<String>, tags: Vec<String>) -> Self {
        Self {
            graph_node: node.into(),
            tags,
            extra: HashMap::new(),
        }
    }

    /// Add extra metadata
    pub fn with_extra(mut self, key: String, value: Value) -> Self {
        self.extra.insert(key, value);
        self
    }
}

/// Debug information for debug stream mode
#[derive(Clone, Debug, Serialize, Deserialize)]
pub struct DebugInfo {
    /// Event type (e.g., "NodeStart", "NodeEnd", "MessageChunk")
    pub event_type: String,

    /// Node name (if applicable)
    pub node: Option<String>,

    /// Additional debug information
    #[serde(flatten)]
    pub info: HashMap<String, Value>,
}

impl DebugInfo {
    /// Create a new DebugInfo
    pub fn new(event_type: impl Into<String>) -> Self {
        Self {
            event_type: event_type.into(),
            node: None,
            info: HashMap::new(),
        }
    }

    /// Create with node name
    pub fn with_node(event_type: impl Into<String>, node: impl Into<String>) -> Self {
        Self {
            event_type: event_type.into(),
            node: Some(node.into()),
            info: HashMap::new(),
        }
    }

    /// Add debug information
    pub fn with_info(mut self, key: String, value: Value) -> Self {
        self.info.insert(key, value);
        self
    }
}

/// Message chunk with metadata
///
/// Represents a single token or message segment from an LLM
/// along with its metadata.
#[derive(Clone, Debug)]
pub struct MessageChunk {
    /// The stream data (token content)
    pub chunk: StreamData,

    /// Metadata about the LLM invocation
    pub metadata: MessageMetadata,
}

impl MessageChunk {
    /// Create a new MessageChunk
    pub fn new(chunk: StreamData, metadata: MessageMetadata) -> Self {
        Self { chunk, metadata }
    }
}