@github/copilot-sdk 1.0.0-beta.6 → 1.0.0-beta.8

package/README.md

@@ -131,10 +131,6 @@ Resume an existing session. Returns the session with `workspacePath` populated i
 
 Ping the server to check connectivity.
 
-##### `getState(): ConnectionState`
-
-Get current connection state.
-
 ##### `listSessions(filter?: SessionListFilter): Promise<SessionMetadata[]>`
 
 List all available sessions. Optionally filter by working directory context.
@@ -573,8 +569,8 @@ The SDK auto-injects environment context, tool instructions, and security guardr
 Use `mode: "customize"` to selectively override individual sections of the prompt while preserving the rest:
 
 ```typescript
-import { SYSTEM_PROMPT_SECTIONS } from "@github/copilot-sdk";
-import type { SectionOverride, SystemPromptSection } from "@github/copilot-sdk";
+import { SYSTEM_MESSAGE_SECTIONS } from "@github/copilot-sdk";
+import type { SectionOverride, SystemMessageSection } from "@github/copilot-sdk";
 
 const session = await client.createSession({
     model: "gpt-5",
@@ -597,7 +593,7 @@ const session = await client.createSession({
 });
 ```
 
-Available section IDs: `identity`, `tone`, `tool_efficiency`, `environment_context`, `code_change_rules`, `guidelines`, `safety`, `tool_instructions`, `custom_instructions`, `last_instructions`. Use the `SYSTEM_PROMPT_SECTIONS` constant for descriptions of each section.
+Available section IDs: `identity`, `tone`, `tool_efficiency`, `environment_context`, `code_change_rules`, `guidelines`, `safety`, `tool_instructions`, `custom_instructions`, `runtime_instructions`, `last_instructions`. Use the `SYSTEM_MESSAGE_SECTIONS` constant for descriptions of each section.
 
 Each section override supports four actions:
 

package/dist/canvas.d.ts

