Skip to main content

gproxy_protocol/wire/gemini/
embeddings.rs

1//! Gemini embedContent and batchEmbedContents wire shapes. Source: Embeddings.md.
2use super::content::Content;
3use crate::{Rest, WireRequest, WireResponse};
4use serde::{Deserialize, Serialize};
5
6#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
7#[serde(rename_all = "camelCase")]
8#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
9#[derive(gproxy_protocol_macros::DeclaredFields)]
10#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
11pub struct EmbedContentRequestBody {
12    pub content: Content,
13    #[serde(alias = "task_type")]
14    #[serde(skip_serializing_if = "Option::is_none")]
15    pub task_type: Option<GeminiTaskType>,
16    #[serde(skip_serializing_if = "Option::is_none")]
17    pub title: Option<String>,
18    #[serde(alias = "output_dimensionality")]
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub output_dimensionality: Option<i64>,
21    #[serde(alias = "embed_content_config")]
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub embed_content_config: Option<EmbedContentConfig>,
24    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
25    pub rest: Rest,
26}
27pub type EmbedContentRequest = WireRequest<EmbedContentRequestBody>;
28#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
29#[serde(rename_all = "camelCase")]
30#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
31#[derive(gproxy_protocol_macros::DeclaredFields)]
32#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
33pub struct EmbedContentResponseBody {
34    #[serde(skip_serializing_if = "Option::is_none")]
35    pub embedding: Option<ContentEmbedding>,
36    #[serde(alias = "usage_metadata")]
37    #[serde(skip_serializing_if = "Option::is_none")]
38    pub usage_metadata: Option<EmbeddingUsageMetadata>,
39    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
40    pub rest: Rest,
41}
42pub type EmbedContentResponse = WireResponse<EmbedContentResponseBody>;
43#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
44#[serde(rename_all = "camelCase")]
45#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
46#[derive(gproxy_protocol_macros::DeclaredFields)]
47#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
48pub struct EmbedContentConfig {
49    #[serde(alias = "document_ocr", skip_serializing_if = "Option::is_none")]
50    pub document_ocr: Option<bool>,
51    #[serde(
52        alias = "audio_track_extraction",
53        skip_serializing_if = "Option::is_none"
54    )]
55    pub audio_track_extraction: Option<bool>,
56    #[serde(alias = "task_type")]
57    #[serde(skip_serializing_if = "Option::is_none")]
58    pub task_type: Option<GeminiTaskType>,
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub title: Option<String>,
61    #[serde(alias = "output_dimensionality")]
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub output_dimensionality: Option<i64>,
64    #[serde(alias = "auto_truncate")]
65    #[serde(skip_serializing_if = "Option::is_none")]
66    pub auto_truncate: Option<bool>,
67    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
68    pub rest: Rest,
69}
70#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
71#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
72#[derive(gproxy_protocol_macros::DeclaredFields)]
73#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
74pub enum GeminiTaskType {
75    #[serde(rename = "TASK_TYPE_UNSPECIFIED")]
76    Unspecified,
77    #[serde(rename = "RETRIEVAL_QUERY")]
78    RetrievalQuery,
79    #[serde(rename = "RETRIEVAL_DOCUMENT")]
80    RetrievalDocument,
81    #[serde(rename = "SEMANTIC_SIMILARITY")]
82    SemanticSimilarity,
83    #[serde(rename = "CLASSIFICATION")]
84    Classification,
85    #[serde(rename = "CLUSTERING")]
86    Clustering,
87    #[serde(rename = "QUESTION_ANSWERING")]
88    QuestionAnswering,
89    #[serde(rename = "FACT_VERIFICATION")]
90    FactVerification,
91    #[serde(rename = "CODE_RETRIEVAL_QUERY")]
92    CodeRetrievalQuery,
93}
94#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
95#[serde(rename_all = "camelCase")]
96#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
97#[derive(gproxy_protocol_macros::DeclaredFields)]
98#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
99pub struct ContentEmbedding {
100    #[serde(skip_serializing_if = "Option::is_none")]
101    pub values: Option<Vec<serde_json::Number>>,
102    #[serde(skip_serializing_if = "Option::is_none")]
103    pub shape: Option<Vec<i64>>,
104    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
105    pub rest: Rest,
106}
107#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
108#[serde(rename_all = "camelCase")]
109#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
110#[derive(gproxy_protocol_macros::DeclaredFields)]
111#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
112pub struct EmbeddingUsageMetadata {
113    #[serde(alias = "prompt_token_count", skip_serializing_if = "Option::is_none")]
114    pub prompt_token_count: Option<i64>,
115    #[serde(
116        alias = "prompt_token_details",
117        skip_serializing_if = "Option::is_none"
118    )]
119    pub prompt_token_details: Option<Vec<super::count_tokens::ModalityTokenCount>>,
120    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
121    pub rest: Rest,
122}
123#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
124#[serde(rename_all = "camelCase")]
125#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
126#[derive(gproxy_protocol_macros::DeclaredFields)]
127#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
128pub struct BatchEmbedContentsRequestBody {
129    pub requests: Vec<BatchEmbedContentRequest>,
130    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
131    pub rest: Rest,
132}
133pub type BatchEmbedContentsRequest = WireRequest<BatchEmbedContentsRequestBody>;
134#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
135#[serde(rename_all = "camelCase")]
136#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
137#[derive(gproxy_protocol_macros::DeclaredFields)]
138#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
139pub struct BatchEmbedContentRequest {
140    pub model: String,
141    pub content: Content,
142    #[serde(alias = "task_type")]
143    #[serde(skip_serializing_if = "Option::is_none")]
144    pub task_type: Option<GeminiTaskType>,
145    #[serde(skip_serializing_if = "Option::is_none")]
146    pub title: Option<String>,
147    #[serde(alias = "output_dimensionality")]
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub output_dimensionality: Option<i64>,
150    #[serde(alias = "embed_content_config")]
151    #[serde(skip_serializing_if = "Option::is_none")]
152    pub embed_content_config: Option<EmbedContentConfig>,
153    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
154    pub rest: Rest,
155}
156#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, gproxy_protocol_macros::WireBuilder)]
157#[serde(rename_all = "camelCase")]
158#[cfg_attr(not(feature = "exhaustive"), non_exhaustive)]
159#[derive(gproxy_protocol_macros::DeclaredFields)]
160#[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
161pub struct BatchEmbedContentsResponseBody {
162    #[serde(skip_serializing_if = "Option::is_none")]
163    pub embeddings: Option<Vec<ContentEmbedding>>,
164    #[serde(alias = "usage_metadata")]
165    #[serde(skip_serializing_if = "Option::is_none")]
166    pub usage_metadata: Option<EmbeddingUsageMetadata>,
167    #[serde(default, flatten, skip_serializing_if = "serde_json::Map::is_empty")]
168    pub rest: Rest,
169}
170pub type BatchEmbedContentsResponse = WireResponse<BatchEmbedContentsResponseBody>;