Adapt hand-authored code to renamed schema in @github/copilot 1.0.40-1

The 1.0.40-1 schema renames several types that are referenced from
hand-authored code:

  - ToolsHandlePendingToolCallRequest -> HandlePendingToolCallRequest
  - ToolsHandlePendingToolCall (union) -> ExternalToolResult (union)
  - ToolCallResult                     -> ExternalToolTextResultForLlm
  - PermissionCompletedKind enum       -> PermissionResult polymorphism
                                          (PermissionResultApproved,
                                           PermissionResultDeniedInteractivelyByUser,
                                           ...)

Update the corresponding hand-authored files so the SDKs build again:

  - go/rpc/result_union.go: rename receiver and union field references
    on the custom (Un)MarshalJSON methods.
  - go/session.go: use the new request/result type and union field names
    when sending tool call results back via RPC.
  - python/copilot/session.py: import the renamed RPC types and use them
    when constructing handle_pending_tool_call requests.
  - dotnet/test/MultiClientTests.cs: switch from a removed Kind enum
    comparison to Assert.IsType<PermissionResult*> against the new
    polymorphic PermissionResult derived types.

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

Author: stephentoub

dotnet/test/MultiClientTests.cs

@@ -194,7 +194,7 @@ public async Task One_Client_Approves_Permission_And_Both_See_The_Result()
         foreach (var evt in client1Events.OfType<PermissionCompletedEvent>()
             .Concat(client2Events.OfType<PermissionCompletedEvent>()))
         {
-            Assert.Equal(PermissionCompletedKind.Approved, evt.Data.Result.Kind);
+            Assert.IsType<PermissionResultApproved>(evt.Data.Result);
         }
 
         await session2.DisposeAsync();
