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>

Author: stephentoub

dotnet/test/E2E/PendingWorkResumeE2ETests.cs

@@ -161,7 +161,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 +207,59 @@ 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, feeding the result into the assistant's reply.
+            // 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 answer = await TestHelper.GetFinalAssistantMessageAsync(session2, PendingWorkTimeout);
+                Assert.Contains("EXTERNAL_RESUMED_BETA", answer?.Data.Content ?? string.Empty);
+            }
+            else
+            {
+                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 +275,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]

go/internal/e2e/pending_work_resume_e2e_test.go

@@ -18,10 +18,10 @@ const pendingWorkTimeout = 60 * time.Second
 
 // Mirrors dotnet/test/PendingWorkResumeTests.cs (snapshot category "pending_work_resume").
 //
-// Each subtest spawns a TCP server client, connects a "suspended" client through CLIUrl,
-// triggers some pending work (permission request or external tool call), then ForceStops
-// the suspended client (preserving session state) and resumes from a fresh client with
-// ContinuePendingWork=true.
+// Most subtests spawn a TCP server client, connect a "suspended" client through CLIUrl,
+// trigger pending work, then ForceStop the suspended client (preserving session state)
+// and resume from a fresh client with ContinuePendingWork=true. Warm-join coverage keeps
+// the original client connected while a second client resumes the same session.
 func TestPendingWorkResumeE2E(t *testing.T) {
 	ctx := testharness.NewTestContext(t)
 
@@ -433,121 +433,179 @@ func TestPendingWorkResumeE2E(t *testing.T) {
 		resumedSession.Disconnect()
 	})
 
