Add reasoningEffort to setModel/session.model.switchTo across all SDKs

All four SDKs now support passing reasoningEffort when switching models
mid-session via setModel(). The parameter is optional and backward-compatible.

- Node.js: setModel(model, { reasoningEffort? })
- Python:  set_model(model, *, reasoning_effort=None)
- Go:      SetModel(ctx, model, opts ...*SetModelOptions)
- .NET:    SetModelAsync(model, reasoningEffort?, cancellationToken?)

Fixes #687

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

Author: 2 people

dotnet/src/Session.cs

@@ -720,15 +720,25 @@ await InvokeRpcAsync<object>(
     /// The new model takes effect for the next message. Conversation history is preserved.
     /// </summary>
     /// <param name="model">Model ID to switch to (e.g., "gpt-4.1").</param>
+    /// <param name="reasoningEffort">Optional reasoning effort level (e.g., "low", "medium", "high", "xhigh").</param>
     /// <param name="cancellationToken">Optional cancellation token.</param>
     /// <example>
     /// <code>
     /// await session.SetModelAsync("gpt-4.1");
+    /// await session.SetModelAsync("claude-sonnet-4.6", SessionModelSwitchToRequestReasoningEffort.High);
     /// </code>
     /// </example>
-    public async Task SetModelAsync(string model, CancellationToken cancellationToken = default)
+    public async Task SetModelAsync(string model, SessionModelSwitchToRequestReasoningEffort? reasoningEffort = null, CancellationToken cancellationToken = default)
     {
-        await Rpc.Model.SwitchToAsync(model, cancellationToken: cancellationToken);
+        await Rpc.Model.SwitchToAsync(model, reasoningEffort, cancellationToken);
+    }
+
+    /// <summary>
+    /// Changes the model for this session (backward-compatible overload).
+    /// </summary>
+    public Task SetModelAsync(string model, CancellationToken cancellationToken)
+    {
+        return SetModelAsync(model, reasoningEffort: null, cancellationToken);
     }
 
     /// <summary>

dotnet/test/RpcTests.cs

@@ -73,7 +73,7 @@ public async Task Should_Call_Session_Rpc_Model_SwitchTo()
         Assert.NotNull(before.ModelId);
 
         // Switch to a different model
-        var result = await session.Rpc.Model.SwitchToAsync(modelId: "gpt-4.1");
+        var result = await session.Rpc.Model.SwitchToAsync(modelId: "gpt-4.1", reasoningEffort: null);
         Assert.Equal("gpt-4.1", result.ModelId);
 
         // Verify the switch persisted

go/internal/e2e/rpc_test.go

@@ -201,7 +201,7 @@ func TestSessionRpc(t *testing.T) {
 			t.Fatalf("Failed to create session: %v", err)
 		}
 
-		if err := session.SetModel(t.Context(), "gpt-4.1"); err != nil {
+		if err := session.SetModel(t.Context(), "gpt-4.1", nil); err != nil {
 			t.Fatalf("SetModel returned error: %v", err)
 		}
 	})

go/session.go

@@ -737,16 +737,31 @@ func (s *Session) Abort(ctx context.Context) error {
 	return nil
 }
 
+// SetModelOptions configures optional parameters for SetModel.
+type SetModelOptions struct {
+	// ReasoningEffort sets the reasoning effort level for the new model (e.g., "low", "medium", "high", "xhigh").
+	ReasoningEffort rpc.ReasoningEffort
+}
+
 // SetModel changes the model for this session.
 // The new model takes effect for the next message. Conversation history is preserved.
+// Pass nil for opts if no additional options are needed.
 //
 // Example:
 //
-//	if err := session.SetModel(context.Background(), "gpt-4.1"); err != nil {
+//	if err := session.SetModel(context.Background(), "gpt-4.1", nil); err != nil {
 //	    log.Printf("Failed to set model: %v", err)
 //	}