@@ -246,7 +246,7 @@ await session1.SendAndWaitAsync(new MessageOptions
         foreach (var evt in client1Events.OfType<PermissionCompletedEvent>()
             .Concat(client2Events.OfType<PermissionCompletedEvent>()))
         {
-            Assert.Equal(PermissionCompletedKind.DeniedInteractivelyByUser, evt.Data.Result.Kind);
+            Assert.IsType<PermissionResultDeniedInteractivelyByUser>(evt.Data.Result);
         }
 
         await session2.DisposeAsync();

go/rpc/result_union.go

@@ -2,33 +2,33 @@ package rpc
 
 import "encoding/json"
 
-// MarshalJSON serializes ToolsHandlePendingToolCall as the appropriate JSON variant:
-// a plain string when String is set, or the ToolCallResult object otherwise.
+// MarshalJSON serializes ExternalToolResult as the appropriate JSON variant:
+// a plain string when String is set, or the ExternalToolTextResultForLlm object otherwise.
 // The generated struct has no custom marshaler, so without this the Go
-// struct fields would serialize as {"ToolCallResult":...,"String":...}
+// struct fields would serialize as {"ExternalToolTextResultForLlm":...,"String":...}
 // instead of the union the server expects.
-func (r ToolsHandlePendingToolCall) MarshalJSON() ([]byte, error) {
+func (r ExternalToolResult) MarshalJSON() ([]byte, error) {
 	if r.String != nil {
 		return json.Marshal(*r.String)
 	}
-	if r.ToolCallResult != nil {
-		return json.Marshal(*r.ToolCallResult)
+	if r.ExternalToolTextResultForLlm != nil {
+		return json.Marshal(*r.ExternalToolTextResultForLlm)
 	}
 	return []byte("null"), nil
 }
 
-// UnmarshalJSON deserializes a JSON value into the appropriate ToolsHandlePendingToolCall variant.
-func (r *ToolsHandlePendingToolCall) UnmarshalJSON(data []byte) error {
+// UnmarshalJSON deserializes a JSON value into the appropriate ExternalToolResult variant.
+func (r *ExternalToolResult) UnmarshalJSON(data []byte) error {
 	// Try string first
 	var s string
 	if err := json.Unmarshal(data, &s); err == nil {
 		r.String = &s
 		return nil
 	}
-	// Try ToolCallResult object
-	var rr ToolCallResult
+	// Try ExternalToolTextResultForLlm object
+	var rr ExternalToolTextResultForLlm
 	if err := json.Unmarshal(data, &rr); err == nil {
-		r.ToolCallResult = &rr
+		r.ExternalToolTextResultForLlm = &rr
 		return nil
 	}
 	return nil

go/session.go

@@ -966,7 +966,7 @@ func (s *Session) executeToolAndRespond(requestID, toolName, toolCallID string,
 	defer func() {
 		if r := recover(); r != nil {
 			errMsg := fmt.Sprintf("tool panic: %v", r)
-			s.RPC.Tools.HandlePendingToolCall(ctx, &rpc.ToolsHandlePendingToolCallRequest{
+			s.RPC.Tools.HandlePendingToolCall(ctx, &rpc.HandlePendingToolCallRequest{
 				RequestID: requestID,
 				Error:     &errMsg,
 			})
@@ -984,7 +984,7 @@ func (s *Session) executeToolAndRespond(requestID, toolName, toolCallID string,
 	result, err := handler(invocation)
 	if err != nil {
 		errMsg := err.Error()
-		s.RPC.Tools.HandlePendingToolCall(ctx, &rpc.ToolsHandlePendingToolCallRequest{
+		s.RPC.Tools.HandlePendingToolCall(ctx, &rpc.HandlePendingToolCallRequest{
 			RequestID: requestID,
 			Error:     &errMsg,
 		})
@@ -1006,17 +1006,17 @@ func (s *Session) executeToolAndRespond(requestID, toolName, toolCallID string,
 		}
 	}
 
-	rpcResult := rpc.ToolsHandlePendingToolCall{
-		ToolCallResult: &rpc.ToolCallResult{
+	rpcResult := rpc.ExternalToolResult{
+		ExternalToolTextResultForLlm: &rpc.ExternalToolTextResultForLlm{
 			TextResultForLlm: textResultForLLM,
 			ToolTelemetry:    result.ToolTelemetry,
 			ResultType:       &effectiveResultType,
 		},
 	}
 	if result.Error != "" {
-		rpcResult.ToolCallResult.Error = &result.Error
+		rpcResult.ExternalToolTextResultForLlm.Error = &result.Error
 	}
-	s.RPC.Tools.HandlePendingToolCall(ctx, &rpc.ToolsHandlePendingToolCallRequest{
+	s.RPC.Tools.HandlePendingToolCall(ctx, &rpc.HandlePendingToolCallRequest{
 		RequestID: requestID,
 		Result:    &rpcResult,
 	})

python/copilot/session.py

@@ -24,15 +24,15 @@
 from .generated.rpc import (
     ClientSessionApiHandlers,
     CommandsHandlePendingCommandRequest,
+    ExternalToolTextResultForLlm,
+    HandlePendingToolCallRequest,
     LogRequest,
     ModelSwitchToRequest,
     PermissionDecision,
     PermissionDecisionKind,
     PermissionDecisionRequest,
     SessionLogLevel,
     SessionRpc,
-    ToolCallResult,
-    ToolsHandlePendingToolCallRequest,
     UIElicitationRequest,
     UIElicitationResponse,
     UIElicitationResponseAction,
@@ -1403,16 +1403,16 @@ async def _execute_tool_and_respond(
             # failures send the full structured result to preserve metadata.
             if tool_result._from_exception:
                 await self.rpc.tools.handle_pending_tool_call(
-                    ToolsHandlePendingToolCallRequest(
+                    HandlePendingToolCallRequest(
                         request_id=request_id,
                         error=tool_result.error,
                     )
                 )
             else:
                 await self.rpc.tools.handle_pending_tool_call(
-                    ToolsHandlePendingToolCallRequest(
+                    HandlePendingToolCallRequest(
                         request_id=request_id,
-                        result=ToolCallResult(
+                        result=ExternalToolTextResultForLlm(
                             text_result_for_llm=tool_result.text_result_for_llm,
                             error=tool_result.error,
                             result_type=tool_result.result_type,
@@ -1423,7 +1423,7 @@ async def _execute_tool_and_respond(
         except Exception as exc:
             try:
                 await self.rpc.tools.handle_pending_tool_call(
-                    ToolsHandlePendingToolCallRequest(
+                    HandlePendingToolCallRequest(
                         request_id=request_id,
                         error=str(exc),
                     )