feat: allow responses api to use tool

Author: cyborg42

async-openai/Cargo.toml

@@ -50,7 +50,7 @@ secrecy = { version = "0.10.3", features = ["serde"] }
 bytes = "1.9.0"
 eventsource-stream = "0.2.3"
 tokio-tungstenite = { version = "0.26.1", optional = true, default-features = false }
-schemars = "0.8.22"
+schemars = "0.9.0"
 
 [dev-dependencies]
 tokio-test = "0.4.4"

async-openai/src/tools.rs

@@ -12,6 +12,7 @@ use serde::{Deserialize, Serialize};
 use serde_json::json;
 
 use crate::types::{
+    responses::{self, Function, ToolDefinition},
     ChatCompletionMessageToolCall, ChatCompletionMessageToolCallChunk,
     ChatCompletionRequestToolMessage, ChatCompletionTool, ChatCompletionToolType, FunctionCall,
     FunctionObject,
@@ -29,7 +30,7 @@ pub trait Tool: Send + Sync {
 
     /// Returns the name of the tool.
     fn name() -> String {
-        Self::Args::schema_name()
+        Self::Args::schema_name().to_string()
     }
 
     /// Returns an optional description of the tool.
@@ -42,8 +43,8 @@ pub trait Tool: Send + Sync {
         None
     }
 
-    /// Creates a ChatCompletionTool definition for the tool.
-    fn definition() -> ChatCompletionTool {
+    /// Returns the tool's definition for chat.
+    fn definition_for_chat() -> ChatCompletionTool {
         ChatCompletionTool {
             r#type: ChatCompletionToolType::Function,
             function: FunctionObject {
@@ -55,6 +56,16 @@ pub trait Tool: Send + Sync {
         }
     }
 
+    /// Returns the tool's definition for responses.
+    fn definition_for_responses() -> ToolDefinition {
+        ToolDefinition::Function(Function {
+            name: Self::name(),
+            description: Self::description(),
+            parameters: json!(schema_for!(Self::Args)),
+            strict: Self::strict().unwrap_or(false),
+        })
+    }
+
     /// Executes the tool with the given arguments.
     /// Returns a Future that resolves to either the tool's output or an error.
     fn call(
@@ -66,8 +77,14 @@ pub trait Tool: Send + Sync {
 /// A dynamic trait for tools that allows for runtime tool management.
 /// This trait provides a way to work with tools without knowing their concrete types at compile time.
 pub trait ToolDyn: Send + Sync {
-    /// Returns the tool's definition as a ChatCompletionTool.
-    fn definition(&self) -> ChatCompletionTool;
+    /// Returns the tool's name.
+    fn name(&self) -> String;
+
+    /// Returns the tool's definition for chat.
+    fn definition_for_chat(&self) -> ChatCompletionTool;
+
+    /// Returns the tool's definition for responses.
+    fn definition_for_responses(&self) -> ToolDefinition;
 
     /// Executes the tool with the given JSON string arguments.
     /// Returns a Future that resolves to either a JSON string output or an error string.
@@ -79,8 +96,16 @@ pub trait ToolDyn: Send + Sync {
 
 // Implementation of ToolDyn for any type that implements Tool
 impl<T: Tool> ToolDyn for T {
-    fn definition(&self) -> ChatCompletionTool {
-        T::definition()
+    fn name(&self) -> String {
+        T::name()
+    }
+
+    fn definition_for_chat(&self) -> ChatCompletionTool {
+        T::definition_for_chat()
+    }
+
+    fn definition_for_responses(&self) -> ToolDefinition {
+        T::definition_for_responses()
     }
 
     fn call(
@@ -125,29 +150,39 @@ impl ToolManager {
 
     /// Adds a new tool to the manager.
     pub fn add_tool<T: Tool + 'static>(&mut self, tool: T) {
-        self.tools
-            .insert(T::name(), Arc::new(tool));
+        self.tools.insert(T::name(), Arc::new(tool));
     }
 
     /// Adds a new tool with an Arc to the manager.
     ///
     /// Use this if you want to access this tool after being added to the manager.
     pub fn add_tool_dyn(&mut self, tool: Arc<dyn ToolDyn>) {
-        self.tools.insert(tool.definition().function.name, tool);
+        self.tools.insert(tool.name(), tool);
     }
 
     /// Removes a tool from the manager.
     pub fn remove_tool(&mut self, name: &str) -> bool {
         self.tools.remove(name).is_some()
     }
 
-    /// Returns the definitions of all tools in the manager.
-    pub fn get_tools(&self) -> Vec<ChatCompletionTool> {
-        self.tools.values().map(|tool| tool.definition()).collect()
+    /// Returns the definitions of all tools for chat in the manager.
+    pub fn get_tools_for_chat(&self) -> Vec<ChatCompletionTool> {
+        self.tools
+            .values()
+            .map(|tool| tool.definition_for_chat())
+            .collect()
+    }
+
+    /// Returns the definitions of all tools for responses in the manager.
+    pub fn get_tools_for_responses(&self) -> Vec<ToolDefinition> {
+        self.tools
+            .values()
+            .map(|tool| tool.definition_for_responses())
+            .collect()
     }
 
-    /// Executes multiple tool calls concurrently and returns their results.
-    pub async fn call(
+    /// Executes multiple tool calls concurrently and returns their results for chat.
+    pub async fn call_for_chat(
         &self,
         calls: impl IntoIterator<Item = ChatCompletionMessageToolCall>,
     ) -> Vec<ChatCompletionRequestToolMessage> {
@@ -183,6 +218,46 @@ impl ToolManager {
         }
         outputs
     }
+
+    /// Executes multiple tool calls concurrently and returns their results for responses.
+    pub async fn call_for_responses(
+        &self,
+        calls: impl IntoIterator<Item = responses::FunctionCall>,
+    ) -> Vec<responses::InputItem> {
+        let mut handles = Vec::new();
+        let mut outputs = Vec::new();
+
+        // Spawn a task for each tool call
+        for call in calls {
+            if let Some(tool) = self.tools.get(&call.name).cloned() {
+                let handle = tokio::spawn(async move { tool.call(call.arguments).await });
+                handles.push((call.call_id, handle));
+            } else {
+                outputs.push(responses::InputItem::Custom(json!({
+                    "type": "function_call_output",
+                    "call_id": call.call_id,
+                    "output": "Tool call failed: tool not found",
+                })));
+            }
+        }
+
+        // Collect results from all spawned tasks
+        for (id, handle) in handles {
+            let output = match handle.await {
+                Ok(Ok(output)) => output,
+                Ok(Err(e)) => {
+                    format!("Tool call failed: {}", e)
+                }
+                Err(_) => "Tool call failed: runtime error".to_string(),
+            };
+            outputs.push(responses::InputItem::Custom(json!({
+                "type": "function_call_output",
+                "call_id": id,
+                "output": output,
+            })));
+        }
+        outputs
+    }
 }
 
 /// A manager for handling streaming tool calls.

async-openai/src/types/impls.rs

@@ -13,6 +13,7 @@ use crate::{
 
 use bytes::Bytes;
 
+#[allow(deprecated)]
 use super::{
     responses::{CodeInterpreterContainer, Input, InputContent, Role as ResponsesRole},
     AddUploadPartRequest, AudioInput, AudioResponseFormat, ChatCompletionFunctionCall,
@@ -531,6 +532,7 @@ impl From<String> for ChatCompletionToolChoiceOption {
     }
 }
 
+#[allow(deprecated)]
 impl From<(String, serde_json::Value)> for ChatCompletionFunctions {
     fn from(value: (String, serde_json::Value)) -> Self {
         Self {

examples/responses-function-call/Cargo.toml

@@ -9,3 +9,5 @@ async-openai = {path = "../../async-openai"}
 serde_json = "1.0.135"
 tokio = { version = "1.43.0", features = ["full"] }
 serde = { version = "1.0.219", features = ["derive"] }
+schemars = "0.9.0"
+rand = "0.9.1"

examples/responses-function-call/src/main.rs

@@ -1,57 +1,23 @@
 use async_openai::{
+    tools::{Tool, ToolManager},
     types::responses::{
-        CreateResponseArgs, FunctionArgs, FunctionCall, Input, InputItem, InputMessageArgs,
-        OutputContent, Role, ToolDefinition,
+        CreateResponseArgs, FunctionCall, Input, InputItem, InputMessageArgs, OutputContent, Role,
     },
     Client,
 };
-use serde::Deserialize;
+use rand::{rng, seq::IndexedRandom, Rng};
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
 use std::error::Error;
 
-#[derive(Debug, Deserialize)]
-struct WeatherFunctionArgs {
-    location: String,
-    units: String,
-}
-
-fn check_weather(location: String, units: String) -> String {
-    format!("The weather in {location} is 25 {units}")
-}
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn Error>> {
     let client = Client::new();
 
-    let tools = vec![ToolDefinition::Function(
-        FunctionArgs::default()
-            .name("get_weather")
-            .description("Retrieves current weather for the given location")
-            .parameters(serde_json::json!(
-                {
-                    "type": "object",
-                    "properties": {
-                        "location": {
-                            "type": "string",
-                            "description": "City and country e.g. Bogotá, Colombia"
-                        },
-                        "units": {
-                            "type": "string",
-                            "enum": [
-                                "celsius",
-                                "fahrenheit"
-                            ],
-                            "description": "Units the temperature will be returned in."
-                        }
-                    },
-                    "required": [
-                        "location",
-                        "units"
-                    ],
-                    "additionalProperties": false
-                }
-            ))
-            .build()?,
-    )];
+    let weather_tool = WeatherTool;
+    let mut tool_manager = ToolManager::new();
+    tool_manager.add_tool(weather_tool);
+    let tools = tool_manager.get_tools_for_responses();
 
     let mut input_messages = vec![InputItem::Message(
         InputMessageArgs::default()
@@ -71,40 +37,33 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     let response = client.responses().create(request).await?;
 
+    for output_content in response.output.clone() {
+        input_messages.push(InputItem::Custom(serde_json::to_value(output_content)?));
+    }
+
     // the model might ask for us to do a function call
-    let function_call_request: Option<FunctionCall> =
-        response.output.into_iter().find_map(|output_content| {
+    let function_call_request: Vec<FunctionCall> = response
+        .output
+        .into_iter()
+        .filter_map(|output_content| {
             if let OutputContent::FunctionCall(inner) = output_content {
                 Some(inner)
             } else {
                 None
             }
-        });
+        })
+        .collect();
 
-    let Some(function_call_request) = function_call_request else {
+    if function_call_request.is_empty() {
         println!("No function_call request found");
         return Ok(());
     };
 
-    let function_result = match function_call_request.name.as_str() {
-        "get_weather" => {
-            let args: WeatherFunctionArgs = serde_json::from_str(&function_call_request.arguments)?;
-            check_weather(args.location, args.units)
-        }
-        _ => {
-            println!("Unknown function {}", function_call_request.name);
-            return Ok(());
-        }
-    };
+    let function_result = tool_manager
+        .call_for_responses(function_call_request.clone())
+        .await;
 
-    input_messages.push(InputItem::Custom(serde_json::to_value(
-        &OutputContent::FunctionCall(function_call_request.clone()),
-    )?));
-    input_messages.push(InputItem::Custom(serde_json::json!({
-        "type": "function_call_output",
-        "call_id": function_call_request.call_id,
-        "output": function_result,
-    })));
+    input_messages.extend(function_result);
 
     let request = CreateResponseArgs::default()
         .max_output_tokens(512u32)
@@ -121,3 +80,61 @@ async fn main() -> Result<(), Box<dyn Error>> {
 
     Ok(())
 }
+
+#[derive(Debug, JsonSchema, Deserialize, Serialize)]
+enum Unit {
+    Fahrenheit,
+    Celsius,
+}
+
+#[derive(Debug, JsonSchema, Deserialize)]
+struct WeatherRequest {
+    /// The city and state, e.g. San Francisco, CA
+    location: String,
+    unit: Unit,
+}
+
+#[derive(Debug, Serialize)]
+struct WeatherResponse {
+    location: String,
+    temperature: String,
+    unit: Unit,
+    forecast: String,
+}
+
+struct WeatherTool;
+
+impl Tool for WeatherTool {
+    type Args = WeatherRequest;
+    type Output = WeatherResponse;
+    type Error = String;
+
+    fn name() -> String {
+        "get_current_weather".to_string()
+    }
+
+    fn description() -> Option<String> {
+        Some("Get the current weather in a given location".to_string())
+    }
+
+    async fn call(&self, args: Self::Args) -> Result<Self::Output, Self::Error> {
+        let mut rng = rng();
+
+        let temperature: i32 = rng.random_range(20..=55);
+
+        let forecasts = [
+            "sunny", "cloudy", "overcast", "rainy", "windy", "foggy", "snowy",
+        ];
+
+        let forecast = forecasts.choose(&mut rng).unwrap_or(&"sunny");
+
+        let weather_info = WeatherResponse {
+            location: args.location,
+            temperature: temperature.to_string(),
+            unit: args.unit,
+            forecast: forecast.to_string(),
+        };
+
+        Ok(weather_info)
+    }
+}

examples/tool-call-stream/Cargo.toml

@@ -13,4 +13,4 @@ serde = "1.0"
 serde_json = "1.0.135"
 tokio = { version = "1.43.0", features = ["full"] }
 futures = "0.3.31"
-schemars = "0.8.22"
+schemars = "0.9.0"