fix: some provider may not return funciton id / function name in the first chunk during tool_call stream

Author: cyborg42

async-openai/src/tools.rs

@@ -1,7 +1,7 @@
 //! This module provides functionality for managing and executing tools in an async OpenAI context.
 //! It defines traits and structures for tool management, execution, and streaming.
 use std::{
-    collections::{hash_map::Entry, BTreeMap, HashMap},
+    collections::{BTreeMap, HashMap},
     future::Future,
     pin::Pin,
     sync::Arc,
@@ -14,7 +14,7 @@ use serde_json::json;
 use crate::types::{
     ChatCompletionMessageToolCall, ChatCompletionMessageToolCallChunk,
     ChatCompletionRequestToolMessage, ChatCompletionTool, ChatCompletionToolType, FunctionCall,
-    FunctionCallStream, FunctionObject,
+    FunctionObject,
 };
 
 /// A trait defining the interface for tools that can be used with the OpenAI API.
@@ -92,7 +92,7 @@ impl<T: Tool> ToolDyn for T {
             // If the tool doesn't require arguments (T::Args is unit type),
             // we can safely ignore the provided arguments string
             match serde_json::from_str::<T::Args>(&args)
-                .or_else(|e| serde_json::from_str::<T::Args>(&"null").map_err(|_| e))
+                .or_else(|e| serde_json::from_str::<T::Args>("null").map_err(|_| e))
             {
                 Ok(args) => T::call(self, args)
                     .await
@@ -166,9 +166,7 @@ impl ToolManager {
                 Ok(Err(e)) => {
                     format!("Tool call failed: {}", e)
                 }
-                Err(_) => {
-                    format!("Tool call failed: runtime error")
-                }
+                Err(_) => "Tool call failed: runtime error".to_string(),
             };
             outputs.push(ChatCompletionRequestToolMessage {
                 content: output.into(),
@@ -192,37 +190,26 @@ impl ToolCallStreamManager {
 
     /// Processes a single streaming tool call chunk and merges it with existing data.
     pub fn process_chunk(&mut self, chunk: ChatCompletionMessageToolCallChunk) {
-        match self.0.entry(chunk.index) {
-            Entry::Occupied(mut o) => {
-                if let Some(FunctionCallStream {
-                    name: _,
-                    arguments: Some(arguments),
-                }) = chunk.function
-                {
-                    o.get_mut().function.arguments.push_str(&arguments);
-                }
-            }
-            Entry::Vacant(o) => {
-                let ChatCompletionMessageToolCallChunk {
-                    index: _,
-                    id: Some(id),
-                    r#type: _,
-                    function:
-                        Some(FunctionCallStream {
-                            name: Some(name),
-                            arguments: Some(arguments),
-                        }),
-                } = chunk
-                else {
-                    tracing::error!("Tool call chunk is not complete: {:?}", chunk);
-                    return;
-                };
-                let tool_call = ChatCompletionMessageToolCall {
-                    id,
+        let tool_call =
+            self.0
+                .entry(chunk.index)
+                .or_insert_with(|| ChatCompletionMessageToolCall {
+                    id: "".to_string(),
                     r#type: ChatCompletionToolType::Function,
-                    function: FunctionCall { name, arguments },
-                };
-                o.insert(tool_call);
+                    function: FunctionCall {
+                        name: "".to_string(),
+                        arguments: "".to_string(),
+                    },
+                });
+        if let Some(id) = chunk.id {
+            tool_call.id = id;
+        }
+        if let Some(function) = chunk.function {
+            if let Some(name) = function.name {
+                tool_call.function.name = name;
+            }
+            if let Some(arguments) = function.arguments {
+                tool_call.function.arguments.push_str(&arguments);
             }
         }
     }
@@ -239,6 +226,15 @@ impl ToolCallStreamManager {
 
     /// Returns all completed tool calls as a vector.
     pub fn finish_stream(self) -> Vec<ChatCompletionMessageToolCall> {
-        self.0.into_values().collect()
+        self.0
+            .into_values()
+            .filter(|tool_call| {
+                let is_complete = !tool_call.id.is_empty() && !tool_call.function.name.is_empty();
+                if !is_complete {
+                    tracing::error!("Tool call is not complete: {:?}", tool_call);
+                }
+                is_complete
+            })
+            .collect()
     }
 }