Add provider model and token limit overrides to ProviderConfig (#966)

* Add token limit and model override fields to ProviderConfig

Adds the following optional fields to ProviderConfig across all SDKs:

- modelId: well-known model ID for agent config + token limit lookup

- wireModel: model name sent to the provider API for inference

- maxPromptTokens: prompt token cap (triggers compaction)

- maxOutputTokens: response token cap

Both modelId and wireModel default to the session's configured model when unset.

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

* Add tests for new ProviderConfig fields

Extends existing provider-forwarding/serialization tests across all 4 SDKs

to cover modelId, wireModel, maxPromptTokens, and maxOutputTokens.

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

* 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>

* 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>

* Rename MaxPromptTokens to MaxInputTokens and clarify ProviderConfig docs

Renames the SDK-facing ProviderConfig field across all four languages while preserving the wire JSON key as maxPromptTokens:

- .NET: MaxPromptTokens -> MaxInputTokens (JsonPropertyName unchanged)

- Go: MaxPromptTokens -> MaxInputTokens (json tag unchanged)

- Python: max_prompt_tokens -> max_input_tokens (wire conversion in _convert_provider_to_wire_format unchanged)

- Node: maxPromptTokens -> maxInputTokens; adds a small toWireProviderConfig helper in client.ts that remaps the field before sending session.create / session.resume.

Also rewrites the doc comments for modelId, wireModel, maxInputTokens, and maxOutputTokens to make the priority order clear: WireModel falls back to ModelId falls back to SessionConfig.Model, and ModelId drives both runtime configuration lookup and the wire model when WireModel is unset.

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

* Fix Windows teardown flake in ClientE2ETests

Remove 'using var' from three ClientE2ETests that also call ForceStopAsync in their finally block. The double-disposal (using Dispose → DisposeAsync → ForceStopAsync, plus the explicit ForceStopAsync) races on Windows when the CLI process/pipes are mid-teardown, causing OperationCanceledException to bubble up and fail an otherwise-passing test.

Matches the existing pattern in SessionFsE2ETests where ForceStopAsync is wrapped in try-catch to swallow teardown-only exceptions.

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

* Revert "Fix Windows teardown flake in ClientE2ETests"

This reverts commit 6c794c4.

---------

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

Author: MackinnonBuck

dotnet/src/Types.cs

@@ -1528,6 +1528,40 @@ public class ProviderConfig
     /// </summary>
     [JsonPropertyName("headers")]
     public IDictionary<string, string>? Headers { get; set; }
+
+    /// <summary>
+    /// Well-known model name used by the runtime to look up agent configuration
+    /// (tools, prompts, reasoning behavior) and default token limits. Also used
+    /// as the wire model when <see cref="WireModel"/> is not set.
+    /// Falls back to <see cref="SessionConfig.Model"/>.
+    /// </summary>
+    [JsonPropertyName("modelId")]
+    public string? ModelId { get; set; }
+
+    /// <summary>
+    /// Model name sent to the provider API for inference. Use this when the
+    /// provider's model name (e.g. an Azure deployment name or a custom
+    /// fine-tune name) differs from <see cref="ModelId"/>.
+    /// Falls back to <see cref="ModelId"/>, then <see cref="SessionConfig.Model"/>.
+    /// </summary>
+    [JsonPropertyName("wireModel")]
+    public string? WireModel { get; set; }
+
+    /// <summary>
+    /// Overrides the resolved model's default max prompt tokens. The runtime
+    /// triggers conversation compaction before sending a request when the
+    /// prompt (system message, history, tool definitions, user message) would
+    /// exceed this limit.
+    /// </summary>
+    [JsonPropertyName("maxPromptTokens")]
+    public int? MaxInputTokens { get; set; }
+
+    /// <summary>
+    /// Overrides the resolved model's default max output tokens. When hit, the
+    /// model stops generating and returns a truncated response.
+    /// </summary>
+    [JsonPropertyName("maxOutputTokens")]
+    public int? MaxOutputTokens { get; set; }
 }
 
 /// <summary>

dotnet/test/E2E/SessionConfigE2ETests.cs

@@ -238,6 +238,62 @@ public async Task Should_Forward_Custom_Provider_Headers_On_Resume()
         await session2.DisposeAsync();
     }
 
+    [Fact]
+    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",
+            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);
+
+        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/Unit/SerializationTests.cs

