oxi-ai 0.25.8

Unified LLM API — multi-provider streaming interface for AI coding assistants
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
111
112
113
114
115
116
117
118
119
120
121

//! Fallback chain for sequential model failover.

#![allow(missing_docs)]

use crate::context::Context;
use crate::error::ProviderError;
use crate::providers::ProviderRegistry;
use crate::providers::StreamOptions;
use crate::types::Model;
use crate::ProviderEvent;
use futures::Stream;
use std::pin::Pin;
use std::sync::Arc;

/// Stream type alias.
pub type BoxStream = Pin<Box<dyn Stream<Item = ProviderEvent> + Send>>;

/// Ordered fallback chain that tries models sequentially.
#[derive(Debug, Clone, Default)]
pub struct FallbackChain {
    /// Ordered list of `"provider/model-id"` fallback targets.
    pub models: Vec<String>,
}

impl FallbackChain {
    /// Create a new fallback chain.
    pub fn new(models: Vec<String>) -> Self {
        Self { models }
    }

    /// Try each model in sequence using a ProviderRegistry.
    pub async fn try_models(
        &self,
        registry: &Arc<ProviderRegistry>,
        context: &Context,
        options: Option<StreamOptions>,
    ) -> Result<BoxStream, ProviderError> {
        let mut last_err = ProviderError::StreamError("no fallback models configured".to_string());

        for model_str in &self.models {
            let Some((provider_name, model_id)) = Self::parse_model(model_str) else {
                continue;
            };

            let Some(provider) = registry.get(&provider_name) else {
                last_err = ProviderError::UnknownProvider(provider_name.clone());
                continue;
            };

            let model = Self::build_model(&provider_name, &model_id);
            match provider.stream(&model, context, options.clone()).await {
                Ok(stream) => {
                    tracing::info!(model = model_str, "Fallback model succeeded");
                    return Ok(stream);
                }
                Err(e) => {
                    tracing::warn!(model = model_str, error = %e, "Fallback model failed");
                    last_err = e;
                }
            }
        }
        Err(last_err)
    }

    /// Try each model using a generic resolver closure.
    pub async fn try_models_with_resolver<F>(
        &self,
        resolver: F,
        context: &Context,
        options: Option<StreamOptions>,
    ) -> Result<BoxStream, ProviderError>
    where
        F: Fn(&str) -> Option<Arc<dyn crate::providers::Provider>> + Sync,
    {
        let mut last_err = ProviderError::StreamError("no fallback models configured".to_string());

        for model_str in &self.models {
            let Some((provider_name, model_id)) = Self::parse_model(model_str) else {
                continue;
            };

            let Some(provider) = resolver(&provider_name) else {
                last_err = ProviderError::UnknownProvider(provider_name.clone());
                continue;
            };

            let model = Self::build_model(&provider_name, &model_id);
            match provider.stream(&model, context, options.clone()).await {
                Ok(stream) => {
                    tracing::info!(model = model_str, "Fallback model succeeded");
                    return Ok(stream);
                }
                Err(e) => {
                    tracing::warn!(model = model_str, error = %e, "Fallback model failed");
                    last_err = e;
                }
            }
        }
        Err(last_err)
    }

    fn parse_model(s: &str) -> Option<(String, String)> {
        let (provider, model_id) = s.split_once('/')?;
        let provider = provider.trim().to_string();
        let model_id = model_id.trim().to_string();
        if provider.is_empty() || model_id.is_empty() {
            return None;
        }
        Some((provider, model_id))
    }

    fn build_model(provider: &str, model_id: &str) -> Model {
        Model::new(
            model_id,
            model_id,
            crate::Api::AnthropicMessages,
            provider,
            "",
        )
    }
}