@@ -0,0 +1,103 @@
+import type { CanvasJsonSchema, CanvasProviderCloseRequest, CanvasProviderInvokeActionRequest, CanvasProviderOpenRequest, CanvasProviderOpenResult } from "./generated/rpc.js";
+export type { CanvasJsonSchema, CanvasHostContext } from "./generated/rpc.js";
+/**
+ * Extension-owned canvases declared via
+ * `joinSession({ canvases: [createCanvas({...})] })`.
+ *
+ * The runtime sends provider callbacks as `canvas.open`, `canvas.close`, and
+ * `canvas.invokeAction` JSON-RPC requests via the codegen client session API
+ * pipeline. The SDK routes those requests by `canvasId` to the in-process
+ * handlers bound by `createCanvas`. Re-opening with an existing `instanceId`
+ * is how the host focuses an existing panel; reload is a renderer-only concern.
+ */
+/**
+ * A single agent-callable action contributed by a canvas. The metadata
+ * (`name`, `description`, `inputSchema`) is serialized over the wire on
+ * `session.create` / `session.resume`; the `handler` closure is stripped
+ * before the declaration is sent and dispatched in-process by the SDK.
+ *
+ * Names MUST NOT start with `canvas.` — that prefix is reserved for
+ * lifecycle verbs.
+ */
+export interface CanvasAction {
+    /** Action identifier, unique within the canvas. */
+    name: string;
+    /** Description shown to the model when picking an action. */
+    description?: string;
+    /** Optional JSON Schema for the action's `input` payload. */
+    inputSchema?: CanvasJsonSchema;
+    /** Required per-action dispatch handler. */
+    handler: (ctx: CanvasProviderInvokeActionRequest) => Promise<unknown> | unknown;
+}
+/**
+ * Declarative metadata for a single canvas, serialized over the wire on
+ * `session.create` / `session.resume`.
+ */
+export interface CanvasDeclaration {
+    /** Canvas id, unique within the declaring connection. */
+    id: string;
+    /** Human-readable label shown in discovery and host UI chrome. */
+    displayName: string;
+    /** Short, single-sentence description shown to the agent in canvas catalogs. */
+    description: string;
+    /** Optional JSON Schema for the `input` payload accepted by `canvas.open`. */
+    inputSchema?: CanvasJsonSchema;
+    /** Agent-invocable actions exposed via `invoke_canvas_action`. */
+    actions?: Omit<CanvasAction, "handler">[];
+}
+/** Structured error returned from canvas handlers. */
+export declare class CanvasError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+    /** Default error when an action is declared but no `handler` is wired. */
+    static noHandler(): CanvasError;
+}
+/**
+ * Options accepted by {@link createCanvas}. Combines the declarative
+ * {@link CanvasDeclaration} fields with the in-process handler closures.
+ */
+export interface CanvasOptions {
+    /** @see CanvasDeclaration.id */
+    id: string;
+    /** @see CanvasDeclaration.displayName */
+    displayName: string;
+    /** @see CanvasDeclaration.description */
+    description: string;
+    /** @see CanvasDeclaration.inputSchema */
+    inputSchema?: CanvasJsonSchema;
+    /**
+     * Agent-invocable actions exposed via `invoke_canvas_action`. Each action
+     * carries its own required `handler`; the action's wire metadata
+     * (`name`, `description`, `inputSchema`) is what reaches the runtime.
+     */
+    actions?: CanvasAction[];
+    /** Required. Open a new canvas instance. */
+    open: (ctx: CanvasProviderOpenRequest) => Promise<CanvasProviderOpenResult> | CanvasProviderOpenResult;
+    /**
+     * Optional. Notified when a canvas instance is closed by the user, the
+     * agent, or the host. Fire-and-forget: the return value is ignored and
+     * errors are logged but not surfaced to the runtime.
+     */
+    onClose?: (ctx: CanvasProviderCloseRequest) => Promise<void> | void;
+}
+/** A registered canvas: declarative metadata + in-process handler closures.
+ *
+ * Node intentionally uses a per-canvas factory pattern (mirroring
+ * {@link https://github.com/github/copilot-sdk | `DefineTool`}'s co-location
+ * ergonomics) where other SDKs (Rust, Python, Go, .NET) expose a single
+ * `CanvasHandler` per session that switches on `canvasId`. Both shapes target
+ * the same JSON-RPC wire protocol; the divergence is API ergonomics only.
+ */
+export declare class Canvas {
+    readonly declaration: CanvasDeclaration;
+    readonly open: NonNullable<CanvasOptions["open"]>;
+    readonly onClose?: CanvasOptions["onClose"];
+}
+/** Create a canvas declaration with bound in-process handlers.
+ *
+ * Node intentionally uses this per-canvas factory pattern (mirroring
+ * `DefineTool`'s co-location ergonomics) where other SDKs (Rust, Python, Go,
+ * .NET) expose a single `CanvasHandler` per session that switches on
+ * `canvasId`. Both shapes target the same JSON-RPC wire protocol.
+ */
+export declare function createCanvas(options: CanvasOptions): Canvas;

package/dist/canvas.js

@@ -0,0 +1,49 @@
+class CanvasError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CanvasError";
+  }
+  /** Default error when an action is declared but no `handler` is wired. */
+  static noHandler() {
+    return new CanvasError(
+      "canvas_action_no_handler",
+      "No handler implemented for this canvas action"
+    );
+  }
+}
+class Canvas {
+  declaration;
+  open;
+  onClose;
+  /** @internal */
+  actionHandlers;
+  /** @internal */
+  constructor(options) {
+    const actionHandlers = /* @__PURE__ */ new Map();
+    const wireActions = options.actions?.map(
+      ({ handler, ...wire }) => {
+        actionHandlers.set(wire.name, handler);
+        return wire;
+      }
+    );
+    this.declaration = {
+      id: options.id,
+      displayName: options.displayName,
+      description: options.description,
+      inputSchema: options.inputSchema,
+      actions: wireActions
+    };
+    this.open = options.open;
+    this.onClose = options.onClose;
+    this.actionHandlers = actionHandlers;
+  }
+}
+function createCanvas(options) {
+  return new Canvas(options);
+}
+export {
+  Canvas,
+  CanvasError,
+  createCanvas
+};

