Merge latest origin/main into codex/gemini-embedding-batch

# Conflicts:
#	apps/aether-gateway/src/ai_serving/planner/standard/openai/mod.rs
#	apps/aether-gateway/src/execution_runtime/fallback.rs

crates/aether-usage-runtime/src/record.rs

@@ -136,7 +136,7 @@ fn lifecycle_status_and_billing(event_type: UsageEventType) -> (&'static str, &'
         UsageEventType::Streaming => ("streaming", "pending"),
         UsageEventType::Completed => ("completed", "pending"),
         UsageEventType::Failed => ("failed", "void"),
-        UsageEventType::Cancelled => ("cancelled", "void"),
+        UsageEventType::Cancelled => ("cancelled", "pending"),
     }
 }
 
@@ -181,6 +181,38 @@ mod tests {
         assert_eq!(record.finalized_at_unix_secs, Some(1_700_000_000));
     }
 
+    #[test]
+    fn cancelled_terminal_record_stays_pending_for_settlement() {
+        let record = build_upsert_usage_record_from_event(&UsageEvent {
+            event_type: UsageEventType::Cancelled,
+            request_id: "req-cancelled".to_string(),
+            timestamp_ms: 1_700_000_000_000,
+            data: UsageEventData {
+                provider_name: "OpenAI".to_string(),
+                model: "gpt-5".to_string(),
+                input_tokens: Some(10),
+                output_tokens: Some(20),
+                total_tokens: Some(30),
+                total_cost_usd: Some(0.03),
+                actual_total_cost_usd: Some(0.02),
+                status_code: Some(499),
+                response_time_ms: Some(200),
+                first_byte_time_ms: Some(50),
+                ..UsageEventData::default()
+            },
+        })
+        .expect("record should build");
+
+        assert_eq!(record.status, "cancelled");
+        assert_eq!(record.billing_status, "pending");
+        assert_eq!(record.total_tokens, Some(30));
+        assert_eq!(record.total_cost_usd, Some(0.03));
+        assert_eq!(record.actual_total_cost_usd, Some(0.02));
+        assert_eq!(record.status_code, Some(499));
+        assert_eq!(record.response_time_ms, Some(200));
+        assert_eq!(record.first_byte_time_ms, Some(50));
+    }
+
     #[test]
     fn sanitizes_request_metadata_before_building_upsert_record() {
         let record = build_upsert_usage_record_from_event(&UsageEvent {

crates/aether-usage-runtime/src/settlement.rs

@@ -164,6 +164,29 @@ mod tests {
         assert!(!inputs[0].api_key_is_standalone);
     }
 
+    #[tokio::test]
+    async fn settles_pending_cancelled_usage() {
+        let writer = TestSettlementWriter {
+            has_writer: true,
+            ..Default::default()
+        };
+        let mut usage = sample_usage();
+        usage.status = "cancelled".to_string();
+        usage.status_code = Some(499);
+
+        settle_usage_if_needed(&writer, &usage)
+            .await
+            .expect("settlement should succeed");
+
+        let inputs = writer.inputs.lock().expect("settlement inputs lock");
+        assert_eq!(inputs.len(), 1);
+        assert_eq!(inputs[0].request_id, "req-1");
+        assert_eq!(inputs[0].status, "cancelled");
+        assert_eq!(inputs[0].billing_status, "pending");
+        assert_eq!(inputs[0].total_cost_usd, 1.25);
+        assert_eq!(inputs[0].actual_total_cost_usd, 0.75);
+    }
+
     #[tokio::test]
     async fn propagates_standalone_key_flag_from_usage_metadata() {
         let writer = TestSettlementWriter {

crates/aether-usage-runtime/src/usage_mapper.rs

@@ -27,15 +27,21 @@ impl UsageMapper {
         }
 
         derive_missing_input_tokens(raw_usage, api_format, &mut usage);
+        copy_explicit_total_tokens(raw_usage, api_format, &mut usage);
         usage.normalize_cache_creation_breakdown()
     }
 
     pub fn map_from_response(response: &serde_json::Value, api_format: &str) -> StandardizedUsage {
         let family = api_family(api_format);
-        let Some(usage_value) = resolve_usage_value(response, family.as_str()) else {
-            return StandardizedUsage::new();
+        let mut usage = if let Some(usage_value) = resolve_usage_value(response, family.as_str()) {
+            Self::map(usage_value, api_format, None)
+        } else {
+            StandardizedUsage::new()
         };
-        Self::map(usage_value, api_format, None)
+        if is_openai_image_api(api_format) {
+            apply_openai_image_response_dimensions(response, &mut usage);
+        }
+        usage
     }
 }
 
@@ -59,6 +65,53 @@ fn api_family(api_format: &str) -> String {
         .to_ascii_lowercase()
 }
 
+fn api_kind(api_format: &str) -> String {
+    api_format
+        .split(':')
+        .nth(1)
+        .unwrap_or_default()
+        .trim()
+        .to_ascii_lowercase()
+}
+
+fn is_openai_image_api(api_format: &str) -> bool {
+    api_family(api_format).as_str() == "openai" && api_kind(api_format).as_str() == "image"
+}
+
+fn apply_openai_image_response_dimensions(
+    response: &serde_json::Value,
+    usage: &mut StandardizedUsage,
+) {
+    let image_count = openai_image_response_image_count(response);
+    if image_count <= 0 {
+        return;
+    }
+
+    usage.request_count = image_count;
+    usage
+        .dimensions
+        .insert("image_count".to_string(), serde_json::json!(image_count));
+}
+
+fn openai_image_response_image_count(response: &serde_json::Value) -> i64 {
+    response
+        .get("data")
+        .and_then(serde_json::Value::as_array)
+        .map(|items| items.len() as i64)
+        .filter(|value| *value > 0)
+        .or_else(|| image_result_count(response.get("result")))
+        .unwrap_or(0)
+}
+
+fn image_result_count(value: Option<&serde_json::Value>) -> Option<i64> {
+    match value? {
+        serde_json::Value::Array(items) => Some(items.len() as i64).filter(|count| *count > 0),
+        serde_json::Value::Object(object) if !object.is_empty() => Some(1),
+        serde_json::Value::String(text) if !text.trim().is_empty() => Some(1),
+        _ => None,
+    }
+}
+
 fn base_mapping(api_format: &str) -> BTreeMap<String, String> {
     let mut mapping = BTreeMap::new();
     match api_family(api_format).as_str() {
@@ -189,6 +242,22 @@ fn derive_missing_input_tokens(
     }
 }
 
+fn copy_explicit_total_tokens(
+    raw_usage: &serde_json::Value,
+    api_format: &str,
+    usage: &mut StandardizedUsage,
+) {
+    let total_tokens = match api_family(api_format).as_str() {
+        "gemini" => numeric_i64(raw_usage.get("totalTokenCount")),
+        _ => numeric_i64(raw_usage.get("total_tokens")),
+    };
+    if let Some(total_tokens) = total_tokens.filter(|value| *value > 0) {
+        usage
+            .dimensions
+            .insert("total_tokens".to_string(), serde_json::json!(total_tokens));
+    }
+}
+
 fn numeric_i64(value: Option<&serde_json::Value>) -> Option<i64> {
     value.and_then(|value| {
         value
@@ -603,4 +672,47 @@ mod tests {
         assert_eq!(usage.output_tokens, 6);
         assert_eq!(usage.cache_read_tokens, 2);
     }
+
+    #[test]
+    fn maps_openai_image_response_dimensions_without_usage() {
+        let usage = map_usage_from_response(
+            &serde_json::json!({
+                "created": 1_700_000_000,
+                "data": [
+                    { "b64_json": "abc" },
+                    { "url": "https://example.test/image.png" }
+                ]
+            }),
+            "openai:image",
+        );
+
+        assert_eq!(usage.request_count, 2);
+        assert_eq!(
+            usage.dimensions.get("image_count"),
+            Some(&serde_json::json!(2))
+        );
+    }
+
+    #[test]
+    fn maps_openai_image_response_dimensions_with_native_usage() {
+        let usage = map_usage_from_response(
+            &serde_json::json!({
+                "usage": {
+                    "input_tokens": 11,
+                    "output_tokens": 22,
+                    "total_tokens": 33
+                },
+                "data": [{ "b64_json": "abc" }]
+            }),
+            "openai:image",
+        );
+
+        assert_eq!(usage.input_tokens, 11);
+        assert_eq!(usage.output_tokens, 22);
+        assert_eq!(usage.request_count, 1);
+        assert_eq!(
+            usage.dimensions.get("image_count"),
+            Some(&serde_json::json!(1))
+        );
+    }
 }