use crate::error::EncodeError;
use crate::error::ProviderError;
use crate::json_utils::Lenient;
use crate::{
model::{ModelInfo, ModelList, listing},
operation::{ModelListing, ModelPage, Verify, VerifyDecoder},
providers::internal::{wire::classify_marker_keyed_frame, with_query_pairs},
wire::{Body, Descriptor, DocumentDecoder, Encoded, Framing, Mode, Wire},
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
const MAX_PAGE_SIZE: usize = 1000;
fn model_of(entry: &Value) -> Option<ModelInfo> {
let id = entry
.str("baseModelId")
.map(str::trim)
.filter(|id| !id.is_empty());
let name = entry.str("name").map(str::trim).unwrap_or_default();
let name = name.strip_prefix("models/").unwrap_or(name);
let id = id.or((!name.is_empty()).then_some(name))?;
let limit = |key: &str| entry.u64(key).and_then(|limit| u32::try_from(limit).ok());
let mut model = ModelInfo::from_id(id.to_owned());
model.name = entry.str("displayName").map(str::to_owned);
model.description = entry.str("description").map(str::to_owned);
model.context_length = limit("inputTokenLimit");
model.max_output_tokens = limit("outputTokenLimit");
Some(model)
}
fn list_models_path(page_token: Option<&str>) -> String {
let page_size = MAX_PAGE_SIZE.to_string();
let mut pairs = vec![("pageSize", page_size.as_str())];
if let Some(page_token) = page_token {
pairs.push(("pageToken", page_token));
}
with_query_pairs("/v1beta/models", &pairs)
}
fn parse_models_page(body: &[u8], path: &str) -> Result<ModelPage, ProviderError> {
let error =
|details: &dyn std::fmt::Display| listing::parse_error("Gemini", path, details, body);
let page: Value = serde_json::from_slice(body)
.map_err(|parse| error(&format_args!("parse_error={parse}")))?;
if page.get("models").is_some_and(|models| !models.is_array()) {
return Err(error(&"parse_error=`models` is not a list"));
}
let models = page
.arr("models")
.iter()
.map(|entry| {
model_of(entry).ok_or_else(|| {
error(&"parse_error=model entry missing usable `baseModelId` and `name` values")
})
})
.collect::<Result<Vec<_>, _>>()?;
Ok(ModelPage {
models: ModelList::new(models),
next: page
.str("nextPageToken")
.filter(|token| !token.is_empty())
.map(str::to_owned),
})
}
impl super::GeminiConfig {
pub(crate) fn models(&self) -> Models {
Models::new(self.clone())
}
pub(crate) fn verify(&self) -> VerifyKey {
VerifyKey::new(self.clone())
}
}
#[cfg(test)]
mod tests;
const MODEL_PAGE_MARKERS: &[&str] = &["models", "nextPageToken"];
fn list_models_request(
provider: &super::GeminiConfig,
page_token: Option<&str>,
) -> Result<http::Request<Body>, EncodeError> {
provider
.request(http::Method::GET, &list_models_path(page_token))
.body(Body::empty())
.map_err(EncodeError::from)
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Models {
pub provider: super::GeminiConfig,
}
impl Models {
pub fn new(provider: super::GeminiConfig) -> Self {
Self { provider }
}
}
impl Wire for Models {
type Op = ModelListing;
type Payload = crate::wire::Encoded;
type Frame = crate::wire::WireFrame;
type Event = String;
type Decoder<'id> = DocumentDecoder<ModelListing, String>;
type Reassembler = crate::wire::document::Unreassembled;
fn describe(&self) -> Descriptor<'_> {
Descriptor::new(super::PROVIDER_NAME)
}
fn encode(&self, cursor: Option<String>, _mode: Mode) -> Result<Encoded, EncodeError> {
Ok(Encoded::new(
list_models_request(&self.provider, cursor.as_deref())?,
Framing::Whole,
))
}
fn decoder<'id>(&self) -> Self::Decoder<'id> {
models_decoder()
}
}
fn models_decoder() -> DocumentDecoder<ModelListing, String> {
DocumentDecoder::new(
|body| {
classify_marker_keyed_frame::<Value>(body, MODEL_PAGE_MARKERS).map(|_| body.to_owned())
},
|payload| {
parse_models_page(payload.as_bytes(), &list_models_path(None))
},
)
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct VerifyKey {
pub provider: super::GeminiConfig,
}
impl VerifyKey {
pub fn new(provider: super::GeminiConfig) -> Self {
Self { provider }
}
}
impl Wire for VerifyKey {
type Op = Verify;
type Payload = crate::wire::Encoded;
type Frame = crate::wire::WireFrame;
type Event = ();
type Decoder<'id> = VerifyDecoder;
type Reassembler = crate::wire::document::Unreassembled;
fn describe(&self) -> Descriptor<'_> {
Descriptor::new(super::PROVIDER_NAME)
}
fn encode(&self, _request: (), _mode: Mode) -> Result<Encoded, EncodeError> {
let request = self
.provider
.request(http::Method::GET, "/v1beta/models")
.body(Body::empty())?;
Ok(Encoded::new(request, Framing::Whole))
}
fn decoder<'id>(&self) -> Self::Decoder<'id> {
VerifyDecoder
}
}