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: patniko

dotnet/src/Generated/Rpc.cs

@@ -217,6 +217,9 @@ internal class SessionModelSwitchToRequest
 
     [JsonPropertyName("modelId")]
     public string ModelId { get; set; } = string.Empty;
+
+    [JsonPropertyName("reasoningEffort")]
+    public SessionModelSwitchToRequestReasoningEffort? ReasoningEffort { get; set; }
 }
 
 public class SessionModeGetResult
@@ -511,6 +514,20 @@ internal class SessionPermissionsHandlePendingPermissionRequestRequest
     public object Result { get; set; } = null!;
 }
 
+[JsonConverter(typeof(JsonStringEnumConverter<SessionModelSwitchToRequestReasoningEffort>))]
+public enum SessionModelSwitchToRequestReasoningEffort
+{
+    [JsonStringEnumMemberName("low")]
+    Low,
+    [JsonStringEnumMemberName("medium")]
+    Medium,
+    [JsonStringEnumMemberName("high")]
+    High,
+    [JsonStringEnumMemberName("xhigh")]
+    Xhigh,
+}
+
+
 [JsonConverter(typeof(JsonStringEnumConverter<SessionModeGetResultMode>))]
 public enum SessionModeGetResultMode
 {
@@ -664,9 +681,9 @@ public async Task<SessionModelGetCurrentResult> GetCurrentAsync(CancellationToke
     }
 
     /// <summary>Calls "session.model.switchTo".</summary>
-    public async Task<SessionModelSwitchToResult> SwitchToAsync(string modelId, CancellationToken cancellationToken = default)
+    public async Task<SessionModelSwitchToResult> SwitchToAsync(string modelId, SessionModelSwitchToRequestReasoningEffort? reasoningEffort, CancellationToken cancellationToken = default)
     {
-        var request = new SessionModelSwitchToRequest { SessionId = _sessionId, ModelId = modelId };
+        var request = new SessionModelSwitchToRequest { SessionId = _sessionId, ModelId = modelId, ReasoningEffort = reasoningEffort };
         return await CopilotClient.InvokeRpcAsync<SessionModelSwitchToResult>(_rpc, "session.model.switchTo", [request], cancellationToken);
     }
 }

dotnet/src/Session.cs

@@ -674,15 +674,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);
+        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/rpc/generated_rpc.go

@@ -129,7 +129,8 @@ type SessionModelSwitchToResult struct {
 }
 
 type SessionModelSwitchToParams struct {
-	ModelID string `json:"modelId"`
+	ModelID         string           `json:"modelId"`
+	ReasoningEffort *ReasoningEffort `json:"reasoningEffort,omitempty"`
 }
 
 type SessionModeGetResult struct {
@@ -296,6 +297,30 @@ type SessionPermissionsHandlePendingPermissionRequestParamsResult struct {
 	Path     *string       `json:"path,omitempty"`
 }
 
+type SessionLogResult struct {
+	// The unique identifier of the emitted session event
+	EventID string `json:"eventId"`
+}
+
+type SessionLogParams struct {
+	// When true, the message is transient and not persisted to the session event log on disk
+	Ephemeral *bool `json:"ephemeral,omitempty"`
+	// Log severity level. Determines how the message is displayed in the timeline. Defaults to
+	// "info".
+	Level *Level `json:"level,omitempty"`
+	// Human-readable message
+	Message string `json:"message"`
+}
+
+type ReasoningEffort string
+
+const (
+	High   ReasoningEffort = "high"
+	Low    ReasoningEffort = "low"
+	Medium ReasoningEffort = "medium"
+	Xhigh  ReasoningEffort = "xhigh"
+)
+
 // The current agent mode.
 //
 // The agent mode after switching.
@@ -319,6 +344,16 @@ const (
 	DeniedNoApprovalRuleAndCouldNotRequestFromUser Kind = "denied-no-approval-rule-and-could-not-request-from-user"
 )
 
+// Log severity level. Determines how the message is displayed in the timeline. Defaults to
+// "info".
+type Level string
+
+const (
+	Error   Level = "error"
+	Info    Level = "info"
+	Warning Level = "warning"
+)
+
 type ResultUnion struct {
 	ResultResult *ResultResult
 	String       *string
@@ -416,6 +451,9 @@ func (a *ModelRpcApi) SwitchTo(ctx context.Context, params *SessionModelSwitchTo
 	req := map[string]interface{}{"sessionId": a.sessionID}
 	if params != nil {
 		req["modelId"] = params.ModelID
+		if params.ReasoningEffort != nil {
+			req["reasoningEffort"] = *params.ReasoningEffort
+		}
 	}
 	raw, err := a.client.Request("session.model.switchTo", req)
 	if err != nil {
@@ -725,6 +763,28 @@ type SessionRpc struct {
 	Permissions *PermissionsRpcApi
 }
 
+func (a *SessionRpc) Log(ctx context.Context, params *SessionLogParams) (*SessionLogResult, error) {
+	req := map[string]interface{}{"sessionId": a.sessionID}
+	if params != nil {
+		req["message"] = params.Message
+		if params.Level != nil {
+			req["level"] = *params.Level
+		}
+		if params.Ephemeral != nil {
+			req["ephemeral"] = *params.Ephemeral
+		}
+	}
+	raw, err := a.client.Request("session.log", req)
+	if err != nil {
+		return nil, err
+	}
+	var result SessionLogResult
+	if err := json.Unmarshal(raw, &result); err != nil {
+		return nil, err
+	}
+	return &result, nil
+}
+
 func NewSessionRpc(client *jsonrpc2.Client, sessionID string) *SessionRpc {
 	return &SessionRpc{client: client, sessionID: sessionID,
 		Model:       &ModelRpcApi{client: client, sessionID: sessionID},

go/session.go

@@ -685,16 +685,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/generated/rpc.ts

@@ -173,6 +173,7 @@ export interface SessionModelSwitchToParams {
    */
   sessionId: string;
   modelId: string;
+  reasoningEffort?: "low" | "medium" | "high" | "xhigh";
 }
 
 export interface SessionModeGetResult {
@@ -489,6 +490,32 @@ export interface SessionPermissionsHandlePendingPermissionRequestParams {
       };
 }
 
+export interface SessionLogResult {
+  /**
+   * The unique identifier of the emitted session event
+   */
+  eventId: string;
+}
+
+export interface SessionLogParams {
+  /**
+   * Target session identifier
+   */
+  sessionId: string;
+  /**
+   * Human-readable message
+   */
+  message: string;
+  /**
+   * Log severity level. Determines how the message is displayed in the timeline. Defaults to "info".
+   */
+  level?: "info" | "warning" | "error";
+  /**
+   * When true, the message is transient and not persisted to the session event log on disk
+   */
+  ephemeral?: boolean;
+}
+
 /** Create typed server-scoped RPC methods (no session required). */
 export function createServerRpc(connection: MessageConnection) {
     return {
@@ -566,5 +593,7 @@ export function createSessionRpc(connection: MessageConnection, sessionId: strin
             handlePendingPermissionRequest: async (params: Omit<SessionPermissionsHandlePendingPermissionRequestParams, "sessionId">): Promise<SessionPermissionsHandlePendingPermissionRequestResult> =>
                 connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params }),
         },
+        log: async (params: Omit<SessionLogParams, "sessionId">): Promise<SessionLogResult> =>
+            connection.sendRequest("session.log", { sessionId, ...params }),
     };
 }

nodejs/src/session.ts

@@ -684,13 +684,18 @@ 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 });
     }
 }