package/dist/cjs/canvas.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var canvas_exports = {};
+__export(canvas_exports, {
+  Canvas: () => Canvas,
+  CanvasError: () => CanvasError,
+  createCanvas: () => createCanvas
+});
+module.exports = __toCommonJS(canvas_exports);
+class CanvasError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CanvasError";
+  }
+  /** Default error when an action is declared but no `handler` is wired. */
+  static noHandler() {
+    return new CanvasError(
+      "canvas_action_no_handler",
+      "No handler implemented for this canvas action"
+    );
+  }
+}
+class Canvas {
+  declaration;
+  open;
+  onClose;
+  /** @internal */
+  actionHandlers;
+  /** @internal */
+  constructor(options) {
+    const actionHandlers = /* @__PURE__ */ new Map();
+    const wireActions = options.actions?.map(
+      ({ handler, ...wire }) => {
+        actionHandlers.set(wire.name, handler);
+        return wire;
+      }
+    );
+    this.declaration = {
+      id: options.id,
+      displayName: options.displayName,
+      description: options.description,
+      inputSchema: options.inputSchema,
+      actions: wireActions
+    };
+    this.open = options.open;
+    this.onClose = options.onClose;
+    this.actionHandlers = actionHandlers;
+  }
+}
+function createCanvas(options) {
+  return new Canvas(options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Canvas,
+  CanvasError,
+  createCanvas
+});

package/dist/cjs/client.js

@@ -36,7 +36,7 @@ var import_sessionFsProvider = require("./sessionFsProvider.js");
 var import_telemetry = require("./telemetry.js");
 var import_types = require("./types.js");
 const import_meta = {};
-const MIN_PROTOCOL_VERSION = 2;
+const MIN_PROTOCOL_VERSION = 3;
 function isZodSchema(value) {
   return value != null && typeof value === "object" && "toJSONSchema" in value && typeof value.toJSONSchema === "function";
 }
@@ -572,6 +572,7 @@ class CopilotClient {
       this.onGetTraceContext
     );
     session.registerTools(config.tools);
+    session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -614,6 +615,10 @@ class CopilotClient {
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission
         })),
