praxis-graph 0.2.0

React agent orchestrator for building AI agent workflows with LLM and tool execution
Documentation 
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
110

/// Adapter Pattern for Event Conversion
/// 
/// Converts between provider-specific event formats and the graph's internal event format.
/// This abstraction allows the graph to work with different LLM providers without
/// coupling to their specific event structures.

/// Stream adapter trait for converting between event formats
/// 
/// # Type Parameters
/// * `ProviderEvent` - The event type from the LLM provider
/// * `GraphEvent` - The internal graph event type
pub trait StreamAdapter {
    type ProviderEvent;
    type GraphEvent;
    
    /// Convert a provider event to a graph event
    /// 
    /// Returns None if the event should be filtered/ignored
    fn adapt(&self, event: Self::ProviderEvent) -> Option<Self::GraphEvent>;
}

/// OpenAI stream adapter
/// 
/// Converts OpenAI `StreamEvent` to graph `StreamEvent`.
/// Currently uses the From trait for direct conversion, but this adapter
/// provides a clear extension point for custom logic.
pub struct OpenAIStreamAdapter;

impl StreamAdapter for OpenAIStreamAdapter {
    type ProviderEvent = praxis_llm::StreamEvent;
    type GraphEvent = crate::types::StreamEvent;
    
    fn adapt(&self, event: Self::ProviderEvent) -> Option<Self::GraphEvent> {
        // Use the From trait implementation for conversion
        // In the future, we could add filtering, transformation, or enrichment logic here
        Some(event.into())
    }
}

/// Future: Azure OpenAI adapter
#[allow(dead_code)]
pub struct AzureStreamAdapter;

// impl StreamAdapter for AzureStreamAdapter {
//     type ProviderEvent = AzureStreamEvent;
//     type GraphEvent = crate::types::StreamEvent;
//     
//     fn adapt(&self, event: Self::ProviderEvent) -> Option<Self::GraphEvent> {
//         // Convert Azure-specific events to graph events
//         todo!("Azure adapter not yet implemented")
//     }
// }

/// Future: Anthropic adapter
#[allow(dead_code)]
pub struct AnthropicStreamAdapter;

// impl StreamAdapter for AnthropicStreamAdapter {
//     type ProviderEvent = AnthropicStreamEvent;
//     type GraphEvent = crate::types::StreamEvent;
//     
//     fn adapt(&self, event: Self::ProviderEvent) -> Option<Self::GraphEvent> {
//         // Convert Anthropic-specific events to graph events
//         todo!("Anthropic adapter not yet implemented")
//     }
// }

#[cfg(test)]
mod tests {
    use super::*;
    use praxis_llm::StreamEvent as LLMEvent;
    use crate::types::StreamEvent as GraphEvent;
    
    #[test]
    fn test_openai_adapter_message() {
        let adapter = OpenAIStreamAdapter;
        let llm_event = LLMEvent::Message {
            content: "Hello".to_string(),
        };
        
        let graph_event = adapter.adapt(llm_event);
        assert!(graph_event.is_some());
        
        match graph_event.unwrap() {
            GraphEvent::Message { content } => {
                assert_eq!(content, "Hello");
            }
            _ => panic!("Expected Message event"),
        }
    }
    
    #[test]
    fn test_openai_adapter_reasoning() {
        let adapter = OpenAIStreamAdapter;
        let llm_event = LLMEvent::Reasoning {
            content: "Thinking...".to_string(),
        };
        
        let graph_event = adapter.adapt(llm_event);
        assert!(graph_event.is_some());
        
        match graph_event.unwrap() {
            GraphEvent::Reasoning { content } => {
                assert_eq!(content, "Thinking...");
            }
            _ => panic!("Expected Reasoning event"),
        }
    }
}