-	t.Run("should keep pending external tool handleable on warm resume when continuependingwork is false", func(t *testing.T) {
-		ctx.ConfigureForTest(t)
-
-		_, cliURL := startTcpServer(t, ctx)
-
-		type ValueParams struct {
-			Value string `json:"value" jsonschema:"Value to look up"`
-		}
-		toolStarted := make(chan string, 1)
-		releaseTool := make(chan string, 1)
-
-		originalTool := copilot.DefineTool("resume_external_tool", "Looks up a value after resumption",
-			func(params ValueParams, inv copilot.ToolInvocation) (string, error) {
-				select {
-				case toolStarted <- params.Value:
-				default:
-				}
-				return <-releaseTool, nil
+	for _, scenario := range []struct {
+		name                     string
+		disconnectOriginalClient bool
+		expectedSessionWasActive bool
+		expectedHandleResult     bool
+	}{
+		{name: "warm", disconnectOriginalClient: false, expectedSessionWasActive: true, expectedHandleResult: true},
+		{name: "cold", disconnectOriginalClient: true, expectedSessionWasActive: false, expectedHandleResult: false},
+	} {
+		scenario := scenario
+		t.Run(fmt.Sprintf("should keep pending external tool handleable on %s resume when continuependingwork is false", scenario.name), func(t *testing.T) {
+			ctx.ConfigureForTest(t)
+
+			_, cliURL := startTcpServer(t, ctx)
+
+			type ValueParams struct {
+				Value string `json:"value" jsonschema:"Value to look up"`
+			}
+			toolStarted := make(chan string, 1)
+			releaseTool := make(chan string, 1)
+
+			originalTool := copilot.DefineTool("resume_external_tool", "Looks up a value after resumption",
+				func(params ValueParams, inv copilot.ToolInvocation) (string, error) {
+					select {
+					case toolStarted <- params.Value:
+					default:
+					}
+					return <-releaseTool, nil
+				})
+
+			suspendedClient := ctx.NewClient(func(opts *copilot.ClientOptions) {
+				opts.Connection = copilot.UriConnection{URL: cliURL, ConnectionToken: sharedTcpToken}
 			})
+			if !scenario.disconnectOriginalClient {
+				defer suspendedClient.ForceStop()
+			}
+			session1, err := suspendedClient.CreateSession(t.Context(), &copilot.SessionConfig{
+				Tools:               []copilot.Tool{originalTool},
+				OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
+			})
+			if err != nil {
+				t.Fatalf("Failed to create session: %v", err)
+			}
+			sessionID := session1.SessionID
 
-		suspendedClient := ctx.NewClient(func(opts *copilot.ClientOptions) {
-			opts.Connection = copilot.UriConnection{URL: cliURL, ConnectionToken: sharedTcpToken}
-		})
-		session1, err := suspendedClient.CreateSession(t.Context(), &copilot.SessionConfig{
-			Tools:               []copilot.Tool{originalTool},
-			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
-		})
-		if err != nil {
-			t.Fatalf("Failed to create session: %v", err)
-		}
-		sessionID := session1.SessionID
-
-		toolEventCh := waitForExternalToolRequests(session1, []string{"resume_external_tool"})
+			toolEventCh := waitForExternalToolRequests(session1, []string{"resume_external_tool"})
 
-		if _, err := session1.Send(t.Context(), copilot.MessageOptions{
-			Prompt: "Use resume_external_tool with value 'beta', then reply with the result.",
-		}); err != nil {
-			t.Fatalf("Failed to send message: %v", err)
-		}
+			if _, err := session1.Send(t.Context(), copilot.MessageOptions{
+				Prompt: "Use resume_external_tool with value 'beta', then reply with the result.",
+			}); err != nil {
+				t.Fatalf("Failed to send message: %v", err)
+			}
 
-		toolEvents, err := waitForExternalToolResults(toolEventCh, pendingWorkTimeout)
-		if err != nil {
-			t.Fatalf("waiting for external tool requests: %v", err)
-		}
-		toolEvent := toolEvents["resume_external_tool"]
+			toolEvents, err := waitForExternalToolResults(toolEventCh, pendingWorkTimeout)
+			if err != nil {
+				t.Fatalf("waiting for external tool requests: %v", err)
+			}
+			toolEvent := toolEvents["resume_external_tool"]
 
-		select {
-		case v := <-toolStarted:
-			if v != "beta" {
-				t.Errorf("Expected original tool started with 'beta', got %q", v)
+			select {
+			case v := <-toolStarted:
+				if v != "beta" {
+					t.Errorf("Expected original tool started with 'beta', got %q", v)
+				}
+			case <-time.After(pendingWorkTimeout):
+				t.Fatal("Timed out waiting for original tool to start")
 			}
-		case <-time.After(pendingWorkTimeout):
-			t.Fatal("Timed out waiting for original tool to start")
-		}
 
-		suspendedClient.ForceStop()
+			if scenario.disconnectOriginalClient {
+				suspendedClient.ForceStop()
+			}
 
-		resumedClient := ctx.NewClient(func(opts *copilot.ClientOptions) {
-			opts.Connection = copilot.UriConnection{URL: cliURL, ConnectionToken: sharedTcpToken}
-		})
-		t.Cleanup(func() { resumedClient.ForceStop() })
+			resumedClient := ctx.NewClient(func(opts *copilot.ClientOptions) {
+				opts.Connection = copilot.UriConnection{URL: cliURL, ConnectionToken: sharedTcpToken}
+			})
+			t.Cleanup(func() { resumedClient.ForceStop() })
+
+			// 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).
+			resumeConfig := &copilot.ResumeSessionConfig{
+				ContinuePendingWork: false,
+				OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
+			}
+			if scenario.disconnectOriginalClient {
+				resumeConfig.Tools = []copilot.Tool{
+					copilot.DefineTool("resume_external_tool", "Looks up a value after resumption",
+						func(_ ValueParams, _ copilot.ToolInvocation) (string, error) {
+							t.Errorf("Resumed-session handler should not be invoked")
+							return "", fmt.Errorf("resumed-session handler should not be invoked")
+						}),
+				}
+			}
 
-		session2, err := resumedClient.ResumeSession(t.Context(), sessionID, &copilot.ResumeSessionConfig{
-			ContinuePendingWork: false,
-			OnPermissionRequest: copilot.PermissionHandler.ApproveAll,
-		})
-		if err != nil {
-			t.Fatalf("Failed to resume session: %v", err)
-		}
+			session2, err := resumedClient.ResumeSession(t.Context(), sessionID, resumeConfig)
+			if err != nil {
+				t.Fatalf("Failed to resume session: %v", err)
+			}
 
-		// Verify resume event reflects ContinuePendingWork=false and SessionWasActive=true
-		messages, err := session2.GetEvents(t.Context())
-		if err != nil {
-			t.Fatalf("GetEvents failed: %v", err)
-		}
-		var resumeEvent *copilot.SessionResumeData
-		for _, msg := range messages {
-			if msg.Type() == copilot.SessionEventTypeSessionResume {
-				if d, ok := msg.Data.(*copilot.SessionResumeData); ok {
-					resumeEvent = d
-					break
+			messages, err := session2.GetEvents(t.Context())
+			if err != nil {
+				t.Fatalf("GetEvents failed: %v", err)
+			}
+			var resumeEvent *copilot.SessionResumeData
+			for _, msg := range messages {
+				if msg.Type() == copilot.SessionEventTypeSessionResume {
+					if d, ok := msg.Data.(*copilot.SessionResumeData); ok {
+						resumeEvent = d
+						break
+					}
 				}
 			}
-		}
-		if resumeEvent == nil {
-			t.Fatal("Expected a session.resume event")
-			return
-		}
-		if resumeEvent.ContinuePendingWork == nil || *resumeEvent.ContinuePendingWork != false {
-			t.Errorf("Expected ContinuePendingWork=false in resume event, got %v", resumeEvent.ContinuePendingWork)
-		}
-		if resumeEvent.SessionWasActive == nil || *resumeEvent.SessionWasActive != true {
-			t.Errorf("Expected SessionWasActive=true in resume event, got %v", resumeEvent.SessionWasActive)
-		}
+			if resumeEvent == nil {
+				t.Fatal("Expected a session.resume event")
+				return
+			}
+			if resumeEvent.ContinuePendingWork != nil && *resumeEvent.ContinuePendingWork {
+				t.Errorf("Expected ContinuePendingWork=false in resume event, got %v", resumeEvent.ContinuePendingWork)
+			}
+			if resumeEvent.SessionWasActive == nil || *resumeEvent.SessionWasActive != scenario.expectedSessionWasActive {
+				t.Errorf("Expected SessionWasActive=%t in resume event, got %v", scenario.expectedSessionWasActive, resumeEvent.SessionWasActive)
+			}
 
-		// Even with ContinuePendingWork=false, the pending tool call should still be
-		// handleable via HandlePendingToolCall.
-		toolResult, err := session2.RPC.Tools.HandlePendingToolCall(t.Context(), &rpc.HandlePendingToolCallRequest{
-			RequestID: toolEvent.RequestID,
-			Result:    rpc.ExternalToolStringResult("EXTERNAL_RESUMED_BETA"),
-		})
-		if err != nil {
-			t.Fatalf("Failed to handle pending tool call: %v", err)
-		}
-		if !toolResult.Success {
-			t.Errorf("Expected HandlePendingToolCall to succeed, got %+v", toolResult)
-		}
+			// In warm mode the runtime still has the pending request; in cold mode the
+			// runtime auto-completed the orphan with a synthetic interrupt result during
+			// resume, so HandlePendingToolCall is expected to report Success=false.
+			toolResult, err := session2.RPC.Tools.HandlePendingToolCall(t.Context(), &rpc.HandlePendingToolCallRequest{
+				RequestID: toolEvent.RequestID,
+				Result:    rpc.ExternalToolStringResult("EXTERNAL_RESUMED_BETA"),
+			})
+			if err != nil {
+				t.Fatalf("Failed to handle pending tool call: %v", err)
+			}
+			if toolResult.Success != scenario.expectedHandleResult {
+				t.Errorf("Expected HandlePendingToolCall Success=%t, got %+v", scenario.expectedHandleResult, toolResult)
+			}
 
-		select {
-		case releaseTool <- "ORIGINAL_SHOULD_NOT_WIN":
-		default:
-		}
+			if scenario.expectedHandleResult {
+				// Warm path: the result flows through to the LLM and the assistant should
+				// echo it in its final reply.
+				ctxFinal, cancel := context.WithTimeout(t.Context(), pendingWorkTimeout)
+				defer cancel()
+				answer, err := testharness.GetFinalAssistantMessage(ctxFinal, session2)
+				if err != nil {
+					t.Fatalf("Failed to wait for final assistant message: %v", err)
+				}
+				if assistant, ok := answer.Data.(*copilot.AssistantMessageData); !ok || !strings.Contains(assistant.Content, "EXTERNAL_RESUMED_BETA") {
+					t.Errorf("Expected answer to contain 'EXTERNAL_RESUMED_BETA', got %v", answer.Data)
+				}
+			} else {
+				// Cold path: orphan auto-completion does not trigger an LLM turn on its
+				// own, but the session should remain healthy for new work.
+				followUp, err := session2.SendAndWait(t.Context(), copilot.MessageOptions{
+					Prompt: "Reply with exactly: COLD_RESUMED_FOLLOWUP",
+				})
+				if err != nil {
+					t.Fatalf("Failed to send follow-up turn: %v", err)
+				}
+				if assistant, ok := followUp.Data.(*copilot.AssistantMessageData); !ok || !strings.Contains(assistant.Content, "COLD_RESUMED_FOLLOWUP") {
+					t.Errorf("Expected follow-up answer to contain 'COLD_RESUMED_FOLLOWUP', got %v", followUp.Data)
+				}
+			}
 
-		session2.Disconnect()
-	})
+			select {
+			case releaseTool <- "ORIGINAL_SHOULD_NOT_WIN":
+			default:
+			}
+
+			session2.Disconnect()
+		})
+	}
 
 	t.Run("should report continuependingwork true in resume event", func(t *testing.T) {
 		ctx.ConfigureForTest(t)