fix: function_call can be a string or an object

chat.go

@@ -17,8 +17,9 @@ const (
 const chatCompletionsSuffix = "/chat/completions"
 
 var (
-	ErrChatCompletionInvalidModel       = errors.New("this model is not supported with this method, please use CreateCompletion client method instead") //nolint:lll
-	ErrChatCompletionStreamNotSupported = errors.New("streaming is not supported with this method, please use CreateChatCompletionStream")              //nolint:lll
+	ErrChatCompletionInvalidModel        = errors.New("this model is not supported with this method, please use CreateCompletion client method instead") //nolint:lll
+	ErrChatCompletionStreamNotSupported  = errors.New("streaming is not supported with this method, please use CreateChatCompletionStream")              //nolint:lll
+	ErrChatCompletionInvalidFunctionCall = errors.New(`FunctionCall parameter only supports "none", "auto", or a map[string]string`)                     //nolint:lll
 )
 
 type ChatCompletionMessage struct {
@@ -55,7 +56,20 @@ type ChatCompletionRequest struct {
 	LogitBias        map[string]int          `json:"logit_bias,omitempty"`
 	User             string                  `json:"user,omitempty"`
 	Functions        []*FunctionDefine       `json:"functions,omitempty"`
-	FunctionCall     string                  `json:"function_call,omitempty"`
+	FunctionCall     any                     `json:"function_call,omitempty"`
+}
+
+func checkFunctionCall(value any) bool {
+	if value == nil {
+		return true
+	}
+	if v, isString := value.(string); isString {
+		return v == "none" || v == "auto"
+	}
+	if v, isMap := value.(map[string]string); isMap {
+		return v["name"] != ""
+	}
+	return false
 }
 
 type FunctionDefine struct {
@@ -146,6 +160,11 @@ func (c *Client) CreateChatCompletion(
 		return
 	}
 
+	if !checkFunctionCall(request.FunctionCall) {
+		err = ErrChatCompletionInvalidFunctionCall
+		return
+	}
+
 	req, err := c.requestBuilder.Build(ctx, http.MethodPost, c.fullURL(urlSuffix, request.Model), request)
 	if err != nil {
 		return

chat_stream.go

@@ -8,8 +8,9 @@ import (
 )
 
 type ChatCompletionStreamChoiceDelta struct {
-	Content string `json:"content,omitempty"`
-	Role    string `json:"role,omitempty"`
+	Content      string        `json:"content,omitempty"`
+	Role         string        `json:"role,omitempty"`
+	FunctionCall *FunctionCall `json:"function_call,omitempty"`
 }
 
 type ChatCompletionStreamChoice struct {
@@ -46,6 +47,11 @@ func (c *Client) CreateChatCompletionStream(
 		return
 	}
 
+	if !checkFunctionCall(request.FunctionCall) {
+		err = ErrChatCompletionInvalidFunctionCall
+		return
+	}
+
 	request.Stream = true
 	req, err := c.newStreamRequest(ctx, "POST", urlSuffix, request, request.Model)
 	if err != nil {

chat_stream_test.go

@@ -1,6 +1,8 @@
 package openai_test
 
 import (
+	"fmt"
+
 	. "github.com/sashabaranov/go-openai"
 	"github.com/sashabaranov/go-openai/internal/test/checks"
 
@@ -128,6 +130,41 @@ func TestCreateChatCompletionStream(t *testing.T) {
 	}
 }
 
+func TestChatCompletionsStreamWithFunctionCall(t *testing.T) {
+	config := DefaultConfig("whatever")
+	config.BaseURL = "http://localhost/v1"
+	client := NewClientWithConfig(config)
+	ctx := context.Background()
+
+	cases := []struct {
+		FunctionCall any
+		Pass         bool
+	}{
+		{"none", true},
+		{"auto", true},
+		{map[string]string{"name": "test"}, true},
+		{nil, true},
+		{"invalid", false},
+		{map[string]string{}, false},
+	}
+	for _, c := range cases {
+		req := ChatCompletionRequest{
+			FunctionCall: c.FunctionCall,
+		}
+		_, err := client.CreateChatCompletionStream(ctx, req)
+		if c.Pass {
+			checks.ErrorIsNot(t, err, ErrChatCompletionInvalidFunctionCall, "unexpected error")
+		} else {
+			checks.ErrorIs(
+				t,
+				err,
+				ErrChatCompletionInvalidFunctionCall,
+				fmt.Sprintf("should not pass for function call: %v", c.FunctionCall),
+			)
+		}
+	}
+}
+
 func TestCreateChatCompletionStreamError(t *testing.T) {
 	client, server, teardown := setupOpenAITestServer()
 	defer teardown()

chat_test.go

@@ -49,6 +49,41 @@ func TestChatCompletionsWithStream(t *testing.T) {
 	checks.ErrorIs(t, err, ErrChatCompletionStreamNotSupported, "unexpected error")
 }
 
+func TestChatCompletionsWithFunctionCall(t *testing.T) {
+	config := DefaultConfig("whatever")
+	config.BaseURL = "http://localhost/v1"
+	client := NewClientWithConfig(config)
+	ctx := context.Background()
+
+	cases := []struct {
+		FunctionCall any
+		Pass         bool
+	}{
+		{"none", true},
+		{"auto", true},
+		{map[string]string{"name": "test"}, true},
+		{nil, true},
+		{"invalid", false},
+		{map[string]string{}, false},
+	}
+	for _, c := range cases {
+		req := ChatCompletionRequest{
+			FunctionCall: c.FunctionCall,
+		}
+		_, err := client.CreateChatCompletion(ctx, req)
+		if c.Pass {
+			checks.ErrorIsNot(t, err, ErrChatCompletionInvalidFunctionCall, "unexpected error")
+		} else {
+			checks.ErrorIs(
+				t,
+				err,
+				ErrChatCompletionInvalidFunctionCall,
+				fmt.Sprintf("should not pass for function call: %v", c.FunctionCall),
+			)
+		}
+	}
+}
+
 // TestCompletions Tests the completions endpoint of the API using the mocked server.
 func TestChatCompletions(t *testing.T) {
 	client, server, teardown := setupOpenAITestServer()