omniference 0.1.5

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

use crate::*;
use std::collections::BTreeMap;

/// Helper function to create a ProviderEndpoint from test configuration
pub fn create_endpoint_from_config(provider: &crate::config::TestProviderConfig) -> ProviderConfig {
    let kind = match provider.provider_type.as_str() {
        "OpenAI" => ProviderKind::OpenAI,
        "OpenAICompat" => ProviderKind::OpenAICompat,
        "OpenRouter" => ProviderKind::OpenRouter,
        "Anthropic" => ProviderKind::Anthropic,
        "Google" => ProviderKind::Google,
        _ => ProviderKind::OpenAICompat, // fallback
    };

    ProviderConfig {
        name: provider.name.clone(),
        enabled: provider.enabled,
        endpoint: ProviderEndpoint {
            kind,
            base_url: provider.base_url.clone(),
            api_key: provider.api_key.clone(),
            extra_headers: BTreeMap::new(),
            timeout: provider.timeout.map(|t| t as u64),
        },
    }
}

/// Helper function to create a test chat request with configuration
pub fn create_test_request(
    provider_config: &crate::config::TestProviderConfig,
    model_id: &str,
    message: &str,
) -> ChatRequestIR {
    let test_provider_config = create_endpoint_from_config(provider_config);

    ChatRequestIR {
        model: ModelRef {
            alias: format!("{}-{}", provider_config.name, model_id),
            provider: test_provider_config,
            model_id: model_id.to_string(),
            input_modalities: vec![Modality::Text],
            output_modalities: vec![Modality::Text],
        },
        messages: vec![Message {
            role: Role::User,
            parts: vec![ContentPart::Text(message.to_string())],
            name: None,
        }],
        reasoning: None,
        tools: vec![],
        tool_choice: ToolChoice::Auto,
        sampling: Sampling::default(),
        stream: false,
        metadata: BTreeMap::new(),
        request_timeout: None,
        response_format: None,
        audio_output: None,
        web_search_options: None,
        prediction: None,
        safety_identifier: None,
        cache_key: None,
    }
}

/// Helper function to check if we should run live tests based on configuration
pub fn should_run_live_tests() -> bool {
    if let Ok(config) = crate::config::TestConfig::load() {
        !config.should_skip_live_tests()
    } else {
        false // Default to skipping if config fails to load
    }
}

/// Helper function to check if a provider is enabled and configured
pub fn is_provider_enabled(provider_name: &str) -> bool {
    if let Ok(config) = crate::config::TestConfig::load() {
        config
            .get_provider(provider_name)
            .map_or(false, |p| p.enabled && p.api_key.is_some())
    } else {
        false
    }
}