Drop protocol v2 support: bump MIN to 3 + delete v2 RPC handlers

Bumps the minimum supported wire protocol version from 2 to 3 across
TypeScript, Python, .NET, Go, and Rust (Java intentionally left at 2 —
out of scope for this PR).

Before this change every SDK registered v2-only RPC handlers for
``tool.call`` and ``permission.request`` alongside the v3
broadcast-event model. The handlers were dead code on a v3 server (the
server only ever sends broadcast events) but were kept "just in case"
the SDK ever connected to a v2 server.

Now that ``MIN_PROTOCOL_VERSION = 3``, a v2 server is rejected at the
``connect`` handshake before any session-level RPC can fire, so the v2
adapters can be deleted outright.

Deletions per SDK:

- **.NET** (``Client.cs``):
  - ``OnToolCallV2`` and ``OnPermissionRequestV2`` RPC handler methods
  - ``ToolCallResponseV2`` and ``PermissionRequestResponseV2`` records
  - Their ``[JsonSerializable]`` entries
  - ``NoResultPermissionDirectRpcErrorMessage`` constant (no longer
    reachable)

- **TypeScript** (``client.ts``, ``session.ts``):
  - ``handleToolCallRequestV2`` / ``handlePermissionRequestV2`` private
    methods on ``CopilotClient``
  - ``normalizeToolResultV2`` / ``isToolResultObject`` helpers
  - ``CopilotSession._handlePermissionRequestV2``
  - ``NO_RESULT_PERMISSION_V2_ERROR`` constant
  - Unused ``ToolCallRequestPayload`` / ``ToolCallResponsePayload`` /
    ``ToolResultObject`` imports in ``client.ts``

- **Python** (``client.py``):
  - ``_handle_tool_call_request_v2`` and ``_handle_permission_request_v2``
    methods (both create_session and resume_session paths)
  - The whole "Protocol v2 backward-compatibility adapters" section
  - ``_NO_RESULT_PERMISSION_V2_ERROR`` constant
  - ``test_v2_permission_adapter_rejects_no_result`` unit test

- **Go** (``client.go``):
  - ``handleToolCallRequestV2`` and ``handlePermissionRequestV2`` methods
  - ``toolCallRequestV2`` / ``toolCallResponseV2`` /
    ``permissionRequestV2`` / ``permissionResponseV2`` payload types
  - ``noResultPermissionDirectRpcError`` constant

- **Rust** (``session.rs``, ``lib.rs``):
  - ``permission.request`` direct-RPC match arm in the session router
  - ``direct_permission_payload`` helper + its unit tests

What's preserved:

- ``MIN_PROTOCOL_VERSION`` constant in each SDK (now ``= 3``)
- The handshake check that rejects servers reporting older versions
- ``negotiated_protocol_version`` field on the client (no longer
  branched on anywhere, but harmless and may grow back if we add a v4
  later)

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

Author: SteveSandersonMS

dotnet/src/Client.cs

