i/Aether
1
0
Fork 0
mirror of https://github.com/fawney19/Aether.git synced 2026-09-03 01:40:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge PR #488 and #489

Browse Source
This commit is contained in:
fawney19
2026-05-19 03:16:35 +08:00
parent cd1aa92931 be2e8e594c
commit 69af74b1e0
77 changed files with 4051 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
crates/aether-ai-formats/src/api.rs
View File

@@ -16,18 +16,21 @@ pub use crate::contracts::{
GEMINI_CHAT_SYNC_SUCCESS_REPORT_KIND, GEMINI_CLI_STREAM_PLAN_KIND,
GEMINI_CLI_STREAM_SUCCESS_REPORT_KIND, GEMINI_CLI_SYNC_ERROR_REPORT_KIND,
GEMINI_CLI_SYNC_FINALIZE_REPORT_KIND, GEMINI_CLI_SYNC_PLAN_KIND,
GEMINI_CLI_SYNC_SUCCESS_REPORT_KIND, GEMINI_FILES_DELETE_PLAN_KIND,
GEMINI_CLI_SYNC_SUCCESS_REPORT_KIND, GEMINI_EMBEDDING_SYNC_PLAN_KIND,
GEMINI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND, GEMINI_FILES_DELETE_PLAN_KIND,
GEMINI_FILES_DOWNLOAD_PLAN_KIND, GEMINI_FILES_GET_PLAN_KIND, GEMINI_FILES_LIST_PLAN_KIND,
GEMINI_FILES_UPLOAD_PLAN_KIND, GEMINI_VIDEO_CANCEL_SYNC_PLAN_KIND,
GEMINI_VIDEO_CREATE_SYNC_FINALIZE_REPORT_KIND, GEMINI_VIDEO_CREATE_SYNC_PLAN_KIND,
OPENAI_CHAT_STREAM_PLAN_KIND, OPENAI_CHAT_STREAM_SUCCESS_REPORT_KIND,
OPENAI_CHAT_SYNC_ERROR_REPORT_KIND, OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND,
OPENAI_CHAT_SYNC_PLAN_KIND, OPENAI_CHAT_SYNC_SUCCESS_REPORT_KIND,
OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND,
OPENAI_IMAGE_STREAM_SUCCESS_REPORT_KIND, OPENAI_IMAGE_SYNC_ERROR_REPORT_KIND,
OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND,
OPENAI_IMAGE_SYNC_SUCCESS_REPORT_KIND, OPENAI_RERANK_SYNC_PLAN_KIND,
OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_SUCCESS_REPORT_KIND,
OPENAI_EMBEDDING_SYNC_ERROR_REPORT_KIND, OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND,
OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND,
OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_STREAM_SUCCESS_REPORT_KIND,
OPENAI_IMAGE_SYNC_ERROR_REPORT_KIND, OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND,
OPENAI_IMAGE_SYNC_PLAN_KIND, OPENAI_IMAGE_SYNC_SUCCESS_REPORT_KIND,
OPENAI_RERANK_SYNC_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND,
OPENAI_RESPONSES_COMPACT_STREAM_SUCCESS_REPORT_KIND,
OPENAI_RESPONSES_COMPACT_SYNC_ERROR_REPORT_KIND,
OPENAI_RESPONSES_COMPACT_SYNC_FINALIZE_REPORT_KIND, OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND,
OPENAI_RESPONSES_COMPACT_SYNC_SUCCESS_REPORT_KIND, OPENAI_RESPONSES_STREAM_PLAN_KIND,
@@ -139,18 +142,22 @@ pub use crate::formats::{
resolve_stream_spec as resolve_gemini_stream_spec,
resolve_sync_spec as resolve_gemini_sync_spec,
},
openai::responses::{
codex::{
apply_codex_openai_responses_chat_body_edits,
apply_codex_openai_responses_special_body_edits,
apply_codex_openai_responses_special_headers,
apply_openai_responses_compact_special_body_edits, CODEX_OPENAI_IMAGE_DEFAULT_MODEL,
CODEX_OPENAI_IMAGE_DEFAULT_OUTPUT_FORMAT, CODEX_OPENAI_IMAGE_DEFAULT_VARIATION_MODEL,
CODEX_OPENAI_IMAGE_DEFAULT_VARIATION_PROMPT, CODEX_OPENAI_IMAGE_INTERNAL_MODEL,
},
spec::{
resolve_stream_spec as resolve_openai_responses_stream_spec,
resolve_sync_spec as resolve_openai_responses_sync_spec, LocalOpenAiResponsesSpec,
openai::{
embedding::spec::resolve_sync_spec as resolve_openai_embedding_sync_spec,
responses::{
codex::{
apply_codex_openai_responses_chat_body_edits,
apply_codex_openai_responses_special_body_edits,
apply_codex_openai_responses_special_headers,
apply_openai_responses_compact_special_body_edits,
CODEX_OPENAI_IMAGE_DEFAULT_MODEL, CODEX_OPENAI_IMAGE_DEFAULT_OUTPUT_FORMAT,
CODEX_OPENAI_IMAGE_DEFAULT_VARIATION_MODEL,
CODEX_OPENAI_IMAGE_DEFAULT_VARIATION_PROMPT, CODEX_OPENAI_IMAGE_INTERNAL_MODEL,
},
spec::{
resolve_stream_spec as resolve_openai_responses_stream_spec,
resolve_sync_spec as resolve_openai_responses_sync_spec, LocalOpenAiResponsesSpec,
},
},
},
shared::{

14
crates/aether-ai-formats/src/contracts/mod.rs
View File

@@ -14,9 +14,9 @@ pub use plan_kinds::{
is_openai_responses_stream_plan_kind, is_openai_responses_sync_plan_kind,
CLAUDE_CHAT_STREAM_PLAN_KIND, CLAUDE_CHAT_SYNC_PLAN_KIND, CLAUDE_CLI_STREAM_PLAN_KIND,
CLAUDE_CLI_SYNC_PLAN_KIND, GEMINI_CHAT_STREAM_PLAN_KIND, GEMINI_CHAT_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, GEMINI_FILES_DELETE_PLAN_KIND,
GEMINI_FILES_DOWNLOAD_PLAN_KIND, GEMINI_FILES_GET_PLAN_KIND, GEMINI_FILES_LIST_PLAN_KIND,
GEMINI_FILES_UPLOAD_PLAN_KIND, GEMINI_VIDEO_CANCEL_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, GEMINI_EMBEDDING_SYNC_PLAN_KIND,
GEMINI_FILES_DELETE_PLAN_KIND, GEMINI_FILES_DOWNLOAD_PLAN_KIND, GEMINI_FILES_GET_PLAN_KIND,
GEMINI_FILES_LIST_PLAN_KIND, GEMINI_FILES_UPLOAD_PLAN_KIND, GEMINI_VIDEO_CANCEL_SYNC_PLAN_KIND,
GEMINI_VIDEO_CREATE_SYNC_PLAN_KIND, OPENAI_CHAT_STREAM_PLAN_KIND, OPENAI_CHAT_SYNC_PLAN_KIND,
OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND,
OPENAI_RERANK_SYNC_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND,
@@ -36,9 +36,11 @@ pub use report_kinds::{
GEMINI_CHAT_SYNC_ERROR_REPORT_KIND, GEMINI_CHAT_SYNC_FINALIZE_REPORT_KIND,
GEMINI_CHAT_SYNC_SUCCESS_REPORT_KIND, GEMINI_CLI_STREAM_SUCCESS_REPORT_KIND,
GEMINI_CLI_SYNC_ERROR_REPORT_KIND, GEMINI_CLI_SYNC_FINALIZE_REPORT_KIND,
GEMINI_CLI_SYNC_SUCCESS_REPORT_KIND, GEMINI_VIDEO_CREATE_SYNC_FINALIZE_REPORT_KIND,
OPENAI_CHAT_STREAM_SUCCESS_REPORT_KIND, OPENAI_CHAT_SYNC_ERROR_REPORT_KIND,
OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND, OPENAI_CHAT_SYNC_SUCCESS_REPORT_KIND,
GEMINI_CLI_SYNC_SUCCESS_REPORT_KIND, GEMINI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND,
GEMINI_VIDEO_CREATE_SYNC_FINALIZE_REPORT_KIND, OPENAI_CHAT_STREAM_SUCCESS_REPORT_KIND,
OPENAI_CHAT_SYNC_ERROR_REPORT_KIND, OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND,
OPENAI_CHAT_SYNC_SUCCESS_REPORT_KIND, OPENAI_EMBEDDING_SYNC_ERROR_REPORT_KIND,
OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND, OPENAI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND,
OPENAI_IMAGE_STREAM_SUCCESS_REPORT_KIND, OPENAI_IMAGE_SYNC_ERROR_REPORT_KIND,
OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND, OPENAI_IMAGE_SYNC_SUCCESS_REPORT_KIND,
OPENAI_RESPONSES_COMPACT_STREAM_SUCCESS_REPORT_KIND,

1
crates/aether-ai-formats/src/contracts/plan_kinds.rs
View File

@@ -22,6 +22,7 @@ pub const OPENAI_VIDEO_CREATE_SYNC_PLAN_KIND: &str = "openai_video_create_sync";
pub const OPENAI_CHAT_SYNC_PLAN_KIND: &str = "openai_chat_sync";
pub const OPENAI_EMBEDDING_SYNC_PLAN_KIND: &str = "openai_embedding_sync";
pub const OPENAI_RERANK_SYNC_PLAN_KIND: &str = "openai_rerank_sync";
pub const GEMINI_EMBEDDING_SYNC_PLAN_KIND: &str = "gemini_embedding_sync";
pub const OPENAI_RESPONSES_SYNC_PLAN_KIND: &str = "openai_responses_sync";
pub const OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND: &str = "openai_responses_compact_sync";
pub const CLAUDE_CHAT_SYNC_PLAN_KIND: &str = "claude_chat_sync";

16
crates/aether-ai-formats/src/contracts/report_kinds.rs
View File

@@ -1,8 +1,8 @@
use crate::contracts::{
CLAUDE_CHAT_SYNC_PLAN_KIND, CLAUDE_CLI_SYNC_PLAN_KIND, GEMINI_CHAT_SYNC_PLAN_KIND,
GEMINI_CLI_SYNC_PLAN_KIND, OPENAI_CHAT_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND,
OPENAI_IMAGE_SYNC_PLAN_KIND, OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND,
OPENAI_RESPONSES_SYNC_PLAN_KIND,
GEMINI_CLI_SYNC_PLAN_KIND, OPENAI_CHAT_SYNC_PLAN_KIND, OPENAI_EMBEDDING_SYNC_PLAN_KIND,
OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND,
OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND, OPENAI_RESPONSES_SYNC_PLAN_KIND,
};
pub const OPENAI_CHAT_SYNC_FINALIZE_REPORT_KIND: &str = "openai_chat_sync_finalize";
@@ -11,6 +11,7 @@ pub const GEMINI_CHAT_SYNC_FINALIZE_REPORT_KIND: &str = "gemini_chat_sync_finali
pub const OPENAI_RESPONSES_SYNC_FINALIZE_REPORT_KIND: &str = "openai_responses_sync_finalize";
pub const OPENAI_RESPONSES_COMPACT_SYNC_FINALIZE_REPORT_KIND: &str =
"openai_responses_compact_sync_finalize";
pub const OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND: &str = "openai_embedding_sync_finalize";
pub const OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND: &str = "openai_image_sync_finalize";
pub const CLAUDE_CLI_SYNC_FINALIZE_REPORT_KIND: &str = "claude_cli_sync_finalize";
pub const GEMINI_CLI_SYNC_FINALIZE_REPORT_KIND: &str = "gemini_cli_sync_finalize";
@@ -25,6 +26,8 @@ pub const GEMINI_CHAT_SYNC_SUCCESS_REPORT_KIND: &str = "gemini_chat_sync_success
pub const OPENAI_RESPONSES_SYNC_SUCCESS_REPORT_KIND: &str = "openai_responses_sync_success";
pub const OPENAI_RESPONSES_COMPACT_SYNC_SUCCESS_REPORT_KIND: &str =
"openai_responses_compact_sync_success";
pub const OPENAI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND: &str = "openai_embedding_sync_success";
pub const GEMINI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND: &str = "gemini_embedding_sync_success";
pub const OPENAI_IMAGE_SYNC_SUCCESS_REPORT_KIND: &str = "openai_image_sync_success";
pub const CLAUDE_CLI_SYNC_SUCCESS_REPORT_KIND: &str = "claude_cli_sync_success";
pub const GEMINI_CLI_SYNC_SUCCESS_REPORT_KIND: &str = "gemini_cli_sync_success";
@@ -45,6 +48,7 @@ pub const GEMINI_CHAT_SYNC_ERROR_REPORT_KIND: &str = "gemini_chat_sync_error";
pub const OPENAI_RESPONSES_SYNC_ERROR_REPORT_KIND: &str = "openai_responses_sync_error";
pub const OPENAI_RESPONSES_COMPACT_SYNC_ERROR_REPORT_KIND: &str =
"openai_responses_compact_sync_error";
pub const OPENAI_EMBEDDING_SYNC_ERROR_REPORT_KIND: &str = "openai_embedding_sync_error";
pub const OPENAI_IMAGE_SYNC_ERROR_REPORT_KIND: &str = "openai_image_sync_error";
pub const CLAUDE_CLI_SYNC_ERROR_REPORT_KIND: &str = "claude_cli_sync_error";
pub const GEMINI_CLI_SYNC_ERROR_REPORT_KIND: &str = "gemini_cli_sync_error";
@@ -58,6 +62,7 @@ pub fn implicit_sync_finalize_report_kind(plan_kind: &str) -> Option<&'static st
OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND => {
Some(OPENAI_RESPONSES_COMPACT_SYNC_FINALIZE_REPORT_KIND)
}
OPENAI_EMBEDDING_SYNC_PLAN_KIND => Some(OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND),
OPENAI_IMAGE_SYNC_PLAN_KIND => Some(OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND),
CLAUDE_CLI_SYNC_PLAN_KIND => Some(CLAUDE_CLI_SYNC_FINALIZE_REPORT_KIND),
GEMINI_CLI_SYNC_PLAN_KIND => Some(GEMINI_CLI_SYNC_FINALIZE_REPORT_KIND),
@@ -72,6 +77,7 @@ pub fn core_error_default_client_api_format(report_kind: &str) -> Option<&'stati
GEMINI_CHAT_SYNC_FINALIZE_REPORT_KIND => Some("gemini:generate_content"),
OPENAI_RESPONSES_SYNC_FINALIZE_REPORT_KIND => Some("openai:responses"),
OPENAI_RESPONSES_COMPACT_SYNC_FINALIZE_REPORT_KIND => Some("openai:responses:compact"),
OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND => Some("openai:embedding"),
LEGACY_OPENAI_CLI_SYNC_FINALIZE_REPORT_KIND => Some("openai:responses"),
LEGACY_OPENAI_COMPACT_SYNC_FINALIZE_REPORT_KIND => Some("openai:responses:compact"),
OPENAI_IMAGE_SYNC_FINALIZE_REPORT_KIND => Some("openai:image"),
@@ -90,6 +96,7 @@ pub fn core_error_background_report_kind(report_kind: &str) -> Option<&'static s
OPENAI_RESPONSES_COMPACT_SYNC_FINALIZE_REPORT_KIND => {
Some(OPENAI_RESPONSES_COMPACT_SYNC_ERROR_REPORT_KIND)
}
OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND => Some(OPENAI_EMBEDDING_SYNC_ERROR_REPORT_KIND),
LEGACY_OPENAI_CLI_SYNC_FINALIZE_REPORT_KIND => {
Some(OPENAI_RESPONSES_SYNC_ERROR_REPORT_KIND)
}
@@ -115,6 +122,9 @@ pub fn core_success_background_report_kind(report_kind: &str) -> Option<&'static
OPENAI_RESPONSES_COMPACT_SYNC_FINALIZE_REPORT_KIND => {
Some(OPENAI_RESPONSES_COMPACT_SYNC_SUCCESS_REPORT_KIND)
}
OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND => {
Some(OPENAI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND)
}
LEGACY_OPENAI_CLI_SYNC_FINALIZE_REPORT_KIND => {
Some(OPENAI_RESPONSES_SYNC_SUCCESS_REPORT_KIND)
}

1
crates/aether-ai-formats/src/formats/gemini/embedding/mod.rs
View File

@@ -1 +1,2 @@
pub mod request;
pub mod response;

186
crates/aether-ai-formats/src/formats/gemini/embedding/request.rs
View File

@@ -1,9 +1,8 @@
use serde_json::json;
use serde_json::Value;
use serde_json::{json, Map, Value};
use crate::formats::context::FormatContext;
use crate::formats::openai::embedding::request::mapped_embedding_model;
use crate::protocol::canonical::CanonicalRequest;
use crate::protocol::canonical::{CanonicalEmbeddingRequest, CanonicalRequest};
pub fn to(request: &CanonicalRequest, ctx: &FormatContext) -> Option<Value> {
let embedding = request.embedding.as_ref()?;
@@ -13,22 +12,169 @@ pub fn to(request: &CanonicalRequest, ctx: &FormatContext) -> Option<Value> {
}
let model = mapped_embedding_model(request, ctx.mapped_model_or(request.model.as_str()));
if items.len() == 1 {
return Some(json!({
"model": model,
"content": {
"parts": [{"text": items[0]}]
}
}));
return Some(Value::Object(gemini_embedding_request_object(
&model, items[0], embedding,
)));
}
let model_resource = gemini_embedding_model_resource_name(&model);
let requests = items
.into_iter()
.map(|text| {
Value::Object(gemini_embedding_request_object(
&model_resource,
text,
embedding,
))
})
.collect::<Vec<_>>();
Some(json!({ "requests": requests }))
}
fn gemini_embedding_request_object(
model: &str,
text: &str,
embedding: &CanonicalEmbeddingRequest,
) -> Map<String, Value> {
let mut object = Map::new();
object.insert("model".to_string(), Value::String(model.to_string()));
object.insert(
"content".to_string(),
json!({
"parts": [{"text": text}]
}),
);
insert_gemini_embedding_options(&mut object, embedding);
object
}
fn gemini_embedding_model_resource_name(model: &str) -> String {
let trimmed = model.trim();
if trimmed.starts_with("models/") {
trimmed.to_string()
} else {
format!("models/{trimmed}")
}
}
fn insert_gemini_embedding_options(
object: &mut Map<String, Value>,
embedding: &CanonicalEmbeddingRequest,
) {
if let Some(dimensions) = embedding.dimensions {
object.insert("outputDimensionality".to_string(), Value::from(dimensions));
}
if let Some(task_type) = embedding
.task
.as_deref()
.and_then(normalize_gemini_embedding_task_type)
{
object.insert("taskType".to_string(), Value::String(task_type));
}
}
fn normalize_gemini_embedding_task_type(value: &str) -> Option<String> {
let normalized = value.trim();
if normalized.is_empty() {
return None;
}
let key = normalized.replace(['-', ' '], "_").to_ascii_uppercase();
let task_type = match key.as_str() {
"QUERY" | "RETRIEVAL_QUERY" => "RETRIEVAL_QUERY",
"DOCUMENT" | "RETRIEVAL_DOCUMENT" => "RETRIEVAL_DOCUMENT",
"TEXT_MATCHING" | "SEMANTIC_SIMILARITY" => "SEMANTIC_SIMILARITY",
"CLASSIFICATION" => "CLASSIFICATION",
"CLUSTERING" => "CLUSTERING",
"QUESTION_ANSWERING" => "QUESTION_ANSWERING",
"FACT_VERIFICATION" => "FACT_VERIFICATION",
"CODE_RETRIEVAL_QUERY" => "CODE_RETRIEVAL_QUERY",
_ => key.as_str(),
};
Some(task_type.to_string())
}
#[cfg(test)]
mod tests {
use std::collections::BTreeMap;
use serde_json::json;
use super::to;
use crate::formats::context::FormatContext;
use crate::protocol::canonical::{
CanonicalEmbeddingInput, CanonicalEmbeddingRequest, CanonicalRequest,
};
fn canonical_embedding(input: CanonicalEmbeddingInput) -> CanonicalRequest {
CanonicalRequest {
model: "text-embedding-3-small".to_string(),
embedding: Some(CanonicalEmbeddingRequest {
input,
encoding_format: None,
dimensions: None,
task: None,
user: None,
extensions: BTreeMap::new(),
}),
..CanonicalRequest::default()
}
}
#[test]
fn single_string_array_item_uses_single_embed_content_body() {
let request = canonical_embedding(CanonicalEmbeddingInput::StringArray(vec![
"hello".to_string()
]));
let body = to(
&request,
&FormatContext::default().with_mapped_model("gemini-embedding-2-preview"),
)
.expect("gemini embedding request");
assert_eq!(body["model"], "gemini-embedding-2-preview");
assert_eq!(body["content"]["parts"][0]["text"], "hello");
assert!(body.get("requests").is_none());
}
#[test]
fn multiple_string_items_use_gemini_batch_request_body() {
let request = canonical_embedding(CanonicalEmbeddingInput::StringArray(vec![
"alpha".to_string(),
"beta".to_string(),
]));
let body = to(
&request,
&FormatContext::default().with_mapped_model("gemini-embedding-2-preview"),
)
.expect("gemini embedding request");
assert!(body.get("model").is_none());
assert_eq!(body["requests"].as_array().map(Vec::len), Some(2));
assert_eq!(
body["requests"][0]["model"],
"models/gemini-embedding-2-preview"
);
assert_eq!(body["requests"][0]["content"]["parts"][0]["text"], "alpha");
assert_eq!(
body["requests"][1]["model"],
"models/gemini-embedding-2-preview"
);
assert_eq!(body["requests"][1]["content"]["parts"][0]["text"], "beta");
}
#[test]
fn explicit_embedding_options_are_preserved_without_defaults() {
let mut request = canonical_embedding(CanonicalEmbeddingInput::String("query".to_string()));
let embedding = request.embedding.as_mut().expect("embedding request");
embedding.dimensions = Some(768);
embedding.task = Some("retrieval_query".to_string());
let body = to(
&request,
&FormatContext::default().with_mapped_model("gemini-embedding-2-preview"),
)
.expect("gemini embedding request");
assert_eq!(body["outputDimensionality"], json!(768));
assert_eq!(body["taskType"], "RETRIEVAL_QUERY");
}
Some(json!({
"model": model,
"requests": items.into_iter().map(|text| {
json!({
"model": model,
"content": {
"parts": [{"text": text}]
}
})
}).collect::<Vec<_>>()
}))
}

158
crates/aether-ai-formats/src/formats/gemini/embedding/response.rs Normal file
View File

@@ -0,0 +1,158 @@
use serde_json::Value;
use crate::formats::openai::embedding::request::namespace_extensions;
use crate::protocol::canonical::{
gemini_usage_to_canonical, CanonicalEmbedding, CanonicalEmbeddingResponse,
};
pub fn from(body_json: &Value) -> Option<CanonicalEmbeddingResponse> {
let body = body_json.as_object()?;
if body.contains_key("error") {
return None;
}
let embeddings = if let Some(raw_embeddings) = vertex_predict_embeddings(body) {
raw_embeddings
} else if let Some(values) = body
.get("embedding")
.and_then(Value::as_object)
.and_then(|embedding| embedding.get("values"))
.and_then(Value::as_array)
{
vec![CanonicalEmbedding {
index: 0,
embedding: embedding_values(values)?,
extensions: Default::default(),
}]
} else {
let raw_embeddings = body.get("embeddings")?.as_array()?;
raw_embeddings
.iter()
.enumerate()
.map(|(index, item)| {
let item_object = item.as_object()?;
let values = item_object.get("values")?.as_array()?;
Some(CanonicalEmbedding {
index,
embedding: embedding_values(values)?,
extensions: namespace_extensions("gemini", item_object, &["values"]),
})
})
.collect::<Option<Vec<_>>>()?
};
if embeddings.is_empty()
|| embeddings
.iter()
.any(|embedding| embedding.embedding.is_empty())
{
return None;
}
Some(CanonicalEmbeddingResponse {
id: body
.get("id")
.or_else(|| body.get("responseId"))
.and_then(Value::as_str)
.unwrap_or("embd-gemini-unknown")
.to_string(),
model: body
.get("model")
.or_else(|| body.get("modelVersion"))
.or_else(|| body.get("deployedModelId"))
.and_then(Value::as_str)
.unwrap_or("unknown")
.to_string(),
embeddings,
usage: gemini_usage_to_canonical(body.get("usageMetadata")),
extensions: namespace_extensions(
"gemini",
body,
&[
"id",
"responseId",
"model",
"modelVersion",
"deployedModelId",
"embedding",
"embeddings",
"predictions",
"usageMetadata",
],
),
})
}
fn vertex_predict_embeddings(
body: &serde_json::Map<String, Value>,
) -> Option<Vec<CanonicalEmbedding>> {
let predictions = body.get("predictions")?.as_array()?;
predictions
.iter()
.enumerate()
.map(|(index, item)| {
let item_object = item.as_object()?;
let embedding_object = item_object.get("embeddings")?.as_object()?;
let values = embedding_object.get("values")?.as_array()?;
Some(CanonicalEmbedding {
index,
embedding: embedding_values(values)?,
extensions: namespace_extensions("vertex", item_object, &["embeddings"]),
})
})
.collect()
}
fn embedding_values(values: &[Value]) -> Option<Vec<f64>> {
values.iter().map(Value::as_f64).collect()
}
#[cfg(test)]
mod tests {
use serde_json::json;
use super::from;
#[test]
fn parses_gemini_single_embedding_response() {
let body = json!({
"embedding": {"values": [0.1, 0.2, 0.3]},
"usageMetadata": {
"promptTokenCount": 4,
"totalTokenCount": 4
}
});
let parsed = from(&body).expect("response should parse");
assert_eq!(parsed.model, "unknown");
assert_eq!(parsed.embeddings[0].embedding, vec![0.1, 0.2, 0.3]);
let usage = parsed.usage.expect("usage should parse");
assert_eq!(usage.input_tokens, 4);
assert_eq!(usage.total_tokens, 4);
}
#[test]
fn parses_vertex_predict_embedding_response() {
let body = json!({
"predictions": [
{
"embeddings": {
"values": [0.1, 0.2, 0.3]
}
},
{
"embeddings": {
"values": [0.4, 0.5, 0.6]
}
}
],
"deployedModelId": "gemini-embedding-2"
});
let parsed = from(&body).expect("response should parse");
assert_eq!(parsed.model, "gemini-embedding-2");
assert_eq!(parsed.embeddings[0].embedding, vec![0.1, 0.2, 0.3]);
assert_eq!(parsed.embeddings[1].embedding, vec![0.4, 0.5, 0.6]);
}
}

85
crates/aether-ai-formats/src/formats/gemini/generate_content/response.rs
View File

@@ -66,6 +66,10 @@ pub fn from_raw(body_json: &Value) -> Option<CanonicalResponse> {
extensions: Default::default(),
});
}
outputs.retain(gemini_response_output_has_visible_content);
if outputs.is_empty() {
return None;
}
let content = outputs
.first()
.map(|output| output.content.clone())
@@ -108,6 +112,18 @@ pub fn from_raw(body_json: &Value) -> Option<CanonicalResponse> {
Some(canonical)
}
fn gemini_response_output_has_visible_content(output: &CanonicalResponseOutput) -> bool {
output.content.iter().any(|block| match block {
CanonicalContentBlock::Text { text, .. } => !text.trim().is_empty(),
CanonicalContentBlock::ToolUse { .. }
| CanonicalContentBlock::ToolResult { .. }
| CanonicalContentBlock::Image { .. }
| CanonicalContentBlock::File { .. }
| CanonicalContentBlock::Audio { .. } => true,
CanonicalContentBlock::Thinking { .. } | CanonicalContentBlock::Unknown { .. } => false,
})
}
pub fn to_raw(canonical: &CanonicalResponse, report_context: &Value) -> Option<Value> {
let mut response = canonical_to_gemini_response(canonical, report_context)?;
if let Some(object) = response.as_object_mut() {
@@ -353,3 +369,72 @@ fn canonical_usage_to_gemini_usage_metadata(usage: &CanonicalUsage) -> Value {
}
Value::Object(out)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::CanonicalContentBlock;
#[test]
fn gemini_response_without_visible_parts_is_not_success() {
let body = json!({
"candidates": [{
"content": {"role": "model"},
"finishReason": "MAX_TOKENS"
}],
"usageMetadata": {
"promptTokenCount": 8,
"candidatesTokenCount": 1,
"thoughtsTokenCount": 25,
"totalTokenCount": 34
},
"modelVersion": "gemini-3-flash-preview",
"responseId": "resp-empty"
});
assert!(from_raw(&body).is_none());
}
#[test]
fn gemini_response_with_only_thought_parts_is_not_success() {
let body = json!({
"candidates": [{
"content": {
"role": "model",
"parts": [{"text": "hidden plan", "thought": true}]
},
"finishReason": "MAX_TOKENS"
}],
"modelVersion": "gemini-3-flash-preview",
"responseId": "resp-thought-only"
});
assert!(from_raw(&body).is_none());
}
#[test]
fn gemini_response_with_function_call_is_visible_output() {
let body = json!({
"candidates": [{
"content": {
"role": "model",
"parts": [{
"functionCall": {
"name": "lookup",
"args": {"query": "weather"}
}
}]
},
"finishReason": "STOP"
}],
"modelVersion": "gemini-3-flash-preview",
"responseId": "resp-tool"
});
let canonical = from_raw(&body).expect("function call should be visible output");
assert!(matches!(
canonical.content.first(),
Some(CanonicalContentBlock::ToolUse { name, .. }) if name == "lookup"
));
}
}

1
crates/aether-ai-formats/src/formats/openai/embedding/mod.rs
View File

@@ -1,2 +1,3 @@
pub mod request;
pub mod response;
pub mod spec;

35
crates/aether-ai-formats/src/formats/openai/embedding/spec.rs Normal file
View File

@@ -0,0 +1,35 @@
use crate::contracts::{
OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND, OPENAI_EMBEDDING_SYNC_PLAN_KIND,
};
use crate::formats::shared::family::{
LocalStandardSourceFamily, LocalStandardSourceMode, LocalStandardSpec,
};
pub fn resolve_sync_spec(plan_kind: &str) -> Option<LocalStandardSpec> {
match plan_kind {
OPENAI_EMBEDDING_SYNC_PLAN_KIND => Some(LocalStandardSpec {
api_format: "openai:embedding",
decision_kind: OPENAI_EMBEDDING_SYNC_PLAN_KIND,
report_kind: OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND,
family: LocalStandardSourceFamily::Standard,
mode: LocalStandardSourceMode::Embedding,
require_streaming: false,
}),
_ => None,
}
}
#[cfg(test)]
mod tests {
use super::resolve_sync_spec;
use crate::formats::shared::family::LocalStandardSourceMode;
#[test]
fn resolves_openai_embedding_sync_standard_spec() {
let spec = resolve_sync_spec("openai_embedding_sync").expect("spec");
assert_eq!(spec.api_format, "openai:embedding");
assert_eq!(spec.report_kind, "openai_embedding_sync_finalize");
assert_eq!(spec.mode, LocalStandardSourceMode::Embedding);
assert!(!spec.require_streaming);
}
}

7
crates/aether-ai-formats/src/formats/registry.rs
View File

@@ -228,11 +228,16 @@ mod tests {
&FormatContext::default().with_mapped_model("gemini-embedding-001"),
)
.expect("gemini embedding conversion should succeed");
assert_eq!(gemini["model"], "gemini-embedding-001");
assert!(gemini.get("model").is_none());
assert_eq!(
gemini["requests"][0]["model"],
"models/gemini-embedding-001"
);
assert_eq!(
gemini["requests"][0]["content"]["parts"][0]["text"],
"alpha"
);
assert_eq!(gemini["requests"][0]["outputDimensionality"], 2);
assert!(gemini.get("messages").is_none());
let doubao = convert_request(

2
crates/aether-ai-formats/src/formats/shared/error_body.rs
View File

@@ -38,7 +38,7 @@ pub fn build_core_error_body_for_client_format(
error_object.insert("message".to_string(), Value::String(message.to_string()));
match aether_ai_formats::normalize_api_format_alias(client_api_format).as_str() {
"openai:chat" | "openai:responses" | "openai:responses:compact" => {
"openai:chat" | "openai:responses" | "openai:responses:compact" | "openai:embedding" => {
error_object.insert(
"type".to_string(),
Value::String(map_local_sync_error_kind_to_openai_type(kind).to_string()),

19
crates/aether-ai-formats/src/formats/shared/passthrough.rs
View File

@@ -1,7 +1,8 @@
use crate::contracts::{
CLAUDE_CHAT_STREAM_PLAN_KIND, CLAUDE_CHAT_SYNC_PLAN_KIND, CLAUDE_CLI_STREAM_PLAN_KIND,
CLAUDE_CLI_SYNC_PLAN_KIND, GEMINI_CHAT_STREAM_PLAN_KIND, GEMINI_CHAT_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, OPENAI_EMBEDDING_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, GEMINI_EMBEDDING_SYNC_PLAN_KIND,
GEMINI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND, OPENAI_EMBEDDING_SYNC_PLAN_KIND,
OPENAI_RERANK_SYNC_PLAN_KIND,
};
@@ -50,6 +51,13 @@ pub fn resolve_sync_spec(plan_kind: &str) -> Option<LocalSameFormatProviderSpec>
family: LocalSameFormatProviderFamily::Gemini,
require_streaming: false,
}),
GEMINI_EMBEDDING_SYNC_PLAN_KIND => Some(LocalSameFormatProviderSpec {
api_format: "gemini:embedding",
decision_kind: GEMINI_EMBEDDING_SYNC_PLAN_KIND,
report_kind: GEMINI_EMBEDDING_SYNC_SUCCESS_REPORT_KIND,
family: LocalSameFormatProviderFamily::Gemini,
require_streaming: false,
}),
OPENAI_EMBEDDING_SYNC_PLAN_KIND => Some(LocalSameFormatProviderSpec {
api_format: "openai:embedding",
decision_kind: OPENAI_EMBEDDING_SYNC_PLAN_KIND,
@@ -130,6 +138,15 @@ mod tests {
assert!(!spec.require_streaming);
}
#[test]
fn resolves_gemini_embedding_sync_same_format_spec() {
let spec = resolve_sync_spec("gemini_embedding_sync").expect("spec");
assert_eq!(spec.api_format, "gemini:embedding");
assert_eq!(spec.report_kind, "gemini_embedding_sync_success");
assert_eq!(spec.family, super::LocalSameFormatProviderFamily::Gemini);
assert!(!spec.require_streaming);
}
#[test]
fn resolves_openai_rerank_sync_same_format_spec() {
let spec = resolve_sync_spec("openai_rerank_sync").expect("spec");

50
crates/aether-ai-formats/src/formats/shared/routing.rs
View File

@@ -4,9 +4,9 @@ use url::form_urlencoded;
use crate::contracts::{
CLAUDE_CHAT_STREAM_PLAN_KIND, CLAUDE_CHAT_SYNC_PLAN_KIND, CLAUDE_CLI_STREAM_PLAN_KIND,
CLAUDE_CLI_SYNC_PLAN_KIND, GEMINI_CHAT_STREAM_PLAN_KIND, GEMINI_CHAT_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, GEMINI_FILES_DELETE_PLAN_KIND,
GEMINI_FILES_DOWNLOAD_PLAN_KIND, GEMINI_FILES_GET_PLAN_KIND, GEMINI_FILES_LIST_PLAN_KIND,
GEMINI_FILES_UPLOAD_PLAN_KIND, GEMINI_VIDEO_CANCEL_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, GEMINI_EMBEDDING_SYNC_PLAN_KIND,
GEMINI_FILES_DELETE_PLAN_KIND, GEMINI_FILES_DOWNLOAD_PLAN_KIND, GEMINI_FILES_GET_PLAN_KIND,
GEMINI_FILES_LIST_PLAN_KIND, GEMINI_FILES_UPLOAD_PLAN_KIND, GEMINI_VIDEO_CANCEL_SYNC_PLAN_KIND,
GEMINI_VIDEO_CREATE_SYNC_PLAN_KIND, OPENAI_CHAT_STREAM_PLAN_KIND, OPENAI_CHAT_SYNC_PLAN_KIND,
OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND,
OPENAI_RERANK_SYNC_PLAN_KIND, OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND,
@@ -166,6 +166,14 @@ pub fn resolve_execution_runtime_sync_plan_kind(
return Some(GEMINI_VIDEO_CREATE_SYNC_PLAN_KIND);
}
if route_family == Some("gemini")
&& route_kind == Some("embedding")
&& *method == Method::POST
&& (path.ends_with(":embedContent") || path.ends_with(":batchEmbedContents"))
{
return Some(GEMINI_EMBEDDING_SYNC_PLAN_KIND);
}
if route_family == Some("openai")
&& route_kind == Some("chat")
&& *method == Method::POST
@@ -411,6 +419,7 @@ pub fn supports_sync_execution_decision_kind(plan_kind: &str) -> bool {
| CLAUDE_CLI_SYNC_PLAN_KIND
| GEMINI_CHAT_SYNC_PLAN_KIND
| GEMINI_CLI_SYNC_PLAN_KIND
| GEMINI_EMBEDDING_SYNC_PLAN_KIND
| GEMINI_FILES_UPLOAD_PLAN_KIND
| OPENAI_VIDEO_CREATE_SYNC_PLAN_KIND
| OPENAI_VIDEO_REMIX_SYNC_PLAN_KIND
@@ -455,9 +464,9 @@ mod tests {
use crate::contracts::{
CLAUDE_CHAT_STREAM_PLAN_KIND, CLAUDE_CHAT_SYNC_PLAN_KIND, CLAUDE_CLI_STREAM_PLAN_KIND,
CLAUDE_CLI_SYNC_PLAN_KIND, GEMINI_CHAT_STREAM_PLAN_KIND, GEMINI_CHAT_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, OPENAI_CHAT_STREAM_PLAN_KIND,
OPENAI_CHAT_SYNC_PLAN_KIND, OPENAI_EMBEDDING_SYNC_PLAN_KIND, OPENAI_IMAGE_STREAM_PLAN_KIND,
OPENAI_IMAGE_SYNC_PLAN_KIND, OPENAI_RERANK_SYNC_PLAN_KIND,
GEMINI_CLI_STREAM_PLAN_KIND, GEMINI_CLI_SYNC_PLAN_KIND, GEMINI_EMBEDDING_SYNC_PLAN_KIND,
OPENAI_CHAT_STREAM_PLAN_KIND, OPENAI_CHAT_SYNC_PLAN_KIND, OPENAI_EMBEDDING_SYNC_PLAN_KIND,
OPENAI_IMAGE_STREAM_PLAN_KIND, OPENAI_IMAGE_SYNC_PLAN_KIND, OPENAI_RERANK_SYNC_PLAN_KIND,
OPENAI_RESPONSES_COMPACT_STREAM_PLAN_KIND, OPENAI_RESPONSES_COMPACT_SYNC_PLAN_KIND,
OPENAI_RESPONSES_STREAM_PLAN_KIND, OPENAI_RESPONSES_SYNC_PLAN_KIND,
};
@@ -783,6 +792,35 @@ mod tests {
));
}
#[test]
fn resolves_gemini_embedding_sync_plan_kind() {
assert_eq!(
resolve_execution_runtime_sync_plan_kind(
Some("ai_public"),
Some("gemini"),
Some("embedding"),
Some("api_key"),
&Method::POST,
"/v1beta/models/gemini-embedding-2-preview:embedContent",
),
Some(GEMINI_EMBEDDING_SYNC_PLAN_KIND)
);
assert_eq!(
resolve_execution_runtime_sync_plan_kind(
Some("ai_public"),
Some("gemini"),
Some("embedding"),
Some("api_key"),
&Method::POST,
"/v1beta/models/gemini-embedding-2-preview:batchEmbedContents",
),
Some(GEMINI_EMBEDDING_SYNC_PLAN_KIND)
);
assert!(supports_sync_execution_decision_kind(
GEMINI_EMBEDDING_SYNC_PLAN_KIND
));
}
#[test]
fn resolves_openai_rerank_sync_plan_kind() {
assert_eq!(

107
crates/aether-ai-formats/src/formats/shared/sync_products.rs
View File

@@ -9,9 +9,10 @@ use aether_ai_formats::formats::conversion::response::{
};
use aether_ai_formats::formats::registry::{convert_response, FormatContext};
use aether_ai_formats::{
canonical_to_claude_response, canonical_to_gemini_response, canonical_to_openai_chat_response,
canonical_to_openai_responses_compact_response, canonical_to_openai_responses_response,
from_claude_to_canonical_response, from_gemini_to_canonical_response,
canonical_to_claude_response, canonical_to_embedding_response, canonical_to_gemini_response,
canonical_to_openai_chat_response, canonical_to_openai_responses_compact_response,
canonical_to_openai_responses_response, from_claude_to_canonical_response,
from_embedding_to_canonical_response, from_gemini_to_canonical_response,
from_openai_chat_to_canonical_response, from_openai_responses_to_canonical_response,
sync_chat_response_conversion_kind, sync_cli_response_conversion_kind,
};
@@ -330,6 +331,18 @@ pub fn maybe_build_standard_sync_finalize_product_from_normalized_payload(
)));
}
if let Some(product) = maybe_build_embedding_cross_format_sync_product_from_normalized_payload(
report_kind,
status_code,
report_context,
body_json,
body_base64,
)? {
return Ok(Some(StandardSyncFinalizeNormalizedProduct::CrossFormat(
product,
)));
}
Ok(
maybe_build_standard_cross_format_sync_product_from_normalized_payload(
report_kind,
@@ -342,6 +355,90 @@ pub fn maybe_build_standard_sync_finalize_product_from_normalized_payload(
)
}
pub fn maybe_build_embedding_cross_format_sync_product_from_normalized_payload(
report_kind: &str,
status_code: u16,
report_context: Option<&Value>,
body_json: Option<&Value>,
body_base64: Option<&str>,
) -> Result<Option<StandardCrossFormatSyncProduct>, AiSurfaceFinalizeError> {
if report_kind != crate::contracts::OPENAI_EMBEDDING_SYNC_FINALIZE_REPORT_KIND
|| status_code >= 400
{
return Ok(None);
}
let Some(report_context) = report_context else {
return Ok(None);
};
let provider_api_format = report_context
.get("provider_api_format")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_ascii_lowercase();
let client_api_format = report_context
.get("client_api_format")
.and_then(Value::as_str)
.unwrap_or_default()
.trim()
.to_ascii_lowercase();
if provider_api_format == client_api_format {
return Ok(None);
}
let Some(provider_namespace) =
embedding_response_namespace_for_api_format(&provider_api_format)
else {
return Ok(None);
};
let Some(client_namespace) = embedding_response_namespace_for_api_format(&client_api_format)
else {
return Ok(None);
};
let provider_body_json = match body_base64 {
Some(body_base64) => {
let body_bytes = base64::engine::general_purpose::STANDARD.decode(body_base64)?;
serde_json::from_slice::<Value>(&body_bytes).ok()
}
None => body_json.cloned(),
};
let Some(provider_body_json) =
provider_body_json.filter(|value| !is_error_like_sync_body(value))
else {
return Ok(None);
};
let mut canonical =
match from_embedding_to_canonical_response(&provider_body_json, provider_namespace) {
Some(canonical) => canonical,
None => return Ok(None),
};
apply_report_context_model_fallback(&mut canonical.model, report_context);
let Some(client_body_json) = canonical_to_embedding_response(&canonical, client_namespace)
else {
return Ok(None);
};
let client_body_json =
client_body_with_report_context_model(client_body_json, report_context, &client_api_format);
Ok(Some(StandardCrossFormatSyncProduct {
client_body_json,
provider_body_json,
}))
}
fn embedding_response_namespace_for_api_format(api_format: &str) -> Option<&'static str> {
match aether_ai_formats::normalize_api_format_alias(api_format).as_str() {
"openai:embedding" => Some("openai"),
"jina:embedding" => Some("jina"),
"gemini:embedding" => Some("gemini"),
_ => None,
}
}
fn maybe_build_standard_same_format_sync_body(
report_kind: &str,
status_code: u16,
@@ -829,6 +926,9 @@ fn client_body_with_report_context_model(
"openai:chat" | "openai:responses" | "openai:responses:compact" | "claude:messages" => {
object.insert("model".to_string(), Value::String(display_model));
}
"openai:embedding" | "jina:embedding" => {
object.insert("model".to_string(), Value::String(display_model));
}
"gemini:generate_content" => {
object.insert("modelVersion".to_string(), Value::String(display_model));
}
@@ -1310,6 +1410,7 @@ fn standard_same_format_api_format(report_kind: &str) -> Option<&'static str> {
"openai_chat_sync_finalize" => Some("openai:chat"),
"claude_chat_sync_finalize" => Some("claude:messages"),
"gemini_chat_sync_finalize" => Some("gemini:generate_content"),
"openai_embedding_sync_finalize" => Some("openai:embedding"),
"claude_cli_sync_finalize" => Some("claude:messages"),
"gemini_cli_sync_finalize" => Some("gemini:generate_content"),
_ => None,

7
crates/aether-ai-formats/src/protocol/canonical.rs
View File

@@ -684,6 +684,7 @@ pub fn from_embedding_to_canonical_response(
crate::formats::openai::embedding::response::from_namespace(body_json, "openai")
}
"jina" => crate::formats::openai::embedding::response::from_namespace(body_json, "jina"),
"gemini" => crate::formats::gemini::embedding::response::from(body_json),
_ => None,
}
}
@@ -4830,10 +4831,16 @@ mod tests {
let gemini =
super::canonical_to_embedding_request(&canonical, "gemini-embedding-001", "gemini")
.expect("gemini embedding request");
assert!(gemini.get("model").is_none());
assert_eq!(
gemini["requests"][0]["model"],
"models/gemini-embedding-001"
);
assert_eq!(
gemini["requests"][0]["content"]["parts"][0]["text"],
"alpha"
);
assert_eq!(gemini["requests"][0]["outputDimensionality"], 2);
assert!(gemini.get("messages").is_none());
let doubao = super::canonical_to_embedding_request(