Add E2E tests for ProviderConfig model and token limit overrides

Adds two end-to-end tests per SDK (Node, Python, Go, .NET) that exercise the new ProviderConfig fields against the replaying CAPI proxy:

- should_forward_provider_wire_model_and_max_output_tokens: verifies wireModel overrides the wire request model and maxOutputTokens is forwarded as max_tokens.

- should_use_provider_model_id_as_wire_model: verifies modelId acts as the wire model when wireModel is unspecified and SessionConfig.Model is omitted.

Also adds MaxTokens to the Go and .NET ChatCompletionRequest harness types so the assertion is observable, and ships two shared snapshot YAMLs under test/snapshots/session_config/.

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

Author: MackinnonBuck

dotnet/test/E2E/SessionConfigE2ETests.cs

@@ -177,6 +177,56 @@ public async Task Should_Forward_Custom_Provider_Headers_On_Resume()
         await session2.DisposeAsync();
     }
 
+    [Fact]
+    public async Task Should_Forward_Provider_Wire_Model_And_Max_Output_Tokens()
+    {
+        var session = await CreateSessionAsync(new SessionConfig
+        {
+            Model = "claude-sonnet-4.5",
+            Provider = new ProviderConfig
+            {
+                Type = "openai",
+                BaseUrl = Ctx.ProxyUrl,
+                ApiKey = "test-provider-key",
+                WireModel = "test-wire-model",
+                MaxOutputTokens = 1024,
+            },
+        });
+
+        await session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 1+1?" });
+
+        var exchange = Assert.Single(await Ctx.GetExchangesAsync());
+        Assert.Equal("test-wire-model", exchange.Request.Model);
+        Assert.Equal(1024, exchange.Request.MaxTokens);
+
+        await session.DisposeAsync();
+    }
+
+    [Fact]
+    public async Task Should_Use_Provider_Model_Id_As_Wire_Model()
+    {
+        // ProviderConfig.ModelId drives both the runtime resolved model AND the wire model
+        // when WireModel is not specified. Here SessionConfig.Model is intentionally omitted
+        // so that ModelId is the only model source.
+        var session = await CreateSessionAsync(new SessionConfig
+        {
+            Provider = new ProviderConfig
+            {
+                Type = "openai",
+                BaseUrl = Ctx.ProxyUrl,
+                ApiKey = "test-provider-key",
+                ModelId = "claude-sonnet-4.5",
+            },
+        });
+
+        await session.SendAndWaitAsync(new MessageOptions { Prompt = "What is 1+1?" });
+
+        var exchange = Assert.Single(await Ctx.GetExchangesAsync());
+        Assert.Equal("claude-sonnet-4.5", exchange.Request.Model);
+
+        await session.DisposeAsync();
+    }
+
     [Fact]
     public async Task Should_Use_WorkingDirectory_For_Tool_Execution()
     {

dotnet/test/Harness/CapiProxy.cs

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

go/internal/e2e/session_config_e2e_test.go

@@ -323,6 +323,85 @@ func TestSessionConfigExtrasE2E(t *testing.T) {
 		}
 	})
 
