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

package/dist/cjs/generated/rpc.js

@@ -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.
@@ -738,6 +775,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 */

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
 });

package/dist/cjs/session.js

@@ -18,14 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var session_exports = {};
 __export(session_exports, {
-  CopilotSession: () => CopilotSession,
-  NO_RESULT_PERMISSION_V2_ERROR: () => NO_RESULT_PERMISSION_V2_ERROR
+  CopilotSession: () => CopilotSession
 });
 module.exports = __toCommonJS(session_exports);
 var import_node = require("vscode-jsonrpc/node.js");
 var import_rpc = require("./generated/rpc.js");
 var import_telemetry = require("./telemetry.js");
-const NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
     return raw;
@@ -53,6 +51,7 @@ class CopilotSession {
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
+  canvases = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
   permissionHandler;
   userInputHandler;
@@ -64,6 +63,7 @@ class CopilotSession {
   _rpc = null;
   traceContextProvider;
   _capabilities = {};
+  openCanvasInstances = [];
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
   clientSessionApis = {};
   /**
@@ -393,6 +393,31 @@ class CopilotSession {
   getToolHandler(name) {
     return this.toolHandlers.get(name);
   }
+  /**
+   * Registers canvas declarations and handlers for this session.
+   *
+   * @param canvases - Canvases created via `createCanvas`, or undefined to clear all canvases
+   * @internal Called by the SDK when creating/resuming a session with `canvases`.
+   */
+  registerCanvases(canvases) {
+    this.canvases.clear();
+    if (!canvases) {
+      return;
+    }
+    for (const canvas of canvases) {
+      this.canvases.set(canvas.declaration.id, canvas);
+    }
+  }
+  /**
+   * Retrieves a registered canvas by id.
+   *
+   * @param canvasId - The id of the canvas to retrieve
+   * @returns The registered Canvas if found, or undefined
+   * @internal Used by the SDK's direct `canvas.*` dispatcher.
+   */
+  getCanvas(canvasId) {
+    return this.canvases.get(canvasId);
+  }
   /**
    * Registers command handlers for this session.
    *
@@ -489,6 +514,24 @@ class CopilotSession {
   setCapabilities(capabilities) {
     this._capabilities = capabilities ?? {};
   }
+  /**
+   * Snapshot of canvas instances that were already open when the session was
+   * resumed. Populated from the `session.resume` response; empty for freshly
+   * created sessions. Returns a defensive copy — mutating the returned array
+   * has no effect on the session.
+   */
+  get openCanvases() {
+    return [...this.openCanvasInstances];
+  }
+  /**
+   * Sets the open-canvas snapshot for this session.
+   *
+   * @param instances - The `openCanvases` array from the `session.resume` response.
+   * @internal This method is typically called internally when resuming a session.
+   */
+  setOpenCanvases(instances) {
+    this.openCanvasInstances = [...instances];
+  }
   assertElicitation() {
     if (!this._capabilities.ui?.elicitation) {
       throw new Error(
@@ -628,33 +671,6 @@ class CopilotSession {
     }
     return { sections: result };
   }
-  /**
-   * Handles a permission request in the v2 protocol format (synchronous RPC).
-   * Used as a back-compat adapter when connected to a v2 server.
-   *
-   * @param request - The permission request data from the CLI
-   * @returns A promise that resolves with the permission decision
-   * @internal This method is for internal use by the SDK.
-   */
-  async _handlePermissionRequestV2(request) {
-    if (!this.permissionHandler) {
-      return { kind: "user-not-available" };
-    }
-    try {
-      const result = await this.permissionHandler(request, {
-        sessionId: this.sessionId
-      });
-      if (result.kind === "no-result") {
-        throw new Error(NO_RESULT_PERMISSION_V2_ERROR);
-      }
-      return result;
-    } catch (error) {
-      if (error instanceof Error && error.message === NO_RESULT_PERMISSION_V2_ERROR) {
-        throw error;
-      }
-      return { kind: "user-not-available" };
-    }
-  }
   /**
    * Handles a user input request from the Copilot CLI.
    *
@@ -853,6 +869,5 @@ function isToolResultObject(value) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  CopilotSession,
-  NO_RESULT_PERMISSION_V2_ERROR
+  CopilotSession
 });

package/dist/cjs/types.js

@@ -19,7 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var types_exports = {};
 __export(types_exports, {
   RuntimeConnection: () => RuntimeConnection,
-  SYSTEM_PROMPT_SECTIONS: () => SYSTEM_PROMPT_SECTIONS,
+  SYSTEM_MESSAGE_SECTIONS: () => SYSTEM_MESSAGE_SECTIONS,
   approveAll: () => approveAll,
   convertMcpCallToolResult: () => convertMcpCallToolResult,
   createSessionFsAdapter: () => import_sessionFsProvider.createSessionFsAdapter,
@@ -101,7 +101,7 @@ function convertMcpCallToolResult(callResult) {
 function defineTool(name, config) {
   return { name, ...config };
 }
-const SYSTEM_PROMPT_SECTIONS = {
+const SYSTEM_MESSAGE_SECTIONS = {
   identity: { description: "Agent identity preamble and mode statement" },
   tone: { description: "Response style, conciseness rules, output formatting preferences" },
   tool_efficiency: { description: "Tool usage patterns, parallel calling, batching guidelines" },
@@ -111,6 +111,9 @@ const SYSTEM_PROMPT_SECTIONS = {
   safety: { description: "Environment limitations, prohibited actions, security policies" },
   tool_instructions: { description: "Per-tool usage instructions" },
   custom_instructions: { description: "Repository and organization custom instructions" },
+  runtime_instructions: {
+    description: "Runtime-provided context and instructions (e.g. system notifications, memories, workspace context, mode-specific instructions, content-exclusion policy)"
+  },
   last_instructions: {
     description: "End-of-prompt instructions: parallel tool calling, persistence, task completion"
   }
@@ -122,7 +125,7 @@ const defaultJoinSessionPermissionHandler = () => ({
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   RuntimeConnection,
-  SYSTEM_PROMPT_SECTIONS,
+  SYSTEM_MESSAGE_SECTIONS,
   approveAll,
   convertMcpCallToolResult,
   createSessionFsAdapter,

package/dist/client.d.ts

@@ -1,6 +1,6 @@
 import { createServerRpc } from "./generated/rpc.js";
 import { CopilotSession } from "./session.js";
-import type { ConnectionState, CopilotClientOptions, GetAuthStatusResponse, GetStatusResponse, ModelInfo, ResumeSessionConfig, SessionConfig, SessionLifecycleEventType, SessionLifecycleHandler, SessionListFilter, SessionMetadata, TypedSessionLifecycleHandler } from "./types.js";
+import type { CopilotClientOptions, GetAuthStatusResponse, GetStatusResponse, ModelInfo, ResumeSessionConfig, SessionConfig, SessionLifecycleEventType, SessionLifecycleHandler, SessionListFilter, SessionMetadata, TypedSessionLifecycleHandler } from "./types.js";
 /**
  * Main client for interacting with the Copilot CLI.
  *
@@ -244,19 +244,6 @@ export declare class CopilotClient {
      * ```
      */
     resumeSession(sessionId: string, config: ResumeSessionConfig): Promise<CopilotSession>;
-    /**
-     * 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(): ConnectionState;
     /**
      * Sends a ping request to the server to verify connectivity.
      *
@@ -480,16 +467,6 @@ export declare class CopilotClient {
     private handleAutoModeSwitchRequest;
     private handleHooksInvoke;
     private handleSystemMessageTransform;
-    /**
-     * 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.
-     */
-    private handleToolCallRequestV2;
-    /**
-     * Handles a v2-style permission.request RPC request from the server.
-     */
-    private handlePermissionRequestV2;
-    private normalizeToolResultV2;
-    private isToolResultObject;
+    private handleCanvasProviderRequest;
+    private handleCanvasActionInvokeRequest;
 }

package/dist/client.js

@@ -17,12 +17,15 @@ import {
   createInternalServerRpc,
   registerClientSessionApiHandlers
 } from "./generated/rpc.js";
+import {
+  dispatchCanvasProviderRequest
+} from "./canvas.js";
 import { getSdkProtocolVersion } from "./sdkProtocolVersion.js";
-import { CopilotSession, NO_RESULT_PERMISSION_V2_ERROR } from "./session.js";
+import { CopilotSession } from "./session.js";
 import { createSessionFsAdapter } from "./sessionFsProvider.js";
 import { getTraceContext } from "./telemetry.js";
 import { defaultJoinSessionPermissionHandler } from "./types.js";
-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";
 }
@@ -53,6 +56,16 @@ function toWireCustomAgents(agents) {
     return { ...rest, mcpServers: toWireMcpServers(mcpServers) };
   });
 }
