rig-core 0.44.0

An opinionated library for building LLM powered applications.
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

//! The Gemini client: a [`GeminiConfig`] on a transport, and the models it
//! builds.

use crate::client::macros::http_client;
use crate::driver::Model;
use crate::error::ProviderError;
use crate::model::ModelList;

use crate::providers::gemini::GeminiConfig;
use crate::providers::gemini::cached_content::CachedContents;
use crate::providers::gemini::completion::GenerateContent;
use crate::providers::gemini::embedding::Embeddings;
#[cfg(feature = "image")]
use crate::providers::gemini::image_generation::Images;
use crate::providers::gemini::interactions_api::{InteractionResume, Interactions};
use crate::providers::gemini::transcription::Transcriptions;

http_client!(
    /// Gemini: its [`GeminiConfig`] on a transport. Every model it builds
    /// sends through that transport.
    Gemini,
    GeminiConfig
);

impl Gemini {
    /// Gemini with `api_key` and the public base URL, on the shared reqwest
    /// client.
    #[cfg(feature = "reqwest")]
    #[cfg_attr(docsrs, doc(cfg(feature = "reqwest")))]
    pub fn new(api_key: impl Into<crate::wire::Secret>) -> Self {
        GeminiConfig::new(api_key).client()
    }

    /// Gemini from `GEMINI_API_KEY`, on the shared reqwest client.
    #[cfg(feature = "reqwest")]
    #[cfg_attr(docsrs, doc(cfg(feature = "reqwest")))]
    pub fn from_env() -> Result<Self, crate::client::env::EnvError> {
        Ok(GeminiConfig::from_env()?.client())
    }

    /// The `generateContent` / `streamGenerateContent` model for `model`.
    pub fn completion(&self, model: impl Into<String>) -> Model<GenerateContent> {
        self.model(self.config.completion(model))
    }

    /// The Interactions API model for `model`.
    pub fn interactions(&self, model: impl Into<String>) -> Model<Interactions> {
        self.model(self.config.interactions(model))
    }

    /// The `batchEmbedContents` embedding model for `model`. `ndims`
    /// defaults from the model identifier.
    pub fn embedding(&self, model: impl Into<String>, ndims: Option<usize>) -> Model<Embeddings> {
        self.model(self.config.embedding(model, ndims))
    }

    /// The audio transcription model for `model`.
    pub fn transcription(&self, model: impl Into<String>) -> Model<Transcriptions> {
        self.model(self.config.transcription(model))
    }

    /// The image-generation model for `model`.
    #[cfg(feature = "image")]
    #[cfg_attr(docsrs, doc(cfg(feature = "image")))]
    pub fn image_generation(&self, model: impl Into<String>) -> Model<Images> {
        self.model(self.config.image_generation(model))
    }

    /// Gemini's explicit context cache (`cachedContents`).
    pub fn cached_contents(&self) -> Model<CachedContents> {
        self.model(self.config.cached_contents())
    }

    /// The model that retrieves the interaction `interaction_id`, or resumes
    /// its stream. A unary call fetches the current resource; the caller
    /// controls repeated polling.
    pub fn interaction(&self, interaction_id: impl Into<String>) -> Model<InteractionResume> {
        self.model(InteractionResume::new(self.config.clone(), interaction_id))
    }

    /// [`Self::interaction`], resuming a streamed read after the last event
    /// the consumer saw.
    pub fn interaction_resumed(
        &self,
        interaction_id: impl Into<String>,
        last_event_id: Option<&str>,
    ) -> Model<InteractionResume> {
        let wire = InteractionResume::new(self.config.clone(), interaction_id);
        self.model(match last_event_id {
            Some(last_event_id) => wire.after_event(last_event_id),
            None => wire,
        })
    }

    /// The models this API key can use, every page followed.
    pub async fn list_models(&self) -> Result<ModelList, ProviderError> {
        self.model(self.config.models()).list().await
    }

    /// Check that the provider accepts the configured key. A 401 or 403
    /// reply is [`ProviderError::InvalidAuthentication`].
    pub async fn verify(&self) -> Result<(), ProviderError> {
        self.model(self.config.verify()).verify().await
    }
}