fix: handle chatcompletions streaming tool calls with no text preamble and non-zero indices

Author: ssncferreira

bridge_integration_test.go

@@ -437,6 +437,78 @@ func TestOpenAIChatCompletions(t *testing.T) {
 			})
 		}
 	})
+
+	t.Run("streaming injected tool call only", func(t *testing.T) {
+		t.Parallel()
+
+		arc := txtar.Parse(fixtures.OaiChatStreamingToolCallOnly)
+		t.Logf("%s: %s", t.Name(), arc.Comment)
+
+		files := filesMap(arc)
+		require.Len(t, files, 2)
+		require.Contains(t, files, fixtureRequest)
+		require.Contains(t, files, fixtureStreamingResponse)
+
+		reqBody := files[fixtureRequest]
+
+		// Add the stream param to the request.
+		newBody, err := setJSON(reqBody, "stream", true)
+		require.NoError(t, err)
+		reqBody = newBody
+
+		ctx, cancel := context.WithTimeout(t.Context(), time.Second*30)
+		t.Cleanup(cancel)
+		srv := newMockServer(ctx, t, files, nil)
+		t.Cleanup(srv.Close)
+
+		fmt.Printf("########## Fixture streaming content length: %d\n", len(files[fixtureStreamingResponse]))
+		fmt.Printf("########## Fixture streaming content:\n%s\n", string(files[fixtureStreamingResponse]))
+
+		recorderClient := &testutil.MockRecorder{}
+
+		// Setup MCP proxies with the tool from the fixture
+		mcpProxiers, mcpCalls := setupMCPServerProxiesForTest(t, testTracer)
+		mcpMgr := mcp.NewServerProxyManager(mcpProxiers, testTracer)
+		require.NoError(t, mcpMgr.Init(ctx))
+
+		logger := slogtest.Make(t, &slogtest.Options{IgnoreErrors: false}).Leveled(slog.LevelDebug)
+		providers := []aibridge.Provider{provider.NewOpenAI(openaiCfg(srv.URL, apiKey))}
+		b, err := aibridge.NewRequestBridge(t.Context(), providers, recorderClient, mcpMgr, logger, nil, testTracer)
+		require.NoError(t, err)
+
+		mockSrv := httptest.NewUnstartedServer(b)
+		t.Cleanup(mockSrv.Close)
+		mockSrv.Config.BaseContext = func(_ net.Listener) context.Context {
+			return aibcontext.AsActor(ctx, userID, nil)
+		}
+		mockSrv.Start()
+
+		req := createOpenAIChatCompletionsReq(t, mockSrv.URL, reqBody)
+
+		client := &http.Client{}
+		resp, err := client.Do(req)
+		require.NoError(t, err)
+		require.Equal(t, http.StatusOK, resp.StatusCode)
+		defer resp.Body.Close()
+
+		// Verify the MCP tool was actually invoked
+		invocations := mcpCalls.getCallsByTool(mockToolName)
+		require.Len(t, invocations, 1, "expected MCP tool to be invoked")
+
+		// Verify tool was invoked with the args from the fixture
+		expected, err := json.Marshal(map[string]any{"owner": "me"})
+		require.NoError(t, err)
+		actual, err := json.Marshal(invocations[0])
+		require.NoError(t, err)
+		require.EqualValues(t, expected, actual)
+
+		// Verify tool usage was recorded
+		toolUsages := recorderClient.RecordedToolUsages()
+		require.Len(t, toolUsages, 1)
+		assert.Equal(t, mockToolName, toolUsages[0].Tool)
+
+		recorderClient.VerifyAllInterceptionsEnded(t)
+	})
 }
 
 func TestSimple(t *testing.T) {

fixtures/fixtures.go

@@ -45,6 +45,9 @@ var (
 
 	//go:embed openai/chatcompletions/non_stream_error.txtar
 	OaiChatNonStreamError []byte
+
+	//go:embed openai/chatcompletions/tool_call_only.txtar
+	OaiChatStreamingToolCallOnly []byte
 )
 
 var (

fixtures/openai/chatcompletions/tool_call_only.txtar

@@ -0,0 +1,33 @@
+First chunk as a tool call.
+Copilot error: `Execution failed: Error: request ended without sending any chunks`
+
+-- request --
+{
+    "messages": [
+      {
+        "content": "<current_datetime>2026-01-22T18:35:17.612Z</current_datetime>\n\nlist all my coder workspaces",
+        "role": "user"
+      }
+    ],
+    "model": "claude-haiku-4.5",
+    "n": 1,
+    "temperature": 1,
+    "parallel_tool_calls": false,
+    "stream_options": {
+        "include_usage": true
+    },
+    "stream": true
+}
+
+-- streaming --
+data: {"choices":[{"index":0,"delta":{"content":null,"tool_calls":[{"function":{"name":"bmcp_coder_coder_list_workspaces"},"id":"toolu_vrtx_01CvBi1d4qpKTG2PCuc9wDbZ","index":0,"type":"function"}]}}],"created":1769106921,"id":"msg_vrtx_01UoiRJwj3JXcwNYAh3z7ARs","model":"claude-haiku-4.5"}
+
+data: {"choices":[{"index":0,"delta":{"content":null,"tool_calls":[{"function":{"arguments":""},"index":0}]}}],"created":1769106921,"id":"msg_vrtx_01UoiRJwj3JXcwNYAh3z7ARs","model":"claude-haiku-4.5"}
+
+data: {"choices":[{"index":0,"delta":{"content":null,"tool_calls":[{"function":{"arguments":"{\"own"},"index":0}]}}],"created":1769106921,"id":"msg_vrtx_01UoiRJwj3JXcwNYAh3z7ARs","model":"claude-haiku-4.5"}
+
+data: {"choices":[{"index":0,"delta":{"content":null,"tool_calls":[{"function":{"arguments":"er\": \"me\"}"},"index":0}]}}],"created":1769106921,"id":"msg_vrtx_01UoiRJwj3JXcwNYAh3z7ARs","model":"claude-haiku-4.5"}
+
+data: {"choices":[{"finish_reason":"tool_calls","index":0,"delta":{"content":null}}],"created":1769106921,"id":"msg_vrtx_01UoiRJwj3JXcwNYAh3z7ARs","usage":{"completion_tokens":65,"prompt_tokens":25716,"prompt_tokens_details":{"cached_tokens":20470},"total_tokens":25781},"model":"claude-haiku-4.5"}
+
+data: [DONE]

intercept/chatcompletions/streaming.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"fmt"
 	"net/http"
+	"slices"
 	"strings"
 	"time"
 
@@ -160,6 +161,28 @@ func (i *StreamingInterception) ProcessRequest(w http.ResponseWriter, r *http.Re
 			toolCall = nil
 		}
 
+		if toolCall != nil {
+			// Builtin tools are not intercepted.
+			if i.getInjectedToolByName(toolCall.Name) == nil {
+				// Builtin tool - record usage and clear toolCall
+				_ = i.recorder.RecordToolUsage(streamCtx, &recorder.ToolUsageRecord{
+					InterceptionID: i.ID().String(),
+					MsgID:          processor.getMsgID(),
+					Tool:           toolCall.Name,
+					Args:           i.unmarshalArgs(toolCall.Arguments),
+					Injected:       false,
+				})
+				toolCall = nil
+			} else {
+				// Injected tools mark the stream as initiated so we continue to tool invocation.
+				// When the provider responds with a tool call as the first chunk (no text
+				// preamble), no chunks are relayed to the client. Marking as initiated
+				// ensures we continue to tool invocation instead of returning early.
+				events.MarkInitiated()
+
+			}
+		}
+
 		if prompt != nil {
 			_ = i.recorder.RecordPromptUsage(streamCtx, &recorder.PromptUsageRecord{
 				InterceptionID: i.ID().String(),
@@ -239,7 +262,13 @@ func (i *StreamingInterception) ProcessRequest(w http.ResponseWriter, r *http.Re
 
 		// Invoke the injected tool, and use the tool result to make a subsequent request to the upstream.
 		// Append the completion from this stream as context.
-		i.req.Messages = append(i.req.Messages, processor.getLastCompletion().ToParam())
+		// Some providers may return tool calls with non-zero starting indices,
+		// resulting in nil entries in the array that must be removed.
+		completion := processor.getLastCompletion()
+		if completion != nil {
+			compactToolCalls(completion)
+			i.req.Messages = append(i.req.Messages, completion.ToParam())
+		}
 
 		id := toolCall.ID
 		args := i.unmarshalArgs(toolCall.Arguments)
@@ -486,3 +515,13 @@ func (s *streamProcessor) getLastUsage() openai.CompletionUsage {
 func (s *streamProcessor) getCumulativeUsage() openai.CompletionUsage {
 	return s.cumulativeUsage
 }
+
+// compactToolCalls removes nil/empty tool call entries (without an ID).
+func compactToolCalls(msg *openai.ChatCompletionMessage) {
+	if msg == nil || len(msg.ToolCalls) == 0 {
+		return
+	}
+	msg.ToolCalls = slices.DeleteFunc(msg.ToolCalls, func(tc openai.ChatCompletionMessageToolCallUnion) bool {
+		return tc.ID == ""
+	})
+}

intercept/eventstream/eventstream.go

@@ -199,6 +199,15 @@ func (s *EventStream) IsStreaming() bool {
 	return s.initiated.Load() || len(s.eventsCh) > 0
 }
 
+// MarkInitiated marks the stream as initiated, even if no events have been
+// sent to the client yet. A stream is considered initiated when processing
+// injected tool calls that don't relay chunks to the client.
+func (s *EventStream) MarkInitiated() {
+	s.initiateOnce.Do(func() {
+		s.initiated.Store(true)
+	})
+}
+
 // IsConnError checks if an error is related to client disconnection or context cancellation.
 func IsConnError(err error) bool {
 	if err == nil {