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

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

Author: dannykopping

intercept/chatcompletions/base.go

@@ -171,6 +171,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

@@ -99,7 +99,7 @@ func (i *StreamingInterception) ProcessRequest(w http.ResponseWriter, r *http.Re
 
 	// 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.
+	if i.HasInjectableTools() && 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)
 	}
 

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,93 @@ 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.
+//
+// NOTE: the blocking chat completions interceptor does not yet disable
+// parallel_tool_calls (unlike the streaming path). The blocking sub-tests
+// document this gap. See intercept/chatcompletions/blocking.go.
+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: parallel_tool_calls is NOT yet disabled even with
+		// injected tools. These tests document the current behavior gap
+		// vs the streaming path.
+		{
+			name:                    "blocking/with_injected_tools",
+			streaming:               false,
+			withInjectedTools:       true,
+			expectParallelToolCalls: true, // TODO: should be 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 := fix.Request()
+			var err error
+			reqBody, err = sjson.SetBytes(reqBody, "stream", tc.streaming)
+			require.NoError(t, err)
+			reqBody, err = sjson.SetBytes(reqBody, "parallel_tool_calls", true)
+			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()
 

internal/integrationtest/responses_test.go

@@ -442,58 +442,83 @@ func TestResponsesParallelToolsOverwritten(t *testing.T) {
 		name                         string
 		request                      string
 		streaming                    bool
+		injectMCP                    bool
 		expectParallelToolCalls      bool
 		expectParallelToolCallsValue bool
 	}{
 		{
 			name:                         "blocking_with_tools",
 			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": false, "parallel_tool_calls": true, "tools": [{"type": "function", "name": "test", "parameters": {}}]}`,
 			streaming:                    false,
+			injectMCP:                    true,
 			expectParallelToolCalls:      true,
 			expectParallelToolCallsValue: false,
 		},
 		{
 			name:                         "streaming_with_tools",
 			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": true, "parallel_tool_calls": true, "tools": [{"type": "function", "name": "test", "parameters": {}}]}`,
 			streaming:                    true,
+			injectMCP:                    true,
 			expectParallelToolCalls:      true,
 			expectParallelToolCallsValue: false,
 		},
 		{
 			name:                         "blocking_with_tools_no_parallel_param",
 			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": false, "tools": [{"type": "function", "name": "test", "parameters": {}}]}`,
 			streaming:                    false,
+			injectMCP:                    true,
 			expectParallelToolCalls:      true,
 			expectParallelToolCallsValue: false,
 		},
 		{
 			name:                         "streaming_with_tools_no_parallel_param",
 			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": true, "tools": [{"type": "function", "name": "test", "parameters": {}}]}`,
 			streaming:                    true,
+			injectMCP:                    true,
 			expectParallelToolCalls:      true,
 			expectParallelToolCallsValue: false,
 		},
 		{
 			name:      "blocking_without_tools",
 			request:   `{"input": "hello", "model": "gpt-4o-mini", "stream": false}`,
 			streaming: false,
+			injectMCP: true,
 		},
 		{
 			name:      "streaming_without_tools",
 			request:   `{"input": "hello", "model": "gpt-4o-mini", "stream": true}`,
 			streaming: true,
+			injectMCP: true,
 		},
 		{
 			name:                         "blocking_without_tools_parallel_true",
 			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": false, "parallel_tool_calls": true}`,
 			streaming:                    false,
+			injectMCP:                    true,
 			expectParallelToolCalls:      true,
 			expectParallelToolCallsValue: true,
 		},
 		{
 			name:                         "streaming_without_tools_parallel_true",
 			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": true, "parallel_tool_calls": true}`,
 			streaming:                    true,
+			injectMCP:                    true,
+			expectParallelToolCalls:      true,
+			expectParallelToolCallsValue: true,
+		},
+		{
+			name:                         "blocking_without_injectable_tools_true",
+			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": false, "parallel_tool_calls": true}`,
+			streaming:                    false,
+			injectMCP:                    false,
+			expectParallelToolCalls:      true,
+			expectParallelToolCallsValue: true,
+		},
+		{
+			name:                         "streaming_without_injectable_tools_true",
+			request:                      `{"input": "hello", "model": "gpt-4o-mini", "stream": true, "parallel_tool_calls": true}`,
+			streaming:                    true,
+			injectMCP:                    false,
 			expectParallelToolCalls:      true,
 			expectParallelToolCallsValue: true,
 		},
@@ -511,7 +536,13 @@ func TestResponsesParallelToolsOverwritten(t *testing.T) {
 				fix = fixtures.OaiResponsesStreamingSimple
 			}
 			upstream := newMockUpstream(t, ctx, newFixtureResponse(fixtures.Parse(t, fix)))
-			bridgeServer := newBridgeTestServer(t, ctx, upstream.URL)
+
+			var opts []bridgeOption
+			if tc.injectMCP {
+				mockMCP := setupMCPForTest(t, defaultTracer)
+				opts = append(opts, withMCP(mockMCP))
+			}
+			bridgeServer := newBridgeTestServer(t, ctx, upstream.URL, opts...)
 
 			resp := bridgeServer.makeRequest(t, http.MethodPost, pathOpenAIResponses, []byte(tc.request))
 			_, err := io.ReadAll(resp.Body)