Update @github/copilot to 1.0.56 (#1504)

* Update @github/copilot to 1.0.56

- Updated nodejs and test harness dependencies
- Re-ran code generators
- Formatted generated code

* test: cover pending external tool resume in both warm and cold modes

Runtime 1.0.56 changed disconnect semantics so that ForceStop of the
last RPC owner now triggers session cleanup. The previous
warm-only test for `Should_Keep_Pending_External_Tool_Handleable_On_*_Resume_When_ContinuePendingWork_Is_False`
asserted SessionWasActive == true and that `handlePendingToolCall`
fed a result into the assistant reply -- assumptions that only hold for
warm resume. On cold resume the runtime intentionally auto-completes
orphan tool calls with a synthetic interrupt result, so the SDK call
correctly returns success=false.

Split that test into two scenarios across Node, Go, .NET, and Python:

- Warm (original client stays connected): SessionWasActive=true,
  handlePendingToolCall returns success=true, and the assistant echoes
  the supplied result.
- Cold (original client ForceStopped before resume): SessionWasActive=false,
  handlePendingToolCall returns success=false, and a follow-up turn
  confirms the resumed session is still healthy.

In warm mode the resumed client must not re-register the external tool
(it would clash with the original owner); in cold mode it re-registers
with a throwing handler to assert the runtime does not re-invoke the
handler on resume.

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

* Skip pending-resume tests broken by runtime cold-cleanup contract

Runtime PR #9040 (commit b8e1220b45) made SDKServer.handleConnectionClosed
clean up session state when the last RPC owner disconnects. As a result,
the existing Should_Continue_Pending_{Permission,External_Tool}_Request_
After_Resume tests, which ForceStop the suspended client and then expect
the resumed client to successfully complete the pending request, no longer
pass: HandlePendingPermissionRequest/HandlePendingToolCall return
success=false after the cold cleanup runs.

A runtime-side fix is being tracked separately. Skip these two tests in
all four SDKs (.NET, Go, Node, Python) with a TODO referencing the
runtime contract change so they can be re-enabled once that work lands.

Also drop the GetFinalAssistantMessageAsync continuation assertions from
the .NET and Go warm theory and from the older OLD tests, matching the
Node and Python tests which never made that assertion. The
ContinuePendingWork=false warm path provides no guarantee that the
suspended client's agentic loop will propagate a final assistant.message
to the resumed client, and waiting for one was flaking on Linux .NET CI.

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

* Reword pending-resume skip messages to match actual runtime contract

The previous wording ('Pending runtime fix') implied a runtime change was being tracked separately. That isn't accurate: runtime 1.0.56 (copilot-agent-runtime PR #9040) intentionally cleans up the session when the last RPC client disconnects, and there is no in-flight fix planned.

The OLD tests model same-process ForceStop+resume and rely on the old behavior where the session stayed alive in the runtime process. They need to be redesigned to either keep an owner connected (warm resume) or to model true process-restart resume from persisted session state.

No code change beyond the skip-reason text; tests remain skipped while the redesign is figured out.

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

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Stephen Toub <stoub@microsoft.com>
Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: 3 people

dotnet/src/Generated/Rpc.cs

@@ -19,12 +19,18 @@ public class PendingWorkResumeE2ETests(E2ETestFixture fixture, ITestOutputHelper
     private static readonly TimeSpan PendingWorkTimeout = TimeSpan.FromSeconds(60);
     private const string SharedToken = "pending-work-resume-shared-token";
 
-    [Fact]
+    // Skipped after the runtime 1.0.56 bump. Runtime PR #9040 (commit b8e1220b45) changed
+    // SDKServer.handleConnectionClosed to tear down the session when the last RPC client
+    // disconnects, so the in-memory pending permission request is gone before the resumed
+    // client can satisfy it and HandlePendingPermissionRequest returns success=false. This
+    // test models same-process ForceStop+resume; it needs to be redesigned to either keep
+    // an owner connected (warm resume) or to model a true process restart against the
+    // persisted session state.
+    [Fact(Skip = "Runtime 1.0.56 cleans up the session on last-client disconnect (copilot-agent-runtime PR #9040), so the in-memory pending request is gone before resume can satisfy it. Test needs redesign.")]
     public async Task Should_Continue_Pending_Permission_Request_After_Resume()
     {
         var originalPermissionRequest = new TaskCompletionSource<PermissionRequest>(TaskCreationOptions.RunContinuationsAsynchronously);
         var releaseOriginalPermission = new TaskCompletionSource<PermissionDecision>(TaskCreationOptions.RunContinuationsAsynchronously);
-        var resumedToolInvoked = false;
 
         await using var server = Ctx.CreateClient(options: new CopilotClientOptions { Connection = RuntimeConnection.ForTcp(connectionToken: SharedToken) });
         await server.StartAsync();
@@ -66,10 +72,7 @@ await session1.SendAsync(new MessageOptions
                 [
                     AIFunctionFactory.Create(
                         ([Description("Value to transform")] string value) =>
-                        {
-                            resumedToolInvoked = true;
-                            return $"PERMISSION_RESUMED_{value.ToUpperInvariant()}";
-                        },
+                            $"PERMISSION_RESUMED_{value.ToUpperInvariant()}",
                         "resume_permission_tool")
                 ],
             });
@@ -79,11 +82,6 @@ await session1.SendAsync(new MessageOptions
                 new RpcPermissionDecisionApproveOnce());
             Assert.True(permissionResult.Success);
 
-            var answer = await TestHelper.GetFinalAssistantMessageAsync(session2, PendingWorkTimeout);
-
-            Assert.True(resumedToolInvoked);
-            Assert.Contains("PERMISSION_RESUMED_ALPHA", answer?.Data.Content ?? string.Empty);
-
             await session2.DisposeAsync();
             await resumedTcpClient.ForceStopAsync();
         }
@@ -97,7 +95,12 @@ static string ResumePermissionTool([Description("Value to transform")] string va
             $"ORIGINAL_SHOULD_NOT_RUN_{value}";
     }
 
-    [Fact]
+    // Skipped for the same reason as Should_Continue_Pending_Permission_Request_After_Resume:
+    // runtime 1.0.56 (copilot-agent-runtime PR #9040) tears down the session when the last
+    // RPC client disconnects, so the in-memory pending external tool call is gone before
+    // the resumed client can satisfy it. Needs redesign to keep an owner connected (warm)
+    // or to model true process-restart resume from persisted state.
+    [Fact(Skip = "Runtime 1.0.56 cleans up the session on last-client disconnect (copilot-agent-runtime PR #9040), so the in-memory pending tool call is gone before resume can satisfy it. Test needs redesign.")]
     public async Task Should_Continue_Pending_External_Tool_Request_After_Resume()
     {
         var originalToolStarted = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -140,10 +143,6 @@ await session1.SendAsync(new MessageOptions
                 result: JsonDocument.Parse("\"EXTERNAL_RESUMED_BETA\"").RootElement.Clone());
             Assert.True(toolResult.Success);
 
-            var answer = await TestHelper.GetFinalAssistantMessageAsync(session2, PendingWorkTimeout);
-
-            Assert.Contains("EXTERNAL_RESUMED_BETA", answer?.Data.Content ?? string.Empty);
-
             await session2.DisposeAsync();
             await resumedClient.ForceStopAsync();
         }
@@ -161,7 +160,23 @@ async Task<string> BlockingExternalTool([Description("Value to look up")] string
     }
 
     [Fact]
-    public async Task Should_Keep_Pending_External_Tool_Handleable_On_Warm_Resume_When_ContinuePendingWork_Is_False()
+    public Task Should_Keep_Pending_External_Tool_Handleable_On_Warm_Resume_When_ContinuePendingWork_Is_False() =>
+        AssertPendingExternalToolHandleableOnResumeAsync(
+            disconnectOriginalClient: false,
+            expectedSessionWasActive: true,
+            expectedHandleResult: true);
+
+    [Fact]
+    public Task Should_Keep_Pending_External_Tool_Handleable_On_Cold_Resume_When_ContinuePendingWork_Is_False() =>
+        AssertPendingExternalToolHandleableOnResumeAsync(
+            disconnectOriginalClient: true,
+            expectedSessionWasActive: false,
+            expectedHandleResult: false);
+
+    private async Task AssertPendingExternalToolHandleableOnResumeAsync(
+        bool disconnectOriginalClient,
+        bool expectedSessionWasActive,
+        bool expectedHandleResult)
     {
         var originalToolStarted = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
         var releaseOriginalTool = new TaskCompletionSource<string>(TaskCreationOptions.RunContinuationsAsynchronously);
@@ -191,28 +206,54 @@ await session1.SendAsync(new MessageOptions
             var toolEvent = await toolRequested;
             Assert.Equal("beta", await originalToolStarted.Task.WaitAsync(PendingWorkTimeout));
 
-            await suspendedClient.ForceStopAsync();
+            if (disconnectOriginalClient)
+            {
+                await suspendedClient.ForceStopAsync();
+            }
 
             await using var resumedClient = Ctx.CreateClient(options: new CopilotClientOptions { Connection = RuntimeConnection.ForUri(cliUrl, connectionToken: SharedToken) });
-            var session2 = await resumedClient.ResumeSessionAsync(sessionId, new ResumeSessionConfig
+
+            // In warm mode the original client still owns the tool registration;
+            // re-registering it from the resumed client would cause a name-clash. In
+            // cold mode the original is gone, so we register a fresh throwing handler
+            // to assert the runtime doesn't re-invoke the tool on resume (orphan
+            // auto-completion happens internally).
+            var resumeConfig = new ResumeSessionConfig
             {
                 ContinuePendingWork = false,
                 OnPermissionRequest = PermissionHandler.ApproveAll,
-            });
+            };
+            if (disconnectOriginalClient)
+            {
+                resumeConfig.Tools = [AIFunctionFactory.Create(ResumedExternalTool, "resume_external_tool")];
+            }
+
+            var session2 = await resumedClient.ResumeSessionAsync(sessionId, resumeConfig);
 
             var resumeEvent = await GetSingleResumeEventAsync(session2);
             Assert.Equal(false, resumeEvent.Data.ContinuePendingWork);
-            Assert.Equal(true, resumeEvent.Data.SessionWasActive);
+            Assert.Equal(expectedSessionWasActive, resumeEvent.Data.SessionWasActive);
 
+            // Warm: the runtime still has the pending request and HandlePendingToolCall
+            // will succeed.
+            // Cold: the runtime auto-completed the orphaned tool call with a synthetic
+            // interrupt result during resume, so HandlePendingToolCall correctly reports
+            // success=false. The session should still be healthy for new turns.
             var resumedResult = await session2.Rpc.Tools.HandlePendingToolCallAsync(
                 toolEvent.Data.RequestId,
                 result: JsonDocument.Parse("\"EXTERNAL_RESUMED_BETA\"").RootElement.Clone());
-            Assert.True(resumedResult.Success);
-
-            // continuePendingWork=false may interrupt agent continuation before this response,
-            // but the pending call should still accept an explicit completion.
+            Assert.Equal(expectedHandleResult, resumedResult.Success);
             Assert.Equal(1, invocationCount);
 
+            if (!expectedHandleResult)
+            {
+                var followUp = await session2.SendAndWaitAsync(new MessageOptions
+                {
+                    Prompt = "Reply with exactly: COLD_RESUMED_FOLLOWUP",
+                });
+                Assert.Contains("COLD_RESUMED_FOLLOWUP", followUp?.Data.Content ?? string.Empty);
+            }
+
             await session2.DisposeAsync();
             await resumedClient.ForceStopAsync();
         }
@@ -228,6 +269,10 @@ async Task<string> BlockingExternalTool([Description("Value to look up")] string
             originalToolStarted.TrySetResult(value);
             return await releaseOriginalTool.Task;
         }
+
+        [Description("Looks up a value after resumption")]
+        string ResumedExternalTool([Description("Value to look up")] string value) =>
+            throw new InvalidOperationException("Resumed-session handler should not be invoked");
     }
 
     [Fact]