Fix streaming tool calls and input parsing for Responses API

- Add DeltaToolCall struct with optional fields for streaming chunks
(first chunk has id/type/name, subsequent chunks only have arguments)
- Restructure InputItem as enum with FunctionCall, FunctionCallOutput, Message variants
- Extract tool name from call_id patterns (e.g., "functions.shell:0" -> "shell")
- Track current_function_name across streaming chunks for proper close handling
- Add debug logging for tool call chunks and request conversion

src/adapter/convert_responses.rs

@@ -4,7 +4,7 @@ use crate::types::openrouter::{
     ContentPartType, ImageUrl, ChatCompletionChunk, Tool, Function, Role, ToolCallType,
 };
 use crate::types::responses::{
-    CreateResponseRequest, Input, InputMessage, InputMessageContent,
+    CreateResponseRequest, Input, InputItem, InputMessage, InputMessageContent,
     ContentPart as ResponsesContentPart, Tool as ResponsesTool, ToolChoice as ResponsesToolChoice,
     Response, ResponseStatus, ResponseUsage, OutputItem, OutputStatus,
     OutputContent, ReasoningContent, StreamEvent,
@@ -40,9 +40,9 @@ pub fn convert_responses_to_openrouter(req: &CreateResponseRequest) -> CreateCha
                 reasoning_details: None,
             });
         }
