feat(openai): align GPT-5.6 and Codex request contracts

2026-09-13 06:30:20 +08:00 · 2026-07-11 07:40:12 +08:00
parent bc1da3bf3f
commit dfa121dd5b
178 changed files with 17947 additions and 3541 deletions
@@ -3,13 +3,15 @@ use std::time::Duration;
 use std::time::{SystemTime, UNIX_EPOCH};

 use aether_data_contracts::repository::provider_catalog::{
-    StoredProviderCatalogEndpoint, StoredProviderCatalogKey, StoredProviderCatalogProvider,
+    ProviderCatalogUpstreamMetadataNamespaceUpdate, StoredProviderCatalogEndpoint,
+    StoredProviderCatalogKey, StoredProviderCatalogProvider,
 };
 use aether_model_fetch::{
-    apply_model_filters, fetch_models_from_transports, json_string_list, merge_upstream_metadata,
-    model_fetch_interval_minutes, model_fetch_startup_delay_seconds, model_fetch_startup_enabled,
-    preset_models_for_provider, selected_models_fetch_endpoints,
-    sync_provider_model_whitelist_associations, ModelFetchAssociationStore, ModelFetchRunSummary,
+    apply_model_filters, fetch_models_from_transports, json_string_list,
+    model_catalog_upstream_metadata, model_fetch_interval_minutes,
+    model_fetch_startup_delay_seconds, model_fetch_startup_enabled, preset_models_for_provider,
+    selected_models_fetch_endpoints, sync_provider_model_whitelist_associations,
+    upstream_metadata_namespace_updates, ModelFetchAssociationStore, ModelFetchRunSummary,
 };
 use serde_json::{json, Value};
 use tracing::{debug, info, warn};
@@ -239,8 +241,16 @@ async fn fetch_and_persist_key_models(
                json_string_list(target.key.model_include_patterns.as_ref()),
                json_string_list(target.key.model_exclude_patterns.as_ref()),
            );
-            persist_key_fetch_success(state, &target.key, now_unix_secs, &filtered_models, None)
-                .await?;
+            let upstream_metadata =
+                model_catalog_upstream_metadata(&target.provider.provider_type, &models);
+            persist_key_fetch_success(
+                state,
+                &target.key,
+                now_unix_secs,
+                &filtered_models,
+                upstream_metadata.as_ref(),
+            )
+            .await?;
            state
                .write_upstream_models_cache(&target.provider.id, &target.key.id, &models)
                .await;
@@ -328,7 +338,6 @@ async fn fetch_and_persist_key_models(
        json_string_list(target.key.model_include_patterns.as_ref()),
        json_string_list(target.key.model_exclude_patterns.as_ref()),
    );
