Update @github/copilot to 1.0.51-1

dotnet/src/Session.cs

@@ -1427,7 +1427,7 @@ public async Task LogAsync(string message, SessionLogLevel? level = null, bool?
         ArgumentNullException.ThrowIfNull(message);
         ThrowIfDisposed();
 
-        await Rpc.LogAsync(message, level, ephemeral, url, cancellationToken);
+        await Rpc.LogAsync(message, level, ephemeral: ephemeral, url: url, cancellationToken: cancellationToken);
     }
 
     /// <summary>

dotnet/src/Types.cs

@@ -2795,9 +2795,9 @@ public class PingResponse
     /// </summary>
     public string Message { get; set; } = string.Empty;
     /// <summary>
-    /// Server timestamp when the ping was processed.
+    /// ISO 8601 timestamp when the ping was processed.
     /// </summary>
-    public long Timestamp { get; set; }
+    public DateTimeOffset Timestamp { get; set; }
     /// <summary>
     /// Protocol version supported by the server.
     /// </summary>

dotnet/test/E2E/ClientE2ETests.cs

@@ -25,7 +25,7 @@ public async Task Should_Start_And_Connect_To_Server(bool useStdio)
 
             var pong = await client.PingAsync("test message");
             Assert.Equal("pong: test message", pong.Message);
-            Assert.True(pong.Timestamp >= 0);
+            Assert.NotEqual(default, pong.Timestamp);
 
             await client.StopAsync();
             Assert.Equal(ConnectionState.Disconnected, client.State);

dotnet/test/E2E/HookLifecycleAndOutputE2ETests.cs

@@ -322,7 +322,12 @@ public async Task Should_Allow_PostToolUse_To_Return_ModifiedResult()
 
                     return Task.FromResult<PostToolUseHookOutput?>(new PostToolUseHookOutput
                     {
-                        ModifiedResult = "modified by post hook",
+                        ModifiedResult = new ToolResultObject
+                        {
+                            TextResultForLlm = "modified by post hook",
+                            ResultType = "success",
+                            ToolTelemetry = new Dictionary<string, object>(),
+                        },
                         SuppressOutput = false,
                     });
                 },

dotnet/test/E2E/ModeHandlersE2ETests.cs

@@ -103,9 +103,10 @@ public async Task Should_Invoke_Auto_Mode_Switch_Handler_When_Rate_Limited()
             },
         });
 
+        const long expectedRetryAfter = 1;
         var requestedEventTask = GetNextEventOfTypeAllowingRateLimitAsync<AutoModeSwitchRequestedEvent>(
             session,
-            evt => evt.Data.ErrorCode == "user_weekly_rate_limited" && evt.Data.RetryAfterSeconds == 1,
+            evt => evt.Data.ErrorCode == "user_weekly_rate_limited" && evt.Data.RetryAfterSeconds == expectedRetryAfter,
             TimeSpan.FromSeconds(30),
             timeoutDescription: "auto_mode_switch.requested event");
         var completedEventTask = GetNextEventOfTypeAllowingRateLimitAsync<AutoModeSwitchCompletedEvent>(
@@ -137,7 +138,7 @@ public async Task Should_Invoke_Auto_Mode_Switch_Handler_When_Rate_Limited()
 
         var requestedEvent = await requestedEventTask;
         Assert.Equal(request.ErrorCode, requestedEvent.Data.ErrorCode);
-        Assert.Equal(request.RetryAfterSeconds, requestedEvent.Data.RetryAfterSeconds);
+        Assert.Equal(expectedRetryAfter, requestedEvent.Data.RetryAfterSeconds);
 
         var completedEvent = await completedEventTask;
         Assert.Equal(AutoModeSwitchResponse.Yes, completedEvent.Data.Response);

dotnet/test/E2E/RpcAdditionalEdgeCasesE2ETests.cs

@@ -151,11 +151,11 @@ public async Task Usage_GetMetrics_On_Fresh_Session_Returns_Zero_Tokens()
         var metrics = await session.Rpc.Usage.GetMetricsAsync();
 
         // Fresh session = no LLM calls yet. Last-call counters and the user-request count
-        // must be zero, and SessionStartTime must be a positive epoch (set at create-time).
+        // must be zero, and SessionStartTime must be populated at create-time.
         Assert.Equal(0, metrics.LastCallInputTokens);
         Assert.Equal(0, metrics.LastCallOutputTokens);
         Assert.Equal(0, metrics.TotalUserRequests);
-        Assert.True(metrics.SessionStartTime > 0, "SessionStartTime should be a positive epoch.");
+        Assert.NotEqual(default, metrics.SessionStartTime);
     }
 
     [Fact]

