fix(usage): 修复含失败信号的 pending 请求被误判为活跃的问题

- pending/streaming 状态含 status_code >= 400 或 error_message 时视为 failed
- 候选状态派生改为 failed 优先于 stale pending/streaming
- 活跃请求轮询时保留失败信号字段的更新
- 图片流支持 partial_image 事件转发及从 response.completed 读取最终图片

apps/aether-gateway/src/ai_pipeline/finalize/internal/stream_rewrite.rs

@@ -106,6 +106,7 @@ struct OpenAiImageStreamState {
     buffered: Vec<u8>,
     latest_image: Option<OpenAiImageFrame>,
     emitted_partial_count: u64,
+    saw_upstream_partial: bool,
 }
 
 #[derive(Clone)]
@@ -166,12 +167,55 @@ impl OpenAiImageStreamState {
             .or(event_name.as_deref())
             .unwrap_or_default();
         match event_type {
+            "response.image_generation_call.partial_image" => {
+                self.handle_image_generation_partial(report_context, &event)
+            }
             "response.output_item.done" => self.handle_output_item_done(report_context, &event),
             "response.completed" => self.handle_completed(report_context, &event),
             _ => Ok(Vec::new()),
         }
     }
 
+    fn handle_image_generation_partial(
+        &mut self,
+        report_context: &Value,
+        event: &Value,
+    ) -> Result<Vec<u8>, GatewayError> {
+        if requested_partial_images(report_context) == 0 {
+            return Ok(Vec::new());
+        }
+        let Some(result) = event
+            .get("partial_image_b64")
+            .or_else(|| event.get("b64_json"))
+            .and_then(Value::as_str)
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
+        else {
+            return Ok(Vec::new());
+        };
+        let partial_image_index = event
+            .get("partial_image_index")
+            .or_else(|| event.get("output_index"))
+            .and_then(Value::as_u64)
+            .unwrap_or(self.emitted_partial_count);
+        self.emitted_partial_count = self
+            .emitted_partial_count
+            .max(partial_image_index.saturating_add(1));
+        self.saw_upstream_partial = true;
+        self.latest_image = Some(OpenAiImageFrame {
+            b64_json: result.to_string(),
+        });
+
+        encode_json_sse(
+            Some(image_partial_event_name(report_context)),
+            &serde_json::json!({
+                "type": image_partial_event_name(report_context),
+                "b64_json": result,
+                "partial_image_index": partial_image_index,
+            }),
+        )
+    }
+
     fn handle_output_item_done(
         &mut self,
         report_context: &Value,
@@ -193,7 +237,7 @@ impl OpenAiImageStreamState {
             b64_json: result.to_string(),
         });
 