+function isCanvasProviderRequestParams(params) {
+  if (!params || typeof params !== "object") {
+    return false;
+  }
+  const request = params;
+  return typeof request.sessionId === "string" && typeof request.extensionId === "string" && typeof request.canvasId === "string" && typeof request.instanceId === "string";
+}
+function isCanvasActionInvokeParams(params) {
+  return isCanvasProviderRequestParams(params) && typeof params.actionName === "string";
+}
 function extractTransformCallbacks(systemMessage) {
   if (!systemMessage || systemMessage.mode !== "customize" || !systemMessage.sections) {
     return { wirePayload: systemMessage, transformCallbacks: void 0 };
@@ -558,6 +571,7 @@ class CopilotClient {
       this.onGetTraceContext
     );
     session.registerTools(config.tools);
+    session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -600,6 +614,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
@@ -610,7 +628,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,
@@ -678,6 +696,7 @@ class CopilotClient {
       this.onGetTraceContext
     );
     session.registerTools(config.tools);
+    session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
     session.registerPermissionHandler(config.onPermissionRequest);
     if (config.onUserInputRequest) {
@@ -724,6 +743,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
@@ -753,32 +776,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.
    *
@@ -1367,14 +1377,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)
@@ -1395,6 +1397,18 @@ stderr: ${stderrOutput}`
       "systemMessage.transform",
       async (params) => await this.handleSystemMessageTransform(params)
     );
+    this.connection.onRequest(
+      "canvas.open",
+      async (params) => this.handleCanvasProviderRequest("canvas.open", params)
+    );
+    this.connection.onRequest(
+      "canvas.close",
+      async (params) => this.handleCanvasProviderRequest("canvas.close", params)
+    );
+    this.connection.onRequest(
+      "canvas.action.invoke",
+      async (params) => this.handleCanvasActionInvokeRequest(params)
+    );
     const sessions = this.sessions;
     registerClientSessionApiHandlers(this.connection, (sessionId) => {
       const session = sessions.get(sessionId);
@@ -1516,104 +1530,25 @@ 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");
+  async handleCanvasProviderRequest(actionName, params) {
+    if (!isCanvasProviderRequestParams(params)) {
+      throw new Error("Invalid canvas provider 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 === NO_RESULT_PERMISSION_V2_ERROR) {
-        throw error;
-      }
-      return {
-        result: {
-          kind: "user-not-available"
-        }
-      };
+    const canvas = session.getCanvas(params.canvasId);
+    if (!canvas) {
+      throw new Error(`No canvas registered with id "${params.canvasId}"`);
     }
+    return dispatchCanvasProviderRequest(canvas, actionName, params);
   }
-  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;
+  async handleCanvasActionInvokeRequest(params) {
+    if (!isCanvasActionInvokeParams(params)) {
+      throw new Error("Invalid canvas provider request payload");
     }
-    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;
+    return this.handleCanvasProviderRequest(params.actionName, params);
   }
 }
 export {

package/dist/extension.d.ts

@@ -1,8 +1,10 @@
 import type { CopilotSession } from "./session.js";
-import { type PermissionHandler, type ResumeSessionConfig } from "./types.js";
+import { type ExtensionInfo, type PermissionHandler, type ResumeSessionConfig } from "./types.js";
+export { Canvas, CanvasError, createCanvas, type CanvasAction, type CanvasActionContext, type CanvasDeclaration, type CanvasHostContext, type CanvasJsonSchema, type CanvasLifecycleContext, type CanvasOpenContext, type CanvasOpenResponse, type CanvasOptions, } from "./canvas.js";
 export type JoinSessionConfig = Omit<ResumeSessionConfig, "onPermissionRequest"> & {
     onPermissionRequest?: PermissionHandler;
 };
+export type { ExtensionInfo };
 /**
  * Joins the current foreground session.
  *

package/dist/extension.js

@@ -2,6 +2,11 @@ import { CopilotClient } from "./client.js";
 import {
   defaultJoinSessionPermissionHandler
 } from "./types.js";
+import {
+  Canvas,
+  CanvasError,
+  createCanvas
+} from "./canvas.js";
 async function joinSession(config = {}) {
   const sessionId = process.env.SESSION_ID;
   if (!sessionId) {
@@ -17,5 +22,8 @@ async function joinSession(config = {}) {
   });
 }
 export {
+  Canvas,
+  CanvasError,
+  createCanvas,
   joinSession
 };