+        canvases: config.canvases?.map((canvas) => canvas.declaration),
+        requestCanvasRenderer: config.requestCanvasRenderer,
+        requestExtensions: config.requestExtensions,
+        extensionInfo: config.extensionInfo,
         commands: config.commands?.map((cmd) => ({
           name: cmd.name,
           description: cmd.description
@@ -624,7 +629,7 @@ class CopilotClient {
         provider: config.provider,
         enableSessionTelemetry: config.enableSessionTelemetry,
         modelCapabilities: config.modelCapabilities,
-        requestPermission: true,
+        requestPermission: !!config.onPermissionRequest,
         requestUserInput: !!config.onUserInputRequest,
         requestElicitation: !!config.onElicitationRequest,
         requestExitPlanMode: !!config.onExitPlanModeRequest,
@@ -692,6 +697,7 @@ class CopilotClient {
       this.onGetTraceContext
     );
     session.registerTools(config.tools);
+    session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -738,6 +744,10 @@ class CopilotClient {
           overridesBuiltInTool: tool.overridesBuiltInTool,
           skipPermission: tool.skipPermission
         })),
+        canvases: config.canvases?.map((canvas) => canvas.declaration),
+        requestCanvasRenderer: config.requestCanvasRenderer,
+        requestExtensions: config.requestExtensions,
+        extensionInfo: config.extensionInfo,
         commands: config.commands?.map((cmd) => ({
           name: cmd.name,
           description: cmd.description
@@ -767,32 +777,19 @@ class CopilotClient {
         suppressResumeEvent: config.suppressResumeEvent,
         continuePendingWork: config.continuePendingWork,
         gitHubToken: config.gitHubToken,
-        remoteSession: config.remoteSession
+        remoteSession: config.remoteSession,
+        openCanvases: config.openCanvases
       });
-      const { workspacePath, capabilities } = response;
+      const { workspacePath, capabilities, openCanvases } = response;
       session["_workspacePath"] = workspacePath;
       session.setCapabilities(capabilities);
+      session.setOpenCanvases(openCanvases ?? []);
     } catch (e) {
       this.sessions.delete(sessionId);
       throw e;
     }
     return session;
   }
-  /**
-   * Gets the current connection state of the client.
-   *
-   * @returns The current connection state: "disconnected", "connecting", "connected", or "error"
-   *
-   * @example
-   * ```typescript
-   * if (client.getState() === "connected") {
-   *   const session = await client.createSession({ onPermissionRequest: approveAll });
-   * }
-   * ```
-   */
-  getState() {
-    return this.state;
-  }
   /**
    * Sends a ping request to the server to verify connectivity.
    *
@@ -1381,14 +1378,6 @@ stderr: ${stderrOutput}`
     this.connection.onNotification("session.lifecycle", (notification) => {
       this.handleSessionLifecycleNotification(notification);
     });
-    this.connection.onRequest(
-      "tool.call",
-      async (params) => await this.handleToolCallRequestV2(params)
-    );
-    this.connection.onRequest(
-      "permission.request",
-      async (params) => await this.handlePermissionRequestV2(params)
-    );
     this.connection.onRequest(
       "userInput.request",
       async (params) => await this.handleUserInputRequest(params)
@@ -1530,105 +1519,6 @@ stderr: ${stderrOutput}`
     }
     return await session._handleSystemMessageTransform(params.sections);
   }
-  // ========================================================================
-  // Protocol v2 backward-compatibility adapters
-  // ========================================================================
-  /**
-   * Handles a v2-style tool.call RPC request from the server.
-   * Looks up the session and tool handler, executes it, and returns the result
-   * in the v2 response format.
-   */
-  async handleToolCallRequestV2(params) {
-    if (!params || typeof params.sessionId !== "string" || typeof params.toolCallId !== "string" || typeof params.toolName !== "string") {
-      throw new Error("Invalid tool call payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Unknown session ${params.sessionId}`);
-    }
-    const handler = session.getToolHandler(params.toolName);
-    if (!handler) {
-      return {
-        result: {
-          textResultForLlm: `Tool '${params.toolName}' is not supported by this client instance.`,
-          resultType: "failure",
-          error: `tool '${params.toolName}' not supported`,
-          toolTelemetry: {}
-        }
-      };
-    }
-    try {
-      const traceparent = params.traceparent;
-      const tracestate = params.tracestate;
-      const invocation = {
-        sessionId: params.sessionId,
-        toolCallId: params.toolCallId,
-        toolName: params.toolName,
-        arguments: params.arguments,
-        traceparent,
-        tracestate
-      };
-      const result = await handler(params.arguments, invocation);
-      return { result: this.normalizeToolResultV2(result) };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return {
-        result: {
-          textResultForLlm: "Invoking this tool produced an error. Detailed information is not available.",
-          resultType: "failure",
-          error: message,
-          toolTelemetry: {}
-        }
-      };
-    }
-  }
-  /**
-   * Handles a v2-style permission.request RPC request from the server.
-   */
-  async handlePermissionRequestV2(params) {
-    if (!params || typeof params.sessionId !== "string" || !params.permissionRequest) {
-      throw new Error("Invalid permission request payload");
-    }
-    const session = this.sessions.get(params.sessionId);
-    if (!session) {
-      throw new Error(`Session not found: ${params.sessionId}`);
-    }
-    try {
-      const result = await session._handlePermissionRequestV2(params.permissionRequest);
-      return { result };
-    } catch (error) {
-      if (error instanceof Error && error.message === import_session.NO_RESULT_PERMISSION_V2_ERROR) {
-        throw error;
-      }
-      return {
-        result: {
-          kind: "user-not-available"
-        }
-      };
-    }
-  }
-  normalizeToolResultV2(result) {
-    if (result === void 0 || result === null) {
-      return {
-        textResultForLlm: "Tool returned no result",
-        resultType: "failure",
-        error: "tool returned no result",
-        toolTelemetry: {}
-      };
-    }
-    if (this.isToolResultObject(result)) {
-      return result;
-    }
-    const textResult = typeof result === "string" ? result : JSON.stringify(result);
-    return {
-      textResultForLlm: textResult,
-      resultType: "success",
-      toolTelemetry: {}
-    };
-  }
-  isToolResultObject(value) {
-    return typeof value === "object" && value !== null && "textResultForLlm" in value && typeof value.textResultForLlm === "string" && "resultType" in value;
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/extension.js

@@ -18,11 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var extension_exports = {};
 __export(extension_exports, {
+  Canvas: () => import_canvas.Canvas,
+  CanvasError: () => import_canvas.CanvasError,
+  createCanvas: () => import_canvas.createCanvas,
   joinSession: () => joinSession
 });
 module.exports = __toCommonJS(extension_exports);
 var import_client = require("./client.js");
 var import_types = require("./types.js");
+var import_canvas = require("./canvas.js");
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
@@ -39,5 +43,8 @@ async function joinSession(config = {}) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Canvas,
+  CanvasError,
+  createCanvas,
   joinSession
 });

package/dist/cjs/generated/rpc.js

@@ -275,7 +275,7 @@ function createServerRpc(connection) {
        *
        * @param params Session metadata records to enrich with summary and context information.
        *
-       * @returns The same metadata records, with summary and context fields backfilled where available.
+       * @returns The enriched metadata records, with summary and context fields backfilled where available. Sessions confirmed empty and unnamed are omitted.
        */
       enrichMetadata: async (params) => connection.sendRequest("sessions.enrichMetadata", params),
       /**
@@ -371,6 +371,43 @@ function createSessionRpc(connection, sessionId) {
       setCredentials: async (params) => connection.sendRequest("session.auth.setCredentials", { sessionId, ...params })
     },
     /** @experimental */
+    canvas: {
+      /**
+       * Lists canvases declared for the session.
+       *
+       * @returns Declared canvases available in this session.
+       */
+      list: async () => connection.sendRequest("session.canvas.list", { sessionId }),
+      /**
+       * Lists currently open canvas instances for the live session.
+       *
+       * @returns Live open-canvas snapshot.
+       */
+      listOpen: async () => connection.sendRequest("session.canvas.listOpen", { sessionId }),
+      /**
+       * Opens or focuses a canvas instance.
+       *
+       * @param params Canvas open parameters.
+       *
+       * @returns Open canvas instance snapshot.
+       */
+      open: async (params) => connection.sendRequest("session.canvas.open", { sessionId, ...params }),
+      /**
+       * Closes an open canvas instance.
+       *
+       * @param params Canvas close parameters.
+       */
+      close: async (params) => connection.sendRequest("session.canvas.close", { sessionId, ...params }),
+      /**
+       * Invokes an action on an open canvas instance.
+       *
+       * @param params Canvas action invocation parameters.
+       *
+       * @returns Canvas action invocation result.
+       */
+      invokeAction: async (params) => connection.sendRequest("session.canvas.invokeAction", { sessionId, ...params })
+    },
+    /** @experimental */
     model: {
       /**
        * Gets the currently selected model for the session.
@@ -501,7 +538,15 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Descriptor for the saved paste file, or null when the workspace is unavailable.
        */
-      saveLargePaste: async (params) => connection.sendRequest("session.workspaces.saveLargePaste", { sessionId, ...params })
+      saveLargePaste: async (params) => connection.sendRequest("session.workspaces.saveLargePaste", { sessionId, ...params }),
+      /**
+       * Computes a diff for the session workspace.
+       *
+       * @param params Parameters for computing a workspace diff.
+       *
+       * @returns Workspace diff result for the requested mode.
+       */
+      diff: async (params) => connection.sendRequest("session.workspaces.diff", { sessionId, ...params })
     },
     /** @experimental */
     instructions: {
@@ -738,6 +783,53 @@ function createSessionRpc(connection, sessionId) {
          * @returns OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
          */
         login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params })
+      },
+      /** @experimental */
+      apps: {
+        /**
+         * Fetch an MCP resource (typically a `ui://` MCP App bundle, per SEP-1865) from a connected server. Requires the `mcp-apps` session capability.
+         *
+         * @param params MCP server and resource URI to fetch.
+         *
+         * @returns Resource contents returned by the MCP server.
+         */
+        readResource: async (params) => connection.sendRequest("session.mcp.apps.readResource", { sessionId, ...params }),
+        /**
+         * List tools that an MCP App view is allowed to call (SEP-1865 visibility filter). Returns tools whose `_meta.ui.visibility` is unset (default `["model","app"]`) or includes `"app"`.
+         *
+         * @param params MCP server to list app-callable tools for.
+         *
+         * @returns App-callable tools from the named MCP server.
+         */
+        listTools: async (params) => connection.sendRequest("session.mcp.apps.listTools", { sessionId, ...params }),
+        /**
+         * Call an MCP tool from an MCP App view (SEP-1865). Enforces the visibility check that prevents an app iframe from invoking model-only tools. Returns the standard MCP `CallToolResult`.
+         *
+         * @param params MCP server, tool name, and arguments to invoke from an MCP App view.
+         *
+         * @returns Standard MCP CallToolResult
+         */
+        callTool: async (params) => connection.sendRequest("session.mcp.apps.callTool", { sessionId, ...params }),
+        /**
+         * Replace the host context returned to MCP App guests on `ui/initialize`. Hosts use this to advertise theme, locale, or other metadata to the guest UI.
+         *
+         * @param params Host context to advertise to MCP App guests.
+         */
+        setHostContext: async (params) => connection.sendRequest("session.mcp.apps.setHostContext", { sessionId, ...params }),
+        /**
+         * Read the current host context advertised to MCP App guests.
+         *
+         * @returns Current host context advertised to MCP App guests.
+         */
+        getHostContext: async () => connection.sendRequest("session.mcp.apps.getHostContext", { sessionId }),
+        /**
+         * Diagnose MCP Apps wiring for a specific MCP server. Reports the session capability, feature-flag state, advertised extension, and how many tools have `_meta.ui` populated.
+         *
+         * @param params MCP server to diagnose MCP Apps wiring for.
+         *
+         * @returns Diagnostic snapshot of MCP Apps wiring for the named server.
+         */
+        diagnose: async (params) => connection.sendRequest("session.mcp.apps.diagnose", { sessionId, ...params })
       }
     },
     /** @experimental */
@@ -1374,6 +1466,21 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
     return handler.sqliteExists(params);
   });
