omniference 0.1.4

A multi-protocol inference engine with provider adapters
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

use crate::router::Router;
use crate::service::OmniferenceService;
use crate::types::{ChatRequestIR, DiscoveredModel, ProviderConfig};
use futures_util::StreamExt;

/// High-level engine for easy library usage
pub struct OmniferenceEngine {
    service: OmniferenceService,
}

impl OmniferenceEngine {
    /// Create a new engine with default configuration
    pub fn new() -> Self {
        Self {
            service: OmniferenceService::new(),
        }
    }

    /// Create an engine with a custom router
    pub fn with_router(router: Router) -> Self {
        Self {
            service: OmniferenceService::with_router(router),
        }
    }

    /// Register a provider configuration
    pub async fn register_provider(&mut self, provider: ProviderConfig) -> Result<(), String> {
        self.service.register_provider(provider).await
    }

    /// Discover all available models from registered providers
    pub async fn discover_models(&mut self) -> Result<Vec<DiscoveredModel>, String> {
        self.service.discover_models().await
    }

    /// Get a specific model by ID
    pub async fn get_model(&self, model_id: &str) -> Option<DiscoveredModel> {
        self.service.get_model(model_id).await
    }

    /// Get an provider by name
    pub async fn get_provider(&self, name: &str) -> Option<ProviderConfig> {
        self.service.get_provider(name).await
    }

    /// List all available providers
    pub async fn list_providers(&self) -> Vec<ProviderConfig> {
        self.service.list_providers().await
    }

    /// List all available models
    pub async fn list_models(&self) -> Vec<DiscoveredModel> {
        self.service.list_models().await
    }

    /// Execute a chat request
    pub async fn chat(
        &self,
        request: ChatRequestIR,
    ) -> Result<impl futures_util::Stream<Item = crate::stream::StreamEvent> + Send + Unpin, String>
    {
        self.service.chat(request).await
    }

    /// Execute a chat request and collect all messages into a string
    pub async fn chat_complete(&self, request: ChatRequestIR) -> Result<String, String> {
        let stream = self.chat(request).await?;

        let mut content = String::new();
        tokio::pin!(stream);

        while let Some(event) = stream.next().await {
            match event {
                crate::stream::StreamEvent::TextDelta { content: chunk } => {
                    content.push_str(&chunk);
                }
                crate::stream::StreamEvent::FinalMessage {
                    content: final_content,
                    ..
                } => {
                    content.push_str(&final_content);
                }
                crate::stream::StreamEvent::Error { code, message } => {
                    return Err(format!("{}: {}", code, message));
                }
                crate::stream::StreamEvent::Done => {
                    break;
                }
                _ => {}
            }
        }

        Ok(content)
    }

    /// Get the underlying service for advanced usage
    pub fn service(&self) -> &OmniferenceService {
        &self.service
    }
}

impl Default for OmniferenceEngine {
    fn default() -> Self {
        Self::new()
    }
}