@@ -53,13 +53,10 @@ namespace GitHub.Copilot;
 /// </example>
 public sealed partial class CopilotClient : IDisposable, IAsyncDisposable
 {
-    internal const string NoResultPermissionDirectRpcErrorMessage =
-        "Permission handlers cannot return PermissionDecision.NoResult() for this permission request.";
-
     /// <summary>
     /// Minimum protocol version this SDK can communicate with.
     /// </summary>
-    private const int MinProtocolVersion = 2;
+    private const int MinProtocolVersion = 3;
 
     /// <summary>
     /// Provides a thread-safe collection of active Copilot sessions, indexed by session identifier.
@@ -1610,12 +1607,6 @@ private async Task<Connection> ConnectToServerAsync(Process? cliProcess, string?
         var handler = new RpcHandler(this);
         rpc.SetLocalRpcMethod("session.event", handler.OnSessionEvent);
         rpc.SetLocalRpcMethod("session.lifecycle", handler.OnSessionLifecycle);
-        // Protocol v3 servers send tool calls / permission requests as broadcast events.
-        // Protocol v2 servers use the older tool.call / permission.request RPC model.
-        // We always register v2 adapters because handlers are set up before version
-        // negotiation; a v3 server will simply never send these requests.
-        rpc.SetLocalRpcMethod("tool.call", handler.OnToolCallV2);
-        rpc.SetLocalRpcMethod("permission.request", handler.OnPermissionRequestV2);
         rpc.SetLocalRpcMethod("userInput.request", handler.OnUserInputRequest);
         rpc.SetLocalRpcMethod("exitPlanMode.request", handler.OnExitPlanModeRequest);
         rpc.SetLocalRpcMethod("autoModeSwitch.request", handler.OnAutoModeSwitchRequest);
@@ -1799,108 +1790,6 @@ public async ValueTask<SystemMessageTransformRpcResponse> OnSystemMessageTransfo
             var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
             return await session.HandleSystemMessageTransformAsync(sections);
         }
-
-        // Protocol v2 backward-compatibility adapters
-
-        public async ValueTask<ToolCallResponseV2> OnToolCallV2(string sessionId,
-            string toolCallId,
-            string toolName,
-            object? arguments,
-            string? traceparent = null,
-            string? tracestate = null)
-        {
-            using var _ = TelemetryHelpers.RestoreTraceContext(traceparent, tracestate);
-
-            var session = client.GetSession(sessionId) ?? throw new ArgumentException($"Unknown session {sessionId}");
-            if (session.GetTool(toolName) is not { } tool)
-            {
-                // Support for not providing the tool handler is only available in the v3+ model.
-                // For v2, it must have been provided.
-                return new ToolCallResponseV2(new ToolResultObject
-                {
-                    TextResultForLlm = $"Tool '{toolName}' is not supported.",
-                    ResultType = "failure",
-                    Error = $"tool '{toolName}' not supported"
-                });
-            }
-
-            try
-            {
-                var invocation = new ToolInvocation
-                {
-                    SessionId = sessionId,
-                    ToolCallId = toolCallId,
-                    ToolName = toolName,
-                    Arguments = arguments
-                };
-
-                var aiFunctionArgs = new AIFunctionArguments
-                {
-                    Context = new Dictionary<object, object?>
-                    {
-                        [typeof(ToolInvocation)] = invocation
-                    }
-                };
-
-                if (arguments is not null)
-                {
-                    if (arguments is not JsonElement incomingJsonArgs)
-                    {
-                        throw new InvalidOperationException($"Incoming arguments must be a {nameof(JsonElement)}; received {arguments.GetType().Name}");
-                    }
-
-                    foreach (var prop in incomingJsonArgs.EnumerateObject())
-                    {
-                        aiFunctionArgs[prop.Name] = prop.Value;
-                    }
-                }
-
-                var toolTimestamp = Stopwatch.GetTimestamp();
-                var result = await tool.InvokeAsync(aiFunctionArgs);
-                LoggingHelpers.LogTiming(client._logger, LogLevel.Debug, null,
-                    "RpcHandler.OnToolCallV2 tool dispatch. Elapsed={Elapsed}, SessionId={SessionId}, ToolCallId={ToolCallId}, Tool={ToolName}",
-                    toolTimestamp,
-                    sessionId,
-                    toolCallId,
-                    toolName);
-
-                var toolResultObject = ToolResultObject.ConvertFromInvocationResult(result, tool.JsonSerializerOptions);
-                return new ToolCallResponseV2(toolResultObject);
-            }
-            catch (Exception ex)
-            {
-                return new ToolCallResponseV2(new ToolResultObject
-                {
-                    TextResultForLlm = "Invoking this tool produced an error. Detailed information is not available.",
-                    ResultType = "failure",
-                    Error = ex.Message
-                });
-            }
-        }
-
-        public async ValueTask<PermissionRequestResponseV2> OnPermissionRequestV2(string sessionId, JsonElement permissionRequest)
-        {
-            var session = client.GetSession(sessionId)
-                ?? throw new ArgumentException($"Unknown session {sessionId}");
-
-            try
-            {
-                var decision = await session.HandlePermissionRequestAsync(permissionRequest);
-                if (decision is PermissionDecisionNoResult)
-                {
-                    throw new InvalidOperationException(NoResultPermissionDirectRpcErrorMessage);
-                }
-                return new PermissionRequestResponseV2(decision);
-            }
-            catch (InvalidOperationException ex) when (ex.Message == NoResultPermissionDirectRpcErrorMessage)
-            {
-                throw;
-            }
-            catch (Exception)
-            {
-                return new PermissionRequestResponseV2(PermissionDecision.UserNotAvailable());
-            }
-        }
     }
 
     private class Connection(
@@ -2071,13 +1960,6 @@ internal record AutoModeSwitchRequestResponse(
     internal record HooksInvokeResponse(
         object? Output);
 
-    // Protocol v2 backward-compatibility response types
-    internal record ToolCallResponseV2(
-        ToolResultObject Result);
-
-    internal record PermissionRequestResponseV2(
-        PermissionDecision Result);
-
     [JsonSourceGenerationOptions(
         JsonSerializerDefaults.Web,
         AllowOutOfOrderMetadataProperties = true,
@@ -2100,7 +1982,6 @@ internal record PermissionRequestResponseV2(
     [JsonSerializable(typeof(GetSessionMetadataRequest))]
     [JsonSerializable(typeof(GetSessionMetadataResponse))]
     [JsonSerializable(typeof(ModelCapabilitiesOverride))]
-    [JsonSerializable(typeof(PermissionRequestResponseV2))]
     [JsonSerializable(typeof(ProviderConfig))]
     [JsonSerializable(typeof(ResumeSessionRequest))]
     [JsonSerializable(typeof(ResumeSessionResponse))]
@@ -2111,7 +1992,6 @@ internal record PermissionRequestResponseV2(
     [JsonSerializable(typeof(SystemMessageConfig))]
     [JsonSerializable(typeof(SystemMessageTransformRpcResponse))]
     [JsonSerializable(typeof(CommandWireDefinition))]
-    [JsonSerializable(typeof(ToolCallResponseV2))]
     [JsonSerializable(typeof(ToolDefinition))]
     [JsonSerializable(typeof(ToolResultAIContent))]
     [JsonSerializable(typeof(ToolResultObject))]

go/client.go

@@ -52,8 +52,6 @@ import (
 	"github.com/github/copilot-sdk/go/rpc"
 )
 
-const noResultPermissionDirectRpcError = "permission handlers cannot return PermissionDecisionNoResult for this permission request"
-
 func validateSessionFsConfig(config *SessionFsConfig) error {
 	if config == nil {
 		return nil
@@ -1384,7 +1382,7 @@ func (c *Client) ListModels(ctx context.Context) ([]ModelInfo, error) {
 }
 
 // minProtocolVersion is the minimum protocol version this SDK can communicate with.
-const minProtocolVersion = 2
+const minProtocolVersion = 3
 
 // verifyProtocolVersion sends the `connect` handshake (carrying the optional token) and
 // verifies the server's protocol version. Falls back to `ping` against legacy servers
@@ -1740,15 +1738,9 @@ func (c *Client) connectViaTcp(ctx context.Context) error {
 }
 
 // setupNotificationHandler configures handlers for session events and RPC requests.
-// Protocol v3 servers send tool calls and permission requests as broadcast session events.
-// Protocol v2 servers use the older tool.call / permission.request RPC model.
-// We always register v2 adapters because handlers are set up before version negotiation;
-// a v3 server will simply never send these requests.
 func (c *Client) setupNotificationHandler() {
 	c.client.SetRequestHandler("session.event", jsonrpc2.NotificationHandlerFor(c.handleSessionEvent))
 	c.client.SetRequestHandler("session.lifecycle", jsonrpc2.NotificationHandlerFor(c.handleLifecycleEvent))
-	c.client.SetRequestHandler("tool.call", jsonrpc2.RequestHandlerFor(c.handleToolCallRequestV2))
-	c.client.SetRequestHandler("permission.request", jsonrpc2.RequestHandlerFor(c.handlePermissionRequestV2))
 	c.client.SetRequestHandler("userInput.request", jsonrpc2.RequestHandlerFor(c.handleUserInputRequest))
 	c.client.SetRequestHandler("exitPlanMode.request", jsonrpc2.RequestHandlerFor(c.handleExitPlanModeRequest))
 	c.client.SetRequestHandler("autoModeSwitch.request", jsonrpc2.RequestHandlerFor(c.handleAutoModeSwitchRequest))
@@ -1902,115 +1894,3 @@ func (c *Client) handleSystemMessageTransform(req systemMessageTransformRequest)
 	}
 	return resp, nil
 }
-
-// ========================================================================
-// Protocol v2 backward-compatibility adapters
-// ========================================================================
-
-// toolCallRequestV2 is the v2 RPC request payload for tool.call.
-type toolCallRequestV2 struct {
-	SessionID   string `json:"sessionId"`
-	ToolCallID  string `json:"toolCallId"`
-	ToolName    string `json:"toolName"`
-	Arguments   any    `json:"arguments"`
-	Traceparent string `json:"traceparent,omitempty"`
-	Tracestate  string `json:"tracestate,omitempty"`
-}
-
-// toolCallResponseV2 is the v2 RPC response payload for tool.call.
-type toolCallResponseV2 struct {
-	Result ToolResult `json:"result"`
-}
-
-// permissionRequestV2 is the v2 RPC request payload for permission.request.
-type permissionRequestV2 struct {
-	SessionID string            `json:"sessionId"`
-	Request   PermissionRequest `json:"permissionRequest"`
-}
-
-// permissionResponseV2 is the v2 RPC response payload for permission.request.
-type permissionResponseV2 struct {
-	Result rpc.PermissionDecision `json:"result"`
-}
-
-// handleToolCallRequestV2 handles a v2-style tool.call RPC request from the server.
-func (c *Client) handleToolCallRequestV2(req toolCallRequestV2) (*toolCallResponseV2, *jsonrpc2.Error) {
-	if req.SessionID == "" || req.ToolCallID == "" || req.ToolName == "" {
-		return nil, &jsonrpc2.Error{Code: -32602, Message: "invalid tool call payload"}
-	}
-
-	c.sessionsMux.Lock()
-	session, ok := c.sessions[req.SessionID]
-	c.sessionsMux.Unlock()
-	if !ok {
-		return nil, &jsonrpc2.Error{Code: -32602, Message: fmt.Sprintf("unknown session %s", req.SessionID)}
-	}
-
-	handler, ok := session.getToolHandler(req.ToolName)
-	if !ok {
-		return &toolCallResponseV2{Result: ToolResult{
-			TextResultForLLM: fmt.Sprintf("Tool '%s' is not supported by this client instance.", req.ToolName),
-			ResultType:       "failure",
-			Error:            fmt.Sprintf("tool '%s' not supported", req.ToolName),
-			ToolTelemetry:    map[string]any{},
-		}}, nil
-	}
-
-	ctx := contextWithTraceParent(context.Background(), req.Traceparent, req.Tracestate)
-
-	invocation := ToolInvocation{
-		SessionID:    req.SessionID,
-		ToolCallID:   req.ToolCallID,
-		ToolName:     req.ToolName,
-		Arguments:    req.Arguments,
-		TraceContext: ctx,
-	}
-
-	result, err := handler(invocation)
-	if err != nil {
-		return &toolCallResponseV2{Result: ToolResult{
-			TextResultForLLM: "Invoking this tool produced an error. Detailed information is not available.",
-			ResultType:       "failure",
-			Error:            err.Error(),
-			ToolTelemetry:    map[string]any{},
-		}}, nil
-	}
-
-	return &toolCallResponseV2{Result: result}, nil
-}
-
-// handlePermissionRequestV2 handles a v2-style permission.request RPC request from the server.
-func (c *Client) handlePermissionRequestV2(req permissionRequestV2) (*permissionResponseV2, *jsonrpc2.Error) {
-	if req.SessionID == "" {
-		return nil, &jsonrpc2.Error{Code: -32602, Message: "invalid permission request payload"}
-	}
-
-	c.sessionsMux.Lock()
-	session, ok := c.sessions[req.SessionID]
-	c.sessionsMux.Unlock()
-	if !ok {
-		return nil, &jsonrpc2.Error{Code: -32602, Message: fmt.Sprintf("unknown session %s", req.SessionID)}
-	}
-
-	handler := session.getPermissionHandler()
-	if handler == nil {
-		return &permissionResponseV2{Result: &rpc.PermissionDecisionUserNotAvailable{}}, nil
-	}
-
-	invocation := PermissionInvocation{
-		SessionID: session.SessionID,
-	}
-
-	decision, err := handler(req.Request, invocation)
-	if err != nil {
-		return &permissionResponseV2{Result: &rpc.PermissionDecisionUserNotAvailable{}}, nil
-	}
-	if _, isNoResult := decision.(*rpc.PermissionDecisionNoResult); isNoResult {
-		return nil, &jsonrpc2.Error{Code: -32603, Message: noResultPermissionDirectRpcError}
-	}
-	if _, isNoResult := decision.(rpc.PermissionDecisionNoResult); isNoResult {
-		return nil, &jsonrpc2.Error{Code: -32603, Message: noResultPermissionDirectRpcError}
-	}
-
-	return &permissionResponseV2{Result: decision}, nil
-}