dotnet/test/E2E/RpcServerE2ETests.cs

@@ -45,7 +45,7 @@ public async Task Should_Call_Rpc_Ping_With_Typed_Params_And_Result()
         var result = await Client.Rpc.PingAsync(message: "typed rpc test");
 
         Assert.Equal("pong: typed rpc test", result.Message);
-        Assert.True(result.Timestamp >= 0);
+        Assert.NotEqual(default, result.Timestamp);
     }
 
     [Fact]

dotnet/test/E2E/RpcSessionStateE2ETests.cs

@@ -356,7 +356,7 @@ public async Task Should_Call_Session_Usage_And_Permission_Rpcs()
         await using var session = await CreateSessionAsync();
 
         var metrics = await session.Rpc.Usage.GetMetricsAsync();
-        Assert.True(metrics.SessionStartTime > 0);
+        Assert.NotEqual(default, metrics.SessionStartTime);
         Assert.True(metrics.TotalNanoAiu is null or >= 0);
         if (metrics.TokenDetails is not null)
         {

go/client.go

@@ -1312,7 +1312,7 @@ func (c *Client) ActualPort() int {
 //	if err != nil {
 //	    log.Printf("Server unreachable: %v", err)
 //	} else {
-//	    log.Printf("Server responded at %d", resp.Timestamp)
+//	    log.Printf("Server responded at %s", resp.Timestamp)
 //	}
 func (c *Client) Ping(ctx context.Context, message string) (*PingResponse, error) {
 	if c.client == nil {

go/internal/e2e/client_e2e_test.go

@@ -38,8 +38,8 @@ func TestClientE2E(t *testing.T) {
 			t.Errorf("Expected pong.message to be 'pong: test message', got %q", pong.Message)
 		}
 
-		if pong.Timestamp < 0 {
-			t.Errorf("Expected pong.timestamp >= 0, got %d", pong.Timestamp)
+		if pong.Timestamp.IsZero() {
+			t.Errorf("Expected non-zero pong.timestamp, got %s", pong.Timestamp)
 		}
 
 		if err := client.Stop(); err != nil {
@@ -75,8 +75,8 @@ func TestClientE2E(t *testing.T) {
 			t.Errorf("Expected pong.message to be 'pong: test message', got %q", pong.Message)
 		}
 
-		if pong.Timestamp < 0 {
-			t.Errorf("Expected pong.timestamp >= 0, got %d", pong.Timestamp)
+		if pong.Timestamp.IsZero() {
+			t.Errorf("Expected non-zero pong.timestamp, got %s", pong.Timestamp)
 		}
 
 		if err := client.Stop(); err != nil {

go/internal/e2e/hooks_extended_e2e_test.go

@@ -301,7 +301,11 @@ func TestHooksExtendedE2E(t *testing.T) {
 						return nil, nil
 					}
 					return &copilot.PostToolUseHookOutput{
-						ModifiedResult: "modified by post hook",
+						ModifiedResult: copilot.ToolResult{
+							TextResultForLLM: "modified by post hook",
+							ResultType:       "success",
+							ToolTelemetry:    map[string]any{},
+						},
 						SuppressOutput: false,
 					}, nil
 				},

go/internal/e2e/rpc_e2e_test.go

@@ -35,8 +35,8 @@ func TestRpcE2E(t *testing.T) {
 			t.Errorf("Expected message 'pong: typed rpc test', got %q", result.Message)
 		}
 
-		if result.Timestamp < 0 {
-			t.Errorf("Expected timestamp >= 0, got %d", result.Timestamp)
+		if result.Timestamp.IsZero() {
+			t.Errorf("Expected non-zero timestamp, got %s", result.Timestamp)
 		}
 
 		if err := client.Stop(); err != nil {

go/internal/e2e/rpc_event_side_effects_e2e_test.go

@@ -199,7 +199,7 @@ func TestRpcEventSideEffectsE2E(t *testing.T) {
 		if !strings.EqualFold(rewindData.UpToEventID, targetEventID) {
 			t.Fatalf("Expected rewind to target %q, got %+v", targetEventID, rewindData)
 		}
-		if rewindData.EventsRemoved != float64(truncateResult.EventsRemoved) {
+		if rewindData.EventsRemoved != truncateResult.EventsRemoved {
 			t.Fatalf("Expected rewind count %d, got %+v", truncateResult.EventsRemoved, rewindData)
 		}
 

go/internal/e2e/rpc_server_e2e_test.go

@@ -33,8 +33,8 @@ func TestRpcServerE2E(t *testing.T) {
 		if !strings.Contains(result.Message, "typed rpc test") {
 			t.Errorf("Expected ping response to contain 'typed rpc test', got %q", result.Message)
 		}
-		if result.Timestamp < 0 {
-			t.Errorf("Expected non-negative Timestamp, got %d", result.Timestamp)
+		if result.Timestamp.IsZero() {
+			t.Errorf("Expected non-zero Timestamp, got %s", result.Timestamp)
 		}
 	})
 

go/internal/e2e/rpc_session_state_e2e_test.go

@@ -469,8 +469,8 @@ func TestRpcSessionStateE2E(t *testing.T) {
 		if err != nil {
 			t.Fatalf("Failed to get usage metrics: %v", err)
 		}
-		if metrics.SessionStartTime <= 0 {
-			t.Errorf("Expected positive sessionStartTime, got %d", metrics.SessionStartTime)
+		if metrics.SessionStartTime.IsZero() {
+			t.Errorf("Expected non-zero sessionStartTime, got %s", metrics.SessionStartTime)
 		}
 		if metrics.TotalNanoAiu != nil && *metrics.TotalNanoAiu < 0 {
 			t.Errorf("Expected non-negative totalNanoAiu, got %d", *metrics.TotalNanoAiu)

go/internal/e2e/session_e2e_test.go

@@ -1457,7 +1457,7 @@ func TestSessionAttachmentsE2E(t *testing.T) {
 			t.Fatalf("CreateSession failed: %v", err)
 		}
 
-		number := float64(1234)
+		number := int64(1234)
 		referenceType := copilot.UserMessageAttachmentGithubReferenceTypeIssue
 		state := "open"
 		title := "Add E2E attachment coverage"

go/rpc/generated_rpc_union_test.go

@@ -133,6 +133,38 @@ func TestMcpServerConfigJSONUnion(t *testing.T) {
 	}
 }
 
+func TestTaskProgressUnmarshalsTaskAgentProgressVariants(t *testing.T) {
+	var agentProgress TaskProgress
+	if err := json.Unmarshal([]byte(`{"type":"agent","recentActivity":[],"latestIntent":"Summarizing"}`), &agentProgress); err != nil {
+		t.Fatalf("unmarshal agent task progress: %v", err)
+	}
+	agentValue, ok := agentProgress.TaskAgentProgress.(*TaskAgentProgressAgent)
+	if !ok {
+		t.Fatalf("agent task progress = %T, want *TaskAgentProgressAgent", agentProgress.TaskAgentProgress)
+	}
+	if agentValue.LatestIntent == nil || *agentValue.LatestIntent != "Summarizing" {
+		t.Fatalf("agent latest intent = %v, want Summarizing", agentValue.LatestIntent)
+	}
+	if agentProgress.TaskShellProgress != nil {
+		t.Fatalf("agent task shell progress = %#v, want nil", *agentProgress.TaskShellProgress)
+	}
+
+	var shellProgress TaskProgress
+	if err := json.Unmarshal([]byte(`{"type":"shell","recentOutput":"building","pid":123}`), &shellProgress); err != nil {
+		t.Fatalf("unmarshal shell task progress: %v", err)
+	}
+	shellValue, ok := shellProgress.TaskAgentProgress.(*TaskAgentProgressShell)
+	if !ok {
+		t.Fatalf("shell task progress = %T, want *TaskAgentProgressShell", shellProgress.TaskAgentProgress)
+	}
+	if shellValue.RecentOutput != "building" {
+		t.Fatalf("shell recent output = %q, want building", shellValue.RecentOutput)
+	}
+	if shellValue.Pid == nil || *shellValue.Pid != 123 {
+		t.Fatalf("shell pid = %v, want 123", shellValue.Pid)
+	}
+}
+
 func TestCommandsInvokeUnmarshalsSlashCommandInvocationResult(t *testing.T) {
 	clientToServerReader, clientToServerWriter := io.Pipe()
 	serverToClientReader, serverToClientWriter := io.Pipe()