Merge pull request #645 from zhefox/main

修复 OpenAI Chat/Responses/Messages 转换兼容性并透传 Codex cyber_policy 错误

crates/aether-ai-formats/src/formats/conversion/request.rs

@@ -221,7 +221,7 @@ mod tests {
     }
 
     #[test]
-    fn claude_request_to_chat_clamps_max_reasoning_effort_to_high() {
+    fn claude_request_to_chat_maps_max_reasoning_effort_to_xhigh() {
         let body = json!({
             "model": "claude-sonnet",
             "messages": [{"role": "user", "content": "hello"}],
@@ -233,11 +233,11 @@ mod tests {
         let converted =
             normalize_claude_request_to_openai_chat_request(&body).expect("openai chat request");
 
-        assert_eq!(converted["reasoning_effort"], "high");
+        assert_eq!(converted["reasoning_effort"], "xhigh");
     }
 
     #[test]
-    fn gemini_request_to_chat_clamps_xhigh_reasoning_effort_to_high() {
+    fn gemini_request_to_chat_preserves_xhigh_reasoning_effort() {
         let body = json!({
             "contents": [{
                 "role": "user",
@@ -254,7 +254,7 @@ mod tests {
         )
         .expect("openai chat request");
 
-        assert_eq!(converted["reasoning_effort"], "high");
+        assert_eq!(converted["reasoning_effort"], "xhigh");
     }
 
     #[test]
@@ -372,7 +372,8 @@ mod tests {
     }
 
     #[test]
-    fn responses_request_normalizer_clamps_chat_reasoning_effort_and_filters_extensions() {
+    fn responses_request_normalizer_preserves_official_chat_reasoning_effort_and_filters_extensions(
+    ) {
         let body = json!({
             "model": "gpt-5.1",
             "input": "hello",
@@ -388,7 +389,7 @@ mod tests {
         let converted = normalize_openai_responses_request_to_openai_chat_request(&body)
             .expect("openai chat request");
 
-        assert_eq!(converted["reasoning_effort"], "high");
+        assert_eq!(converted["reasoning_effort"], "xhigh");
         assert_eq!(converted["verbosity"], "high");
         assert_eq!(converted["service_tier"], "priority");
         assert_eq!(converted["prompt_cache_key"], "cache_123");
@@ -399,6 +400,22 @@ mod tests {
         assert!(converted.get("reasoning").is_none());
     }
 
+    #[test]
+    fn responses_request_normalizer_preserves_none_and_minimal_chat_reasoning_effort() {
+        for effort in ["none", "minimal"] {
+            let body = json!({
+                "model": "gpt-5.1",
+                "input": "hello",
+                "reasoning": {"effort": effort},
+            });
+
+            let converted = normalize_openai_responses_request_to_openai_chat_request(&body)
+                .expect("openai chat request");
+
+            assert_eq!(converted["reasoning_effort"], effort);
+        }
+    }
+
     #[test]
     fn request_normalizer_preserves_multiple_claude_tool_results() {
         let body = json!({

crates/aether-ai-formats/src/formats/openai/chat/request.rs

@@ -2,16 +2,19 @@ use serde_json::{json, Map, Value};
 
 use crate::{
     formats::context::FormatContext,
+    formats::openai::shared::OpenAiChatReasoningEffort,
     protocol::canonical::{
         canonical_extension_object_mut, canonical_message_to_openai_chat_messages,
         canonical_response_format_to_openai, canonical_tool_choice_to_openai,
-        canonical_tool_to_openai, is_claude_tool_result, namespace_extension_object,
-        openai_content_text, openai_extensions, openai_generation_config,
-        openai_message_content_blocks, openai_response_format_to_canonical,
-        openai_responses_extension, openai_role_to_canonical, openai_tool_choice_to_canonical,
-        openai_tools_to_canonical, write_openai_generation_config, CanonicalContentBlock,
-        CanonicalInstruction, CanonicalRequest, CanonicalRole, CanonicalThinkingConfig,
-        OPENAI_RESPONSES_EXTENSION_NAMESPACE, OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE,
+        canonical_tool_is_openai_custom, canonical_tool_to_openai, is_claude_tool_result,
+        namespace_extension_object, openai_content_text, openai_extensions,
+        openai_generation_config, openai_message_content_blocks,
+        openai_response_format_to_canonical, openai_responses_extension, openai_role_to_canonical,
+        openai_tool_choice_raw_to_chat, openai_tool_choice_to_canonical, openai_tools_to_canonical,
+        write_openai_generation_config, CanonicalContentBlock, CanonicalInstruction,
+        CanonicalRequest, CanonicalRole, CanonicalThinkingConfig, CanonicalToolChoice,
+        CanonicalToolDefinition, OPENAI_RESPONSES_EXTENSION_NAMESPACE,
+        OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE,
     },
 };
 
@@ -108,7 +111,6 @@ pub fn from_raw(body_json: &Value) -> Option<CanonicalRequest> {
             "top_k",
             "stop",
             "tools",
-            "tool_choice",
             "parallel_tool_calls",
             "metadata",
             "response_format",
@@ -121,6 +123,9 @@ pub fn from_raw(body_json: &Value) -> Option<CanonicalRequest> {
             "top_logprobs",
         ],
     );
+    if canonical.tool_choice.is_some() {
+        remove_tool_choice_extension(&mut canonical.extensions, "openai");
+    }
     if let Some(verbosity) = request.get("verbosity").cloned() {
         canonical_extension_object_mut(
             &mut canonical.extensions,
@@ -168,11 +173,8 @@ pub fn to_raw(canonical: &CanonicalRequest) -> Value {
             ),
         );
     }
-    if let Some(tool_choice) = &canonical.tool_choice {
-        output.insert(
-            "tool_choice".to_string(),
-            canonical_tool_choice_to_openai(tool_choice),
-        );
+    if let Some(tool_choice) = canonical_tool_choice_to_openai_for_request(canonical) {
+        output.insert("tool_choice".to_string(), tool_choice);
     }
     if let Some(value) = canonical.parallel_tool_calls {
         output.insert("parallel_tool_calls".to_string(), Value::Bool(value));
@@ -223,6 +225,60 @@ pub fn to_raw(canonical: &CanonicalRequest) -> Value {
     Value::Object(output)
 }
 
+fn canonical_tool_choice_to_openai_for_request(canonical: &CanonicalRequest) -> Option<Value> {
+    canonical
+        .tool_choice
+        .as_ref()
+        .map(|tool_choice| canonical_tool_choice_to_openai_for_tools(tool_choice, &canonical.tools))
+        .or_else(|| raw_tool_choice_extension(canonical).map(openai_tool_choice_raw_to_chat))
+}
+
+fn canonical_tool_choice_to_openai_for_tools(
+    choice: &CanonicalToolChoice,
+    tools: &[CanonicalToolDefinition],
+) -> Value {
+    match choice {
+        CanonicalToolChoice::Tool { name }
+            if tools
+                .iter()
+                .any(|tool| tool.name == *name && canonical_tool_is_openai_custom(tool)) =>
+        {
+            json!({
+                "type": "custom",
+                "custom": { "name": name },
+            })
+        }
+        _ => canonical_tool_choice_to_openai(choice),
+    }
+}
+
+fn raw_tool_choice_extension(canonical: &CanonicalRequest) -> Option<&Value> {
+    canonical
+        .extensions
+        .get("openai")
+        .and_then(|value| value.get("tool_choice"))
+        .or_else(|| {
+            openai_responses_extension(&canonical.extensions)
+                .and_then(|value| value.get("tool_choice"))
+        })
+}
+
+fn remove_tool_choice_extension(
+    extensions: &mut std::collections::BTreeMap<String, Value>,
+    namespace: &str,
+) {
+    let should_remove_namespace = extensions
+        .get_mut(namespace)
+        .and_then(Value::as_object_mut)
+        .is_some_and(|object| {
+            object.remove("tool_choice");
+            object.is_empty()
+        });
+    if should_remove_namespace {
+        extensions.remove(namespace);
+    }
+}
+
 fn canonical_request_has_unrepresentable_claude_tool_result_for_openai_chat(
     request: &CanonicalRequest,
 ) -> bool {
@@ -312,12 +368,10 @@ fn non_empty_source_str<'a>(source: &'a Map<String, Value>, key: &str) -> Option
 }
 
 fn openai_chat_reasoning_effort(value: &str) -> Option<&'static str> {
-    match value.trim().to_ascii_lowercase().as_str() {
-        "low" => Some("low"),
-        "medium" => Some("medium"),
-        "high" | "xhigh" | "max" => Some("high"),
-        _ => None,
+    if value.trim().eq_ignore_ascii_case("max") {
+        return Some("xhigh");
     }
+    OpenAiChatReasoningEffort::parse(value).map(OpenAiChatReasoningEffort::as_str)
 }
 
 fn chat_compatible_openai_responses_extension_object(

crates/aether-ai-formats/src/formats/openai/chat/stream.rs

@@ -1528,6 +1528,48 @@ impl OpenAIResponsesProviderState {
                     &content,
                 );
             }
+            event_type if openai_responses_hosted_tool_output_item_type(event_type).is_some() => {
+                let item_type = openai_responses_hosted_tool_output_item_type(event_type)
+                    .expect("guarded by is_some");
+                let tool_use_id = value
+                    .get("call_id")
+                    .or_else(|| value.get("tool_call_id"))
+                    .or_else(|| value.get("item_id"))
+                    .or_else(|| value.get("id"))
+                    .and_then(Value::as_str)
+                    .filter(|value| !value.trim().is_empty())
+                    .unwrap_or("call_auto_0")
+                    .to_string();
+                let output_index = value
+                    .get("output_index")
+                    .and_then(Value::as_u64)
+                    .map(|value| value as usize);
+                let index = self
+                    .tool_index_for_key(Some(format!("{item_type}:{tool_use_id}")), output_index);
+                let content = openai_tool_result_content_from_value(
+                    value
+                        .get("delta")
+                        .or_else(|| value.get("output"))
+                        .or_else(|| value.get("content")),
+                );
+                let name = openai_responses_hosted_tool_output_name(item_type)
+                    .map(ToOwned::to_owned)
+                    .or_else(|| {
+                        value
+                            .get("name")
+                            .and_then(Value::as_str)
+                            .filter(|value| !value.trim().is_empty())
+                            .map(ToOwned::to_owned)
+                    });
+                self.emit_missing_tool_result(
+                    report_context,
+                    &mut out,
+                    index,
+                    tool_use_id,
+                    name,
+                    &content,
+                );
+            }
             "response.output_item.done" => {
                 let Some(item) = value.get("item").and_then(Value::as_object) else {
                     return Ok(out);
@@ -3087,6 +3129,7 @@ fn openai_responses_stream_event_is_known_noop(event_type: &str) -> bool {
     matches!(
         event_type,
         "response.queued"
+            | "response.metadata"
             | "response.output_text.annotation.added"
             | "response.audio.delta"
             | "response.audio.done"
@@ -3113,9 +3156,56 @@ fn openai_responses_stream_event_is_known_noop(event_type: &str) -> bool {
             | "response.web_search_call.in_progress"
             | "response.web_search_call.searching"
             | "response.web_search_call.completed"
+            | "response.local_shell_call.in_progress"
+            | "response.local_shell_call.running"
+            | "response.local_shell_call.completed"
+            | "response.local_shell_call.failed"
+            | "response.shell_call.in_progress"
+            | "response.shell_call.running"
+            | "response.shell_call.completed"
+            | "response.shell_call.failed"
+            | "response.apply_patch_call.in_progress"
+            | "response.apply_patch_call.running"
+            | "response.apply_patch_call.completed"
+            | "response.apply_patch_call.failed"
+            | "response.computer_call.in_progress"
+            | "response.computer_call.running"
+            | "response.computer_call.completed"
+            | "response.computer_call.failed"
     )
 }
 
+fn openai_responses_hosted_tool_output_item_type(event_type: &str) -> Option<&'static str> {
+    match event_type {
+        "response.custom_tool_call_output.delta" | "response.custom_tool_call_output.done" => {
+            Some("custom_tool_call_output")
+        }
+        "response.local_shell_call_output.delta" | "response.local_shell_call_output.done" => {
+            Some("local_shell_call_output")
+        }
+        "response.shell_call_output.delta" | "response.shell_call_output.done" => {
+            Some("shell_call_output")
+        }
+        "response.apply_patch_call_output.delta" | "response.apply_patch_call_output.done" => {
+            Some("apply_patch_call_output")
+        }
+        "response.computer_call_output.delta" | "response.computer_call_output.done" => {
+            Some("computer_call_output")
+        }
+        _ => None,
+    }
+}
+
+fn openai_responses_hosted_tool_output_name(item_type: &str) -> Option<&'static str> {
+    match item_type {
+        "local_shell_call_output" => Some("local_shell"),
+        "shell_call_output" => Some("shell"),
+        "apply_patch_call_output" => Some("apply_patch"),
+        "computer_call_output" => Some("computer"),
+        _ => None,
+    }
+}
+
 fn openai_responses_incomplete_finish_reason(payload: &Value) -> String {
     let reason = payload
         .get("response")
@@ -4010,6 +4100,78 @@ mod tests {
         )));
     }
 
+    #[test]
+    fn openai_responses_provider_state_ignores_hosted_tool_progress_events() {
+        let mut state = OpenAIResponsesProviderState::default();
+        let report_context = json!({});
+        let mut frames = Vec::new();
+
+        for event_type in [
+            "response.local_shell_call.in_progress",
+            "response.local_shell_call.running",
+            "response.local_shell_call.completed",
+            "response.apply_patch_call.in_progress",
+            "response.apply_patch_call.completed",
+            "response.computer_call.in_progress",
+            "response.computer_call.completed",
+        ] {
+            frames.extend(
+                state
+                    .push_line(
+                        &report_context,
+                        data_line(json!({
+                            "type": event_type,
+                            "response_id": "resp_123",
+                            "output_index": 0,
+                            "item_id": "call_123",
+                        })),
+                    )
+                    .expect("hosted tool progress event should parse"),
+            );
+        }
+
+        assert!(frames
+            .iter()
+            .any(|frame| matches!(frame.event, CanonicalStreamEvent::Start)));
+        assert!(!frames
+            .iter()
+            .any(|frame| matches!(frame.event, CanonicalStreamEvent::UnknownEvent { .. })));
+    }
+
+    #[test]
+    fn openai_responses_provider_state_parses_hosted_tool_output_as_tool_result() {
+        let mut state = OpenAIResponsesProviderState::default();
+        let report_context = json!({});
+        let frames = state
+            .push_line(
+                &report_context,
+                data_line(json!({
+                    "type": "response.local_shell_call_output.done",
+                    "response_id": "resp_123",
+                    "output_index": 3,
+                    "call_id": "call_shell_123",
+                    "output": {
+                        "stdout": "ok\n",
+                        "stderr": "",
+                        "outcome": "success"
+                    },
+                })),
+            )
+            .expect("hosted tool result should parse");
+
+        assert!(frames.iter().any(|frame| matches!(
+            frame.event,
+            CanonicalStreamEvent::ToolResultDelta {
+                index: 3,
+                ref tool_use_id,
+                name: Some(ref name),
+                ref content,
+            } if tool_use_id == "call_shell_123"
+                && name == "local_shell"
+                && content.contains("\"stdout\":\"ok\\n\"")
+        )));
+    }
+
     #[test]
     fn openai_responses_provider_state_preserves_image_generation_calls() {
         let mut state = OpenAIResponsesProviderState::default();

crates/aether-ai-formats/src/formats/openai/responses/request.rs

@@ -8,15 +8,18 @@ use crate::{
         map_thinking_budget_to_openai_reasoning_effort, OpenAiResponsesReasoningEffort,
     },
     protocol::canonical::{
-        canonical_response_format_to_openai, canonicalize_tool_arguments,
-        is_claude_messages_request, is_claude_system_instruction, is_claude_thinking_block,
-        is_claude_tool_result, media_data_or_url, namespace_extension_object, openai_content_text,
-        openai_extensions, openai_response_format_to_canonical, openai_responses_extension,
+        canonical_response_format_to_openai_responses, canonical_tool_is_openai_custom,
+        canonical_tool_use_to_openai_responses_input_item, is_claude_messages_request,
+        is_claude_system_instruction, is_claude_thinking_block, is_claude_tool_result,
+        is_openai_responses_input_message, is_openai_thinking_block, media_data_or_url,
+        namespace_extension_object, openai_content_text, openai_extensions,
+        openai_response_format_to_canonical, openai_responses_extension,
         openai_responses_generation_config, openai_responses_input_to_canonical_messages,
         openai_responses_tool_choice_to_canonical, openai_responses_tools_to_canonical,
-        CanonicalContentBlock, CanonicalInstruction, CanonicalRequest, CanonicalRole,
-        CanonicalThinkingConfig, CanonicalToolChoice, CanonicalToolDefinition,
-        OPENAI_RESPONSES_EXTENSION_NAMESPACE, OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE,
+        openai_tool_choice_raw_to_responses, CanonicalContentBlock, CanonicalInstruction,
+        CanonicalRequest, CanonicalRole, CanonicalThinkingConfig, CanonicalToolChoice,
+        CanonicalToolDefinition, OPENAI_RESPONSES_EXTENSION_NAMESPACE,
+        OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE,
     },
 };
 
@@ -98,7 +101,6 @@ pub fn from_raw(body_json: &Value) -> Option<CanonicalRequest> {
             "top_p",
             "metadata",
             "tools",
-            "tool_choice",
             "parallel_tool_calls",
             "text",
             "reasoning",
@@ -109,6 +111,12 @@ pub fn from_raw(body_json: &Value) -> Option<CanonicalRequest> {
             .extensions
             .insert(OPENAI_RESPONSES_EXTENSION_NAMESPACE.to_string(), raw);
     }
+    if canonical.tool_choice.is_some() {
+        remove_tool_choice_extension(
+            &mut canonical.extensions,
+            OPENAI_RESPONSES_EXTENSION_NAMESPACE,
+        );
+    }
     if let Some(verbosity) = request
         .get("text")
         .and_then(Value::as_object)
@@ -174,11 +182,8 @@ pub fn to_raw(
             Value::Array(canonical_tools_to_responses(canonical)),
         );
     }
-    if let Some(tool_choice) = canonical.tool_choice.as_ref() {
-        output.insert(
-            "tool_choice".to_string(),
-            canonical_tool_choice_to_responses(tool_choice),
-        );
+    if let Some(tool_choice) = canonical_tool_choice_to_responses_for_request(canonical) {
+        output.insert("tool_choice".to_string(), tool_choice);
     }
     if let Some(reasoning) = canonical_reasoning_config_to_responses(canonical) {
         output.insert("reasoning".to_string(), reasoning);
@@ -303,6 +308,12 @@ fn canonical_messages_to_responses_input(canonical: &CanonicalRequest) -> Option
         let role = match message.role {
             CanonicalRole::Assistant => "assistant",
             CanonicalRole::Tool | CanonicalRole::User | CanonicalRole::Unknown => "user",
+            CanonicalRole::System if is_openai_responses_input_message(&message.extensions) => {
+                "system"
+            }
+            CanonicalRole::Developer if is_openai_responses_input_message(&message.extensions) => {
+                "developer"
+            }
             CanonicalRole::System | CanonicalRole::Developer => continue,
         };
         let mut content = Vec::new();
@@ -313,19 +324,16 @@ fn canonical_messages_to_responses_input(canonical: &CanonicalRequest) -> Option
                     id,
                     name,
                     input: arguments,
-                    ..
+                    extensions,
                 } => {
                     flush_responses_message(&mut input, role, &mut content);
                     saw_tool_item = true;
                     let call_id = responses_tool_call_id(id, &mut next_generated_tool_call_index);
                     let tool_name = responses_tool_name(name);
                     pending_tool_call_ids.push_back(call_id.clone());
-                    input.push(json!({
-                        "type": "function_call",
-                        "call_id": call_id,
-                        "name": tool_name,
-                        "arguments": canonicalize_tool_arguments(arguments),
-                    }));
+                    input.push(canonical_tool_use_to_openai_responses_input_item(
+                        &call_id, &tool_name, arguments, extensions,
+                    ));
                 }
                 CanonicalContentBlock::ToolResult {
                     tool_use_id,
@@ -344,7 +352,8 @@ fn canonical_messages_to_responses_input(canonical: &CanonicalRequest) -> Option
                     let call_id =
                         responses_tool_result_call_id(tool_use_id, &mut pending_tool_call_ids)?;
                     input.push(json!({
-                        "type": "function_call_output",
+                        "type": responses_tool_result_item_type(extensions)
+                            .unwrap_or("function_call_output"),
                         "call_id": call_id,
                         "output": tool_output,
                     }));
@@ -357,11 +366,28 @@ fn canonical_messages_to_responses_input(canonical: &CanonicalRequest) -> Option
                     }
                 }
                 CanonicalContentBlock::Thinking {
-                    text, extensions, ..
+                    text,
+                    encrypted_content,
+                    extensions,
+                    ..
                 } => {
                     if is_claude_thinking_block(extensions) {
                         continue;
                     }
+                    if role == "assistant"
+                        && is_openai_responses_reasoning_history_block(extensions)
+                    {
+                        flush_responses_message(&mut input, role, &mut content);
+                        if let Some(reasoning_item) = canonical_thinking_to_responses_reasoning_item(
+                            text,
+                            encrypted_content.as_deref(),
+                            extensions,
+                        ) {
+                            input.push(reasoning_item);
+                            saw_tool_item = true;
+                        }
+                        continue;
+                    }
                     if role == "assistant" && !text.trim().is_empty() {
                         content.push(json!({
                             "type": "output_text",
@@ -526,6 +552,43 @@ fn flush_responses_message(input: &mut Vec<Value>, role: &str, content: &mut Vec
     }));
 }
 
+fn canonical_thinking_to_responses_reasoning_item(
+    text: &str,
+    encrypted_content: Option<&str>,
+    extensions: &BTreeMap<String, Value>,
+) -> Option<Value> {
+    let mut item = openai_responses_extension(extensions)
+        .and_then(Value::as_object)
+        .cloned()
+        .unwrap_or_default();
+    item.remove("item_type");
+    item.insert("type".to_string(), Value::String("reasoning".to_string()));
+    if !text.trim().is_empty() {
+        item.entry("summary".to_string()).or_insert_with(|| {
+            json!([{
+                "type": "summary_text",
+                "text": text,
+            }])
+        });
+    }
+    if let Some(value) = encrypted_content.filter(|value| !value.is_empty()) {
+        item.insert(
+            "encrypted_content".to_string(),
+            Value::String(value.to_string()),
+        );
+    }
+    (item.len() > 1).then_some(Value::Object(item))
+}
+
+fn is_openai_responses_reasoning_history_block(extensions: &BTreeMap<String, Value>) -> bool {
+    is_openai_thinking_block(extensions)
+        && openai_responses_extension(extensions)
+            .and_then(Value::as_object)
+            .and_then(|object| object.get("item_type"))
+            .and_then(Value::as_str)
+            == Some("reasoning")
+}
+
 fn canonical_block_to_responses_input_part(
     block: &CanonicalContentBlock,
     role: &str,
@@ -579,10 +642,14 @@ fn canonical_block_to_responses_input_part(
                 item.insert("file_id".to_string(), Value::String(value.clone()));
             }
             if data.is_some() || file_url.is_some() {
-                item.insert(
-                    "file_data".to_string(),
-                    Value::String(media_data_or_url(media_type, data, file_url)),
-                );
+                if data.is_some() {
+                    item.insert(
+                        "file_data".to_string(),
+                        Value::String(media_data_or_url(media_type, data, file_url)),
+                    );
+                } else if let Some(value) = file_url {
+                    item.insert("file_url".to_string(), Value::String(value.clone()));
+                }
             }
             if let Some(value) = filename {
                 item.insert("filename".to_string(), Value::String(value.clone()));
@@ -714,7 +781,7 @@ fn canonical_text_config_to_responses(canonical: &CanonicalRequest) -> Option<Va
     if let Some(response_format) = &canonical.response_format {
         text.insert(
             "format".to_string(),
-            canonical_response_format_to_openai(response_format),
+            canonical_response_format_to_openai_responses(response_format),
         );
     }
     if let Some(verbosity) = canonical
@@ -746,17 +813,17 @@ fn canonical_tool_to_responses(tool: &CanonicalToolDefinition) -> Value {
             tool.extensions
                 .get(OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE)
         })
-        .filter(|value| {
-            value
-                .get("type")
-                .and_then(Value::as_str)
-                .is_some_and(|tool_type| {
-                    tool_type == "custom" || tool_type.starts_with("web_search")
-                })
-        })
     {
         return raw.clone();
     }
+    if let Some(raw) = tool.extensions.get("openai").filter(|value| {
+        value
+            .get("type")
+            .and_then(Value::as_str)
+            .is_some_and(|tool_type| tool_type.eq_ignore_ascii_case("custom"))
+    }) {
+        return openai_chat_custom_tool_to_responses_tool(tool, raw);
+    }
     let mut out = Map::new();
     out.insert("type".to_string(), Value::String("function".to_string()));
     out.insert("name".to_string(), Value::String(tool.name.clone()));
@@ -781,6 +848,22 @@ fn canonical_tool_to_responses(tool: &CanonicalToolDefinition) -> Value {
     Value::Object(out)
 }
 
+fn openai_chat_custom_tool_to_responses_tool(tool: &CanonicalToolDefinition, raw: &Value) -> Value {
+    let mut out = raw
+        .get("custom")
+        .and_then(Value::as_object)
+        .cloned()
+        .unwrap_or_default();
+    out.insert("type".to_string(), Value::String("custom".to_string()));
+    out.entry("name".to_string())
+        .or_insert_with(|| Value::String(tool.name.clone()));
+    if let Some(description) = &tool.description {
+        out.entry("description".to_string())
+            .or_insert_with(|| Value::String(description.clone()));
+    }
+    Value::Object(out)
+}
+
 fn responses_tool_parameters_schema(parameters: Option<&Value>) -> Value {
     match parameters {
         Some(Value::Object(schema)) => {
@@ -800,11 +883,59 @@ fn responses_tool_parameters_schema(parameters: Option<&Value>) -> Value {
     }
 }
 
-fn canonical_tool_choice_to_responses(choice: &CanonicalToolChoice) -> Value {
+fn canonical_tool_choice_to_responses_for_request(canonical: &CanonicalRequest) -> Option<Value> {
+    canonical
+        .tool_choice
+        .as_ref()
+        .map(|tool_choice| canonical_tool_choice_to_responses(tool_choice, &canonical.tools))
+        .or_else(|| raw_tool_choice_extension(canonical).map(openai_tool_choice_raw_to_responses))
+}
+
+fn raw_tool_choice_extension(canonical: &CanonicalRequest) -> Option<&Value> {
+    canonical
+        .extensions
+        .get("openai")
+        .and_then(|value| value.get("tool_choice"))
+        .or_else(|| {
+            openai_responses_extension(&canonical.extensions)
+                .and_then(|value| value.get("tool_choice"))
+        })
+}
+
+fn remove_tool_choice_extension(
+    extensions: &mut std::collections::BTreeMap<String, Value>,
+    namespace: &str,
+) {
+    let should_remove_namespace = extensions
+        .get_mut(namespace)
+        .and_then(Value::as_object_mut)
+        .is_some_and(|object| {
+            object.remove("tool_choice");
+            object.is_empty()
+        });
+    if should_remove_namespace {
+        extensions.remove(namespace);
+    }
+}
+
+fn canonical_tool_choice_to_responses(
+    choice: &CanonicalToolChoice,
+    tools: &[CanonicalToolDefinition],
+) -> Value {
     match choice {
         CanonicalToolChoice::Auto => Value::String("auto".to_string()),
         CanonicalToolChoice::None => Value::String("none".to_string()),
         CanonicalToolChoice::Required => Value::String("required".to_string()),
+        CanonicalToolChoice::Tool { name }
+            if tools
+                .iter()
+                .any(|tool| tool.name == *name && canonical_tool_is_openai_custom(tool)) =>
+        {
+            json!({
+                "type": "custom",
+                "name": name,
+            })
+        }
         CanonicalToolChoice::Tool { name } => json!({
             "type": "function",
             "name": name,
@@ -817,10 +948,13 @@ fn responses_tool_result_payload(
     content_text: Option<&str>,
     extensions: &BTreeMap<String, Value>,
 ) -> Option<(Value, Vec<Value>)> {
-    if is_claude_tool_result(extensions) {
-        if let Some(Value::Array(parts)) = output {
+    if let Some(Value::Array(parts)) = output {
+        if is_claude_tool_result(extensions) {
             return claude_tool_result_parts_to_responses_payload(parts);
         }
+        if let Some(output) = openai_chat_tool_result_parts_to_responses_output(parts) {
+            return Some((output, Vec::new()));
+        }
     }
     Some((
         responses_tool_result_output(output, content_text),
@@ -828,6 +962,117 @@ fn responses_tool_result_payload(
     ))
 }
 
+fn responses_tool_result_item_type(extensions: &BTreeMap<String, Value>) -> Option<&str> {
+    let item_type = extensions
+        .get(OPENAI_RESPONSES_EXTENSION_NAMESPACE)
+        .or_else(|| extensions.get(OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE))
+        .and_then(|value| value.get("item_type"))
+        .and_then(Value::as_str)?;
+    matches!(
+        item_type,
+        "custom_tool_call_output"
+            | "local_shell_call_output"
+            | "shell_call_output"
+            | "apply_patch_call_output"
+            | "computer_call_output"
+    )
+    .then_some(item_type)
+}
+
+fn openai_chat_tool_result_parts_to_responses_output(parts: &[Value]) -> Option<Value> {
+    if parts.is_empty()
+        || !parts.iter().all(|part| {
+            part.as_object()
+                .and_then(|object| object.get("type"))
+                .and_then(Value::as_str)
+                .is_some()
+        })
+    {
+        return None;
+    }
+    parts
+        .iter()
+        .map(openai_chat_tool_result_part_to_responses_output_part)
+        .collect::<Option<Vec<_>>>()
+        .map(Value::Array)
+}
+
+fn openai_chat_tool_result_part_to_responses_output_part(part: &Value) -> Option<Value> {
+    let part_object = part.as_object()?;
+    match part_object
+        .get("type")
+        .and_then(Value::as_str)
+        .unwrap_or_default()
+    {
+        "input_text" | "input_image" | "input_file" => Some(part.clone()),
+        "text" => part_object
+            .get("text")
+            .and_then(Value::as_str)
+            .map(|text| json!({ "type": "input_text", "text": text }))
+            .or_else(|| Some(openai_chat_tool_result_fallback_part(part))),
+        "image_url" => openai_chat_tool_result_image_part(part_object)
+            .or_else(|| Some(openai_chat_tool_result_fallback_part(part))),
+        "file" => openai_chat_tool_result_file_part(part_object)
+            .or_else(|| Some(openai_chat_tool_result_fallback_part(part))),
+        _ => Some(openai_chat_tool_result_fallback_part(part)),
+    }
+}
+
+fn openai_chat_tool_result_image_part(part_object: &Map<String, Value>) -> Option<Value> {
+    let image_value = part_object.get("image_url")?;
+    let image_object = image_value.as_object();
+    let image_url = image_value.as_str().or_else(|| {
+        image_object
+            .and_then(|image| image.get("url"))
+            .and_then(Value::as_str)
+    });
+    let file_id = image_object
+        .and_then(|image| image.get("file_id"))
+        .and_then(Value::as_str)
+        .or_else(|| part_object.get("file_id").and_then(Value::as_str));
+    if image_url.is_none() && file_id.is_none() {
+        return None;
+    }
+    let mut part = Map::new();
+    part.insert("type".to_string(), Value::String("input_image".to_string()));
+    if let Some(value) = image_url {
+        part.insert("image_url".to_string(), Value::String(value.to_string()));
+    }
+    if let Some(value) = file_id {
+        part.insert("file_id".to_string(), Value::String(value.to_string()));
+    }
+    if let Some(detail) = image_object
+        .and_then(|image| image.get("detail"))
+        .and_then(Value::as_str)
+        .or_else(|| part_object.get("detail").and_then(Value::as_str))
+    {
+        part.insert("detail".to_string(), Value::String(detail.to_string()));
+    }
+    Some(Value::Object(part))
+}
+
+fn openai_chat_tool_result_file_part(part_object: &Map<String, Value>) -> Option<Value> {
+    let file_object = part_object
+        .get("file")
+        .and_then(Value::as_object)
+        .unwrap_or(part_object);
+    let mut part = Map::new();
+    part.insert("type".to_string(), Value::String("input_file".to_string()));
+    for field in ["file_id", "file_data", "file_url", "filename"] {
+        if let Some(value) = file_object.get(field).and_then(Value::as_str) {
+            part.insert(field.to_string(), Value::String(value.to_string()));
+        }
+    }
+    (part.len() > 1).then_some(Value::Object(part))
+}
+
+fn openai_chat_tool_result_fallback_part(part: &Value) -> Value {
+    json!({
+        "type": "input_text",
+        "text": serde_json::to_string(part).unwrap_or_else(|_| part.to_string()),
+    })
+}
+
 fn responses_tool_result_output(output: Option<&Value>, content_text: Option<&str>) -> Value {
     let text = match output {
         Some(Value::String(text)) => text.clone(),
@@ -1185,6 +1430,7 @@ mod tests {
 
         assert_eq!(body["input"].as_array().expect("input").len(), 2);
         assert_eq!(body["input"][0]["type"], "function_call");
+        assert!(body["input"][0].get("id").is_none());
         assert_eq!(body["input"][0]["call_id"], "call_auto_0");
         assert_eq!(body["input"][0]["name"], "unknown");
         assert_eq!(body["input"][0]["arguments"], "{\"q\":\"rust\"}");

crates/aether-ai-formats/src/formats/openai/responses/response.rs

@@ -9,12 +9,13 @@ use crate::{
     formats::context::FormatContext,
     protocol::canonical::{
         canonical_content_block_to_openai_responses_part, canonical_extension_object_mut,
-        canonical_usage_to_openai_responses_usage, canonicalize_tool_arguments,
-        flush_openai_responses_message_item, is_openai_thinking_block, namespace_extension_object,
-        openai_responses_extensions, openai_responses_output_to_canonical_blocks,
-        openai_usage_to_canonical, CanonicalContentBlock, CanonicalResponse,
-        CanonicalResponseOutput, CanonicalRole, CanonicalStopReason,
-        OPENAI_RESPONSES_EXTENSION_NAMESPACE, OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE,
+        canonical_tool_use_to_openai_responses_item, canonical_usage_to_openai_responses_usage,
+        flush_openai_responses_message_item, is_openai_responses_raw_block,
+        is_openai_thinking_block, namespace_extension_object, openai_responses_extensions,
+        openai_responses_output_to_canonical_blocks, openai_usage_to_canonical,
+        CanonicalContentBlock, CanonicalResponse, CanonicalResponseOutput, CanonicalRole,
+        CanonicalStopReason, OPENAI_RESPONSES_EXTENSION_NAMESPACE,
+        OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE,
     },
 };
 
@@ -199,7 +200,10 @@ pub fn to_raw(canonical: &CanonicalResponse, report_context: &Value, _compact: b
                 output.push(Value::Object(item));
             }
             CanonicalContentBlock::ToolUse {
-                id, name, input, ..
+                id,
+                name,
+                input,
+                extensions,
             } => {
                 flush_openai_responses_message_item(
                     &mut output,
@@ -218,13 +222,9 @@ pub fn to_raw(canonical: &CanonicalResponse, report_context: &Value, _compact: b
                         },
                     }));
                 } else {
-                    output.push(json!({
-                        "type": "function_call",
-                        "id": id,
-                        "call_id": id,
-                        "name": name,
-                        "arguments": canonicalize_tool_arguments(input),
-                    }));
+                    output.push(canonical_tool_use_to_openai_responses_item(
+                        id, name, input, extensions,
+                    ));
                 }
             }
             CanonicalContentBlock::ToolResult {
@@ -232,6 +232,7 @@ pub fn to_raw(canonical: &CanonicalResponse, report_context: &Value, _compact: b
                 output: result_output,
                 content_text,
                 is_error,
+                extensions,
                 ..
             } => {
                 flush_openai_responses_message_item(
@@ -243,7 +244,11 @@ pub fn to_raw(canonical: &CanonicalResponse, report_context: &Value, _compact: b
                 let mut item = Map::new();
                 item.insert(
                     "type".to_string(),
-                    Value::String("function_call_output".to_string()),
+                    Value::String(
+                        responses_tool_result_item_type(extensions)
+                            .unwrap_or("function_call_output")
+                            .to_string(),
+                    ),
                 );
                 item.insert("call_id".to_string(), Value::String(tool_use_id.clone()));
                 item.insert(
@@ -269,6 +274,19 @@ pub fn to_raw(canonical: &CanonicalResponse, report_context: &Value, _compact: b
                     }
                 }
             }
+            CanonicalContentBlock::Unknown {
+                payload,
+                extensions,
+                ..
+            } if is_openai_responses_raw_block(extensions) => {
+                flush_openai_responses_message_item(
+                    &mut output,
+                    &mut message_content,
+                    &response_id,
+                    &mut message_index,
+                );
+                output.push(payload.clone());
+            }
             CanonicalContentBlock::Unknown { .. } => {}
         }
     }
@@ -331,6 +349,23 @@ pub fn to_raw(canonical: &CanonicalResponse, report_context: &Value, _compact: b
     Value::Object(response)
 }
 
+fn responses_tool_result_item_type(extensions: &BTreeMap<String, Value>) -> Option<&str> {
+    let item_type = extensions
+        .get(OPENAI_RESPONSES_EXTENSION_NAMESPACE)
+        .or_else(|| extensions.get(OPENAI_RESPONSES_LEGACY_EXTENSION_NAMESPACE))
+        .and_then(|value| value.get("item_type"))
+        .and_then(Value::as_str)?;
+    matches!(
+        item_type,
+        "custom_tool_call_output"
+            | "local_shell_call_output"
+            | "shell_call_output"
+            | "apply_patch_call_output"
+            | "computer_call_output"
+    )
+    .then_some(item_type)
+}
+
 pub(crate) fn ensure_modern_openai_responses_response_fields(
     response: &mut Map<String, Value>,
 ) -> bool {

crates/aether-ai-formats/src/formats/registry.rs

@@ -356,9 +356,38 @@ fn validate_response_conversion(
     }
 
     validate_source_response_stop_enums(source, target, body)?;
+    validate_response_content_has_no_unknown_blocks(source, target, response)?;
     validate_canonical_response_stop_reasons(source, target, response)
 }
 
+fn validate_response_content_has_no_unknown_blocks(
+    source: FormatId,
+    target: FormatId,
+    response: &CanonicalResponse,
+) -> Result<(), FormatError> {
+    for block in response.content.iter().chain(
+        response
+            .outputs
+            .iter()
+            .flat_map(|output| output.content.iter()),
+    ) {
+        if let CanonicalContentBlock::Unknown { raw_type, .. } = block {
+            if raw_type == "refusal" {
+                continue;
+            }
+            return Err(FormatError::LossyConversionBlocked {
+                source_format: source.as_str().to_string(),
+                target_format: target.as_str().to_string(),
+                field: "output[].type".to_string(),
+                reason: format!(
+                    "target format has no lossless mapping for unknown source output item type {raw_type:?}"
+                ),
+            });
+        }
+    }
+    Ok(())
+}
+
 fn validate_known_standard_request_root_fields(
     source: FormatId,
     target: FormatId,
@@ -2580,6 +2609,7 @@ mod tests {
             .value;
 
         assert_eq!(converted["input"][0]["type"], "function_call");
+        assert!(converted["input"][0].get("id").is_none());
         assert_eq!(converted["input"][0]["call_id"], "call_lookup_1");
         assert_eq!(converted["input"][1]["type"], "function_call_output");
         assert_eq!(converted["input"][1]["call_id"], "call_lookup_1");
@@ -2681,7 +2711,7 @@ mod tests {
             .expect("pure conversion should succeed")
             .value;
 
-        assert_eq!(converted["reasoning_effort"], "high");
+        assert_eq!(converted["reasoning_effort"], "xhigh");
     }
 
     #[test]
@@ -3129,6 +3159,44 @@ mod tests {
         }
     }
 
+    #[test]
+    fn pure_openai_responses_request_same_format_preserves_raw_tools_and_roles() {
+        let body = json!({
+            "model": "gpt-source",
+            "input": [
+                {
+                    "type": "message",
+                    "role": "developer",
+                    "content": [{"type": "input_text", "text": "Use policy"}]
+                },
+                {"role": "user", "content": "hello"}
+            ],
+            "tools": [
+                {
+                    "type": "file_search",
+                    "vector_store_ids": ["vs_123"],
+                    "max_num_results": 3
+                },
+                {
+                    "type": "mcp",
+                    "server_label": "docs",
+                    "server_url": "https://example.com/mcp"
+                }
+            ]
+        });
+
+        let converted = convert_request_pure("openai:responses", "openai:responses", &body)
+            .expect("same-format Responses request should preserve official raw fields")
+            .value;
+
+        assert_eq!(converted["input"][0]["role"], "developer");
+        assert_eq!(converted["input"][0]["content"][0]["text"], "Use policy");
+        assert_eq!(converted["tools"][0]["type"], "file_search");
+        assert_eq!(converted["tools"][0]["vector_store_ids"][0], "vs_123");
+        assert_eq!(converted["tools"][1]["type"], "mcp");
+        assert_eq!(converted["tools"][1]["server_label"], "docs");
+    }
+
     #[test]
     fn pure_openai_chat_to_claude_blocks_target_unsupported_generation_field() {
         let body = json!({
@@ -3452,6 +3520,72 @@ mod tests {
         );
     }
 
+    #[test]
+    fn pure_openai_responses_response_same_format_preserves_raw_output_items() {
+        let body = json!({
+            "id": "resp_raw_items",
+            "object": "response",
+            "model": "gpt-source",
+            "status": "completed",
+            "output": [
+                {
+                    "type": "file_search_call",
+                    "id": "fs_123",
+                    "status": "completed",
+                    "queries": ["rust"],
+                    "results": [{"file_id": "file_123", "text": "Rust"}]
+                },
+                {
+                    "type": "code_interpreter_call",
+                    "id": "ci_123",
+                    "status": "completed",
+                    "code": "print('hi')",
+                    "outputs": []
+                },
+                {
+                    "type": "message",
+                    "id": "msg_123",
+                    "role": "assistant",
+                    "content": [{"type": "output_text", "text": "done"}]
+                }
+            ]
+        });
+
+        let converted = convert_response_pure("openai:responses", "openai:responses", &body)
+            .expect("same-format Responses response should preserve raw output items")
+            .value;
+
+        assert_eq!(converted["output"][0]["type"], "file_search_call");
+        assert_eq!(converted["output"][0]["results"][0]["file_id"], "file_123");
+        assert_eq!(converted["output"][1]["type"], "code_interpreter_call");
+        assert_eq!(converted["output"][2]["content"][0]["text"], "done");
+    }
+
+    #[test]
+    fn pure_openai_responses_response_cross_format_blocks_raw_output_items() {
+        let body = json!({
+            "id": "resp_raw_items",
+            "object": "response",
+            "model": "gpt-source",
+            "status": "completed",
+            "output": [{
+                "type": "mcp_call",
+                "id": "mcp_123",
+                "status": "completed",
+                "name": "lookup"
+            }]
+        });
+
+        let error = convert_response_pure("openai:responses", "openai:chat", &body)
+            .expect_err("cross-format raw Responses output items should fail closed");
+
+        assert!(matches!(
+            error,
+            super::FormatError::LossyConversionBlocked { ref field, .. }
+                if field == "output[].type"
+        ));
+    }
+
     #[test]
     fn pure_claude_response_same_format_preserves_unknown_stop_reason() {
         let body = json!({

crates/aether-ai-formats/src/formats/shared/model_directives.rs

@@ -44,7 +44,7 @@ impl ReasoningEffort {
             Self::Low => "low",
             Self::Medium => "medium",
             Self::High => "high",
-            Self::XHigh | Self::Max => "high",
+            Self::XHigh | Self::Max => "xhigh",
         }
     }
 
@@ -534,7 +534,7 @@ mod tests {
             "gpt-5.4-xhigh",
         )
         .expect("directive should apply");
-        assert_eq!(openai_chat["reasoning_effort"], "high");
+        assert_eq!(openai_chat["reasoning_effort"], "xhigh");
 
         let mut responses = json!({
             "model": "gpt-5-upstream",
@@ -607,7 +607,7 @@ mod tests {
             "gpt-5.4-fast-xhigh",
         )
         .expect("directive should apply");
-        assert_eq!(openai_chat["reasoning_effort"], "high");
+        assert_eq!(openai_chat["reasoning_effort"], "xhigh");
         assert_eq!(openai_chat["service_tier"], "priority");
 
         let mut reversed = json!({"model": "gpt-5-upstream", "reasoning_effort": "low"});

crates/aether-ai-formats/src/formats/shared/standard_normalize.rs

@@ -738,7 +738,7 @@ mod tests {
         .expect("openai chat body should build");
 
         assert_eq!(provider_request_body["model"], "gpt-5-upstream");
-        assert_eq!(provider_request_body["reasoning_effort"], "high");
+        assert_eq!(provider_request_body["reasoning_effort"], "xhigh");
     }
 
     #[test]

crates/aether-ai-formats/src/formats/shared/stream_core/common.rs

@@ -331,7 +331,14 @@ pub fn canonical_usage_from_claude_usage(value: Option<&Value>) -> Option<Canoni
         .and_then(Value::as_u64)
         .unwrap_or(0);
     let reasoning_tokens = usage
-        .get("reasoning_tokens")
+        .get("output_tokens_details")
+        .and_then(Value::as_object)
+        .and_then(|details| {
+            details
+                .get("thinking_tokens")
+                .or_else(|| details.get("reasoning_tokens"))
+        })
+        .or_else(|| usage.get("reasoning_tokens"))
         .and_then(Value::as_u64)
         .unwrap_or(0);
     Some(CanonicalUsage {

crates/aether-ai-formats/src/formats/shared/stream_core/format_matrix.rs

@@ -1121,6 +1121,14 @@ mod tests {
                 "item_id": "ws_123",
                 "output_index": 0,
             })),
+            data_line(json!({
+                "type": "response.metadata",
+                "response_id": "resp_sidecar_123",
+                "sequence_number": 4,
+                "metadata": {
+                    "candidate_id": "provider-a",
+                },
+            })),
             data_line(json!({
                 "type": "response.output_text.annotation.added",
                 "response_id": "resp_sidecar_123",

crates/aether-ai-formats/src/formats/shared/sync_products.rs

@@ -2050,7 +2050,7 @@ pub fn aggregate_openai_responses_stream_sync_response(body: &[u8]) -> Option<Va
                         reasoning_states.entry(output_index).or_default(),
                         item,
                     ),
-                    "function_call" => {
+                    "function_call" | "custom_tool_call" => {
                         merge_openai_responses_tool_item(
                             tool_states.entry(output_index).or_default(),
                             item,
@@ -2067,7 +2067,7 @@ pub fn aggregate_openai_responses_stream_sync_response(body: &[u8]) -> Option<Va
                     _ => {}
                 }
             }
-            "response.function_call_arguments.delta" => {
+            "response.function_call_arguments.delta" | "response.custom_tool_call_input.delta" => {
                 let Some(output_index) =
                     resolve_openai_responses_tool_output_index(event_object, &item_output_indexes)
                 else {
@@ -2080,18 +2080,43 @@ pub fn aggregate_openai_responses_stream_sync_response(body: &[u8]) -> Option<Va
                 if delta.is_empty() {
                     continue;
                 }
-                tool_states
-                    .entry(output_index)
-                    .or_default()
-                    .arguments
-                    .push_str(delta);
+                let state = tool_states.entry(output_index).or_default();
+                if event_object
+                    .get("type")
+                    .and_then(Value::as_str)
+                    .is_some_and(|value| value.starts_with("response.custom_tool_call_input."))
+                {
+                    state
+                        .item
+                        .entry("type".to_string())
+                        .or_insert_with(|| Value::String("custom_tool_call".to_string()));
+                    if let Some(name) = event_object.get("name").and_then(Value::as_str) {
+                        state
+                            .item
+                            .entry("name".to_string())
+                            .or_insert_with(|| Value::String(name.to_string()));
+                    }
+                    if let Some(item_id) = event_object.get("item_id").and_then(Value::as_str) {
+                        state
+                            .item
+                            .entry("id".to_string())
+                            .or_insert_with(|| Value::String(item_id.to_string()));
+                    }
+                    if let Some(call_id) = event_object.get("call_id").and_then(Value::as_str) {
+                        state
+                            .item
+                            .entry("call_id".to_string())
+                            .or_insert_with(|| Value::String(call_id.to_string()));
+                    }
+                }
+                state.arguments.push_str(delta);
                 register_openai_responses_tool_event_aliases(
                     &mut item_output_indexes,
                     event_object,
                     output_index,
                 );
             }
-            "response.function_call_arguments.done" => {
+            "response.function_call_arguments.done" | "response.custom_tool_call_input.done" => {
                 let Some(output_index) =
                     resolve_openai_responses_tool_output_index(event_object, &item_output_indexes)
                 else {
@@ -2108,14 +2133,44 @@ pub fn aggregate_openai_responses_stream_sync_response(body: &[u8]) -> Option<Va
                         item,
                     );
                 }
+                if event_object
+                    .get("type")
+                    .and_then(Value::as_str)
+                    .is_some_and(|value| value.starts_with("response.custom_tool_call_input."))
+                {
+                    let state = tool_states.entry(output_index).or_default();
+                    state
+                        .item
+                        .entry("type".to_string())
+                        .or_insert_with(|| Value::String("custom_tool_call".to_string()));
+                    if let Some(name) = event_object.get("name").and_then(Value::as_str) {
+                        state
+                            .item
+                            .entry("name".to_string())
+                            .or_insert_with(|| Value::String(name.to_string()));
+                    }
+                    if let Some(item_id) = event_object.get("item_id").and_then(Value::as_str) {
+                        state
+                            .item
+                            .entry("id".to_string())
+                            .or_insert_with(|| Value::String(item_id.to_string()));
+                    }
+                    if let Some(call_id) = event_object.get("call_id").and_then(Value::as_str) {
+                        state
+                            .item
+                            .entry("call_id".to_string())
+                            .or_insert_with(|| Value::String(call_id.to_string()));
+                    }
+                }
                 let arguments = event_object
                     .get("arguments")
+                    .or_else(|| event_object.get("input"))
                     .and_then(Value::as_str)
                     .or_else(|| {
                         event_object
                             .get("item")
                             .and_then(Value::as_object)
-                            .and_then(|item| item.get("arguments"))
+                            .and_then(|item| item.get("arguments").or_else(|| item.get("input")))
                             .and_then(Value::as_str)
                     })
                     .unwrap_or_default();
@@ -2152,7 +2207,7 @@ pub fn aggregate_openai_responses_stream_sync_response(body: &[u8]) -> Option<Va
                                 reasoning_states.entry(output_index).or_default(),
                                 item,
                             ),
-                            "function_call" => {
+                            "function_call" | "custom_tool_call" => {
                                 merge_openai_responses_tool_item(
                                     tool_states.entry(output_index).or_default(),
                                     item,
@@ -2720,6 +2775,12 @@ fn materialize_openai_responses_tool_item(
     state: OpenAIResponsesSyncToolState,
 ) -> Value {
     let mut item = state.item;
+    let item_type = item
+        .get("type")
+        .and_then(Value::as_str)
+        .filter(|value| *value == "custom_tool_call")
+        .unwrap_or("function_call")
+        .to_string();
     let generated_id = format!("call_auto_{output_index}");
     let call_id = item
         .get("call_id")
@@ -2736,10 +2797,7 @@ fn materialize_openai_responses_tool_item(
         })
         .unwrap_or(generated_id.clone());
 
-    item.insert(
-        "type".to_string(),
-        Value::String("function_call".to_string()),
-    );
+    item.insert("type".to_string(), Value::String(item_type.clone()));
     item.entry("id".to_string())
         .or_insert_with(|| Value::String(call_id.clone()));
     item.insert("call_id".to_string(), Value::String(call_id));
@@ -2748,9 +2806,19 @@ fn materialize_openai_responses_tool_item(
     item.entry("status".to_string())
         .or_insert_with(|| Value::String("completed".to_string()));
     if !state.arguments.is_empty() {
-        item.insert("arguments".to_string(), Value::String(state.arguments));
+        let argument_key = if item_type == "custom_tool_call" {
+            "input"
+        } else {
+            "arguments"
+        };
+        item.insert(argument_key.to_string(), Value::String(state.arguments));
     } else {
-        item.entry("arguments".to_string())
+        let argument_key = if item_type == "custom_tool_call" {
+            "input"
+        } else {
+            "arguments"
+        };
+        item.entry(argument_key.to_string())
             .or_insert_with(|| Value::String(String::new()));
     }
     Value::Object(item)
@@ -4365,6 +4433,27 @@ mod tests {
         assert_eq!(result["output"][0]["arguments"], r#"{"location": "Tokyo"}"#);
     }
 
+    #[test]
+    fn custom_tool_call_input_events_materialize_custom_tool_call() {
+        let body = concat!(
+            "event: response.custom_tool_call_input.delta\n",
+            "data: {\"type\":\"response.custom_tool_call_input.delta\",\"output_index\":0,\"item_id\":\"ctc_123\",\"name\":\"code_exec\",\"delta\":\"print\"}\n\n",
+            "event: response.custom_tool_call_input.done\n",
+            "data: {\"type\":\"response.custom_tool_call_input.done\",\"output_index\":0,\"item_id\":\"ctc_123\",\"call_id\":\"call_custom_123\",\"name\":\"code_exec\",\"input\":\"print('hi')\"}\n\n",
+            "event: response.completed\n",
+            "data: {\"type\":\"response.completed\",\"response\":{\"id\":\"resp_custom_123\",\"object\":\"response\",\"model\":\"gpt-5\",\"status\":\"completed\",\"output\":[]}}\n\n",
+        );
+
+        let result = aggregate_openai_responses_stream_sync_response(body.as_bytes())
+            .expect("custom tool stream should aggregate into a sync body");
+
+        assert_eq!(result["output"][0]["type"], "custom_tool_call");
+        assert_eq!(result["output"][0]["call_id"], "call_custom_123");
+        assert_eq!(result["output"][0]["name"], "code_exec");
+        assert_eq!(result["output"][0]["input"], "print('hi')");
+        assert!(result["output"][0].get("arguments").is_none());
+    }
+
     #[test]
     fn aggregates_modern_reasoning_text_and_response_done_alias() {
         let body = concat!(