+  connection.onRequest("canvas.open", async (params) => {
+    const handler = getHandlers(params.sessionId).canvas;
+    if (!handler) throw new Error(`No canvas handler registered for session: ${params.sessionId}`);
+    return handler.open(params);
+  });
+  connection.onRequest("canvas.close", async (params) => {
+    const handler = getHandlers(params.sessionId).canvas;
+    if (!handler) throw new Error(`No canvas handler registered for session: ${params.sessionId}`);
+    return handler.close(params);
+  });
+  connection.onRequest("canvas.invokeAction", async (params) => {
+    const handler = getHandlers(params.sessionId).canvas;
+    if (!handler) throw new Error(`No canvas handler registered for session: ${params.sessionId}`);
+    return handler.invokeAction(params);
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/index.js

@@ -18,12 +18,15 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var index_exports = {};
 __export(index_exports, {
+  Canvas: () => import_canvas.Canvas,
+  CanvasError: () => import_canvas.CanvasError,
   CopilotClient: () => import_client.CopilotClient,
   CopilotSession: () => import_session.CopilotSession,
   RuntimeConnection: () => import_types.RuntimeConnection,
-  SYSTEM_PROMPT_SECTIONS: () => import_types2.SYSTEM_PROMPT_SECTIONS,
+  SYSTEM_MESSAGE_SECTIONS: () => import_types2.SYSTEM_MESSAGE_SECTIONS,
   approveAll: () => import_types2.approveAll,
   convertMcpCallToolResult: () => import_types2.convertMcpCallToolResult,
+  createCanvas: () => import_canvas.createCanvas,
   createSessionFsAdapter: () => import_types2.createSessionFsAdapter,
   defineTool: () => import_types2.defineTool
 });
@@ -31,15 +34,19 @@ module.exports = __toCommonJS(index_exports);
 var import_client = require("./client.js");
 var import_types = require("./types.js");
 var import_session = require("./session.js");
+var import_canvas = require("./canvas.js");
 var import_types2 = require("./types.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Canvas,
+  CanvasError,
   CopilotClient,
   CopilotSession,
   RuntimeConnection,
-  SYSTEM_PROMPT_SECTIONS,
+  SYSTEM_MESSAGE_SECTIONS,
   approveAll,
   convertMcpCallToolResult,
+  createCanvas,
   createSessionFsAdapter,
   defineTool
 });