@@ -20,19 +20,31 @@ public void ProviderConfig_CanSerializeHeaders_WithSdkOptions()
         var original = new ProviderConfig
         {
             BaseUrl = "https://example.com/provider",
-            Headers = new Dictionary<string, string> { ["Authorization"] = "Bearer provider-token" }
+            Headers = new Dictionary<string, string> { ["Authorization"] = "Bearer provider-token" },
+            ModelId = "gpt-4o",
+            WireModel = "my-finetune-v3",
+            MaxInputTokens = 100_000,
+            MaxOutputTokens = 4096
         };
 
         var json = JsonSerializer.Serialize(original, options);
         using var document = JsonDocument.Parse(json);
         var root = document.RootElement;
         Assert.Equal("https://example.com/provider", root.GetProperty("baseUrl").GetString());
         Assert.Equal("Bearer provider-token", root.GetProperty("headers").GetProperty("Authorization").GetString());
+        Assert.Equal("gpt-4o", root.GetProperty("modelId").GetString());
+        Assert.Equal("my-finetune-v3", root.GetProperty("wireModel").GetString());
+        Assert.Equal(100_000, root.GetProperty("maxPromptTokens").GetInt32());
+        Assert.Equal(4096, root.GetProperty("maxOutputTokens").GetInt32());
 
         var deserialized = JsonSerializer.Deserialize<ProviderConfig>(json, options);
         Assert.NotNull(deserialized);
         Assert.Equal("https://example.com/provider", deserialized.BaseUrl);
         Assert.Equal("Bearer provider-token", deserialized.Headers!["Authorization"]);
+        Assert.Equal("gpt-4o", deserialized.ModelId);
+        Assert.Equal("my-finetune-v3", deserialized.WireModel);
+        Assert.Equal(100_000, deserialized.MaxInputTokens);
+        Assert.Equal(4096, deserialized.MaxOutputTokens);
     }
 
     [Fact]

go/internal/e2e/session_config_e2e_test.go

@@ -323,6 +323,85 @@ func TestSessionConfigExtrasE2E(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
+		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)
+		}
+	})
+
+	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/types.go

@@ -859,6 +859,25 @@ type ProviderConfig struct {
 	Azure *AzureProviderOptions `json:"azure,omitempty"`
 	// Headers are custom HTTP headers included in outbound provider requests.
 	Headers map[string]string `json:"headers,omitempty"`
+	// ModelID is the well-known model name used by the runtime to look up
+	// agent configuration (tools, prompts, reasoning behavior) and default
+	// token limits. Also used as the wire model when WireModel is not set.
+	// Falls back to SessionConfig.Model.
+	ModelID string `json:"modelId,omitempty"`
+	// WireModel is the model name sent to the provider API for inference. Use
+	// this when the provider's model name (e.g. an Azure deployment name or a
+	// custom fine-tune name) differs from ModelID.
+	// Falls back to ModelID, then SessionConfig.Model.
+	WireModel string `json:"wireModel,omitempty"`
+	// MaxInputTokens overrides the resolved model's default max prompt tokens.
+	// The runtime triggers conversation compaction before sending a request
+	// when the prompt (system message, history, tool definitions, user
+	// message) would exceed this limit.
+	MaxInputTokens int `json:"maxPromptTokens,omitempty"`
+	// MaxOutputTokens overrides the resolved model's default max output
+	// tokens. When hit, the model stops generating and returns a truncated
+	// response.
+	MaxOutputTokens int `json:"maxOutputTokens,omitempty"`
 }
 
 // AzureProviderOptions contains Azure-specific provider configuration

go/types_test.go

@@ -151,3 +151,68 @@ func TestSessionSendRequest_JSONIncludesRequestHeaders(t *testing.T) {
 		t.Fatalf("expected Authorization header, got %v", headers["Authorization"])
 	}
 }