+	t.Run("should forward provider wire model and max output tokens", func(t *testing.T) {
+		ctx.ConfigureForTest(t)
+
+		maxOutputTokens := 1024
+		session, err := client.CreateSession(t.Context(), &copilot.SessionConfig{
+			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
+			Model:               "claude-sonnet-4.5",
+			Provider: &copilot.ProviderConfig{
+				Type:            "openai",
+				BaseURL:         ctx.ProxyURL,
+				APIKey:          "test-provider-key",
+				WireModel:       "test-wire-model",
+				MaxOutputTokens: maxOutputTokens,
+			},
+		})
+		if err != nil {
+			t.Fatalf("CreateSession failed: %v", err)
+		}
+
+		_, err = session.SendAndWait(t.Context(), copilot.MessageOptions{Prompt: "What is 1+1?"})
+		if err != nil {
+			t.Fatalf("SendAndWait failed: %v", err)
+		}
+
+		exchanges, err := ctx.GetExchanges()
+		if err != nil {
+			t.Fatalf("GetExchanges failed: %v", err)
+		}
+		if len(exchanges) != 1 {
+			t.Fatalf("Expected exactly 1 exchange, got %d", len(exchanges))
+		}
+		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) {
+		// ProviderConfig.ModelID drives both the runtime resolved model AND the wire
+		// model when WireModel is not specified. SessionConfig.Model is intentionally
+		// omitted so that ModelID is the only model source.
+		ctx.ConfigureForTest(t)
+
+		session, err := client.CreateSession(t.Context(), &copilot.SessionConfig{
+			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
+			Provider: &copilot.ProviderConfig{
+				Type:    "openai",
+				BaseURL: ctx.ProxyURL,
+				APIKey:  "test-provider-key",
+				ModelID: "claude-sonnet-4.5",
+			},
+		})
+		if err != nil {
+			t.Fatalf("CreateSession failed: %v", err)
+		}
+
+		_, err = session.SendAndWait(t.Context(), copilot.MessageOptions{Prompt: "What is 1+1?"})
+		if err != nil {
+			t.Fatalf("SendAndWait failed: %v", err)
+		}
+
+		exchanges, err := ctx.GetExchanges()
+		if err != nil {
+			t.Fatalf("GetExchanges failed: %v", err)
+		}
+		if len(exchanges) != 1 {
+			t.Fatalf("Expected exactly 1 exchange, got %d", len(exchanges))
+		}
+		if exchanges[0].Request.Model != "claude-sonnet-4.5" {
+			t.Errorf("Expected request model to be 'claude-sonnet-4.5', got %q", exchanges[0].Request.Model)
+		}
+	})
+
 	t.Run("should use workingDirectory for tool execution", func(t *testing.T) {
 		ctx.ConfigureForTest(t)
 

go/internal/e2e/testharness/proxy.go

@@ -167,9 +167,10 @@ 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"`
+	Model     string                  `json:"model"`
+	Messages  []ChatCompletionMessage `json:"messages"`
+	Tools     []ChatCompletionTool    `json:"tools,omitempty"`
+	MaxTokens *int                    `json:"max_tokens,omitempty"`
 }
 
 // ChatCompletionMessage represents a message in the chat completion request.

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

@@ -325,6 +325,52 @@ describe("Session Configuration", async () => {
         await session2.disconnect();
     });
 
+    it("should forward provider wire model and max output tokens", async () => {
+        const session = await client.createSession({
+            onPermissionRequest: approveAll,
+            model: "claude-sonnet-4.5",
+            provider: {
+                type: "openai",
+                baseUrl: openAiEndpoint.url,
+                apiKey: "test-provider-key",
+                wireModel: "test-wire-model",
+                maxOutputTokens: 1024,
+            },
+        });
+
+        await session.sendAndWait({ prompt: "What is 1+1?" });
+
+        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();
+    });
+
+    it("should use provider model id as wire model", async () => {
+        // ProviderConfig.modelId drives both the runtime resolved model AND the wire
+        // model when wireModel is not specified. SessionConfig.model is intentionally
+        // omitted so that modelId is the only model source.
+        const session = await client.createSession({
+            onPermissionRequest: approveAll,
+            provider: {
+                type: "openai",
+                baseUrl: openAiEndpoint.url,
+                apiKey: "test-provider-key",
+                modelId: "claude-sonnet-4.5",
+            },
+        });
+
+        await session.sendAndWait({ prompt: "What is 1+1?" });
+
+        const exchanges = await openAiEndpoint.getExchanges();
+        expect(exchanges.length).toBe(1);
+        expect(exchanges[0].request.model).toBe("claude-sonnet-4.5");
+
+        await session.disconnect();
+    });
+
     it("should apply workingDirectory on session resume", async () => {
         const subDir = join(workDir, "resume-subproject");
         await mkdir(subDir, { recursive: true });

python/e2e/test_session_config_e2e.py

@@ -236,6 +236,53 @@ 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
+    ):
+        session = await ctx.client.create_session(
+            on_permission_request=PermissionHandler.approve_all,
+            model="claude-sonnet-4.5",
+            provider={
+                "type": "openai",
+                "base_url": ctx.proxy_url,
+                "api_key": "test-provider-key",
+                "wire_model": "test-wire-model",
+                "max_output_tokens": 1024,
+            },
+        )
+
+        await session.send_and_wait("What is 1+1?")
+
+        exchanges = await ctx.get_exchanges()
+        assert len(exchanges) == 1
+        request = exchanges[0]["request"]
+        assert request["model"] == "test-wire-model"
+        assert request.get("max_tokens") == 1024
+
+        await session.disconnect()
+
+    async def test_should_use_provider_model_id_as_wire_model(self, ctx: E2ETestContext):
+        # ProviderConfig.model_id drives both the runtime resolved model AND the wire
+        # model when wire_model is not specified. SessionConfig.model is intentionally
+        # omitted so that model_id is the only model source.
+        session = await ctx.client.create_session(
+            on_permission_request=PermissionHandler.approve_all,
+            provider={
+                "type": "openai",
+                "base_url": ctx.proxy_url,
+                "api_key": "test-provider-key",
+                "model_id": "claude-sonnet-4.5",
+            },
+        )
+
+        await session.send_and_wait("What is 1+1?")
+
+        exchanges = await ctx.get_exchanges()
+        assert len(exchanges) == 1
+        assert exchanges[0]["request"]["model"] == "claude-sonnet-4.5"
+
+        await session.disconnect()
+
     async def test_should_use_workingdirectory_for_tool_execution(self, ctx: E2ETestContext):
         sub_dir = os.path.join(ctx.work_dir, "subproject")
         os.makedirs(sub_dir, exist_ok=True)

test/snapshots/session_config/should_forward_provider_wire_model_and_max_output_tokens.yaml

@@ -0,0 +1,11 @@
+models:
+  - claude-sonnet-4.5
+  - test-wire-model
+conversations:
+  - messages:
+      - role: system
+        content: ${system}
+      - role: user
+        content: What is 1+1?
+      - role: assistant
+        content: 1 + 1 = 2

test/snapshots/session_config/should_use_provider_model_id_as_wire_model.yaml

@@ -0,0 +1,10 @@
+models:
+  - claude-sonnet-4.5
+conversations:
+  - messages:
+      - role: system
+        content: ${system}
+      - role: user
+        content: What is 1+1?
+      - role: assistant
+        content: 1 + 1 = 2