fix(openai): ensure non-compatible providers send correct max_tokens field

DeepSeek and Mistral are not fully OpenAI-compatible but delegated to
CompatibleProvider.Completion(), which unconditionally mapped MaxTokens
to max_completion_tokens on the wire. Both APIs expect max_tokens.

Add ChatCompletionRequestTransform hook to CompatibleConfig (Strategy
pattern) that lets providers adjust the SDK request after convertParams
builds it. DeepSeek and Mistral supply transforms that swap
max_completion_tokens back to max_tokens and clear unsupported fields.

Move Mistral's user/reasoning_effort stripping from preprocessParams
(CompletionParams level) to transformRequest (SDK request level) where
it correctly prevents the fields from being serialized.

Add FakeCompletionServer test helper and wire-level tests that capture
actual JSON request bodies to assert correct field names on the wire.

Author: peteski22

internal/testutil/fakeserver.go

@@ -0,0 +1,117 @@
+// Package testutil provides testing utilities and fixtures for any-llm.
+package testutil
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+)
+
+// FakeCompletionServer creates an httptest server that captures the raw JSON
+// request body and returns a minimal valid OpenAI-compatible chat completion
+// response. The captured body is returned so callers can assert on the exact
+// JSON field names sent over the wire.
+func FakeCompletionServer(t *testing.T) (serverURL string, capturedBody func() map[string]any) {
+	t.Helper()
+
+	var (
+		mu   sync.Mutex
+		body map[string]any
+	)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Errorf("reading request body: %v", err)
+			http.Error(w, "bad request", http.StatusBadRequest)
+			return
+		}
+
+		mu.Lock()
+		if err := json.Unmarshal(raw, &body); err != nil {
+			mu.Unlock()
+			t.Errorf("unmarshalling request body: %v", err)
+			http.Error(w, "bad request", http.StatusBadRequest)
+			return
+		}
+		mu.Unlock()
+
+		w.Header().Set("Content-Type", "application/json")
+		// Minimal valid chat completion response.
+		_, _ = w.Write([]byte(`{
+			"id": "chatcmpl-test",
+			"object": "chat.completion",
+			"created": 1700000000,
+			"model": "test-model",
+			"choices": [{
+				"index": 0,
+				"message": {"role": "assistant", "content": "hello"},
+				"finish_reason": "stop"
+			}],
+			"usage": {"prompt_tokens": 5, "completion_tokens": 3, "total_tokens": 8}
+		}`))
+	}))
+
+	t.Cleanup(srv.Close)
+
+	return srv.URL, func() map[string]any {
+		mu.Lock()
+		defer mu.Unlock()
+		return body
+	}
+}
+
+// FakeStreamingServer creates an httptest server that captures the raw JSON
+// request body and returns a minimal valid OpenAI-compatible streaming (SSE)
+// response. The captured body is returned so callers can assert on the exact
+// JSON field names sent over the wire.
+func FakeStreamingServer(t *testing.T) (serverURL string, capturedBody func() map[string]any) {
+	t.Helper()
+
+	var (
+		mu   sync.Mutex
+		body map[string]any
+	)
+
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		raw, err := io.ReadAll(r.Body)
+		if err != nil {
+			t.Errorf("reading request body: %v", err)
+			http.Error(w, "bad request", http.StatusBadRequest)
+			return
+		}
+
+		mu.Lock()
+		if err := json.Unmarshal(raw, &body); err != nil {
+			mu.Unlock()
+			t.Errorf("unmarshalling request body: %v", err)
+			http.Error(w, "bad request", http.StatusBadRequest)
+			return
+		}
+		mu.Unlock()
+
+		w.Header().Set("Content-Type", "text/event-stream")
+		w.Header().Set("Cache-Control", "no-cache")
+		w.Header().Set("Connection", "keep-alive")
+
+		// Minimal valid SSE streaming response.
+		chunk := `{"id":"chatcmpl-test","object":"chat.completion.chunk","created":1700000000,"model":"test-model","choices":[{"index":0,"delta":{"role":"assistant","content":"hello"},"finish_reason":null}]}`
+		done := `{"id":"chatcmpl-test","object":"chat.completion.chunk","created":1700000000,"model":"test-model","choices":[{"index":0,"delta":{},"finish_reason":"stop"}]}`
+
+		_, _ = fmt.Fprintf(w, "data: %s\n\n", chunk)
+		_, _ = fmt.Fprintf(w, "data: %s\n\n", done)
+		_, _ = fmt.Fprint(w, "data: [DONE]\n\n")
+	}))
+
+	t.Cleanup(srv.Close)
+
+	return srv.URL, func() map[string]any {
+		mu.Lock()
+		defer mu.Unlock()
+		return body
+	}
+}

