fix: prevent empty tool names from overwriting valid names in SSE deltas

This commit addresses the root cause identified in GitHub issues:
- #7094: Empty function name cause Azure to reject the request
- #7517: Tool call streaming broken in 0.64.0 with local LLM providers
- #7579: Regression: Tool Name Lost in Streaming Chat Completions

Root Cause (Issue #7579):
The SSE streaming parser was unconditionally overwriting tool call names
with values from subsequent deltas. Many providers (Azure OpenAI, LM Studio,
etc.) send the tool name in the first delta, then send empty strings in
subsequent deltas containing only arguments.

Before this fix:
1. First delta: name="my_tool", arguments="{"
2. Second delta: name="", arguments="foo}"
3. Result: name gets overwritten with "" -> causes API errors

The Fix (Two Layers):

1. ROOT CAUSE FIX (lines 165-170):
   Don't overwrite existing tool call names with empty strings during
   delta parsing. Only update the name if the new value is non-empty.
   This preserves the name from the first delta.

2. DEFENSIVE FIX (lines 228-251):
   Even with the root cause fixed, we add defensive handling at the
   emission point to skip any tool calls that somehow end up with
   empty/missing names, with debug logging to help diagnose issues.

Test Coverage:
- preserves_name_when_subsequent_deltas_have_empty_names: Tests the
  root cause scenario (name in first delta, empty in subsequent)
- skips_tool_calls_with_empty_or_missing_names: Tests the defensive
  layer for edge cases

This fixes compatibility with:
- Azure OpenAI (via LiteLLM)
- LM Studio
- Other OpenAI-compatible local providers

Author: timvw

codex-rs/codex-api/src/sse/chat.rs

@@ -162,7 +162,12 @@ pub async fn process_chat_sse<S>(
 
                         if let Some(func) = tool_call.get("function") {
                             if let Some(fname) = func.get("name").and_then(|n| n.as_str()) {
-                                call_state.name = Some(fname.to_string());
+                                // Only update name if non-empty to prevent subsequent deltas
+                                // from overwriting the initial name with empty strings.
+                                // See: https://github.com/openai/codex/issues/7579
+                                if !fname.is_empty() {
+                                    call_state.name = Some(fname.to_string());
+                                }
                             }
                             if let Some(arguments) = func.get("arguments").and_then(|a| a.as_str())
                             {
@@ -520,6 +525,51 @@ mod tests {
         assert_matches!(events.last(), Some(ResponseEvent::Completed { .. }));
     }
 
+    #[tokio::test]
+    async fn preserves_name_when_subsequent_deltas_have_empty_names() {
+        // Regression test for https://github.com/openai/codex/issues/7579
+        // First delta has the name, subsequent deltas have empty names
+        let delta_with_name = json!({
+            "choices": [{
+                "delta": {
+                    "tool_calls": [{
+                        "id": "call_a",
+                        "function": { "name": "my_tool", "arguments": "{\"arg\":" }
+                    }]
+                }
+            }]
+        });
+
+        let delta_with_empty_name = json!({
+            "choices": [{
+                "delta": {
+                    "tool_calls": [{
+                        "id": "call_a",
+                        "function": { "name": "", "arguments": "123}" }
+                    }]
+                }
+            }]
+        });
+
+        let finish = json!({
+            "choices": [{
+                "finish_reason": "tool_calls"
+            }]
+        });
+
+        let body = build_body(&[delta_with_name, delta_with_empty_name, finish]);
+        let events = collect_events(&body).await;
+
+        // Should preserve the original name "my_tool" despite empty name in second delta
+        assert_matches!(
+            &events[..],
+            [
+                ResponseEvent::OutputItemDone(ResponseItem::FunctionCall { call_id, name, arguments, .. }),
+                ResponseEvent::Completed { .. }
+            ] if call_id == "call_a" && name == "my_tool" && arguments == "{\"arg\":123}"
+        );
+    }
+
     #[tokio::test]
     async fn skips_tool_calls_with_empty_or_missing_names() {
         // Test case for tool call with empty name