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

package/dist/index.d.ts

@@ -4,7 +4,9 @@
  * JSON-RPC based SDK for programmatic control of GitHub Copilot CLI
  */
 export { CopilotClient } from "./client.js";
+export { RuntimeConnection } from "./types.js";
 export { CopilotSession, type AssistantMessageEvent } from "./session.js";
-export { defineTool, approveAll, convertMcpCallToolResult, createSessionFsAdapter, SYSTEM_PROMPT_SECTIONS, } 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 { defineTool, approveAll, convertMcpCallToolResult, createSessionFsAdapter, SYSTEM_MESSAGE_SECTIONS, } from "./types.js";
 export type * from "./generated/session-events.js";
-export type { CommandContext, CommandDefinition, CommandHandler, CloudSessionOptions, CloudSessionRepository, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, ConnectionState, CopilotClientOptions, CustomAgentConfig, ElicitationFieldValue, ElicitationHandler, ElicitationParams, ElicitationContext, ElicitationResult, ElicitationSchema, ElicitationSchemaField, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, InputOptions, MCPStdioServerConfig, MCPHTTPServerConfig, MCPServerConfig, DefaultAgentConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelCapabilitiesOverride, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ProviderConfig, RemoteSessionMode, ResumeSessionConfig, SectionOverride, SectionOverrideAction, SectionTransformFn, SessionCapabilities, SessionConfig, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventType, SessionLifecycleHandler, SessionContext, SessionListFilter, SessionMetadata, SessionUiApi, SessionFsConfig, SessionFsProvider, SessionFsFileInfo, SessionFsSqliteQueryResult, SessionFsSqliteQueryType, SessionFsSqliteProvider, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageCustomizeConfig, SystemMessageReplaceConfig, SystemPromptSection, TelemetryConfig, TraceContext, TraceContextProvider, Tool, ToolHandler, ToolInvocation, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";
+export type { CommandContext, CommandDefinition, CommandHandler, CloudSessionOptions, CloudSessionRepository, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, CopilotClientOptions, StdioRuntimeConnection, TcpRuntimeConnection, UriRuntimeConnection, CustomAgentConfig, ElicitationFieldValue, ElicitationHandler, ElicitationParams, ElicitationContext, ElicitationResult, ElicitationSchema, ElicitationSchemaField, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, ExtensionInfo, ForegroundSessionInfo, GetAuthStatusResponse, GetStatusResponse, InfiniteSessionConfig, UiInputOptions, MCPStdioServerConfig, MCPHTTPServerConfig, MCPServerConfig, DefaultAgentConfig, MessageOptions, ModelBilling, ModelCapabilities, ModelCapabilitiesOverride, ModelInfo, ModelPolicy, PermissionHandler, PermissionRequest, PermissionRequestResult, ProviderConfig, RemoteSessionMode, ResumeSessionConfig, SectionOverride, SectionOverrideAction, SectionTransformFn, SessionCapabilities, SessionConfig, SessionConfigBase, SessionEvent, SessionEventHandler, SessionEventPayload, SessionEventType, SessionLifecycleEvent, SessionLifecycleEventMetadata, SessionLifecycleEventType, SessionLifecycleHandler, SessionCreatedEvent, SessionDeletedEvent, SessionUpdatedEvent, SessionForegroundEvent, SessionBackgroundEvent, SessionContext, SessionListFilter, SessionMetadata, SessionUiApi, SessionFsConfig, SessionFsProvider, SessionFsFileInfo, SessionFsSqliteQueryResult, SessionFsSqliteQueryType, SessionFsSqliteProvider, SystemMessageAppendConfig, SystemMessageConfig, SystemMessageCustomizeConfig, SystemMessageReplaceConfig, SystemMessageSection, TelemetryConfig, TraceContext, TraceContextProvider, Tool, ToolHandler, ToolInvocation, ToolTelemetry, ToolResultObject, TypedSessionEventHandler, TypedSessionLifecycleHandler, ZodSchema, } from "./types.js";

package/dist/index.js

@@ -1,18 +1,28 @@
 import { CopilotClient } from "./client.js";
+import { RuntimeConnection } from "./types.js";
 import { CopilotSession } from "./session.js";
+import {
+  Canvas,
+  CanvasError,
+  createCanvas
+} from "./canvas.js";
 import {
   defineTool,
   approveAll,
   convertMcpCallToolResult,
   createSessionFsAdapter,
-  SYSTEM_PROMPT_SECTIONS
+  SYSTEM_MESSAGE_SECTIONS
 } from "./types.js";
 export {
+  Canvas,
+  CanvasError,
   CopilotClient,
   CopilotSession,
-  SYSTEM_PROMPT_SECTIONS,
+  RuntimeConnection,
+  SYSTEM_MESSAGE_SECTIONS,
   approveAll,
   convertMcpCallToolResult,
+  createCanvas,
   createSessionFsAdapter,
   defineTool
 };

package/dist/session.d.ts

@@ -1,12 +1,6 @@
-/**
- * Copilot Session - represents a single conversation session with the Copilot CLI.
- * @module session
- */
-import type { MessageConnection } from "vscode-jsonrpc/node.js";
 import { createSessionRpc } from "./generated/rpc.js";
-import type { ClientSessionApiHandlers } from "./generated/rpc.js";
-import type { CommandHandler, AutoModeSwitchHandler, AutoModeSwitchRequest, AutoModeSwitchResponse, ElicitationHandler, ElicitationContext, ExitPlanModeHandler, ExitPlanModeRequest, ExitPlanModeResult, MessageOptions, PermissionHandler, PermissionRequestResult, ReasoningEffort, ModelCapabilitiesOverride, SectionTransformFn, SessionCapabilities, SessionEvent, SessionEventHandler, SessionEventType, SessionHooks, SessionUiApi, Tool, ToolHandler, TraceContextProvider, TypedSessionEventHandler, UserInputHandler, UserInputResponse } from "./types.js";
-export declare const NO_RESULT_PERMISSION_V2_ERROR = "Permission handlers cannot return 'no-result' when connected to a protocol v2 server.";
+import type { OpenCanvasInstance } from "./generated/rpc.js";
+import type { MessageOptions, ReasoningEffort, ModelCapabilitiesOverride, SessionCapabilities, SessionEvent, SessionEventHandler, SessionEventType, SessionUiApi, TypedSessionEventHandler } from "./types.js";
 /** Assistant message event - the final response from the assistant. */
 export type AssistantMessageEvent = Extract<SessionEvent, {
     type: "assistant.message";
@@ -43,6 +37,7 @@ export declare class CopilotSession {
     private eventHandlers;
     private typedEventHandlers;
     private toolHandlers;
+    private canvases;
     private commandHandlers;
     private permissionHandler?;
     private userInputHandler?;
@@ -54,18 +49,7 @@ export declare class CopilotSession {
     private _rpc;
     private traceContextProvider?;
     private _capabilities;
-    /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
-    clientSessionApis: ClientSessionApiHandlers;
-    /**
-     * Creates a new CopilotSession instance.
-     *
-     * @param sessionId - The unique identifier for this session
-     * @param connection - The JSON-RPC message connection to the Copilot CLI
-     * @param workspacePath - Path to the session workspace directory (when infinite sessions enabled)
-     * @param traceContextProvider - Optional callback to get W3C Trace Context for outbound RPCs
-     * @internal This constructor is internal. Use {@link CopilotClient.createSession} to create sessions.
-     */
-    constructor(sessionId: string, connection: MessageConnection, _workspacePath?: string | undefined, traceContextProvider?: TraceContextProvider);
+    private openCanvasInstances;
     /**
      * Typed session-scoped RPC methods.
      */
@@ -112,6 +96,7 @@ export declare class CopilotSession {
      * });
      * ```
      */
+    send(prompt: string): Promise<string>;
     send(options: MessageOptions): Promise<string>;
     /**
      * Sends a message to this session and waits until the session becomes idle.
@@ -136,6 +121,7 @@ export declare class CopilotSession {
      * console.log(response?.data.content); // "4"
      * ```
      */
+    sendAndWait(prompt: string, timeout?: number): Promise<AssistantMessageEvent | undefined>;
     sendAndWait(options: MessageOptions, timeout?: number): Promise<AssistantMessageEvent | undefined>;
     /**
      * Subscribes to events from this session.
@@ -184,190 +170,17 @@ export declare class CopilotSession {
      */
     on(handler: SessionEventHandler): () => void;
     /**
-     * Dispatches an event to all registered handlers.
-     * Also handles broadcast request events internally (external tool calls, permissions).
-     *
-     * @param event - The session event to dispatch
-     * @internal This method is for internal use by the SDK.
-     */
-    _dispatchEvent(event: SessionEvent): void;
-    /**
-     * Handles broadcast request events by executing local handlers and responding via RPC.
-     * Handlers are dispatched as fire-and-forget — rejections propagate as unhandled promise
-     * rejections, consistent with standard EventEmitter / event handler semantics.
-     * @internal
-     */
-    private _handleBroadcastEvent;
-    /**
-     * Executes a tool handler and sends the result back via RPC.
-     * @internal
-     */
-    private _executeToolAndRespond;
-    /**
-     * Executes a permission handler and sends the result back via RPC.
-     * @internal
-     */
-    private _executePermissionAndRespond;
-    /**
-     * Executes a command handler and sends the result back via RPC.
-     * @internal
-     */
-    private _executeCommandAndRespond;
-    /**
-     * Registers custom tool handlers for this session.
-     *
-     * Tools with handlers allow the assistant to execute custom functions automatically.
-     * Declaration-only tools are surfaced as events and left pending for the consumer.
-     *
-     * @param tools - An array of tool definitions with their handlers, or undefined to clear all tools
-     * @internal This method is typically called internally when creating a session with tools.
-     */
-    registerTools(tools?: Tool[]): void;
-    /**
-     * Retrieves a registered tool handler by name.
-     *
-     * @param name - The name of the tool to retrieve
-     * @returns The tool handler if found, or undefined
-     * @internal This method is for internal use by the SDK.
-     */
-    getToolHandler(name: string): ToolHandler | undefined;
-    /**
-     * Registers command handlers for this session.
-     *
-     * @param commands - An array of command definitions with handlers, or undefined to clear
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    registerCommands(commands?: {
-        name: string;
-        handler: CommandHandler;
-    }[]): void;
-    /**
-     * Registers the elicitation handler for this session.
-     *
-     * @param handler - The handler to invoke when the server dispatches an elicitation request
-     * @internal This method is typically called internally when creating/resuming a session.
+     * 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.
      */
-    registerElicitationHandler(handler?: ElicitationHandler): void;
-    /**
-     * Registers the exit-plan-mode handler for this session.
-     *
-     * @param handler - The handler to invoke when the server dispatches an exit-plan-mode request
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    registerExitPlanModeHandler(handler?: ExitPlanModeHandler): void;
-    /**
-     * Registers the auto-mode-switch handler for this session.
-     *
-     * @param handler - The handler to invoke when the server dispatches an auto-mode-switch request
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    registerAutoModeSwitchHandler(handler?: AutoModeSwitchHandler): void;
-    /**
-     * Handles an elicitation.requested broadcast event.
-     * Invokes the registered handler and responds via handlePendingElicitation RPC.
-     * @internal
-     */
-    _handleElicitationRequest(context: ElicitationContext, requestId: string): Promise<void>;
-    /**
-     * Handles an exitPlanMode.request callback from the runtime.
-     * @internal
-     */
-    _handleExitPlanModeRequest(request: ExitPlanModeRequest): Promise<ExitPlanModeResult>;
-    /**
-     * Handles an autoModeSwitch.request callback from the runtime.
-     * @internal
-     */
-    _handleAutoModeSwitchRequest(request: AutoModeSwitchRequest): Promise<AutoModeSwitchResponse>;
-    /**
-     * Sets the host capabilities for this session.
-     *
-     * @param capabilities - The capabilities object from the create/resume response
-     * @internal This method is typically called internally when creating/resuming a session.
-     */
-    setCapabilities(capabilities?: SessionCapabilities): void;
+    get openCanvases(): OpenCanvasInstance[];
     private assertElicitation;
     private _elicitation;
     private _confirm;
     private _select;
     private _input;
-    /**
-     * Registers a handler for permission requests.
-     *
-     * When the assistant needs permission to perform certain actions (e.g., file operations),
-     * this handler is called to approve or deny the request.
-     *
-     * @param handler - The permission handler function, or undefined to remove the handler
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerPermissionHandler(handler?: PermissionHandler): void;
-    /**
-     * Registers a user input handler for ask_user requests.
-     *
-     * When the agent needs input from the user (via ask_user tool),
-     * this handler is called to provide the response.
-     *
-     * @param handler - The user input handler function, or undefined to remove the handler
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerUserInputHandler(handler?: UserInputHandler): void;
-    /**
-     * Registers hook handlers for session lifecycle events.
-     *
-     * Hooks allow custom logic to be executed at various points during
-     * the session lifecycle (before/after tool use, session start/end, etc.).
-     *
-     * @param hooks - The hook handlers object, or undefined to remove all hooks
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerHooks(hooks?: SessionHooks): void;
-    /**
-     * Registers transform callbacks for system message sections.
-     *
-     * @param callbacks - Map of section ID to transform callback, or undefined to clear
-     * @internal This method is typically called internally when creating a session.
-     */
-    registerTransformCallbacks(callbacks?: Map<string, SectionTransformFn>): void;
-    /**
-     * Handles a systemMessage.transform request from the runtime.
-     * Dispatches each section to its registered transform callback.
-     *
-     * @param sections - Map of section IDs to their current rendered content
-     * @returns A promise that resolves with the transformed sections
-     * @internal This method is for internal use by the SDK.
-     */
-    _handleSystemMessageTransform(sections: Record<string, {
-        content: string;
-    }>): Promise<{
-        sections: Record<string, {
-            content: string;
-        }>;
-    }>;
-    /**
-     * 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.
-     */
-    _handlePermissionRequestV2(request: unknown): Promise<PermissionRequestResult>;
-    /**
-     * Handles a user input request from the Copilot CLI.
-     *
-     * @param request - The user input request data from the CLI
-     * @returns A promise that resolves with the user's response
-     * @internal This method is for internal use by the SDK.
-     */
-    _handleUserInputRequest(request: unknown): Promise<UserInputResponse>;
-    /**
-     * Handles a hooks invocation from the Copilot CLI.
-     *
-     * @param hookType - The type of hook being invoked
-     * @param input - The input data for the hook
-     * @returns A promise that resolves with the hook output, or undefined
-     * @internal This method is for internal use by the SDK.
-     */
-    _handleHooksInvoke(hookType: string, input: unknown): Promise<unknown>;
     /**
      * Retrieves all events and messages from this session's history.
      *
@@ -379,7 +192,7 @@ export declare class CopilotSession {
      *
      * @example
      * ```typescript
-     * const events = await session.getMessages();
+     * const events = await session.getEvents();
      * for (const event of events) {
      *   if (event.type === "assistant.message") {
      *     console.log("Assistant:", event.data.content);
@@ -387,7 +200,7 @@ export declare class CopilotSession {
      * }
      * ```
      */
-    getMessages(): Promise<SessionEvent[]>;
+    getEvents(): Promise<SessionEvent[]>;
     /**
      * Disconnects this session and releases all in-memory resources (event handlers,
      * tool handlers, permission handlers).
@@ -410,16 +223,6 @@ export declare class CopilotSession {
      * ```
      */
     disconnect(): Promise<void>;
-    /**
-     * @deprecated Use {@link disconnect} instead. This method will be removed in a future release.
-     *
-     * Disconnects this session and releases all in-memory resources.
-     * Session data on disk is preserved for later resumption.
-     *
-     * @returns A promise that resolves when the session is disconnected
-     * @throws Error if the connection fails
-     */
-    destroy(): Promise<void>;
     /** Enables `await using session = ...` syntax for automatic cleanup. */
     [Symbol.asyncDispose](): Promise<void>;
     /**

package/dist/session.js

@@ -1,7 +1,14 @@
 import { ConnectionError, ResponseError } from "vscode-jsonrpc/node.js";
 import { createSessionRpc } from "./generated/rpc.js";
 import { getTraceContext } from "./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;
+  }
+  const obj = raw;
+  const { cwd, ...rest } = obj;
+  return { ...rest, timestamp: new Date(obj.timestamp), workingDirectory: cwd };
+}
 class CopilotSession {
   /**
    * Creates a new CopilotSession instance.
@@ -21,6 +28,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;
@@ -32,6 +40,7 @@ class CopilotSession {
   _rpc = null;
   traceContextProvider;
   _capabilities = {};
+  openCanvasInstances = [];
   /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
   clientSessionApis = {};
   /**
@@ -78,25 +87,8 @@ class CopilotSession {
       input: (message, options) => this._input(message, options)
     };
   }
-  /**
-   * Sends a message to this session and waits for the response.
-   *
-   * The message is processed asynchronously. Subscribe to events via {@link on}
-   * to receive streaming responses and other session events.
-   *
-   * @param options - The message options including the prompt and optional attachments
-   * @returns A promise that resolves with the message ID of the response
-   * @throws Error if the session has been disconnected or the connection fails
-   *
-   * @example
-   * ```typescript
-   * const messageId = await session.send({
-   *   prompt: "Explain this code",
-   *   attachments: [{ type: "file", path: "./src/index.ts" }]
-   * });
-   * ```
-   */
-  async send(options) {
+  async send(optionsOrPrompt) {
+    const options = typeof optionsOrPrompt === "string" ? { prompt: optionsOrPrompt } : optionsOrPrompt;
     const response = await this.connection.sendRequest("session.send", {
       ...await getTraceContext(this.traceContextProvider),
       sessionId: this.sessionId,
@@ -107,30 +99,8 @@ class CopilotSession {
     });
     return response.messageId;
   }
-  /**
-   * Sends a message to this session and waits until the session becomes idle.
-   *
-   * This is a convenience method that combines {@link send} with waiting for
-   * the `session.idle` event. Use this when you want to block until the
-   * assistant has finished processing the message.
-   *
-   * Events are still delivered to handlers registered via {@link on} while waiting.
-   *
-   * @param options - The message options including the prompt and optional attachments
-   * @param timeout - Timeout in milliseconds (default: 60000). Controls how long to wait; does not abort in-flight agent work.
-   * @returns A promise that resolves with the final assistant message when the session becomes idle,
-   *          or undefined if no assistant message was received
-   * @throws Error if the timeout is reached before the session becomes idle
-   * @throws Error if the session has been disconnected or the connection fails
-   *
-   * @example
-   * ```typescript
-   * // Send and wait for completion with default 60s timeout
-   * const response = await session.sendAndWait({ prompt: "What is 2+2?" });
-   * console.log(response?.data.content); // "4"
-   * ```
-   */
-  async sendAndWait(options, timeout) {
+  async sendAndWait(optionsOrPrompt, timeout) {
+    const options = typeof optionsOrPrompt === "string" ? { prompt: optionsOrPrompt } : optionsOrPrompt;
     const effectiveTimeout = timeout ?? 6e4;
     let resolveIdle;
     let rejectWithError;
@@ -400,6 +370,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.
    *
@@ -496,6 +491,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(
@@ -635,33 +648,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.
    *
@@ -694,8 +680,10 @@ class CopilotSession {
     if (!this.hooks) {
       return void 0;
     }
+    const normalized = deserializeHookInput(input);
     const handlerMap = {
       preToolUse: this.hooks.onPreToolUse,
+      preMcpToolCall: this.hooks.onPreMcpToolCall,
       postToolUse: this.hooks.onPostToolUse,
       userPromptSubmitted: this.hooks.onUserPromptSubmitted,
       sessionStart: this.hooks.onSessionStart,
@@ -707,7 +695,7 @@ class CopilotSession {
       return void 0;
     }
     try {
-      const result = await handler(input, { sessionId: this.sessionId });
+      const result = await handler(normalized, { sessionId: this.sessionId });
       return result;
     } catch (_error) {
       return void 0;
@@ -724,7 +712,7 @@ class CopilotSession {
    *
    * @example
    * ```typescript
-   * const events = await session.getMessages();
+   * const events = await session.getEvents();
    * for (const event of events) {
    *   if (event.type === "assistant.message") {
    *     console.log("Assistant:", event.data.content);
@@ -732,7 +720,7 @@ class CopilotSession {
    * }
    * ```
    */
-  async getMessages() {
+  async getEvents() {
     const response = await this.connection.sendRequest("session.getMessages", {
       sessionId: this.sessionId
     });
@@ -772,18 +760,6 @@ class CopilotSession {
     this.exitPlanModeHandler = void 0;
     this.autoModeSwitchHandler = void 0;
   }
-  /**
-   * @deprecated Use {@link disconnect} instead. This method will be removed in a future release.
-   *
-   * Disconnects this session and releases all in-memory resources.
-   * Session data on disk is preserved for later resumption.
-   *
-   * @returns A promise that resolves when the session is disconnected
-   * @throws Error if the connection fails
-   */
-  async destroy() {
-    return this.disconnect();
-  }
   /** Enables `await using session = ...` syntax for automatic cleanup. */
   async [Symbol.asyncDispose]() {
     return this.disconnect();
@@ -869,6 +845,5 @@ function isToolResultObject(value) {
   return allowedResultTypes.includes(value.resultType);
 }
 export {
-  CopilotSession,
-  NO_RESULT_PERMISSION_V2_ERROR
+  CopilotSession
 };