providers/deepseek/deepseek.go

@@ -8,6 +8,9 @@ import (
 	"fmt"
 	"slices"
 
+	oaisdk "github.com/openai/openai-go"
+	"github.com/openai/openai-go/packages/param"
+
 	"github.com/mozilla-ai/any-llm-go/config"
 	"github.com/mozilla-ai/any-llm-go/providers"
 	"github.com/mozilla-ai/any-llm-go/providers/openai"
@@ -50,13 +53,14 @@ type Provider struct {
 // New creates a new DeepSeek provider.
 func New(opts ...config.Option) (*Provider, error) {
 	base, err := openai.NewCompatible(openai.CompatibleConfig{
-		APIKeyEnvVar:   envAPIKey,
-		BaseURLEnvVar:  "",
-		Capabilities:   capabilities(),
-		DefaultAPIKey:  "",
-		DefaultBaseURL: defaultBaseURL,
-		Name:           providerName,
-		RequireAPIKey:  true,
+		APIKeyEnvVar:                   envAPIKey,
+		BaseURLEnvVar:                  "",
+		Capabilities:                   capabilities(),
+		ChatCompletionRequestTransform: transformRequest,
+		DefaultAPIKey:                  "",
+		DefaultBaseURL:                 defaultBaseURL,
+		Name:                           providerName,
+		RequireAPIKey:                  true,
 	}, opts...)
 	if err != nil {
 		return nil, err
@@ -156,6 +160,19 @@ func preprocessParams(params providers.CompletionParams) providers.CompletionPar
 	}
 }
 
+// transformRequest adjusts the OpenAI SDK request for DeepSeek's API.
+// DeepSeek uses max_tokens, not max_completion_tokens.
+// See: https://api-docs.deepseek.com/api/create-chat-completion
+func transformRequest(req *oaisdk.ChatCompletionNewParams) {
+	if req.MaxCompletionTokens.Valid() {
+		// Set max_tokens using max_completion_tokens value.
+		req.MaxTokens = oaisdk.Int(req.MaxCompletionTokens.Value)
+	}
+
+	// Clear unsupported fields from the request.
+	req.MaxCompletionTokens = param.Opt[int64]{}
+}
+
 // preprocessMessagesForJSONSchema injects the JSON schema into the last user message.
 // Returns the modified messages and true if injection succeeded, or the original messages
 // and false if injection failed (no user message, non-string content, or marshal error).

providers/deepseek/deepseek_test.go

@@ -354,6 +354,73 @@ func TestPreprocessMessagesForJSONSchema(t *testing.T) {
 	})
 }
 