-
    persist_key_fetch_success(
        state,
        &target.key,
@@ -352,11 +361,15 @@ async fn persist_key_fetch_failure(
    now_unix_secs: u64,
    error: String,
 ) -> Result<(), GatewayError> {
-    let mut updated = key.clone();
-    updated.last_models_fetch_at_unix_secs = Some(now_unix_secs);
-    updated.last_models_fetch_error = Some(error);
-    updated.updated_at_unix_secs = Some(now_unix_secs);
-    state.update_provider_catalog_key(&updated).await?;
+    state
+        .update_provider_catalog_key_model_fetch_state(
+            &key.id,
+            key.allowed_models.as_ref(),
+            Some(now_unix_secs),
+            Some(&error),
+            Some(now_unix_secs),
+        )
+        .await?;
    Ok(())
 }

@@ -367,22 +380,33 @@ async fn persist_key_fetch_success(
    allowed_models: &[String],
    upstream_metadata: Option<&Value>,
 ) -> Result<(), GatewayError> {
-    let mut updated = key.clone();
-    updated.allowed_models = if allowed_models.is_empty() {
+    let allowed_models = if allowed_models.is_empty() {
        None
    } else {
        Some(json!(allowed_models))
    };
-    if let Some(upstream_metadata) = upstream_metadata {
-        updated.upstream_metadata = Some(merge_upstream_metadata(
-            updated.upstream_metadata.as_ref(),
-            upstream_metadata,
-        ));
-    }
-    updated.last_models_fetch_at_unix_secs = Some(now_unix_secs);
-    updated.last_models_fetch_error = None;
-    updated.updated_at_unix_secs = Some(now_unix_secs);
-    state.update_provider_catalog_key(&updated).await?;
+    let upstream_metadata_updates = upstream_metadata
+        .map(|upstream_metadata| {
+            upstream_metadata_namespace_updates(key.upstream_metadata.as_ref(), upstream_metadata)
+                .into_iter()
+                .map(
+                    |(namespace, value)| ProviderCatalogUpstreamMetadataNamespaceUpdate {
+                        namespace,
+                        value,
+                    },
+                )
+                .collect::<Vec<_>>()
+        })
+        .unwrap_or_default();
+    state
+        .update_provider_catalog_key_model_fetch_success(
+            &key.id,
+            allowed_models.as_ref(),
+            now_unix_secs,
+            &upstream_metadata_updates,
+            Some(now_unix_secs),
+        )
+        .await?;
    Ok(())
 }

@@ -402,7 +426,8 @@ mod tests {
        StoredAdminProviderModel, UpsertAdminProviderModelRecord,
    };
    use aether_data_contracts::repository::provider_catalog::{
-        StoredProviderCatalogEndpoint, StoredProviderCatalogKey, StoredProviderCatalogProvider,
+        ProviderCatalogUpstreamMetadataNamespaceUpdate, StoredProviderCatalogEndpoint,
+        StoredProviderCatalogKey, StoredProviderCatalogProvider,
    };
    use aether_model_fetch::{
        build_models_fetch_execution_plan, ModelFetchAssociationStore, ModelFetchTransportRuntime,
@@ -428,6 +453,7 @@ mod tests {
        execution_results: Arc<Mutex<VecDeque<ExecutionResult>>>,
        executed_plans: Arc<Mutex<Vec<ExecutionPlan>>>,
        cached_models: Arc<Mutex<HashMap<(String, String), Vec<Value>>>>,
+        upstream_metadata_updates: Arc<Mutex<Vec<(String, String, Value, Option<u64>)>>>,
    }

    impl TestState {
@@ -446,6 +472,7 @@ mod tests {
                execution_results: Arc::new(Mutex::new(VecDeque::from(execution_results))),
                executed_plans: Arc::new(Mutex::new(Vec::new())),
                cached_models: Arc::new(Mutex::new(HashMap::new())),
+                upstream_metadata_updates: Arc::new(Mutex::new(Vec::new())),
            }
        }

@@ -615,15 +642,63 @@ mod tests {
            ))
        }

-        async fn update_provider_catalog_key(
+        async fn update_provider_catalog_key_model_fetch_state(
            &self,
-            key: &StoredProviderCatalogKey,
+            key_id: &str,
+            allowed_models: Option<&Value>,
+            last_models_fetch_at_unix_secs: Option<u64>,
+            last_models_fetch_error: Option<&str>,
+            updated_at_unix_secs: Option<u64>,
        ) -> Result<(), GatewayError> {
            let mut keys = self.keys.lock().expect("keys mutex");
-            let Some(slot) = keys.iter_mut().find(|item| item.id == key.id) else {
+            let Some(key) = keys.iter_mut().find(|item| item.id == key_id) else {
                return Err(GatewayError::Internal("key not found".to_string()));
            };
-            *slot = key.clone();
+            key.allowed_models = allowed_models.cloned();
+            key.last_models_fetch_at_unix_secs = last_models_fetch_at_unix_secs;
+            key.last_models_fetch_error = last_models_fetch_error.map(str::to_string);
+            key.updated_at_unix_secs = updated_at_unix_secs;
+            Ok(())
+        }
+
+        async fn update_provider_catalog_key_model_fetch_success(
+            &self,
+            key_id: &str,
+            allowed_models: Option<&Value>,
+            last_models_fetch_at_unix_secs: u64,
+            upstream_metadata_updates: &[ProviderCatalogUpstreamMetadataNamespaceUpdate],
+            updated_at_unix_secs: Option<u64>,
+        ) -> Result<(), GatewayError> {
+            let mut keys = self.keys.lock().expect("keys mutex");
+            let Some(key) = keys.iter_mut().find(|key| key.id == key_id) else {
+                return Err(GatewayError::Internal("key not found".to_string()));
+            };
+            key.allowed_models = allowed_models.cloned();
+            key.last_models_fetch_at_unix_secs = Some(last_models_fetch_at_unix_secs);
+            key.last_models_fetch_error = None;
+            if !upstream_metadata_updates.is_empty() {
+                let metadata = key
+                    .upstream_metadata
+                    .get_or_insert_with(|| json!({}))
+                    .as_object_mut()
+                    .expect("upstream metadata object");
+                for update in upstream_metadata_updates {
+                    metadata.insert(update.namespace.clone(), update.value.clone());
+                }
+            }
+            key.updated_at_unix_secs = updated_at_unix_secs;
+            drop(keys);
+            self.upstream_metadata_updates
+                .lock()
+                .expect("metadata updates mutex")
+                .extend(upstream_metadata_updates.iter().map(|update| {
+                    (
+                        key_id.to_string(),
+                        update.namespace.clone(),
+                        update.value.clone(),
+                        updated_at_unix_secs,
+                    )
+                }));
            Ok(())
        }

@@ -815,12 +890,19 @@ mod tests {
    #[tokio::test]
    async fn model_fetch_uses_preset_models_without_endpoint() {
        let provider = sample_provider("provider-codex", "codex");
-        let key = sample_key(
+        let mut key = sample_key(
            "key-codex",
            "provider-codex",
            "api_key",
            &["openai:responses"],
        );
+        key.upstream_metadata = Some(json!({
+            "codex": {
+                "quota_by_model": {
+                    "gpt-5.6-sol": {"remaining_fraction": 0.75}
+                }
+            }
+        }));
        let state = TestState::new(vec![provider], vec![], vec![key], HashMap::new(), vec![]);

        let summary = perform_model_fetch_once_with_state(&state)
@@ -832,9 +914,47 @@ mod tests {
        let updated = state.key("key-codex");
        let allowed_models = updated
            .allowed_models
+            .as_ref()
            .and_then(|value| value.as_array().cloned())
            .expect("allowed_models should be set");
        assert!(allowed_models.iter().any(|model| model == "gpt-5.4"));
+        let upstream_metadata = updated
+            .upstream_metadata
+            .as_ref()
+            .expect("Codex model catalog should be persisted");
+        assert_eq!(
+            upstream_metadata["codex"]["quota_by_model"]["gpt-5.6-sol"]["remaining_fraction"],
+            0.75
+        );
+        assert_eq!(
+            upstream_metadata["codex_models"]["cards"]["gpt-5.6-sol"]["multi_agent_version"],
+            "v2"
+        );
+        let capabilities = crate::ai_serving::resolve_codex_responses_model_capabilities(
+            "gpt-5.6-sol",
+            "gpt-5.6-sol",
+            Some(upstream_metadata),
+        );
+        assert!(capabilities.use_responses_lite);
+        assert_eq!(
+            capabilities.default_reasoning_effort.as_deref(),
+            Some("low")
+        );
+        assert!(capabilities
+            .supported_reasoning_efforts
+            .iter()
+            .any(|effort| effort == "ultra"));
+        let metadata_updates = state
+            .upstream_metadata_updates
+            .lock()
+            .expect("metadata updates mutex");
+        assert_eq!(metadata_updates.len(), 1);
+        assert_eq!(metadata_updates[0].0, "key-codex");
+        assert_eq!(metadata_updates[0].1, "codex_models");
+        assert_eq!(
+            metadata_updates[0].2["cards"]["gpt-5.6-sol"]["multi_agent_version"],
+            "v2"
+        );
        assert!(state
            .cached_models
            .lock()
@@ -4,7 +4,8 @@ use aether_data_contracts::repository::global_models::{
    StoredAdminProviderModel, UpsertAdminProviderModelRecord,
 };
 use aether_data_contracts::repository::provider_catalog::{
-    StoredProviderCatalogEndpoint, StoredProviderCatalogKey, StoredProviderCatalogProvider,
+    ProviderCatalogUpstreamMetadataNamespaceUpdate, StoredProviderCatalogEndpoint,
+    StoredProviderCatalogKey, StoredProviderCatalogProvider,
 };
 use aether_model_fetch::{ModelFetchAssociationStore, ModelFetchTransportRuntime};
 use async_trait::async_trait;
@@ -42,9 +43,22 @@ pub(crate) trait ModelFetchRuntimeState:
        plan: &ExecutionPlan,
    ) -> Result<ExecutionResult, GatewayError>;

-    async fn update_provider_catalog_key(
+    async fn update_provider_catalog_key_model_fetch_state(
        &self,
-        key: &StoredProviderCatalogKey,
+        key_id: &str,
+        allowed_models: Option<&Value>,
+        last_models_fetch_at_unix_secs: Option<u64>,
+        last_models_fetch_error: Option<&str>,
+        updated_at_unix_secs: Option<u64>,
+    ) -> Result<(), GatewayError>;
+
+    async fn update_provider_catalog_key_model_fetch_success(
+        &self,
+        key_id: &str,
+        allowed_models: Option<&Value>,
+        last_models_fetch_at_unix_secs: u64,
+        upstream_metadata_updates: &[ProviderCatalogUpstreamMetadataNamespaceUpdate],
+        updated_at_unix_secs: Option<u64>,
    ) -> Result<(), GatewayError>;

    async fn write_upstream_models_cache(
@@ -310,6 +310,89 @@ async fn gateway_model_fetch_updates_key_and_syncs_provider_model_whitelist_asso
    execution_runtime_handle.abort();
 }

+#[tokio::test]
+async fn codex_preset_model_fetch_associates_the_api_supported_review_model() {
+    let provider = StoredProviderCatalogProvider::new(
+        "provider-codex".to_string(),
+        "codex".to_string(),
+        Some("https://chatgpt.com".to_string()),
+        "codex".to_string(),
+    )
+    .expect("provider should build")
+    .with_transport_fields(true, false, true, None, None, None, None, None, None);
+    let mut key = sample_key("provider-codex", "key-codex");
+    key.locked_models = None;
+    key.model_include_patterns = None;
+    key.model_exclude_patterns = None;
+    let provider_catalog_repository = Arc::new(InMemoryProviderCatalogReadRepository::seed(
+        vec![provider],
+        Vec::new(),
+        vec![key],
+    ));
+    let global_model_repository = Arc::new(
+        InMemoryGlobalModelReadRepository::seed(Vec::new()).with_admin_global_models(vec![
+            sample_global_model(
+                "global-model-codex-auto-review",
+                "codex-auto-review",
+                &["codex-auto-review"],
+            ),
+        ]),
+    );
+    let data_state = crate::data::GatewayDataState::disabled()
+        .attach_provider_catalog_repository_for_tests(Arc::clone(&provider_catalog_repository))
+        .with_global_model_repository_for_tests(Arc::clone(&global_model_repository))
+        .with_encryption_key_for_tests(DEVELOPMENT_ENCRYPTION_KEY);
+    let state = AppState::new()
+        .expect("gateway should build")
+        .with_data_state_for_tests(data_state);
+
+    let summary = perform_model_fetch_once(&state)
+        .await
+        .expect("Codex preset model fetch should succeed");
+    assert_eq!(
+        summary,
+        ModelFetchRunSummary {
+            attempted: 1,
+            succeeded: 1,
+            failed: 0,
+            skipped: 0,
+        }
+    );
+
+    let updated_key = provider_catalog_repository
+        .list_keys_by_ids(&["key-codex".to_string()])
+        .await
+        .expect("keys should load")
+        .into_iter()
+        .next()
+        .expect("updated key should exist");
+    assert!(updated_key
+        .allowed_models
+        .as_ref()
+        .and_then(serde_json::Value::as_array)
+        .is_some_and(|models| models.iter().any(|model| model == "codex-auto-review")));
+    assert!(updated_key
+        .upstream_metadata
+        .as_ref()
+        .is_some_and(|metadata| {
+            metadata["codex_models"]["cards"]["codex-auto-review"]["supported_in_api"] == true
+        }));
+
+    let provider_models = global_model_repository
+        .list_admin_provider_models(&AdminProviderModelListQuery {
+            provider_id: "provider-codex".to_string(),
+            is_active: None,
+            offset: 0,
+            limit: 10_000,
+        })
+        .await
+        .expect("provider models should load");
+    assert!(provider_models.iter().any(|model| {
+        model.provider_model_name == "codex-auto-review"
+            && model.global_model_id == "global-model-codex-auto-review"
+    }));
+}
+
 #[tokio::test]
 async fn gateway_model_fetch_updates_key_and_syncs_provider_model_whitelist_associations_without_execution_runtime_override(
 ) {