Drop unverifiable max_tokens assertion from BYOK wire model E2E test

The OpenAI BYOK provider code path in the CLI does not echo the
configured maxOutputTokens as max_tokens on the wire request body
(it's used internally for token budgeting and only appears on
Anthropic-style requests). The new wire model E2E test asserted on
max_tokens in the captured chat completion request, which always
returned undefined/nil and failed across all four SDKs.

Rename the test to `should forward provider wire model'' and drop
the wire-side max_tokens assertion. The test still sets
maxOutputTokens to confirm the SDK serializes the field without
errors; per-SDK unit tests already cover ProviderConfig serialization
in detail. Also drop the now-unused MaxTokens field from the Go and
.NET harness ChatCompletionRequest types.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: MackinnonBuck

dotnet/test/E2E/SessionConfigE2ETests.cs

@@ -178,8 +178,15 @@ public async Task Should_Forward_Custom_Provider_Headers_On_Resume()
     }
 
     [Fact]
-    public async Task Should_Forward_Provider_Wire_Model_And_Max_Output_Tokens()
+    public async Task Should_Forward_Provider_Wire_Model()
     {
+        // Verifies that ProviderConfig.WireModel overrides the model name sent to
+        // the provider API, while SessionConfig.Model still drives runtime
+        // configuration lookup (capabilities, prompts, reasoning behavior).
+        // MaxOutputTokens is also set here to confirm the SDK accepts it without
+        // serialization errors; the CLI does not echo it as `max_tokens` on the
+        // OpenAI-style wire request, so we don't assert on it directly (see unit
+        // tests for serialization coverage).
         var session = await CreateSessionAsync(new SessionConfig
         {
             Model = "claude-sonnet-4.5",
@@ -197,7 +204,6 @@ public async Task Should_Forward_Provider_Wire_Model_And_Max_Output_Tokens()
 
         var exchange = Assert.Single(await Ctx.GetExchangesAsync());
         Assert.Equal("test-wire-model", exchange.Request.Model);
-        Assert.Equal(1024, exchange.Request.MaxTokens);
 
         await session.DisposeAsync();
     }

dotnet/test/Harness/CapiProxy.cs

@@ -206,8 +206,7 @@ public record ParsedHttpExchange(
 public record ChatCompletionRequest(
     string Model,
     List<ChatCompletionMessage> Messages,
-    List<ChatCompletionTool>? Tools,
-    [property: JsonPropertyName("max_tokens")] int? MaxTokens = null);
+    List<ChatCompletionTool>? Tools);
 
 public record ChatCompletionMessage(
     string Role,

go/internal/e2e/session_config_e2e_test.go

@@ -323,7 +323,14 @@ func TestSessionConfigExtrasE2E(t *testing.T) {
 		}
 	})
 
-	t.Run("should forward provider wire model and max output tokens", func(t *testing.T) {
+	t.Run("should forward provider wire model", func(t *testing.T) {
+		// Verifies that ProviderConfig.WireModel overrides the model name sent to
+		// the provider API, while SessionConfig.Model still drives runtime
+		// configuration lookup (capabilities, prompts, reasoning behavior).
+		// MaxOutputTokens is also set here to confirm the SDK accepts it without
+		// serialization errors; the CLI does not echo it as `max_tokens` on the
+		// OpenAI-style wire request, so we don't assert on it directly (see unit
+		// tests for serialization coverage).
 		ctx.ConfigureForTest(t)
 
 		maxOutputTokens := 1024
@@ -357,13 +364,6 @@ func TestSessionConfigExtrasE2E(t *testing.T) {
 		if exchanges[0].Request.Model != "test-wire-model" {
 			t.Errorf("Expected request model to be 'test-wire-model', got %q", exchanges[0].Request.Model)
 		}
-		if exchanges[0].Request.MaxTokens == nil || *exchanges[0].Request.MaxTokens != 1024 {
-			got := "nil"
-			if exchanges[0].Request.MaxTokens != nil {
-				got = fmt.Sprintf("%d", *exchanges[0].Request.MaxTokens)
-			}
-			t.Errorf("Expected request max_tokens to be 1024, got %s", got)
-		}
 	})
 
 	t.Run("should use provider model id as wire model", func(t *testing.T) {

go/internal/e2e/testharness/proxy.go

@@ -167,10 +167,9 @@ type ParsedHttpExchange struct {
 
 // ChatCompletionRequest represents an OpenAI chat completion request.
 type ChatCompletionRequest struct {
-	Model     string                  `json:"model"`
-	Messages  []ChatCompletionMessage `json:"messages"`
-	Tools     []ChatCompletionTool    `json:"tools,omitempty"`
-	MaxTokens *int                    `json:"max_tokens,omitempty"`
+	Model    string                  `json:"model"`
+	Messages []ChatCompletionMessage `json:"messages"`
+	Tools    []ChatCompletionTool    `json:"tools,omitempty"`
 }
 
 // ChatCompletionMessage represents a message in the chat completion request.

nodejs/test/e2e/session_config.e2e.test.ts

@@ -325,7 +325,14 @@ describe("Session Configuration", async () => {
         await session2.disconnect();
     });
 
-    it("should forward provider wire model and max output tokens", async () => {
+    it("should forward provider wire model", async () => {
+        // Verifies that ProviderConfig.wireModel overrides the model name sent to
+        // the provider API, while SessionConfig.model still drives runtime
+        // configuration lookup (capabilities, prompts, reasoning behavior).
+        // maxOutputTokens is also set here to confirm the SDK accepts it without
+        // serialization errors; the CLI does not echo it as `max_tokens` on the
+        // OpenAI-style wire request, so we don't assert on it directly (see unit
+        // tests for serialization coverage).
         const session = await client.createSession({
             onPermissionRequest: approveAll,
             model: "claude-sonnet-4.5",
@@ -343,7 +350,6 @@ describe("Session Configuration", async () => {
         const exchanges = await openAiEndpoint.getExchanges();
         expect(exchanges.length).toBe(1);
         expect(exchanges[0].request.model).toBe("test-wire-model");
-        expect((exchanges[0].request as { max_tokens?: number }).max_tokens).toBe(1024);
 
         await session.disconnect();
     });

python/e2e/test_session_config_e2e.py

@@ -236,9 +236,14 @@ async def test_should_forward_custom_provider_headers_on_resume(self, ctx: E2ETe
         await session2.disconnect()
         await session1.disconnect()
 
-    async def test_should_forward_provider_wire_model_and_max_output_tokens(  # noqa: E501
-        self, ctx: E2ETestContext
-    ):
+    async def test_should_forward_provider_wire_model(self, ctx: E2ETestContext):
+        # Verifies that ProviderConfig.wire_model overrides the model name sent
+        # to the provider API, while SessionConfig.model still drives runtime
+        # configuration lookup (capabilities, prompts, reasoning behavior).
+        # max_output_tokens is also set here to confirm the SDK accepts it
+        # without serialization errors; the CLI does not echo it as
+        # `max_tokens` on the OpenAI-style wire request, so we don't assert on
+        # it directly (see unit tests for serialization coverage).
         session = await ctx.client.create_session(
             on_permission_request=PermissionHandler.approve_all,
             model="claude-sonnet-4.5",
@@ -257,7 +262,6 @@ async def test_should_forward_provider_wire_model_and_max_output_tokens(  # noqa
         assert len(exchanges) == 1
         request = exchanges[0]["request"]
         assert request["model"] == "test-wire-model"
-        assert request.get("max_tokens") == 1024
 
         await session.disconnect()