fix: only disable parallel tool calls when injectable tools are present

Signed-off-by: Danny Kopping <danny@coder.com>

Author: dannykopping

fixtures/openai/chatcompletions/single_builtin_tool.txtar

@@ -9,6 +9,7 @@ LLM (https://llm.datasette.io/) configured with a simple "read_file" tool.
     }
   ],
   "model": "gpt-4.1",
+  "parallel_tool_calls": true,
   "tools": [
     {
       "type": "function",

intercept/chatcompletions/base.go

@@ -107,6 +107,12 @@ func (i *interceptionBase) injectTools() {
 		return
 	}
 
+	// Disable parallel tool calls when injectable tools are present to simplify the inner agentic loop.
+	// Only set when there are tools in the request, otherwise it causes a 400 Bad Request.
+	if i.HasInjectableTools() && len(i.req.Tools) > 0 {
+		i.req.ParallelToolCalls = openai.Bool(false)
+	}
+
 	// Inject tools.
 	for _, tool := range i.mcpProxy.ListTools() {
 		fn := openai.ChatCompletionToolUnionParam{
@@ -171,6 +177,10 @@ func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, oaiErr *err
 	}
 }
 
+func (i *interceptionBase) HasInjectableTools() bool {
+	return i.mcpProxy != nil && len(i.mcpProxy.ListTools()) > 0
+}
+
 func sumUsage(ref, in openai.CompletionUsage) openai.CompletionUsage {
 	return openai.CompletionUsage{
 		CompletionTokens: ref.CompletionTokens + in.CompletionTokens,

intercept/chatcompletions/streaming.go

@@ -97,12 +97,6 @@ func (i *StreamingInterception) ProcessRequest(w http.ResponseWriter, r *http.Re
 		_ = events.Shutdown(streamCtx) // Catch-all in case it doesn't get shutdown after stream completes.
 	}()
 
-	// TODO: implement parallel tool calls.
-	// TODO: don't send if not supported by model (i.e. o4-mini).
-	if len(i.req.Tools) > 0 { // If no tools are specified but this setting is set, it'll cause a 400 Bad Request.
-		i.req.ParallelToolCalls = openai.Bool(false)
-	}
-
 	// Force responses to only have one choice.
 	// It's unnecessary to generate multiple responses, and would complicate our stream processing logic if
 	// multiple choices were returned.

intercept/interceptor.go

@@ -34,4 +34,7 @@ type Interceptor interface {
 	// by the model, so any single tool call ID is sufficient to identify the
 	// parent interception.
 	CorrelatingToolCallID() *string
+	// HasInjectableTools returns true if an [mcp.ServerProxier] has been provided
+	// and contains tools which must be injected into requests.
+	HasInjectableTools() bool
 }

intercept/messages/base.go

@@ -315,6 +315,10 @@ func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, antErr *Err
 	}
 }
 
+func (i *interceptionBase) HasInjectableTools() bool {
+	return i.mcpProxy != nil && len(i.mcpProxy.ListTools()) > 0
+}
+
 // accumulateUsage accumulates usage statistics from source into dest.
 // It handles both [anthropic.Usage] and [anthropic.MessageDeltaUsage] types through [any].
 // The function uses reflection to handle the differences between the types:

intercept/responses/base.go

@@ -326,6 +326,10 @@ func (i *responsesInterceptionBase) recordTokenUsage(ctx context.Context, respon
 	}
 }
 
+func (i *responsesInterceptionBase) HasInjectableTools() bool {
+	return i.mcpProxy != nil && len(i.mcpProxy.ListTools()) > 0
+}
+
 // responseCopier helper struct to send original response to the client
 type responseCopier struct {
 	buff            deltaBuffer

intercept/responses/blocking.go

@@ -59,7 +59,6 @@ func (i *BlockingResponsesInterceptor) ProcessRequest(w http.ResponseWriter, r *
 	}
 
 	i.injectTools()
-	i.disableParallelToolCalls()
 
 	var (
 		response        *responses.Response

intercept/responses/injected_tools.go

@@ -25,6 +25,9 @@ func (i *responsesInterceptionBase) injectTools() {
 		return
 	}
 
+	// If there are injectable tools, disable parallel tool calls.
+	i.disableParallelToolCalls()
+
 	// Inject tools.
 	for _, tool := range tools {
 		var params map[string]any

intercept/responses/streaming.go

@@ -70,7 +70,6 @@ func (i *StreamingResponsesInterceptor) ProcessRequest(w http.ResponseWriter, r
 	}
 
 	i.injectTools()
-	i.disableParallelToolCalls()
 
 	events := eventstream.NewEventStream(ctx, i.logger.Named("sse-sender"), nil)
 	go events.Start(w, r)

internal/integrationtest/bridge_test.go

@@ -1308,6 +1308,83 @@ func TestAnthropicToolChoiceParallelDisabled(t *testing.T) {
 	}
 }
 
+// TestChatCompletionsParallelToolCallsDisabled verifies that parallel_tool_calls
+// is set to false only when injectable MCP tools are present and the request
+// includes tools.
+func TestChatCompletionsParallelToolCallsDisabled(t *testing.T) {
+	t.Parallel()
+
+	cases := []struct {
+		name                    string
+		streaming               bool
+		withInjectedTools       bool
+		expectParallelToolCalls bool
+	}{
+		// Streaming with injected tools: parallel_tool_calls should be forced false.
+		{
+			name:                    "streaming/with_injected_tools",
+			streaming:               true,
+			withInjectedTools:       true,
+			expectParallelToolCalls: false,
+		},
+		// Streaming without injected tools: parallel_tool_calls preserved.
+		{
+			name:                    "streaming/no_injected_tools",
+			streaming:               true,
+			withInjectedTools:       false,
+			expectParallelToolCalls: true,
+		},
+		// Blocking with injected tools: parallel_tool_calls should be forced false.
+		{
+			name:                    "blocking/with_injected_tools",
+			streaming:               false,
+			withInjectedTools:       true,
+			expectParallelToolCalls: false,
+		},
+		{
+			name:                    "blocking/no_injected_tools",
+			streaming:               false,
+			withInjectedTools:       false,
+			expectParallelToolCalls: true,
+		},
+	}
+
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			t.Parallel()
+
+			ctx, cancel := context.WithTimeout(t.Context(), time.Second*30)
+			t.Cleanup(cancel)
+
+			fix := fixtures.Parse(t, fixtures.OaiChatSingleBuiltinTool)
+			upstream := newMockUpstream(t, ctx, newFixtureResponse(fix))
+
+			var opts []bridgeOption
+			if tc.withInjectedTools {
+				opts = append(opts, withMCP(setupMCPForTest(t, defaultTracer)))
+			}
+			bridgeServer := newBridgeTestServer(t, ctx, upstream.URL, opts...)
+
+			reqBody, err := sjson.SetBytes(fix.Request(), "stream", tc.streaming)
+			require.NoError(t, err)
+
+			resp := bridgeServer.makeRequest(t, http.MethodPost, pathOpenAIChatCompletions, reqBody)
+			_, err = io.ReadAll(resp.Body)
+			require.NoError(t, err)
+
+			received := upstream.receivedRequests()
+			require.Len(t, received, 1)
+
+			var upstreamReq map[string]any
+			require.NoError(t, json.Unmarshal(received[0].Body, &upstreamReq))
+
+			ptc, ok := upstreamReq["parallel_tool_calls"].(bool)
+			require.True(t, ok, "parallel_tool_calls should be present in upstream request")
+			assert.Equal(t, tc.expectParallelToolCalls, ptc)
+		})
+	}
+}
+
 func TestThinkingAdaptiveIsPreserved(t *testing.T) {
 	t.Parallel()