fix: cache tool call names in streaming to handle providers with incomplete chunks

- Added toolCallNameCache map in combineStreamingChatResponse to store tool call names by ID
- Modified updateToolCall to accept nameCache parameter and restore missing names from cache
- Fixed streaming callback errors when providers omit function names in subsequent chunks (e.g., GPT-4.1 via OpenRouter)
- Added unit tests for name caching logic covering first chunk caching and subsequent chunk restoration
- Added integration tests for different streaming formats (GPT-4 style multi-chunk, Gemini style single-chunk, parallel tool calls)

This ensures streaming tool calls work correctly with all provider formats, including those that send function names only in the first chunk.

Author: asdek

llms/openai/internal/openaiclient/chat.go

@@ -691,8 +691,9 @@ func combineStreamingChatResponse(
 	defer streaming.CallWithDone(ctx, payload.StreamingFunc) //nolint:errcheck
 
 	var (
-		response  ChatCompletionResponse
-		splitters []reasoning.ChunkContentSplitter
+		response         ChatCompletionResponse
+		splitters        []reasoning.ChunkContentSplitter
+		toolCallNameCache = make(map[string]string) // Cache tool call names by ID for streaming
 	)
 
 	for streamResponse := range responseChan {
@@ -748,7 +749,7 @@ func combineStreamingChatResponse(
 			}
 
 			for _, toolCall := range choice.Delta.ToolCalls {
-				updateToolCall(&responseChoice.Message, toolCall)
+				updateToolCall(&responseChoice.Message, toolCall, toolCallNameCache)
 
 				toolCall := streaming.NewToolCall(toolCall.ID, toolCall.Function.Name, toolCall.Function.Arguments)
 				if err := streaming.CallWithToolCall(ctx, payload.StreamingFunc, toolCall); err != nil {
@@ -805,7 +806,7 @@ func updateFunctionCall(message *ChatMessage, functionCall *FunctionCall) {
 	}
 }
 
-func updateToolCall(message *ChatMessage, delta *StreamedToolCall) {
+func updateToolCall(message *ChatMessage, delta *StreamedToolCall, nameCache map[string]string) {
 	if delta == nil {
 		return
 	}
@@ -837,6 +838,11 @@ func updateToolCall(message *ChatMessage, delta *StreamedToolCall) {
 		toolCall.Type = delta.Type
 		toolCall.Function.Name = delta.Function.Name
 		toolCall.Function.Arguments = delta.Function.Arguments
+
+		// Cache the tool call name by ID for subsequent chunks
+		if nameCache != nil && delta.ID != "" {
+			nameCache[delta.ID] = delta.Function.Name
+		}
 	}
 
 	// For next delta chunks, append arguments to the current tool call
@@ -847,6 +853,12 @@ func updateToolCall(message *ChatMessage, delta *StreamedToolCall) {
 		delta.Function.Name = toolCall.Function.Name
 		delta.ID = toolCall.ID
 		delta.Type = toolCall.Type
+	} else if delta.Function.Name == "" && nameCache != nil {
+		// If ID is present but name is missing (some providers don't send name in subsequent chunks),
+		// restore the name from cache
+		if cachedName, ok := nameCache[delta.ID]; ok {
+			delta.Function.Name = cachedName
+		}
 	}
 }
 

llms/openai/internal/openaiclient/chat_sse_test.go

@@ -7,6 +7,8 @@ import (
 	"net/http"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/vxcontrol/langchaingo/llms/streaming"
 )
 
@@ -81,3 +83,216 @@ data: [DONE]`,
 		})
 	}
 }
+
+func TestParseStreamingChatResponse_ToolCallNameCaching(t *testing.T) {
+	ctx := context.Background()
+	t.Parallel()
+
+	testCases := []struct {
+		name                 string
+		body                 string
+		expectedToolCallName string
+		expectedArguments    string
+		checkStreaming       bool
+	}{
+		{
+			name: "gpt4_style_multiple_chunks_without_name",
+			body: `data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_123","index":0,"type":"function","function":{"name":"getCurrentWeather","arguments":""}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"type":"function","function":{"arguments":"{"}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"type":"function","function":{"arguments":"\"location\":"}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"type":"function","function":{"arguments":"\"Boston\"}"}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}
+data: [DONE]`,
+			expectedToolCallName: "getCurrentWeather",
+			expectedArguments:    `{"location":"Boston"}`,
+			checkStreaming:       true,
+		},
+		{
+			name: "gemini_style_single_chunk_with_name",
+			body: `data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"role":"assistant","tool_calls":[{"index":0,"id":"tool_getCurrentWeather_123","type":"function","function":{"name":"getCurrentWeather","arguments":"{\"location\":\"Boston\"}"}}]},"finish_reason":"tool_calls"}]}
+data: [DONE]`,
+			expectedToolCallName: "getCurrentWeather",
+			expectedArguments:    `{"location":"Boston"}`,
+			checkStreaming:       false,
+		},
+		{
+			name: "parallel_tool_calls_without_names_in_subsequent_chunks",
+			body: `data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_1","index":0,"type":"function","function":{"name":"getCurrentWeather","arguments":""}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"type":"function","function":{"arguments":"{"}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"type":"function","function":{"arguments":"\"location\":\"Boston\"}"}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"id":"call_2","index":1,"type":"function","function":{"name":"getCurrentTime","arguments":""}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"index":1,"type":"function","function":{"arguments":"{"}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{"tool_calls":[{"index":1,"type":"function","function":{"arguments":"\"location\":\"Boston\"}"}}]},"finish_reason":null}]}
+data: {"id":"1","object":"chat.completion.chunk","created":1234567890,"model":"test","choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}
+data: [DONE]`,
+			expectedToolCallName: "getCurrentWeather", // Check first tool call
+			expectedArguments:    `{"location":"Boston"}`,
+			checkStreaming:       true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			var streamedToolCalls []streaming.ToolCall
+
+			r := &http.Response{
+				StatusCode: http.StatusOK,
+				Body:       io.NopCloser(bytes.NewBufferString(tc.body)),
+			}
+
+			req := &ChatRequest{
+				StreamingFunc: func(_ context.Context, chunk streaming.Chunk) error {
+					if chunk.Type == streaming.ChunkTypeToolCall {
+						streamedToolCalls = append(streamedToolCalls, chunk.ToolCall)
+					}
+					return nil
+				},
+			}
+
+			resp, err := parseStreamingChatResponse(ctx, r, req)
+			require.NoError(t, err)
+			require.NotNil(t, resp)
+			require.Greater(t, len(resp.Choices), 0)
+			require.Greater(t, len(resp.Choices[0].Message.ToolCalls), 0)
+
+			// Check final accumulated tool call
+			toolCall := resp.Choices[0].Message.ToolCalls[0]
+			assert.Equal(t, tc.expectedToolCallName, toolCall.Function.Name)
+			assert.Equal(t, tc.expectedArguments, toolCall.Function.Arguments)
+
+			// Check streaming callbacks if needed
+			if tc.checkStreaming {
+				require.Greater(t, len(streamedToolCalls), 0, "should have streamed tool calls")
+				// All streamed tool calls should have the name filled in
+				for i, streamedTC := range streamedToolCalls {
+					assert.NotEmpty(t, streamedTC.Name, "streamed tool call %d should have name", i)
+				}
+			}
+		})
+	}
+}
+
+func TestUpdateToolCall_NameCaching(t *testing.T) {
+	t.Parallel()
+
+	t.Run("cache_name_on_first_chunk", func(t *testing.T) {
+		t.Parallel()
+
+		message := &ChatMessage{}
+		nameCache := make(map[string]string)
+		index := 0
+
+		delta := &StreamedToolCall{
+			ID:    "call_123",
+			Type:  "function",
+			Index: &index,
+			Function: ToolFunction{
+				Name:      "testFunction",
+				Arguments: `{"arg":"value"}`,
+			},
+		}
+
+		updateToolCall(message, delta, nameCache)
+
+		assert.Equal(t, 1, len(message.ToolCalls))
+		assert.Equal(t, "testFunction", message.ToolCalls[0].Function.Name)
+		assert.Equal(t, "testFunction", nameCache["call_123"])
+	})
+
+	t.Run("restore_name_from_cache_on_subsequent_chunks", func(t *testing.T) {
+		t.Parallel()
+
+		message := &ChatMessage{
+			ToolCalls: []ToolCall{
+				{
+					ID:   "call_123",
+					Type: "function",
+					Function: ToolFunction{
+						Name:      "testFunction",
+						Arguments: `{"arg":`,
+					},
+				},
+			},
+		}
+		nameCache := map[string]string{
+			"call_123": "testFunction",
+		}
+		index := 0
+
+		// Subsequent chunk without ID and name (like GPT-4.1 style)
+		delta := &StreamedToolCall{
+			ID:    "", // No ID in subsequent chunk
+			Type:  "function",
+			Index: &index,
+			Function: ToolFunction{
+				Name:      "", // No name in subsequent chunk
+				Arguments: `"value"}`,
+			},
+		}
+
+		updateToolCall(message, delta, nameCache)
+
+		// Name should be restored from the message's tool call
+		assert.Equal(t, "testFunction", delta.Function.Name)
+		assert.Equal(t, "call_123", delta.ID)
+		assert.Equal(t, "testFunction", message.ToolCalls[0].Function.Name)
+		assert.Equal(t, `{"arg":"value"}`, message.ToolCalls[0].Function.Arguments)
+	})
+
+	t.Run("handle_multiple_tool_calls_with_cache", func(t *testing.T) {
+		t.Parallel()
+
+		message := &ChatMessage{}
+		nameCache := make(map[string]string)
+
+		// First tool call - first chunk
+		index0 := 0
+		delta1 := &StreamedToolCall{
+			ID:    "call_1",
+			Type:  "function",
+			Index: &index0,
+			Function: ToolFunction{
+				Name:      "function1",
+				Arguments: "",
+			},
+		}
+		updateToolCall(message, delta1, nameCache)
+
+		// Second tool call - first chunk
+		index1 := 1
+		delta2 := &StreamedToolCall{
+			ID:    "call_2",
+			Type:  "function",
+			Index: &index1,
+			Function: ToolFunction{
+				Name:      "function2",
+				Arguments: "",
+			},
+		}
+		updateToolCall(message, delta2, nameCache)
+
+		assert.Equal(t, 2, len(nameCache))
+		assert.Equal(t, "function1", nameCache["call_1"])
+		assert.Equal(t, "function2", nameCache["call_2"])
+
+		// First tool call - subsequent chunk without ID and name
+		delta3 := &StreamedToolCall{
+			ID:    "", // No ID in subsequent chunk
+			Type:  "function",
+			Index: &index0,
+			Function: ToolFunction{
+				Name:      "",
+				Arguments: `{"a":"b"}`,
+			},
+		}
+		updateToolCall(message, delta3, nameCache)
+
+		assert.Equal(t, "function1", delta3.Function.Name)
+		assert.Equal(t, "call_1", delta3.ID)
+		assert.Equal(t, `{"a":"b"}`, message.ToolCalls[0].Function.Arguments)
+	})
+}