-        Input::Messages(input_messages) => {
-            for msg in input_messages {
-                if let Some(chat_msg) = convert_input_message(msg) {
+        Input::Messages(input_items) => {
+            for item in input_items {
+                if let Some(chat_msg) = convert_input_item(item) {
                     messages.push(chat_msg);
                 }
             }
@@ -110,22 +110,83 @@ pub fn convert_responses_to_openrouter(req: &CreateResponseRequest) -> CreateCha
     }
 }
 
+fn convert_input_item(item: &InputItem) -> Option<ChatCompletionMessage> {
+    match item {
+        InputItem::FunctionCall { call_id, name, arguments, .. } => {
+            // Function calls need to be converted to assistant messages with tool_calls
+            // Extract name from call_id if name is empty (format: "functions.<name>:<index>")
+            let tool_name = if name.is_empty() {
+                extract_tool_name_from_call_id(call_id)
+            } else {
+                name.clone()
+            };
+            Some(ChatCompletionMessage {
+                role: Role::Assistant,
+                content: None,
+                tool_call_id: None,
+                refusal: None,
+                tool_calls: Some(vec![crate::types::openrouter::ToolCall {
+                    index: 0,
+                    id: call_id.clone(),
+                    call_type: ToolCallType::Function,
+                    function: crate::types::openrouter::ToolCallFunction {
+                        name: tool_name,
+                        arguments: arguments.clone(),
+                    },
+                }]),
+                reasoning: None,
+                reasoning_details: None,
+            })
+        }
+        InputItem::FunctionCallOutput { call_id, output, .. } => {
+            Some(ChatCompletionMessage {
+                role: Role::Tool,
+                content: Some(MessageContent::Text(output.clone())),
+                tool_call_id: Some(call_id.clone()),
+                refusal: None,
+                tool_calls: None,
+                reasoning: None,
+                reasoning_details: None,
+            })
+        }
+        InputItem::Message(msg) => convert_input_message(msg),
+    }
+}
+
+/// Extract tool name from call_id format like "functions.shell:0" -> "shell"
+fn extract_tool_name_from_call_id(call_id: &str) -> String {
+    // Try format "functions.<name>:<index>"
+    if let Some(rest) = call_id.strip_prefix("functions.") {
+        if let Some(name) = rest.split(':').next() {
+            return name.to_string();
+        }
+    }
+    // Try format "<name>:<index>"
+    if let Some(name) = call_id.split(':').next() {
+        if !name.is_empty() {
+            return name.to_string();
+        }
+    }
+    // Fallback: use the whole call_id
+    call_id.to_string()
+}
+
 fn convert_input_message(msg: &InputMessage) -> Option<ChatCompletionMessage> {
+    // Convert developer to system (not all backends support developer role)
     let role = match msg.role.as_str() {
         "user" => Role::User,
         "assistant" => Role::Assistant,
-        "system" => Role::System,
-        "developer" => Role::Developer,
+        "system" | "developer" => Role::System,
         "tool" => Role::Tool,
         _ => Role::User,
     };
 
-    let (content, tool_call_id) = match &msg.content {
-        InputMessageContent::Text { content } => {
-            (Some(MessageContent::Text(content.clone())), None)
+    let content = match &msg.content {
+        InputMessageContent::Text(text) => {
+            Some(MessageContent::Text(text.clone()))
         }
-        InputMessageContent::Array { content } => {
-            let parts: Vec<ContentPart> = content.iter().filter_map(|part| {
+        InputMessageContent::Array(parts) => {
+            let converted_parts: Vec<ContentPart> = parts.iter().filter_map(|part| {
                 match part {
                     ResponsesContentPart::InputText { text } => {
                         Some(ContentPart {
@@ -159,28 +220,14 @@ fn convert_input_message(msg: &InputMessage) -> Option<ChatCompletionMessage> {
                     }
                 }
             }).collect();
-            (Some(MessageContent::Parts(parts)), None)
-        }
-        InputMessageContent::FunctionCallOutput { call_id, output, .. } => {
-            return Some(ChatCompletionMessage {
-                role: Role::Tool,
-                content: Some(MessageContent::Text(output.clone())),
-                tool_call_id: Some(call_id.clone()),
-                refusal: None,
-                tool_calls: None,
-                reasoning: None,
-                reasoning_details: None,
-            });
-        }
-        InputMessageContent::FunctionCall { .. } => {
-            return None;
+            Some(MessageContent::Parts(converted_parts))
         }
     };
 
     Some(ChatCompletionMessage {
         role,
         content,
-        tool_call_id,
+        tool_call_id: None,
         refusal: None,
         tool_calls: None,
         reasoning: None,
@@ -199,6 +246,7 @@ pub struct ResponsesStreamConverter {
     current_message_id: Option<String>,
     current_reasoning_id: Option<String>,
     current_function_call_id: Option<String>,
+    current_function_name: Option<String>,
     // Accumulated content
     full_text: String,
     full_reasoning: String,
@@ -373,7 +421,7 @@ impl ResponsesStreamConverter {
         events
     }
 
-    fn handle_tool_call(&mut self, tool_call: &crate::types::openrouter::ToolCall) -> Vec<StreamEvent> {
+    fn handle_tool_call(&mut self, tool_call: &crate::types::openrouter::DeltaToolCall) -> Vec<StreamEvent> {
         let mut events = Vec::new();
 
         // Close message/reasoning if needed
@@ -384,9 +432,12 @@ impl ResponsesStreamConverter {
             events.extend(self.close_current_reasoning());
         }
 
-        // Start function call if this is a new one
-        let is_new = !tool_call.id.is_empty() &&
-            self.current_function_call_id.as_ref() != Some(&tool_call.id);
+        // Get the id if present
+        let tool_call_id = tool_call.id.clone().unwrap_or_default();
+
+        // Start function call if this is a new one (has id) or we don't have one yet
+        let is_new = !tool_call_id.is_empty() &&
+            self.current_function_call_id.as_ref() != Some(&tool_call_id);
 
         if is_new || self.current_function_call_id.is_none() {
             if self.current_function_call_id.is_some() {
@@ -394,15 +445,16 @@ impl ResponsesStreamConverter {
             }
 
             let fc_id = format!("fc_{}", &uuid::Uuid::new_v4().to_string().replace("-", "")[..24]);
-            self.current_function_call_id = Some(tool_call.id.clone());
+            self.current_function_call_id = Some(tool_call_id.clone());
+            self.current_function_name = tool_call.function.name.clone();
             self.full_arguments.clear();
 
             events.push(StreamEvent::OutputItemAdded {
                 output_index: self.output_index,
                 item: OutputItem::FunctionCall {
                     id: fc_id,
-                    call_id: tool_call.id.clone(),
-                    name: tool_call.function.name.clone(),
+                    call_id: tool_call_id,
+                    name: tool_call.function.name.clone().unwrap_or_default(),
                     arguments: String::new(),
                     status: Some(OutputStatus::InProgress),
                 },
@@ -411,14 +463,16 @@ impl ResponsesStreamConverter {
         }
 
         // Emit arguments delta
-        if !tool_call.function.arguments.is_empty() {
-            self.full_arguments.push_str(&tool_call.function.arguments);
-            events.push(StreamEvent::FunctionCallArgumentsDelta {
-                item_id: self.current_function_call_id.clone().unwrap_or_default(),
-                output_index: self.output_index,
-                delta: tool_call.function.arguments.clone(),
-                sequence_number: self.next_sequence(),
-            });
+        if let Some(ref arguments) = tool_call.function.arguments {
+            if !arguments.is_empty() {
+                self.full_arguments.push_str(arguments);
+                events.push(StreamEvent::FunctionCallArgumentsDelta {
+                    item_id: self.current_function_call_id.clone().unwrap_or_default(),
+                    output_index: self.output_index,
+                    delta: arguments.clone(),
+                    sequence_number: self.next_sequence(),
+                });
+            }
         }
 
         events
@@ -496,6 +550,8 @@ impl ResponsesStreamConverter {
         let mut events = Vec::new();
 
         if let Some(call_id) = self.current_function_call_id.take() {
+            let name = self.current_function_name.take().unwrap_or_default();
+
             events.push(StreamEvent::FunctionCallArgumentsDone {
                 item_id: call_id.clone(),
                 output_index: self.output_index,
@@ -508,7 +564,7 @@ impl ResponsesStreamConverter {
                 item: OutputItem::FunctionCall {
                     id: format!("fc_{}", &uuid::Uuid::new_v4().to_string().replace("-", "")[..24]),
                     call_id,
-                    name: String::new(), // Would need to track this
+                    name,
                     arguments: self.full_arguments.clone(),
                     status: Some(OutputStatus::Completed),
                 },

src/adapter/convert_stream.rs

@@ -94,39 +94,40 @@ impl StreamConverter {
                 // Handle tool calls
                 if let Some(tool_calls) = &delta.tool_calls {
                     if let Some(tool_call) = tool_calls.first() {
-                        if let Some(function) = Some(&tool_call.function) {
-                            let new_tool = !tool_call.id.is_empty()
-                                && self.current_tool_call_id.as_ref() != Some(&tool_call.id);
-
-                            if self.current_delta_type != Some(MessageContentDeltaType::InputJsonDelta)
-                                || new_tool
-                            {
-                                events.extend(self.close_current_block());
-                                self.current_delta_type = Some(MessageContentDeltaType::InputJsonDelta);
-                                self.current_tool_call_id = Some(tool_call.id.clone());
-
-                                events.push(Event::ContentBlockStart {
-                                    index: self.block_index,
-                                    content_block: MessageContent {
-                                        content_type: MessageContentType::ToolUse,
-                                        id: Some(tool_call.id.clone()),
-                                        name: Some(function.name.clone()),
-                                        input: Some(
-                                            serde_json::value::RawValue::from_string("{}".to_string())
-                                                .unwrap(),
-                                        ),
-                                        ..Default::default()
-                                    },
-                                });
-                            }
+                        let tool_call_id = tool_call.id.clone().unwrap_or_default();
+                        let new_tool = !tool_call_id.is_empty()
+                            && self.current_tool_call_id.as_ref() != Some(&tool_call_id);
+
+                        if self.current_delta_type != Some(MessageContentDeltaType::InputJsonDelta)
+                            || new_tool
+                        {
+                            events.extend(self.close_current_block());
+                            self.current_delta_type = Some(MessageContentDeltaType::InputJsonDelta);
+                            self.current_tool_call_id = Some(tool_call_id.clone());
+
+                            events.push(Event::ContentBlockStart {
+                                index: self.block_index,
+                                content_block: MessageContent {
+                                    content_type: MessageContentType::ToolUse,
+                                    id: Some(tool_call_id),
+                                    name: tool_call.function.name.clone(),
+                                    input: Some(
+                                        serde_json::value::RawValue::from_string("{}".to_string())
+                                            .unwrap(),
+                                    ),
+                                    ..Default::default()
+                                },
+                            });
+                        }
 
-                            // Emit partial JSON if present
-                            if !function.arguments.is_empty() {
+                        // Emit partial JSON if present
+                        if let Some(ref arguments) = tool_call.function.arguments {
+                            if !arguments.is_empty() {
                                 events.push(Event::ContentBlockDelta {
                                     index: self.block_index,
                                     delta: MessageContentDelta {
                                         delta_type: MessageContentDeltaType::InputJsonDelta,
-                                        partial_json: Some(function.arguments.clone()),
+                                        partial_json: Some(arguments.clone()),
                                         text: None,
                                         thinking: None,
                                         signature: None,

src/handlers/responses.rs

@@ -3,7 +3,6 @@ use axum::{
     extract::State,
     http::{header, HeaderMap, StatusCode},
     response::Response,
-    Json,
 };
 use futures::StreamExt;
 use tokio_stream::wrappers::ReceiverStream;
@@ -17,8 +16,20 @@ use crate::AppState;
 pub async fn responses(
     State(state): State<AppState>,
     headers: HeaderMap,
-    Json(request): Json<CreateResponseRequest>,
+    body: String,
 ) -> Result<Response, AppError> {
+    // Log raw body for debugging (first 8000 chars)
+    eprintln!("=== RAW BODY (first 8000 chars) ===\n{}\n=== END ===", &body[..body.len().min(8000)]);
+
+    let request: CreateResponseRequest = serde_json::from_str(&body)
+        .map_err(|e| AppError::InvalidRequest(format!("Failed to parse request: {}", e)))?;
+
+    // Debug: log parsed input items
+    if let crate::types::responses::Input::Messages(items) = &request.input {
+        for (i, item) in items.iter().enumerate() {
+            eprintln!("=== INPUT ITEM {} ===\n{:?}\n=== END ===", i, item);
+        }
+    }
     // Extract API key from incoming request headers
     let api_key = headers
         .get("x-api-key")
@@ -46,6 +57,10 @@ pub async fn responses(
     // Convert Responses API request to OpenRouter/Chat Completions format
     let openrouter_request = convert_responses_to_openrouter(&request);
 
+    // Debug: log the converted request
+    eprintln!("=== OPENROUTER REQUEST ===\n{}\n=== END ===",
+        serde_json::to_string_pretty(&openrouter_request).unwrap_or_default());
+
     // Create request to backend
     let url = format!("{}/v1/chat/completions", state.openrouter_base_url);
 
@@ -112,13 +127,26 @@ pub async fn responses(
                         }
 
                         if !data.is_empty() {
-                            if let Ok(chunk) = serde_json::from_str::<ChatCompletionChunk>(&data) {
-                                let events = converter.convert_chunk(&chunk);
-                                for event in events {
-                                    if tx.send(Ok(event.to_sse_string())).await.is_err() {
-                                        return;
+                            match serde_json::from_str::<ChatCompletionChunk>(&data) {
+                                Ok(chunk) => {
+                                    // Debug: log tool calls if present
+                                    if let Some(choice) = chunk.choices.first() {
+                                        if let Some(delta) = &choice.delta {
+                                            if delta.tool_calls.is_some() {
+                                                eprintln!("=== TOOL CALL CHUNK ===\n{}\n=== END ===", &data);
+                                            }
+                                        }
+                                    }
+                                    let events = converter.convert_chunk(&chunk);
+                                    for event in events {
+                                        if tx.send(Ok(event.to_sse_string())).await.is_err() {
+                                            return;
+                                        }
                                     }
                                 }
+                                Err(e) => {
+                                    eprintln!("Failed to parse chunk: {} - data: {}", e, &data[..data.len().min(500)]);
+                                }
                             }
                         }
                     }

src/types/openrouter.rs

@@ -224,6 +224,28 @@ pub struct ToolCall {
     pub function: ToolCallFunction,
 }
 
+/// Tool call in streaming delta - all fields optional except index
+/// First chunk has: index, id, type, function.name
+/// Subsequent chunks have: index, function.arguments
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DeltaToolCall {
+    #[serde(default)]
+    pub index: i32,
+    #[serde(default, deserialize_with = "deserialize_option_string")]
+    pub id: Option<String>,
+    #[serde(rename = "type")]
+    pub call_type: Option<ToolCallType>,
+    pub function: DeltaToolCallFunction,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DeltaToolCallFunction {
+    #[serde(default, deserialize_with = "deserialize_option_string")]
+    pub name: Option<String>,
+    #[serde(default, deserialize_with = "deserialize_option_string")]
+    pub arguments: Option<String>,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum ToolCallType {
@@ -246,6 +268,15 @@ where
     Ok(opt.unwrap_or_default())
 }
 
+fn deserialize_option_string<'de, D>(deserializer: D) -> Result<Option<String>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let opt: Option<String> = Option::deserialize(deserializer)?;
+    // Filter out empty strings
+    Ok(opt.filter(|s| !s.is_empty()))
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ReasoningDetail {
     #[serde(rename = "type")]
@@ -401,7 +432,7 @@ pub struct ChunkDelta {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub refusal: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub tool_calls: Option<Vec<ToolCall>>,
+    pub tool_calls: Option<Vec<DeltaToolCall>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub reasoning: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]

src/types/responses.rs

@@ -29,34 +29,46 @@ pub struct CreateResponseRequest {
 #[serde(untagged)]
 pub enum Input {
     Text(String),
-    Messages(Vec<InputMessage>),
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-pub struct InputMessage {
-    pub role: String,
-    #[serde(flatten)]
-    pub content: InputMessageContent,
+    Messages(Vec<InputItem>),
 }
 
+/// Input items can be either regular messages (with role) or function call items (with type)
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(untagged)]
-pub enum InputMessageContent {
-    Text { content: String },
-    Array { content: Vec<ContentPart> },
+pub enum InputItem {
+    /// Function call: { type: "function_call", call_id, name, arguments }
     FunctionCall {
         #[serde(rename = "type")]
-        content_type: String, // "function_call"
+        item_type: String,
+        #[serde(default)]
+        id: Option<String>,
         call_id: String,
+        #[serde(default)]
         name: String,
         arguments: String,
     },
+    /// Function call output: { type: "function_call_output", call_id, output }
     FunctionCallOutput {
         #[serde(rename = "type")]
-        content_type: String, // "function_call_output"
+        item_type: String,
         call_id: String,
         output: String,
     },
+    /// Regular message: { role, content }
+    Message(InputMessage),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct InputMessage {
+    pub role: String,
+    pub content: InputMessageContent,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum InputMessageContent {
+    Text(String),
+    Array(Vec<ContentPart>),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]