-func (s *Session) SetModel(ctx context.Context, model string) error {
-	_, err := s.RPC.Model.SwitchTo(ctx, &rpc.SessionModelSwitchToParams{ModelID: model})
+//	if err := session.SetModel(context.Background(), "claude-sonnet-4.6", &SetModelOptions{ReasoningEffort: "high"}); err != nil {
+//	    log.Printf("Failed to set model: %v", err)
+//	}
+func (s *Session) SetModel(ctx context.Context, model string, opts *SetModelOptions) error {
+	params := &rpc.SessionModelSwitchToParams{ModelID: model}
+	if opts != nil && opts.ReasoningEffort != "" {
+		re := opts.ReasoningEffort
+		params.ReasoningEffort = &re
+	}
+	_, err := s.RPC.Model.SwitchTo(ctx, params)
 	if err != nil {
 		return fmt.Errorf("failed to set model: %w", err)
 	}

nodejs/src/session.ts

@@ -718,14 +718,19 @@ export class CopilotSession {
      * The new model takes effect for the next message. Conversation history is preserved.
      *
      * @param model - Model ID to switch to
+     * @param options - Optional settings for the new model
      *
      * @example
      * ```typescript
      * await session.setModel("gpt-4.1");
+     * await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
      * ```
      */
-    async setModel(model: string): Promise<void> {
-        await this.rpc.model.switchTo({ modelId: model });
+    async setModel(
+        model: string,
+        options?: { reasoningEffort?: "low" | "medium" | "high" | "xhigh" }
+    ): Promise<void> {
+        await this.rpc.model.switchTo({ modelId: model, ...options });
     }
 
     /**

nodejs/test/client.test.ts

@@ -123,6 +123,31 @@ describe("CopilotClient", () => {
         spy.mockRestore();
     });
 
+    it("sends reasoningEffort with session.model.switchTo when provided", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const session = await client.createSession({ onPermissionRequest: approveAll });
+
+        const spy = vi
+            .spyOn((client as any).connection!, "sendRequest")
+            .mockImplementation(async (method: string, _params: any) => {
+                if (method === "session.model.switchTo") return {};
+                throw new Error(`Unexpected method: ${method}`);
+            });
+
+        await session.setModel("claude-sonnet-4.6", { reasoningEffort: "high" });
+
+        expect(spy).toHaveBeenCalledWith("session.model.switchTo", {
+            sessionId: session.sessionId,
+            modelId: "claude-sonnet-4.6",
+            reasoningEffort: "high",
+        });
+
+        spy.mockRestore();
+    });
+
     describe("URL parsing", () => {
         it("should parse port-only URL format", () => {
             const client = new CopilotClient({

python/copilot/session.py

@@ -728,7 +728,7 @@ async def abort(self) -> None:
         """
         await self._client.request("session.abort", {"sessionId": self.session_id})
 
-    async def set_model(self, model: str) -> None:
+    async def set_model(self, model: str, *, reasoning_effort: str | None = None) -> None:
         """
         Change the model for this session.
 
@@ -737,14 +737,22 @@ async def set_model(self, model: str) -> None:
 
         Args:
             model: Model ID to switch to (e.g., "gpt-4.1", "claude-sonnet-4").
+            reasoning_effort: Optional reasoning effort level for the new model
+                (e.g., "low", "medium", "high", "xhigh").
 
         Raises:
             Exception: If the session has been destroyed or the connection fails.
 
         Example:
             >>> await session.set_model("gpt-4.1")
+            >>> await session.set_model("claude-sonnet-4.6", reasoning_effort="high")
         """
-        await self.rpc.model.switch_to(SessionModelSwitchToParams(model_id=model))
+        await self.rpc.model.switch_to(
+            SessionModelSwitchToParams(
+                model_id=model,
+                reasoning_effort=reasoning_effort,
+            )
+        )
 
     async def log(
         self,