systemprompt-ai 0.2.1

Provider-agnostic LLM integration for systemprompt.io AI governance — Anthropic, OpenAI, Gemini, and local models unified behind one governed pipeline with cost tracking and audit.
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

use anyhow::{Result, anyhow};
use std::collections::HashMap;
use std::sync::Arc;
use systemprompt_database::DbPool;
use systemprompt_models::services::AiProviderConfig;

use super::{AiProvider, AnthropicProvider, GeminiProvider, OpenAiProvider};

#[derive(Debug, Copy, Clone)]
pub struct ProviderFactory;

impl ProviderFactory {
    pub fn create(
        name: &str,
        config: &AiProviderConfig,
        db_pool: Option<DbPool>,
    ) -> Result<Arc<dyn AiProvider>> {
        if !config.enabled {
            return Err(anyhow!("Provider {name} is disabled"));
        }

        let provider: Arc<dyn AiProvider> = match name {
            "openai" => {
                let provider = config.endpoint.as_ref().map_or_else(
                    || OpenAiProvider::new(config.api_key.clone()),
                    |endpoint| {
                        OpenAiProvider::with_endpoint(config.api_key.clone(), endpoint.clone())
                    },
                );

                let provider = if config.google_search_enabled {
                    provider.with_web_search()
                } else {
                    provider
                };

                Arc::new(provider)
            },
            "anthropic" => {
                let provider = config.endpoint.as_ref().map_or_else(
                    || AnthropicProvider::new(config.api_key.clone()),
                    |endpoint| {
                        AnthropicProvider::with_endpoint(config.api_key.clone(), endpoint.clone())
                    },
                );

                let provider = if config.google_search_enabled {
                    provider.with_web_search()
                } else {
                    provider
                };

                Arc::new(provider)
            },
            "gemini" => {
                let mut provider = if let Some(endpoint) = &config.endpoint {
                    GeminiProvider::with_endpoint(config.api_key.clone(), endpoint.clone())?
                } else {
                    GeminiProvider::new(config.api_key.clone())?
                };

                if config.google_search_enabled {
                    provider = provider.with_google_search();
                }

                if let Some(pool) = db_pool {
                    provider = provider.with_db_pool(pool);
                }

                Arc::new(provider)
            },
            _ => return Err(anyhow!("Unknown provider: {name}")),
        };

        Ok(provider)
    }

    pub fn create_all(
        configs: HashMap<String, AiProviderConfig>,
        db_pool: Option<&DbPool>,
    ) -> Result<HashMap<String, Arc<dyn AiProvider>>> {
        let mut providers = HashMap::new();

        for (name, config) in configs {
            if config.enabled {
                if let Ok(provider) = Self::create(&name, &config, db_pool.cloned()) {
                    providers.insert(name, provider);
                }
            }
        }

        if providers.is_empty() {
            return Err(anyhow!("No providers could be initialized"));
        }

        Ok(providers)
    }
}