Add ContinuePendingWork option to ResumeSessionConfig in all SDKs

stephentoub · Copilot · stephentoub · commit b6ec90d936ff · 2026-04-30T13:46:59.000-04:00
Exposes the new continuePendingWork resume option introduced by runtime PR #6099 (suspend/resume support for permission and tool call continuity). When true, the runtime continues any tool calls or permission prompts that were pending when the session was suspended; default false matches existing behavior.

Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/dotnet/src/Client.cs b/dotnet/src/Client.cs
@@ -632,7 +632,8 @@ public async Task<CopilotSession> ResumeSessionAsync(string sessionId, ResumeSes
                 Traceparent: traceparent,
                 Tracestate: tracestate,
                 ModelCapabilities: config.ModelCapabilities,
-                GitHubToken: config.GitHubToken);
+                GitHubToken: config.GitHubToken,
+                ContinuePendingWork: config.ContinuePendingWork);
 
             var response = await InvokeRpcAsync<ResumeSessionResponse>(
                 connection.Rpc, "session.resume", [request], cancellationToken);
@@ -1705,7 +1706,8 @@ internal record ResumeSessionRequest(
         string? Traceparent = null,
         string? Tracestate = null,
         ModelCapabilitiesOverride? ModelCapabilities = null,
-        string? GitHubToken = null);
+        string? GitHubToken = null,
+        bool? ContinuePendingWork = null);
 
     internal record ResumeSessionResponse(
         string SessionId,
diff --git a/dotnet/src/Types.cs b/dotnet/src/Types.cs
@@ -2005,6 +2005,7 @@ protected ResumeSessionConfig(ResumeSessionConfig? other)
         DisabledSkills = other.DisabledSkills is not null ? [.. other.DisabledSkills] : null;
         DisableResume = other.DisableResume;
         EnableConfigDiscovery = other.EnableConfigDiscovery;
+        ContinuePendingWork = other.ContinuePendingWork;
         ExcludedTools = other.ExcludedTools is not null ? [.. other.ExcludedTools] : null;
         Hooks = other.Hooks;
         InfiniteSessions = other.InfiniteSessions;
@@ -2140,6 +2141,20 @@ protected ResumeSessionConfig(ResumeSessionConfig? other)
     /// </summary>
     public bool DisableResume { get; set; }
 
+    /// <summary>
+    /// When <see langword="true"/>, instructs the runtime to continue any tool calls
+    /// or permission prompts that were still pending when the session was last suspended.
+    /// When <see langword="false"/> (the default), the runtime treats pending work as
+    /// interrupted on resume.
+    /// <para>
+    /// For permission requests, the runtime re-emits <c>permission.requested</c> so the
+    /// registered <see cref="OnPermissionRequest"/> handler can re-prompt; for external
+    /// tool calls, the consumer is expected to supply the result via the corresponding
+    /// low-level RPC method.
+    /// </para>
+    /// </summary>
+    public bool? ContinuePendingWork { get; set; }
+
     /// <summary>
     /// Enable streaming of assistant message and reasoning chunks.
     /// When true, assistant.message_delta and assistant.reasoning_delta events
diff --git a/dotnet/test/CloneTests.cs b/dotnet/test/CloneTests.cs
@@ -303,4 +303,27 @@ public void ResumeSessionConfig_Clone_PreservesIncludeSubAgentStreamingEventsDef
 
         Assert.True(clone.IncludeSubAgentStreamingEvents);
     }
+
+    [Fact]
+    public void ResumeSessionConfig_Clone_CopiesContinuePendingWork()
+    {
+        var original = new ResumeSessionConfig
+        {
+            ContinuePendingWork = true,
+        };
+
+        var clone = original.Clone();
+
+        Assert.True(clone.ContinuePendingWork);
+    }
+
+    [Fact]
+    public void ResumeSessionConfig_Clone_PreservesContinuePendingWorkDefault()
+    {
+        var original = new ResumeSessionConfig();
+
+        var clone = original.Clone();
+
+        Assert.Null(clone.ContinuePendingWork);
+    }
 }
diff --git a/go/client.go b/go/client.go
@@ -779,6 +779,9 @@ func (c *Client) ResumeSessionWithOptions(ctx context.Context, sessionID string,
 	if config.DisableResume {
 		req.DisableResume = Bool(true)
 	}
+	if config.ContinuePendingWork {
+		req.ContinuePendingWork = Bool(true)
+	}
 	req.MCPServers = config.MCPServers
 	req.EnvValueMode = "direct"
 	req.CustomAgents = config.CustomAgents
diff --git a/go/client_test.go b/go/client_test.go
@@ -881,6 +881,36 @@ func TestResumeSessionRequest_RequestElicitation(t *testing.T) {
 	})
 }
 