-        if requested_partial_images(report_context) == 0 {
+        if requested_partial_images(report_context) == 0 || self.saw_upstream_partial {
             return Ok(Vec::new());
         }
 
@@ -218,6 +262,13 @@ impl OpenAiImageStreamState {
         report_context: &Value,
         event: &Value,
     ) -> Result<Vec<u8>, GatewayError> {
+        if self.latest_image.is_none() {
+            if let Some(result) = completed_response_image_result(event) {
+                self.latest_image = Some(OpenAiImageFrame {
+                    b64_json: result.to_string(),
+                });
+            }
+        }
         let Some(latest_image) = self.latest_image.clone() else {
             return Ok(Vec::new());
         };
@@ -244,6 +295,19 @@ impl OpenAiImageStreamState {
     }
 }
 
+fn completed_response_image_result(event: &Value) -> Option<&str> {
+    event
+        .get("response")
+        .and_then(|value| value.get("output"))
+        .and_then(Value::as_array)
+        .into_iter()
+        .flatten()
+        .filter(|item| item.get("type").and_then(Value::as_str) == Some("image_generation_call"))
+        .filter_map(|item| item.get("result").and_then(Value::as_str))
+        .map(str::trim)
+        .find(|value| !value.is_empty())
+}
+
 fn requested_partial_images(report_context: &Value) -> u64 {
     report_context
         .get("image_request")

apps/aether-gateway/src/ai_pipeline/finalize/tests_stream.rs

@@ -172,6 +172,91 @@ fn openai_image_stream_rewriter_emits_completed_event_for_generate() {
     assert!(rewriter.finish().expect("finish should succeed").is_empty());
 }
 
+#[test]
+fn openai_image_stream_rewriter_maps_responses_partial_image_events() {
+    let report_context = json!({
+        "provider_api_format": "openai:image",
+        "client_api_format": "openai:image",
+        "needs_conversion": false,
+        "image_request": {
+            "operation": "generate",
+            "partial_images": 1
+        }
+    });
+    let mut rewriter =
+        maybe_build_local_stream_rewriter(Some(&report_context)).expect("rewriter should exist");
+
+    let partial = rewriter
+        .push_chunk(
+            concat!(
+                "event: response.image_generation_call.partial_image\n",
+                "data: {\"type\":\"response.image_generation_call.partial_image\",\"partial_image_index\":0,\"partial_image_b64\":\"cGFydGlhbA==\"}\n\n"
+            )
+            .as_bytes(),
+        )
+        .expect("rewrite should succeed");
+    let partial_text = utf8(partial);
+    assert!(partial_text.contains("event: image_generation.partial_image"));
+    assert!(partial_text.contains("\"type\":\"image_generation.partial_image\""));
+    assert!(partial_text.contains("\"b64_json\":\"cGFydGlhbA==\""));
+    assert!(partial_text.contains("\"partial_image_index\":0"));
+    assert!(!partial_text.contains("response.image_generation_call.partial_image"));
+
+    let done = rewriter
+        .push_chunk(
+            concat!(
+                "event: response.output_item.done\n",
+                "data: {\"type\":\"response.output_item.done\",\"output_index\":0,\"item\":{\"id\":\"ig_123\",\"type\":\"image_generation_call\",\"result\":\"ZmluYWw=\"}}\n\n"
+            )
+            .as_bytes(),
+        )
+        .expect("rewrite should succeed");
+    assert!(done.is_empty());
+
+    let completed = rewriter
+        .push_chunk(
+            concat!(
+                "event: response.completed\n",
+                "data: {\"type\":\"response.completed\",\"response\":{\"usage\":{\"input_tokens\":4,\"output_tokens\":5,\"total_tokens\":9}}}\n\n"
+            )
+            .as_bytes(),
+        )
+        .expect("rewrite should succeed");
+    let completed_text = utf8(completed);
+    assert!(completed_text.contains("event: image_generation.completed"));
+    assert!(completed_text.contains("\"type\":\"image_generation.completed\""));
+    assert!(completed_text.contains("\"b64_json\":\"ZmluYWw=\""));
+    assert!(completed_text.contains("\"total_tokens\":9"));
+}
+
+#[test]
+fn openai_image_stream_rewriter_reads_final_image_from_completed_response_output() {
+    let report_context = json!({
+        "provider_api_format": "openai:image",
+        "client_api_format": "openai:image",
+        "needs_conversion": false,
+        "image_request": {
+            "operation": "generate"
+        }
+    });
+    let mut rewriter =
+        maybe_build_local_stream_rewriter(Some(&report_context)).expect("rewriter should exist");
+
+    let completed = rewriter
+        .push_chunk(
+            concat!(
+                "event: response.completed\n",
+                "data: {\"type\":\"response.completed\",\"response\":{\"output\":[{\"type\":\"message\"},{\"type\":\"image_generation_call\",\"result\":\"ZnJvbV9vdXRwdXQ=\"}],\"usage\":{\"input_tokens\":1,\"output_tokens\":2,\"total_tokens\":3}}}\n\n"
+            )
+            .as_bytes(),
+        )
+        .expect("rewrite should succeed");
+    let completed_text = utf8(completed);
+    assert!(completed_text.contains("event: image_generation.completed"));
+    assert!(completed_text.contains("\"b64_json\":\"ZnJvbV9vdXRwdXQ=\""));
+    assert!(completed_text.contains("\"total_tokens\":3"));
+}
+
 #[test]
 fn openai_image_stream_rewriter_emits_partial_and_completed_events_for_edit() {
     let report_context = json!({