+
+func TestProviderConfig_JSONIncludesAllFields(t *testing.T) {
+	cfg := ProviderConfig{
+		BaseURL:         "https://example.com/provider",
+		APIKey:          "test-key",
+		Headers:         map[string]string{"Authorization": "Bearer provider-token"},
+		ModelID:         "gpt-4o",
+		WireModel:       "my-finetune-v3",
+		MaxInputTokens:  100000,
+		MaxOutputTokens: 4096,
+	}
+
+	data, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("failed to marshal ProviderConfig: %v", err)
+	}
+
+	var decoded map[string]any
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("failed to unmarshal ProviderConfig: %v", err)
+	}
+
+	if decoded["baseUrl"] != "https://example.com/provider" {
+		t.Errorf("expected baseUrl to round-trip, got %v", decoded["baseUrl"])
+	}
+	if decoded["modelId"] != "gpt-4o" {
+		t.Errorf("expected modelId 'gpt-4o', got %v", decoded["modelId"])
+	}
+	if decoded["wireModel"] != "my-finetune-v3" {
+		t.Errorf("expected wireModel 'my-finetune-v3', got %v", decoded["wireModel"])
+	}
+	if decoded["maxPromptTokens"] != float64(100000) {
+		t.Errorf("expected maxPromptTokens 100000, got %v", decoded["maxPromptTokens"])
+	}
+	if decoded["maxOutputTokens"] != float64(4096) {
+		t.Errorf("expected maxOutputTokens 4096, got %v", decoded["maxOutputTokens"])
+	}
+	headers, ok := decoded["headers"].(map[string]any)
+	if !ok {
+		t.Fatalf("expected headers object, got %T", decoded["headers"])
+	}
+	if headers["Authorization"] != "Bearer provider-token" {
+		t.Errorf("expected Authorization header, got %v", headers["Authorization"])
+	}
+}
+
+func TestProviderConfig_JSONOmitsUnsetTokenFields(t *testing.T) {
+	cfg := ProviderConfig{BaseURL: "https://example.com/provider"}
+
+	data, err := json.Marshal(cfg)
+	if err != nil {
+		t.Fatalf("failed to marshal ProviderConfig: %v", err)
+	}
+
+	var decoded map[string]any
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("failed to unmarshal ProviderConfig: %v", err)
+	}
+
+	for _, field := range []string{"modelId", "wireModel", "maxPromptTokens", "maxOutputTokens", "headers"} {
+		if _, present := decoded[field]; present {
+			t.Errorf("expected %q to be omitted when unset, got %v", field, decoded[field])
+		}
+	}
+}

nodejs/src/client.ts

@@ -42,6 +42,7 @@ import type {
     GetAuthStatusResponse,
     GetStatusResponse,
     ModelInfo,
+    ProviderConfig,
     ResumeSessionConfig,
     SectionTransformFn,
     SessionConfig,
@@ -64,6 +65,17 @@ import type {
 } from "./types.js";
 import { defaultJoinSessionPermissionHandler } from "./types.js";
 
+/**
+ * Convert a {@link ProviderConfig} to its JSON-RPC wire shape, remapping
+ * camelCase SDK property names to the wire keys expected by the runtime
+ * (e.g. `maxInputTokens` → `maxPromptTokens`).
+ */
+function toWireProviderConfig(provider: ProviderConfig): Record<string, unknown> {
+    const { maxInputTokens, ...rest } = provider;
+    if (maxInputTokens === undefined) return rest;
+    return { ...rest, maxPromptTokens: maxInputTokens };
+}
+
 /**
  * Minimum protocol version this SDK can communicate with.
  * Servers reporting a version below this are rejected.
@@ -788,7 +800,7 @@ export class CopilotClient {
                 systemMessage: wireSystemMessage,
                 availableTools: config.availableTools,
                 excludedTools: config.excludedTools,
-                provider: config.provider,
+                provider: config.provider ? toWireProviderConfig(config.provider) : undefined,
                 modelCapabilities: config.modelCapabilities,
                 requestPermission: true,
                 requestUserInput: !!config.onUserInputRequest,
@@ -931,7 +943,7 @@ export class CopilotClient {
                     name: cmd.name,
                     description: cmd.description,
                 })),
-                provider: config.provider,
+                provider: config.provider ? toWireProviderConfig(config.provider) : undefined,
                 modelCapabilities: config.modelCapabilities,
                 requestPermission:
                     config.onPermissionRequest !== defaultJoinSessionPermissionHandler,

nodejs/src/types.ts

@@ -1503,6 +1503,36 @@ export interface ProviderConfig {
      * Custom HTTP headers to include in outbound provider requests.
      */
     headers?: Record<string, string>;
+
+    /**
+     * Well-known model name used by the runtime to look up agent configuration
+     * (tools, prompts, reasoning behavior) and default token limits. Also used
+     * as the wire model when {@link wireModel} is not set.
+     * Falls back to {@link SessionConfig.model}.
+     */
+    modelId?: string;
+
+    /**
+     * Model name sent to the provider API for inference. Use this when the
+     * provider's model name (e.g. an Azure deployment name or a custom
+     * fine-tune name) differs from {@link modelId}.
+     * Falls back to {@link modelId}, then {@link SessionConfig.model}.
+     */
+    wireModel?: string;
+
+    /**
+     * Overrides the resolved model's default max prompt tokens. The runtime
+     * triggers conversation compaction before sending a request when the
+     * prompt (system message, history, tool definitions, user message) would
+     * exceed this limit.
+     */
+    maxInputTokens?: number;
+
+    /**
+     * Overrides the resolved model's default max output tokens. When hit, the
+     * model stops generating and returns a truncated response.
+     */
+    maxOutputTokens?: number;
 }
 
 /**