Add openCanvasInstances to ResumeSessionConfig

Threads agent-canvas instance rehydrate from the host through both Rust and
Node SDKs to the runtime's session.resume RPC.

Rust:
- New CanvasInstanceRehydrate struct in canvas.rs (camelCase serde).
- ResumeSessionConfig gains open_canvas_instances: Vec<CanvasInstanceRehydrate>
  with a with_open_canvas_instances() builder; serializes via the existing
  serde_json::to_value(&config) wire path in resume_session.
- Debug impl includes the new field.

Node:
- CanvasInstanceRehydrate interface mirrored in canvas.ts, re-exported from
  index.ts.
- ResumeSessionConfig.openCanvasInstances?: CanvasInstanceRehydrate[].
- client.ts session.resume payload forwards the field.

The runtime side (copilot-agent-runtime PR #8441) consumes this via
SessionResumeRequest.openCanvasInstances and rehydrateCanvasInstances().

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

Author: jmoseley

nodejs/src/canvas.ts

@@ -97,6 +97,25 @@ export interface CanvasOpenResponse {
     instanceId?: string;
 }
 
+/**
+ * Identifies an extension canvas instance that the host believes is still open
+ * across a runtime restart. Supplied via `ResumeSessionConfig.openCanvasInstances`
+ * so the runtime can re-populate its in-memory instance map without re-invoking
+ * the extension's `onOpen`. Orphans (no matching extension/canvas in the active
+ * extension set) trigger a `session.canvas.closed` event with
+ * `reason: "rehydrate_failed"` so the host can drop the stale UI.
+ */
+export interface CanvasInstanceRehydrate {
+    /** Extension id that originally opened the canvas. */
+    extensionId: string;
+    /** Canvas id (matches the declaring `CanvasDeclaration.id`). */
+    canvasId: string;
+    /** Agent-supplied stable instance id from the original open. */
+    instanceId: string;
+    /** Extension-owned URL the host last rendered, if any. */
+    url?: string;
+}
+
 /** Context handed to a canvas's `onOpen` handler. */
 export interface CanvasOpenContext {
     /** Session that requested the canvas. */

nodejs/src/client.ts

@@ -990,6 +990,7 @@ export class CopilotClient {
                 infiniteSessions: config.infiniteSessions,
                 disableResume: config.disableResume,
                 continuePendingWork: config.continuePendingWork,
+                openCanvasInstances: config.openCanvasInstances,
                 gitHubToken: config.gitHubToken,
                 remoteSession: config.remoteSession,
             });

nodejs/src/index.ts

@@ -17,6 +17,7 @@ export {
     type CanvasActionContext,
     type CanvasAgentActionDeclaration,
     type CanvasDeclaration,
+    type CanvasInstanceRehydrate,
     type CanvasLifecycleContext,
     type CanvasOpenContext,
     type CanvasOpenResponse,

nodejs/src/types.ts

@@ -7,7 +7,7 @@
  */
 
 // Import and re-export generated session event types
-import type { Canvas } from "./canvas.js";
+import type { Canvas, CanvasInstanceRehydrate } from "./canvas.js";
 import type { SessionFsProvider } from "./sessionFsProvider.js";
 import type { SessionEvent as GeneratedSessionEvent } from "./generated/session-events.js";
 import type { CopilotSession } from "./session.js";
@@ -1639,6 +1639,17 @@ export type ResumeSessionConfig = Pick<
      * @default false
      */
     continuePendingWork?: boolean;
+    /**
+     * Extension canvas instances the host believes are still open from a prior
+     * runtime process. Supplied on resume so the runtime can re-populate its
+     * in-memory canvas instance map without re-invoking each extension's
+     * `onOpen`. Instances whose `(extensionId, canvasId)` don't resolve in the
+     * active extension set produce a `session.canvas.closed` event with
+     * `reason: "rehydrate_failed"` so the host can drop the stale UI. Native
+     * host-implemented canvases (e.g. `host.*` ids) should be omitted — the
+     * host owns their lifecycle end-to-end without the runtime instance record.
+     */
+    openCanvasInstances?: CanvasInstanceRehydrate[];
 };
 
 /**

rust/src/canvas.rs

@@ -111,6 +111,31 @@ pub struct CanvasOpenResponse {
     pub instance_id: Option<String>,
 }
 
+/// Per-instance resume hint sent on `session.resume` to rebuild the runtime's
+/// canvas-instance registry. The host persists open canvases across CLI
+/// process restarts and hands them back here so subsequent
+/// `invoke_canvas_action` dispatches find the existing instance instead of
+/// erroring with `canvas_instance_not_found`.
+///
+/// The handler's `on_open` is **not** re-invoked on rehydrate — the extension
+/// keeps whatever state it had in its own process. Entries the runtime cannot
+/// bind to a currently-declared canvas trigger a `session.canvas.closed`
+/// event with `reason: "rehydrate_failed"`.
+#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CanvasInstanceRehydrate {
+    /// Canonical extension id that owns the canvas.
+    pub extension_id: String,
+    /// Canvas declaration id within that extension.
+    pub canvas_id: String,
+    /// Stable instance id the host originally opened the canvas under.
+    pub instance_id: String,
+    /// Optional URL recorded at the original open. Populated as-is into the
+    /// rebuilt instance record; not re-validated by the runtime.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub url: Option<String>,
+}
+
 /// Context handed to [`CanvasHandler::on_open`].
 #[derive(Debug, Clone)]
 pub struct CanvasOpenContext {

rust/src/types.rs

@@ -1823,6 +1823,18 @@ pub struct ResumeSessionConfig {
     /// the prior entry on the runtime side.
     #[serde(default, skip_serializing_if = "Vec::is_empty", skip_deserializing)]
     pub canvases: Vec<crate::canvas::Canvas>,
+    /// Host-supplied list of canvas instances that should still be considered
+    /// open from a prior CLI process run, scoped to this session. The runtime
+    /// rebuilds its in-memory canvas-instance registry from these entries so
+    /// subsequent `invoke_canvas_action` dispatches succeed without the host
+    /// re-issuing `canvas.open`. Handler `on_open` is **not** re-invoked.
+    ///
+    /// Entries that fail to bind to a currently-declared canvas (extension
+    /// not loaded this session, or contribution removed) trigger a
+    /// `session.canvas.closed` event with `reason: "rehydrate_failed"` so the
+    /// host can clean up the stale panel.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub open_canvas_instances: Vec<crate::canvas::CanvasInstanceRehydrate>,
     /// Custom session filesystem provider. Required on resume when the
     /// [`Client`](crate::Client) was started with
     /// [`ClientOptions::session_fs`](crate::ClientOptions::session_fs).
@@ -1897,6 +1909,7 @@ impl std::fmt::Debug for ResumeSessionConfig {
             )
             .field("commands", &self.commands)
             .field("canvases", &self.canvases)
+            .field("open_canvas_instances", &self.open_canvas_instances)
             .field(
                 "session_fs_provider",
                 &self.session_fs_provider.as_ref().map(|_| "<set>"),
@@ -1956,6 +1969,7 @@ impl ResumeSessionConfig {
             include_sub_agent_streaming_events: None,
             commands: None,
             canvases: Vec::new(),
+            open_canvas_instances: Vec::new(),
             session_fs_provider: None,
             disable_resume: None,
             continue_pending_work: None,
@@ -1992,6 +2006,20 @@ impl ResumeSessionConfig {
         self
     }
 
+    /// Supply the list of canvas instances the host still considers open
+    /// from a prior CLI process run. The runtime resolves each entry's
+    /// `(extension_id, canvas_id)` against the canvases declared on this
+    /// resume and rebuilds its in-memory instance registry, so subsequent
+    /// `invoke_canvas_action` dispatches succeed without re-issuing
+    /// `canvas.open`. Handler `on_open` is **not** re-invoked.
+    pub fn with_open_canvas_instances(
+        mut self,
+        instances: Vec<crate::canvas::CanvasInstanceRehydrate>,
+    ) -> Self {
+        self.open_canvas_instances = instances;
+        self
+    }
+
     /// Install a [`SessionFsProvider`] backing the resumed session's
     /// filesystem. See [`SessionConfig::with_session_fs_provider`].
     pub fn with_session_fs_provider(mut self, provider: Arc<dyn SessionFsProvider>) -> Self {