Better ChatCompletionFunctionCall interface

async-openai/src/types/impls.rs

@@ -3,6 +3,8 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use serde::{ser::SerializeMap, Serialize};
+
 use crate::{
     download::{download_url, save_b64},
     error::OpenAIError,
@@ -351,13 +353,36 @@ impl_from_for_array_of_integer_array!(u16, Prompt);
 
 impl From<&str> for ChatCompletionFunctionCall {
     fn from(value: &str) -> Self {
-        ChatCompletionFunctionCall::String(value.to_string())
+        match value {
+            "none" => Self::None,
+            "auto" => Self::Auto,
+            _ => Self::Function(value.to_string()),
+        }
     }
 }
 
-impl From<serde_json::Value> for ChatCompletionFunctionCall {
-    fn from(value: serde_json::Value) -> Self {
-        ChatCompletionFunctionCall::Object(value)
+impl Serialize for ChatCompletionFunctionCall {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            ChatCompletionFunctionCall::None => serializer.serialize_str("none"),
+            ChatCompletionFunctionCall::Auto => serializer.serialize_str("auto"),
+            ChatCompletionFunctionCall::Function(s) => {
+                let mut map = serializer.serialize_map(Some(1))?;
+                map.serialize_entry("name", s)?;
+                map.end()
+            }
+        }
+    }
+}
+
+impl<'de> serde::de::Deserialize<'de> for ChatCompletionFunctionCall {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+
+        Ok(s.as_str().into())
     }
 }
 

async-openai/src/types/types.rs

@@ -37,11 +37,14 @@ pub enum Stop {
     StringArray(Vec<String>), // minItems: 1; maxItems: 4
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
-#[serde(untagged)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum ChatCompletionFunctionCall {
-    String(String),
-    Object(serde_json::Value),
+    /// The model does not call a function, and responds to the end-user.
+    None,
+    /// The model can pick between an end-user or calling a function.
+    Auto,
+    /// Forces the model to call the specified function.
+    Function(String),
 }
 
 #[derive(Clone, Serialize, Default, Debug, Builder, PartialEq)]
@@ -781,10 +784,7 @@ pub struct CreateChatCompletionRequest {
     pub functions: Option<Vec<ChatCompletionFunctions>>,
 
     /// Controls how the model responds to function calls.
-    /// "none" means the model does not call a function, and responds to the end-user.
-    /// "auto" means the model can pick between an end-user or calling a function.
-    /// Specifying a particular function via `{"name":\ "my_function"}` forces the model to call that function.
-    /// "none" is the default when no functions are present. "auto" is the default if functions are present.
+    /// None is the default when no functions are present. Auto is the default if functions are present.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub function_call: Option<ChatCompletionFunctionCall>,