i/Aether
1
0
Fork 0
mirror of https://github.com/fawney19/Aether.git synced 2026-10-04 16:37:46 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: enforce full format field coverage audit

Browse Source
This commit is contained in:
elky
2026-06-03 21:18:49 +08:00
parent 7507af5829
commit b2f68bbaf7
8 changed files with 3121 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/aether-ai-formats/src/formats/gemini/generate_content/request.rs
+1 -5
View File
@@ -15,7 +15,7 @@ use crate::{
apply_gemini_request_extensions, canonical_extension_object_mut,
canonical_openai_reasoning_effort, extract_gemini_model_from_path,
gemini_contents_to_canonical_messages, gemini_extensions, gemini_generation_config,
gemini_generation_config_extra, gemini_google_search_grounding, gemini_openai_extra_body,
gemini_generation_config_extra, gemini_google_search_grounding,
gemini_response_format_to_canonical, gemini_system_to_canonical_instructions,
gemini_thinking_to_canonical, gemini_tool_choice_to_canonical, gemini_tools_to_canonical,
gemini_value_by_case, CanonicalContentBlock, CanonicalMessage, CanonicalRequest,
@@ -173,10 +173,6 @@ pub fn from_raw(body_json: &Value, request_path: &str) -> Option<CanonicalReques
canonical_extension_object_mut(&mut canonical.extensions, "gemini")
.insert("raw_tool_config".to_string(), tool_config);
}
if let Some(extra_body) = gemini_openai_extra_body(request) {
canonical_extension_object_mut(&mut canonical.extensions, "openai")
.insert("extra_body".to_string(), extra_body);
}
if let Some(web_search_options) = web_search_options {
canonical_extension_object_mut(&mut canonical.extensions, "openai")
.insert("web_search_options".to_string(), web_search_options);
crates/aether-ai-formats/src/formats/openai/responses/request.rs
+4 -2
View File
@@ -5,7 +5,7 @@ use serde_json::{json, Map, Value};
use crate::{
formats::context::FormatContext,
formats::openai::shared::{
map_thinking_budget_to_openai_reasoning_effort, OpenAiReasoningEffort,
map_thinking_budget_to_openai_reasoning_effort, OpenAiResponsesReasoningEffort,
},
protocol::canonical::{
canonical_response_format_to_openai, canonicalize_tool_arguments,
@@ -660,7 +660,9 @@ fn reasoning_config_to_responses(thinking: &CanonicalThinkingConfig) -> Option<V
fn openai_responses_reasoning_effort(effort: &str) -> Option<&'static str> {
match effort.trim().to_ascii_lowercase().as_str() {
"max" => Some("xhigh"),
value => OpenAiReasoningEffort::parse(value).map(OpenAiReasoningEffort::as_str),
value => {
OpenAiResponsesReasoningEffort::parse(value).map(OpenAiResponsesReasoningEffort::as_str)
}
}
}
crates/aether-ai-formats/src/formats/openai/shared.rs
+41 -31
View File
@@ -2,40 +2,50 @@ use serde_json::{Map, Value};
use crate::formats::shared::model_directives::ReasoningEffort;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OpenAiReasoningEffort {
None,
Minimal,
Low,
Medium,
High,
XHigh,
macro_rules! define_openai_reasoning_effort {
($name:ident) => {
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum $name {
None,
Minimal,
Low,
Medium,
High,
XHigh,
}
impl $name {
pub fn parse(value: &str) -> Option<Self> {
match value.trim().to_ascii_lowercase().as_str() {
"none" => Some(Self::None),
"minimal" => Some(Self::Minimal),
"low" => Some(Self::Low),
"medium" => Some(Self::Medium),
"high" => Some(Self::High),
"xhigh" => Some(Self::XHigh),
_ => None,
}
}
pub fn as_str(self) -> &'static str {
match self {
Self::None => "none",
Self::Minimal => "minimal",
Self::Low => "low",
Self::Medium => "medium",
Self::High => "high",
Self::XHigh => "xhigh",
}
}
}
};
}
impl OpenAiReasoningEffort {
pub fn parse(value: &str) -> Option<Self> {
match value.trim().to_ascii_lowercase().as_str() {
"none" => Some(Self::None),
"minimal" => Some(Self::Minimal),
"low" => Some(Self::Low),
"medium" => Some(Self::Medium),
"high" => Some(Self::High),
"xhigh" => Some(Self::XHigh),
_ => None,
}
}
define_openai_reasoning_effort!(OpenAiChatReasoningEffort);
define_openai_reasoning_effort!(OpenAiResponsesReasoningEffort);
pub fn as_str(self) -> &'static str {
match self {
Self::None => "none",
Self::Minimal => "minimal",
Self::Low => "low",
Self::Medium => "medium",
Self::High => "high",
Self::XHigh => "xhigh",
}
}
}
#[deprecated(note = "use OpenAiChatReasoningEffort or OpenAiResponsesReasoningEffort")]
pub type OpenAiReasoningEffort = OpenAiChatReasoningEffort;
pub fn parse_openai_stop_sequences(stop: Option<&Value>) -> Option<Vec<Value>> {
match stop {
crates/aether-ai-formats/src/formats/registry.rs
+966 -10
View File
File diff suppressed because it is too large Load Diff
crates/aether-ai-formats/src/protocol/canonical.rs
-59
View File
@@ -5198,65 +5198,6 @@ pub(crate) fn gemini_generation_config_extra(
.collect()
}
pub(crate) fn gemini_openai_extra_body(request: &Map<String, Value>) -> Option<Value> {
let mut extra_body = Map::new();
if let Some(generation_config) = request
.get("generationConfig")
.or_else(|| request.get("generation_config"))
.and_then(Value::as_object)
{
let mut google = Map::new();
if let Some(thinking_config) =
gemini_value_by_case(generation_config, "thinkingConfig", "thinking_config").cloned()
{
google.insert("thinking_config".to_string(), thinking_config);
}
if let Some(response_modalities) = gemini_value_by_case(
generation_config,
"responseModalities",
"response_modalities",
)
.cloned()
{
google.insert("response_modalities".to_string(), response_modalities);
}
if !google.is_empty() {
extra_body.insert("google".to_string(), Value::Object(google));
}
let generation_config_extra = gemini_generation_config_extra(generation_config);
if !generation_config_extra.is_empty() {
extra_body.insert(
"gemini".to_string(),
json!({ "generation_config_extra": generation_config_extra }),
);
}
}
if let Some(safety_settings) = request
.get("safetySettings")
.or_else(|| request.get("safety_settings"))
.cloned()
{
let gemini = extra_body
.entry("gemini".to_string())
.or_insert_with(|| Value::Object(Map::new()))
.as_object_mut()?;
gemini.insert("safety_settings".to_string(), safety_settings);
}
if let Some(cached_content) = request
.get("cachedContent")
.or_else(|| request.get("cached_content"))
.cloned()
{
let gemini = extra_body
.entry("gemini".to_string())
.or_insert_with(|| Value::Object(Map::new()))
.as_object_mut()?;
gemini.insert("cached_content".to_string(), cached_content);
}
(!extra_body.is_empty()).then_some(Value::Object(extra_body))
}
pub(crate) fn extract_gemini_model_from_path(path: &str) -> Option<String> {
let marker = "/models/";
let start = path.find(marker)? + marker.len();