+func TestResumeSessionRequest_ContinuePendingWork(t *testing.T) {
+	t.Run("forwards continuePendingWork when true", func(t *testing.T) {
+		req := resumeSessionRequest{
+			SessionID:           "s1",
+			ContinuePendingWork: Bool(true),
+		}
+		data, err := json.Marshal(req)
+		if err != nil {
+			t.Fatalf("Failed to marshal: %v", err)
+		}
+		var m map[string]any
+		if err := json.Unmarshal(data, &m); err != nil {
+			t.Fatalf("Failed to unmarshal: %v", err)
+		}
+		if m["continuePendingWork"] != true {
+			t.Errorf("Expected continuePendingWork to be true, got %v", m["continuePendingWork"])
+		}
+	})
+
+	t.Run("omits continuePendingWork when not set", func(t *testing.T) {
+		req := resumeSessionRequest{SessionID: "s1"}
+		data, _ := json.Marshal(req)
+		var m map[string]any
+		json.Unmarshal(data, &m)
+		if _, ok := m["continuePendingWork"]; ok {
+			t.Error("Expected continuePendingWork to be omitted when not set")
+		}
+	})
+}
+
 func TestCreateSessionRequest_IncludeSubAgentStreamingEvents(t *testing.T) {
 	t.Run("defaults to true when nil", func(t *testing.T) {
 		req := createSessionRequest{
diff --git a/go/types.go b/go/types.go
@@ -804,6 +804,15 @@ type ResumeSessionConfig struct {
 	// DisableResume, when true, skips emitting the session.resume event.
 	// Useful for reconnecting to a session without triggering resume-related side effects.
 	DisableResume bool
+	// ContinuePendingWork, when true, instructs the runtime to continue any tool calls
+	// or permission prompts that were still pending when the session was last suspended.
+	// When false (the default), the runtime treats pending work as interrupted on resume.
+	//
+	// For permission requests, the runtime re-emits permission.requested so the
+	// registered OnPermissionRequest handler can re-prompt; for external tool calls,
+	// the consumer is expected to supply the result via the corresponding low-level
+	// RPC method.
+	ContinuePendingWork bool
 	// OnEvent is an optional event handler registered before the session.resume RPC
 	// is issued, ensuring early events are delivered. See SessionConfig.OnEvent.
 	OnEvent SessionEventHandler
@@ -1050,6 +1059,7 @@ type resumeSessionRequest struct {
 	ConfigDir                      string                         `json:"configDir,omitempty"`
 	EnableConfigDiscovery          *bool                          `json:"enableConfigDiscovery,omitempty"`
 	DisableResume                  *bool                          `json:"disableResume,omitempty"`
+	ContinuePendingWork            *bool                          `json:"continuePendingWork,omitempty"`
 	Streaming                      *bool                          `json:"streaming,omitempty"`
 	IncludeSubAgentStreamingEvents *bool                          `json:"includeSubAgentStreamingEvents,omitempty"`
 	MCPServers                     map[string]MCPServerConfig     `json:"mcpServers,omitempty"`
diff --git a/nodejs/src/client.ts b/nodejs/src/client.ts
@@ -907,6 +907,7 @@ export class CopilotClient {
                 disabledSkills: config.disabledSkills,
                 infiniteSessions: config.infiniteSessions,
                 disableResume: config.disableResume,
+                continuePendingWork: config.continuePendingWork,
                 gitHubToken: config.gitHubToken,
             });
 
diff --git a/nodejs/src/types.ts b/nodejs/src/types.ts
@@ -1421,6 +1421,18 @@ export type ResumeSessionConfig = Pick<
      * @default false
      */
     disableResume?: boolean;
+    /**
+     * When true, the runtime continues any tool calls or permission prompts that were
+     * still pending when the session was last suspended. When false (the default), the
+     * runtime treats pending work as interrupted on resume.
+     *
+     * For permission requests, the runtime re-emits `permission.requested` so the
+     * registered `onPermissionRequest` handler can re-prompt; for external tool calls,
+     * the consumer is expected to supply the result via the corresponding low-level
+     * RPC method.
+     * @default false
+     */
+    continuePendingWork?: boolean;
 };
 
 /**
diff --git a/nodejs/test/client.test.ts b/nodejs/test/client.test.ts
@@ -166,6 +166,47 @@ describe("CopilotClient", () => {
         spy.mockRestore();
     });
 
+    it("forwards continuePendingWork in session.resume request", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const session = await client.createSession({ onPermissionRequest: approveAll });
+        const spy = vi
+            .spyOn((client as any).connection!, "sendRequest")
+            .mockImplementation(async (method: string, params: any) => {
+                if (method === "session.resume") return { sessionId: params.sessionId };
+                throw new Error(`Unexpected method: ${method}`);
+            });
+        await client.resumeSession(session.sessionId, {
+            onPermissionRequest: approveAll,
+            continuePendingWork: true,
+        });
+
+        const payload = spy.mock.calls.find((c) => c[0] === "session.resume")![1] as any;
+        expect(payload.continuePendingWork).toBe(true);
+        spy.mockRestore();
+    });
+
+    it("omits continuePendingWork from session.resume payload when not specified", async () => {
+        const client = new CopilotClient();
+        await client.start();
+        onTestFinished(() => client.forceStop());
+
+        const session = await client.createSession({ onPermissionRequest: approveAll });
+        const spy = vi
+            .spyOn((client as any).connection!, "sendRequest")
+            .mockImplementation(async (method: string, params: any) => {
+                if (method === "session.resume") return { sessionId: params.sessionId };
+                throw new Error(`Unexpected method: ${method}`);
+            });
+        await client.resumeSession(session.sessionId, { onPermissionRequest: approveAll });
+
+        const payload = spy.mock.calls.find((c) => c[0] === "session.resume")![1] as any;
+        expect(payload.continuePendingWork).toBeUndefined();
+        spy.mockRestore();
+    });
+
     it("forwards provider headers in session.create request", async () => {
         const client = new CopilotClient();
         await client.start();
diff --git a/python/copilot/client.py b/python/copilot/client.py
@@ -1513,6 +1513,7 @@ async def resume_session(
         on_elicitation_request: ElicitationHandler | None = None,
         create_session_fs_handler: CreateSessionFsHandler | None = None,
         github_token: str | None = None,
+        continue_pending_work: bool | None = None,
     ) -> CopilotSession:
         """
         Resume an existing conversation session by its ID.
@@ -1560,6 +1561,10 @@ async def resume_session(
             disabled_skills: Skills to disable.
             infinite_sessions: Infinite session configuration.
             on_event: Callback for session events.
+            continue_pending_work: When True, instructs the runtime to continue any
+                tool calls or permission prompts that were still pending when the
+                session was last suspended. When False (the default), the runtime
+                treats pending work as interrupted on resume.
 
         Returns:
             A :class:`CopilotSession` instance for the resumed session.
@@ -1667,6 +1672,9 @@ async def resume_session(
         if enable_config_discovery is not None:
             payload["enableConfigDiscovery"] = enable_config_discovery
 
+        if continue_pending_work is not None:
+            payload["continuePendingWork"] = continue_pending_work
+
         # TODO: disable_resume is not a keyword arg yet; keeping for future use
         if mcp_servers:
             payload["mcpServers"] = mcp_servers
diff --git a/python/copilot/session.py b/python/copilot/session.py
@@ -962,6 +962,15 @@ class ResumeSessionConfig(TypedDict, total=False):
     # When True, skips emitting the session.resume event.
     # Useful for reconnecting to a session without triggering resume-related side effects.
     disable_resume: bool
+    # When True, instructs the runtime to continue any tool calls or permission prompts
+    # that were still pending when the session was last suspended. When False (the
+    # default), the runtime treats pending work as interrupted on resume.
+    #
+    # For permission requests, the runtime re-emits ``permission.requested`` so the
+    # registered ``on_permission_request`` handler can re-prompt; for external tool
+    # calls, the consumer is expected to supply the result via the corresponding
+    # low-level RPC method.
+    continue_pending_work: bool
     # Optional event handler registered before the session.resume RPC is issued,
     # ensuring early events are delivered. See SessionConfig.on_event.
     on_event: Callable[[SessionEvent], None]
diff --git a/python/test_client.py b/python/test_client.py
@@ -716,6 +716,63 @@ async def mock_request(method, params):
         finally:
             await client.force_stop()
 
+    @pytest.mark.asyncio
+    async def test_resume_session_forwards_continue_pending_work(self):
+        client = CopilotClient(SubprocessConfig(cli_path=CLI_PATH))
+        await client.start()
+
+        try:
+            session = await client.create_session(
+                on_permission_request=PermissionHandler.approve_all
+            )
+
+            captured: dict = {}
+            original_request = client._client.request
+
+            async def mock_request(method, params):
+                captured[method] = params
+                if method == "session.resume":
+                    return {"sessionId": session.session_id}
+                return await original_request(method, params)
+
+            client._client.request = mock_request
+            await client.resume_session(
+                session.session_id,
+                on_permission_request=PermissionHandler.approve_all,
+                continue_pending_work=True,
+            )
+            assert captured["session.resume"]["continuePendingWork"] is True
+        finally:
+            await client.force_stop()
+
+    @pytest.mark.asyncio
+    async def test_resume_session_omits_continue_pending_work_by_default(self):
+        client = CopilotClient(SubprocessConfig(cli_path=CLI_PATH))
+        await client.start()
+
+        try:
+            session = await client.create_session(
+                on_permission_request=PermissionHandler.approve_all
+            )
+
+            captured: dict = {}
+            original_request = client._client.request
+
+            async def mock_request(method, params):
+                captured[method] = params
+                if method == "session.resume":
+                    return {"sessionId": session.session_id}
+                return await original_request(method, params)
+
+            client._client.request = mock_request
+            await client.resume_session(
+                session.session_id,
+                on_permission_request=PermissionHandler.approve_all,
+            )
+            assert "continuePendingWork" not in captured["session.resume"]
+        finally:
+            await client.force_stop()
+
     @pytest.mark.asyncio
     async def test_set_model_sends_correct_rpc(self):
         client = CopilotClient(SubprocessConfig(cli_path=CLI_PATH))