+func TestCompletionSendsMaxTokensOnWire(t *testing.T) {
+	t.Parallel()
+
+	serverURL, capturedBody := testutil.FakeCompletionServer(t)
+
+	provider, err := New(
+		config.WithAPIKey("test-key"),
+		config.WithBaseURL(serverURL),
+	)
+	require.NoError(t, err)
+
+	maxTokens := 512
+	params := providers.CompletionParams{
+		Model:     "deepseek-chat",
+		Messages:  testutil.SimpleMessages(),
+		MaxTokens: &maxTokens,
+	}
+
+	_, err = provider.Completion(context.Background(), params)
+	require.NoError(t, err)
+
+	body := capturedBody()
+
+	// DeepSeek is not fully OpenAI-compatible.
+	// The wire request must use max_tokens (not max_completion_tokens)
+	// because that is what the DeepSeek API accepts.
+	// See: https://api-docs.deepseek.com/api/create-chat-completion
+	require.Contains(t, body, "max_tokens")
+	require.NotContains(t, body, "max_completion_tokens")
+	require.Equal(t, float64(512), body["max_tokens"])
+}
+
+func TestCompletionStreamSendsMaxTokensOnWire(t *testing.T) {
+	t.Parallel()
+
+	serverURL, capturedBody := testutil.FakeStreamingServer(t)
+
+	provider, err := New(
+		config.WithAPIKey("test-key"),
+		config.WithBaseURL(serverURL),
+	)
+	require.NoError(t, err)
+
+	maxTokens := 512
+	params := providers.CompletionParams{
+		Model:     "deepseek-chat",
+		Messages:  testutil.SimpleMessages(),
+		MaxTokens: &maxTokens,
+		Stream:    true,
+	}
+
+	chunks, errs := provider.CompletionStream(context.Background(), params)
+	for range chunks {
+		// Drain the channel.
+	}
+	require.NoError(t, <-errs)
+
+	body := capturedBody()
+
+	// DeepSeek is not fully OpenAI-compatible.
+	// The streaming wire request must also use max_tokens (not max_completion_tokens).
+	// See: https://api-docs.deepseek.com/api/create-chat-completion
+	require.Contains(t, body, "max_tokens")
+	require.NotContains(t, body, "max_completion_tokens")
+	require.Equal(t, float64(512), body["max_tokens"])
+}
+
 // Integration tests - only run if DeepSeek API key is available.
 
 func TestIntegrationCompletion(t *testing.T) {

providers/mistral/mistral.go

@@ -6,6 +6,9 @@ import (
 	"context"
 	"slices"
 
+	oaisdk "github.com/openai/openai-go"
+	"github.com/openai/openai-go/packages/param"
+
 	"github.com/mozilla-ai/any-llm-go/config"
 	"github.com/mozilla-ai/any-llm-go/providers"
 	"github.com/mozilla-ai/any-llm-go/providers/openai"
@@ -48,13 +51,14 @@ type Provider struct {
 // New creates a new Mistral provider.
 func New(opts ...config.Option) (*Provider, error) {
 	base, err := openai.NewCompatible(openai.CompatibleConfig{
-		APIKeyEnvVar:   envAPIKey,
-		BaseURLEnvVar:  "",
-		Capabilities:   capabilities(),
-		DefaultAPIKey:  "",
-		DefaultBaseURL: defaultBaseURL,
-		Name:           providerName,
-		RequireAPIKey:  true,
+		APIKeyEnvVar:                   envAPIKey,
+		BaseURLEnvVar:                  "",
+		Capabilities:                   capabilities(),
+		ChatCompletionRequestTransform: transformRequest,
+		DefaultAPIKey:                  "",
+		DefaultBaseURL:                 defaultBaseURL,
+		Name:                           providerName,
+		RequireAPIKey:                  true,
 	}, opts...)
 	if err != nil {
 		return nil, err
@@ -69,7 +73,7 @@ func (p *Provider) Completion(
 	ctx context.Context,
 	params providers.CompletionParams,
 ) (*providers.ChatCompletion, error) {
-	params = preprocessParams(params)
+	params = patchMessageParams(params)
 	return p.CompatibleProvider.Completion(ctx, params)
 }
 
@@ -79,7 +83,7 @@ func (p *Provider) CompletionStream(
 	ctx context.Context,
 	params providers.CompletionParams,
 ) (<-chan providers.ChatCompletionChunk, <-chan error) {
-	params = preprocessParams(params)
+	params = patchMessageParams(params)
 	return p.CompatibleProvider.CompletionStream(ctx, params)
 }
 
@@ -130,12 +134,24 @@ func patchMessages(messages []providers.Message) []providers.Message {
 	return result
 }
 
-// preprocessParams handles Mistral's API requirements.
-// Mistral doesn't accept the "user" or "reasoning_effort" fields and requires
-// an assistant message between tool results and user messages.
-func preprocessParams(params providers.CompletionParams) providers.CompletionParams {
+// patchMessageParams handles Mistral's message-level requirements.
+// Mistral requires an assistant message between tool results and user messages.
+func patchMessageParams(params providers.CompletionParams) providers.CompletionParams {
 	params.Messages = patchMessages(slices.Clone(params.Messages))
-	params.ReasoningEffort = "" // Mistral doesn't support reasoning_effort; Magistral models reason automatically.
-	params.User = ""            // Mistral doesn't support the user field.
 	return params
 }
+
+// transformRequest adjusts the OpenAI SDK request for Mistral's API.
+// Mistral uses max_tokens (not max_completion_tokens) and does not accept user or reasoning_effort fields.
+// See: https://docs.mistral.ai/api/#tag/chat/operation/chat_completion_v1_chat_completions_post
+func transformRequest(req *oaisdk.ChatCompletionNewParams) {
+	if req.MaxCompletionTokens.Valid() {
+		// Set max_tokens using max_completion_tokens value.
+		req.MaxTokens = oaisdk.Int(req.MaxCompletionTokens.Value)
+	}
+
+	// Clear unsupported fields from the request.
+	req.MaxCompletionTokens = param.Opt[int64]{}
+	req.User = param.Opt[string]{}
+	req.ReasoningEffort = ""
+}