@github/copilot-sdk 1.0.5-preview.0 → 1.0.5

package/dist/generated/rpc.js

@@ -6,8 +6,11 @@ function createServerRpc(connection) {
      * @param params Optional message to echo back to the caller.
      *
      * @returns Server liveness response, including the echoed message, current server timestamp, and protocol version.
+     *
+     * @experimental
      */
     ping: async (params) => connection.sendRequest("ping", params),
+    /** @experimental */
     models: {
       /**
        * Lists Copilot models available to the authenticated user.
@@ -18,6 +21,7 @@ function createServerRpc(connection) {
        */
       list: async (params) => connection.sendRequest("models.list", params)
     },
+    /** @experimental */
     tools: {
       /**
        * Lists built-in tools available for a model.
@@ -28,6 +32,7 @@ function createServerRpc(connection) {
        */
       list: async (params) => connection.sendRequest("tools.list", params)
     },
+    /** @experimental */
     account: {
       /**
        * Gets Copilot quota usage for the authenticated user or supplied GitHub token.
@@ -66,6 +71,7 @@ function createServerRpc(connection) {
        */
       logout: async (params) => connection.sendRequest("account.logout", params)
     },
+    /** @experimental */
     secrets: {
       /**
        * Registers secret values for redaction in session logs and exports. The SDK calls this to inject dynamically generated secret values (e.g., OIDC tokens).
@@ -76,7 +82,9 @@ function createServerRpc(connection) {
        */
       addFilterValues: async (params) => connection.sendRequest("secrets.addFilterValues", params)
     },
+    /** @experimental */
     mcp: {
+      /** @experimental */
       config: {
         /**
          * Lists MCP servers from user configuration.
@@ -218,7 +226,9 @@ function createServerRpc(connection) {
         refresh: async (params) => connection.sendRequest("plugins.marketplaces.refresh", params)
       }
     },
+    /** @experimental */
     skills: {
+      /** @experimental */
       config: {
         /**
          * Replaces the global list of disabled skills.
@@ -241,8 +251,6 @@ function createServerRpc(connection) {
        * @param params Optional project paths to enumerate.
        *
        * @returns Canonical locations where skills can be created so the runtime will recognize them.
-       *
-       * @experimental
        */
       getDiscoveryPaths: async (params) => connection.sendRequest("skills.getDiscoveryPaths", params)
     },
@@ -284,20 +292,38 @@ function createServerRpc(connection) {
        */
       getDiscoveryPaths: async (params) => connection.sendRequest("instructions.getDiscoveryPaths", params)
     },
+    /** @experimental */
     user: {
+      /** @experimental */
       settings: {
         /**
          * Drops this runtime process's in-memory user settings cache so the next settings read observes disk.
          */
-        reload: async () => connection.sendRequest("user.settings.reload", {})
+        reload: async () => connection.sendRequest("user.settings.reload", {}),
+        /**
+         * Lists every known user setting (settings.json overlaid with the legacy config.json, config.json wins), each with its effective value, its default, and whether it is at the default — so settings the user has never set still appear with their default value. Does not include repository- or enterprise-managed overrides that the runtime layers on top at session time.
+         *
+         * @returns Per-key metadata for every known user setting (settings.json overlaid with the legacy config.json, config.json wins), including settings left at their default. Excludes repository- and enterprise-managed overrides.
+         */
+        get: async () => connection.sendRequest("user.settings.get", {}),
+        /**
+         * Writes one or more user settings to settings.json, replacing each provided top-level key. A key whose value is null is removed. Returns the keys whose new value is shadowed by a legacy config.json entry (config.json wins on read), which the runtime leaves in place — such writes do not take effect until the legacy value is removed.
+         *
+         * @param params Partial user settings to write to settings.json. Each top-level key is written individually, replacing the existing value; a key whose value is null is removed.
+         *
+         * @returns Outcome of writing user settings.
+         */
+        set: async (params) => connection.sendRequest("user.settings.set", params)
       }
     },
+    /** @experimental */
     runtime: {
       /**
        * Gracefully shuts down an SDK-owned runtime. The response is sent only after cleanup completes; callers may then terminate the owned runtime process.
        */
       shutdown: async () => connection.sendRequest("runtime.shutdown", {})
     },
+    /** @experimental */
     sessionFs: {
       /**
        * Registers an SDK client as the session filesystem provider.
@@ -537,6 +563,8 @@ function createInternalServerRpc(connection) {
      * @param params Optional connection token presented by the SDK client during the handshake.
      *
      * @returns Handshake result reporting the server's protocol version and package version on success.
+     *
+     * @experimental
      */
     connect: async (params) => connection.sendRequest("connect", params),
     /** @experimental */
@@ -845,6 +873,23 @@ function createSessionRpc(connection, sessionId) {
       diff: async (params) => connection.sendRequest("session.workspaces.diff", { sessionId, ...params })
     },
     /** @experimental */
+    completions: {
+      /**
+       * Gets the characters that should trigger host-driven completions for the session. Empty disables host-driven completions (e.g. local sessions, or a relay host that does not advertise them).
+       *
+       * @returns Characters that, when typed in the composer, should trigger a `completions.request`. Empty when the session has no host-driven completions (e.g. local sessions, or a relay host that does not advertise `completionTriggerCharacters`).
+       */
+      getTriggerCharacters: async () => connection.sendRequest("session.completions.getTriggerCharacters", { sessionId }),
+      /**
+       * Requests host-driven completion items for the current composer input. Returns an empty list when the host has no items or does not support completions.
+       *
+       * @param params Request host-driven completions for the current composer input.
+       *
+       * @returns Host-driven completion items for the current composer input. Empty when the host returns no items or does not support completions.
+       */
+      request: async (params) => connection.sendRequest("session.completions.request", { sessionId, ...params })
+    },
+    /** @experimental */
     instructions: {
       /**
        * Gets instruction sources loaded for the session.
@@ -1401,6 +1446,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns Indicates whether the pending UI request was resolved by this call.
        */
       handlePendingAutoModeSwitch: async (params) => connection.sendRequest("session.ui.handlePendingAutoModeSwitch", { sessionId, ...params }),
+      /**
+       * Resolves a pending `session_limits_exhausted.requested` event with the user's selected limit action.
+       *
+       * @param params Request ID of a pending `session_limits_exhausted.requested` event and the user's selected limit action.
+       *
+       * @returns Indicates whether the pending UI request was resolved by this call.
+       */
+      handlePendingSessionLimitsExhausted: async (params) => connection.sendRequest("session.ui.handlePendingSessionLimitsExhausted", { sessionId, ...params }),
       /**
        * Resolves a pending `exit_plan_mode.requested` event with the user's response.
        *
@@ -1819,6 +1872,23 @@ function createSessionRpc(connection, sessionId) {
       notifySteerableChanged: async (params) => connection.sendRequest("session.remote.notifySteerableChanged", { sessionId, ...params })
     },
     /** @experimental */
+    visibility: {
+      /**
+       * Returns the session's current Mission Control sharing status and shareable GitHub URL. Reflects whether the synced session is visible to repository readers ("repo") or restricted to its creator and collaborators ("unshared").
+       *
+       * @returns Current sharing status and shareable GitHub URL for a session.
+       */
+      get: async () => connection.sendRequest("session.visibility.get", { sessionId }),
+      /**
+       * Sets the session's Mission Control sharing status, controlling whether the synced session is visible to repository readers. Returns the effective status and shareable GitHub URL after the change.
+       *
+       * @param params Desired sharing status for the session.
+       *
+       * @returns Effective sharing status and shareable GitHub URL after updating session visibility.
+       */
+      set: async (params) => connection.sendRequest("session.visibility.set", { sessionId, ...params })
+    },
+    /** @experimental */
     schedule: {
       /**
        * Lists the session's currently active scheduled prompts.
@@ -1988,6 +2058,11 @@ function registerClientGlobalApiHandlers(connection, handlers) {
     if (!handler) throw new Error("No llmInference client-global handler registered");
     return handler.httpRequestChunk(params);
   });
+  connection.onRequest("gitHubTelemetry.event", async (params) => {
+    const handler = handlers.gitHubTelemetry;
+    if (!handler) throw new Error("No gitHubTelemetry client-global handler registered");
+    return handler.event(params);
+  });
 }
 export {
   createInternalServerRpc,

package/dist/generated/session-events.d.ts

@@ -5,7 +5,7 @@
 /**
  * Union of all session event variants emitted by the Copilot CLI runtime.
  */
-export type SessionEvent = StartEvent | ResumeEvent | RemoteSteerableChangedEvent | ErrorEvent | IdleEvent | TitleChangedEvent | ScheduleCreatedEvent | ScheduleCancelledEvent | ScheduleRearmedEvent | AutopilotObjectiveChangedEvent | InfoEvent | WarningEvent | ModelChangeEvent | ModeChangedEvent | PermissionsChangedEvent | PlanChangedEvent | TodosChangedEvent | WorkspaceFileChangedEvent | HandoffEvent | TruncationEvent | SnapshotRewindEvent | ShutdownEvent | ContextChangedEvent | UsageInfoEvent | CompactionStartEvent | CompactionCompleteEvent | TaskCompleteEvent | UserMessageEvent | PendingMessagesModifiedEvent | AssistantTurnStartEvent | AssistantIntentEvent | AssistantReasoningEvent | AssistantReasoningDeltaEvent | AssistantStreamingDeltaEvent | AssistantMessageEvent | AssistantMessageStartEvent | AssistantMessageDeltaEvent | AssistantTurnEndEvent | AssistantIdleEvent | AssistantUsageEvent | ModelCallFailureEvent | AbortEvent | ToolUserRequestedEvent | ToolExecutionStartEvent | ToolExecutionPartialResultEvent | ToolExecutionProgressEvent | ToolExecutionCompleteEvent | SkillInvokedEvent | SubagentStartedEvent | SubagentCompletedEvent | SubagentFailedEvent | SubagentSelectedEvent | SubagentDeselectedEvent | HookStartEvent | HookEndEvent | HookProgressEvent | BinaryAssetEvent | SystemMessageEvent | SystemNotificationEvent | PermissionRequestedEvent | PermissionCompletedEvent | UserInputRequestedEvent | UserInputCompletedEvent | ElicitationRequestedEvent | ElicitationCompletedEvent | SamplingRequestedEvent | SamplingCompletedEvent | McpOauthRequiredEvent | McpOauthCompletedEvent | McpHeadersRefreshRequiredEvent | McpHeadersRefreshCompletedEvent | CustomNotificationEvent | ExternalToolRequestedEvent | ExternalToolCompletedEvent | CommandQueuedEvent | CommandExecuteEvent | CommandCompletedEvent | AutoModeSwitchRequestedEvent | AutoModeSwitchCompletedEvent | CommandsChangedEvent | CapabilitiesChangedEvent | ExitPlanModeRequestedEvent | ExitPlanModeCompletedEvent | ToolsUpdatedEvent | BackgroundTasksChangedEvent | SkillsLoadedEvent | CustomAgentsUpdatedEvent | McpServersLoadedEvent | McpServerStatusChangedEvent | ExtensionsLoadedEvent | CanvasOpenedEvent | CanvasRegistryChangedEvent | CanvasClosedEvent | CanvasUnavailableEvent | CanvasRecordedEvent | CanvasRemovedEvent | ExtensionsAttachmentsPushedEvent | McpAppToolCallCompleteEvent;
+export type SessionEvent = StartEvent | ResumeEvent | RemoteSteerableChangedEvent | ErrorEvent | IdleEvent | TitleChangedEvent | ScheduleCreatedEvent | ScheduleCancelledEvent | ScheduleRearmedEvent | AutopilotObjectiveChangedEvent | InfoEvent | WarningEvent | ModelChangeEvent | ModeChangedEvent | SessionLimitsChangedEvent | PermissionsChangedEvent | PlanChangedEvent | TodosChangedEvent | WorkspaceFileChangedEvent | HandoffEvent | TruncationEvent | SnapshotRewindEvent | ShutdownEvent | UsageCheckpointEvent | ContextChangedEvent | UsageInfoEvent | CompactionStartEvent | CompactionCompleteEvent | TaskCompleteEvent | UserMessageEvent | PendingMessagesModifiedEvent | AssistantTurnStartEvent | AssistantIntentEvent | AssistantReasoningEvent | AssistantReasoningDeltaEvent | AssistantStreamingDeltaEvent | AssistantMessageEvent | AssistantMessageStartEvent | AssistantMessageDeltaEvent | AssistantTurnEndEvent | AssistantIdleEvent | AssistantUsageEvent | ModelCallFailureEvent | AbortEvent | ToolUserRequestedEvent | ToolExecutionStartEvent | ToolExecutionPartialResultEvent | ToolExecutionProgressEvent | ToolExecutionCompleteEvent | SkillInvokedEvent | SubagentStartedEvent | SubagentCompletedEvent | SubagentFailedEvent | SubagentSelectedEvent | SubagentDeselectedEvent | HookStartEvent | HookEndEvent | HookProgressEvent | BinaryAssetEvent | SystemMessageEvent | SystemNotificationEvent | PermissionRequestedEvent | PermissionCompletedEvent | UserInputRequestedEvent | UserInputCompletedEvent | ElicitationRequestedEvent | ElicitationCompletedEvent | SamplingRequestedEvent | SamplingCompletedEvent | McpOauthRequiredEvent | McpOauthCompletedEvent | McpHeadersRefreshRequiredEvent | McpHeadersRefreshCompletedEvent | CustomNotificationEvent | ExternalToolRequestedEvent | ExternalToolCompletedEvent | CommandQueuedEvent | CommandExecuteEvent | CommandCompletedEvent | AutoModeSwitchRequestedEvent | AutoModeSwitchCompletedEvent | SessionLimitsExhaustedRequestedEvent | SessionLimitsExhaustedCompletedEvent | CommandsChangedEvent | CapabilitiesChangedEvent | ExitPlanModeRequestedEvent | ExitPlanModeCompletedEvent | ToolsUpdatedEvent | BackgroundTasksChangedEvent | SkillsLoadedEvent | CustomAgentsUpdatedEvent | McpServersLoadedEvent | McpServerStatusChangedEvent | ExtensionsLoadedEvent | CanvasOpenedEvent | CanvasRegistryChangedEvent | CanvasClosedEvent | CanvasUnavailableEvent | CanvasRecordedEvent | CanvasRemovedEvent | ExtensionsAttachmentsPushedEvent | McpAppToolCallCompleteEvent;
 /**
  * Hosting platform type of the repository (github or ado)
  */
@@ -246,7 +246,7 @@ export type BinaryAssetReferenceType =
 /**
  * A content block within a tool result, which may be text, terminal output, image, audio, or a resource
  */
-export type ToolExecutionCompleteContent = ToolExecutionCompleteContentText | ToolExecutionCompleteContentTerminal | ToolExecutionCompleteContentImage | ToolExecutionCompleteContentAudio | ToolExecutionCompleteContentResourceLink | ToolExecutionCompleteContentResource;
+export type ToolExecutionCompleteContent = ToolExecutionCompleteContentText | ToolExecutionCompleteContentTerminal | ToolExecutionCompleteContentShellExit | ToolExecutionCompleteContentImage | ToolExecutionCompleteContentAudio | ToolExecutionCompleteContentResourceLink | ToolExecutionCompleteContentResource;
 /**
  * Theme variant this icon is intended for
  */
@@ -415,6 +415,18 @@ export type AutoModeSwitchResponse =
  | "yes_always"
 /** Do not switch models. */
  | "no";
+/**
+ * User action selected for an exhausted session limit.
+ */
+export type SessionLimitsExhaustedResponseAction = 
+/** Increase the current max by an exact AI Credits amount. */
+"add"
+/** Set a new absolute max AI Credits value. */
+ | "set"
+/** Remove the current session limit. */
+ | "unset"
+/** Leave the limit unchanged and cancel the blocked model request. */
+ | "cancel";
 /**
  * Exit plan mode action
  */
@@ -573,7 +585,6 @@ export interface StartData {
      * Whether this session supports remote steering via GitHub
      */
     remoteSteerable?: boolean;
-    responseBudget?: ResponseBudgetConfig;
     /**
      * Model selected at session creation time, if any
      */
@@ -582,6 +593,7 @@ export interface StartData {
      * Unique identifier for the session
      */
     sessionId: string;
+    sessionLimits?: SessionLimitsConfig;
     /**
      * ISO 8601 timestamp when the session was created
      */
@@ -626,17 +638,13 @@ export interface WorkingDirectoryContext {
     repositoryHost?: string;
 }
 /**
- * Optional response budget limits.
+ * Optional session limits.
  */
-export interface ResponseBudgetConfig {
+export interface SessionLimitsConfig {
     /**
-     * Maximum AI Credits allowed while responding to one top-level user message.
+     * Maximum AI Credits allowed across the session's current accounting window.
      */
     maxAiCredits?: number;
-    /**
-     * Maximum model-call iterations allowed while responding to one top-level user message.
-     */
-    maxModelIterations?: number;
 }
 /**
  * Session event "session.resume". Session resume metadata including current context and event count
@@ -702,10 +710,6 @@ export interface ResumeData {
      * Whether this session supports remote steering via GitHub
      */
     remoteSteerable?: boolean;
-    /**
-     * Response budget limits currently configured at resume time; null when no budget is active
-     */
-    responseBudget?: ResponseBudgetConfig | null;
     /**
      * ISO 8601 timestamp when the session was resumed
      */
@@ -714,6 +718,10 @@ export interface ResumeData {
      * Model currently selected at resume time
      */
     selectedModel?: string;
+    /**
+     * Session limits currently configured at resume time; null when no limits are active
+     */
+    sessionLimits?: SessionLimitsConfig | null;
     /**
      * True when this resume attached to a session that the runtime already had running in-memory (for example, an extension joining a session another client was actively driving). False (or omitted) for cold resumes — the runtime had to reconstitute the session from its persisted event log.
      */
@@ -1297,6 +1305,45 @@ export interface ModeChangedData {
     newMode: SessionMode;
     previousMode: SessionMode;
 }
+/**
+ * Session event "session.session_limits_changed". Session limits update details. Null clears the limits.
+ */
+export interface SessionLimitsChangedEvent {
+    /**
+     * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events.
+     */
+    agentId?: string;
+    data: SessionLimitsChangedData;
+    /**
+     * When true, the event is transient and not persisted to the session event log on disk
+     */
+    ephemeral?: boolean;
+    /**
+     * Unique event identifier (UUID v4), generated when the event is emitted
+     */
+    id: string;
+    /**
+     * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event.
+     */
+    parentId: string | null;
+    /**
+     * ISO 8601 timestamp when the event was created
+     */
+    timestamp: string;
+    /**
+     * Type discriminator. Always "session.session_limits_changed".
+     */
+    type: "session.session_limits_changed";
+}
+/**
+ * Session limits update details. Null clears the limits.
+ */
+export interface SessionLimitsChangedData {
+    /**
+     * Current session limits, or null when no limits are active
+     */
+    sessionLimits: SessionLimitsConfig | null;
+}
 /**
  * Session event "session.permissions_changed". Permissions change details carrying the aggregate allow-all boolean transition.
  */
@@ -1822,6 +1869,45 @@ export interface ShutdownTokenDetail {
      */
     tokenCount: number;
 }
+/**
+ * Session event "session.usage_checkpoint". Durable session usage checkpoint for reconstructing aggregate accounting on resume
+ */
+export interface UsageCheckpointEvent {
+    /**
+     * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events.
+     */
+    agentId?: string;
+    data: UsageCheckpointData;
+    /**
+     * When true, the event is transient and not persisted to the session event log on disk
+     */
+    ephemeral?: boolean;
+    /**
+     * Unique event identifier (UUID v4), generated when the event is emitted
+     */
+    id: string;
+    /**
+     * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event.
+     */
+    parentId: string | null;
+    /**
+     * ISO 8601 timestamp when the event was created
+     */
+    timestamp: string;
+    /**
+     * Type discriminator. Always "session.usage_checkpoint".
+     */
+    type: "session.usage_checkpoint";
+}
+/**
+ * Durable session usage checkpoint for reconstructing aggregate accounting on resume
+ */
+export interface UsageCheckpointData {
+    /**
+     * Session-wide accumulated nano-AI units cost at checkpoint time
+     */
+    totalNanoAiu: number;
+}
 /**
  * Session event "session.context_changed". Updated working directory and git context after the change
  */
@@ -2999,6 +3085,10 @@ export interface AssistantMessageData {
      * Readable reasoning text from the model's extended thinking
      */
     reasoningText?: string;
+    /**
+     * OpenAI-compatible wire field the provider used for reasoning (e.g. reasoning_content/reasoning). Populated only when non-canonical, so the dialect round-trips across turns.
+     */
+    reasoningWireField?: string;
     /**
      * GitHub request tracing ID (x-github-request-id header) for correlating with server-side logs
      */
@@ -4156,7 +4246,8 @@ export interface ToolExecutionCompleteContentText {
     type: "text";
 }
 /**
- * Terminal/shell output content block with optional exit code and working directory
+ * @deprecated
+ * Deprecated for shell command exit metadata. Use ToolExecutionCompleteContentShellExit instead.
  */
 export interface ToolExecutionCompleteContentTerminal {
     /**
@@ -4176,6 +4267,35 @@ export interface ToolExecutionCompleteContentTerminal {
      */
     type: "terminal";
 }
+/**
+ * Shell command exit metadata with optional output preview
+ */
+export interface ToolExecutionCompleteContentShellExit {
+    /**
+     * Working directory where the shell command was executed
+     */
+    cwd?: string;
+    /**
+     * Exit code from the completed shell command
+     */
+    exitCode: number;
+    /**
+     * Output associated with this shell command, if available. May be partial, truncated, or a preview; not guaranteed to be full output.
+     */
+    outputPreview?: string;
+    /**
+     * Whether outputPreview is known to be incomplete or truncated
+     */
+    outputTruncated?: boolean;
+    /**
+     * Shell id, as assigned by Copilot runtime
+     */
+    shellId: string;
+    /**
+     * Content block type discriminator
+     */
+    type: "shell_exit";
+}
 /**
  * Image content block with base64-encoded data
  */
@@ -5382,6 +5502,14 @@ export interface PermissionRequestRead {
      * Path of the file or directory being read
      */
     path: string;
+    /**
+     * True when the model has requested to run this search outside the sandbox (it set requestSandboxBypass: true and the host opted in via sandbox.allowBypass). This is a request, not a grant: the search runs unsandboxed only if the user approves this permission request. Hosts should highlight the elevated risk in the approval UI.
+     */
+    requestSandboxBypass?: boolean;
+    /**
+     * Model-provided justification for the sandbox-bypass request. Only meaningful when requestSandboxBypass is true.
+     */
+    requestSandboxBypassReason?: string;
     /**
      * Tool call ID that triggered this permission request
      */
@@ -7053,6 +7181,107 @@ export interface AutoModeSwitchCompletedData {
     requestId: string;
     response: AutoModeSwitchResponse;
 }
+/**
+ * Session event "session_limits_exhausted.requested". Session limit exhaustion notification requiring user action.
+ */
+export interface SessionLimitsExhaustedRequestedEvent {
+    /**
+     * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events.
+     */
+    agentId?: string;
+    data: SessionLimitsExhaustedRequestedData;
+    /**
+     * Always true for events that are transient and not persisted to the session event log on disk.
+     */
+    ephemeral: true;
+    /**
+     * Unique event identifier (UUID v4), generated when the event is emitted
+     */
+    id: string;
+    /**
+     * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event.
+     */
+    parentId: string | null;
+    /**
+     * ISO 8601 timestamp when the event was created
+     */
+    timestamp: string;
+    /**
+     * Type discriminator. Always "session_limits_exhausted.requested".
+     */
+    type: "session_limits_exhausted.requested";
+}
+/**
+ * Session limit exhaustion notification requiring user action.
+ */
+export interface SessionLimitsExhaustedRequestedData {
+    /**
+     * Configured max AI Credits for the current accounting window.
+     */
+    maxAiCredits: number;
+    /**
+     * Unique identifier for this request; used to respond via session.ui.handlePendingSessionLimitsExhausted().
+     */
+    requestId: string;
+    /**
+     * AI Credits already consumed in the current accounting window.
+     */
+    usedAiCredits: number;
+}
+/**
+ * Session event "session_limits_exhausted.completed". Session limit exhaustion prompt completion notification.
+ */
+export interface SessionLimitsExhaustedCompletedEvent {
+    /**
+     * Sub-agent instance identifier. Absent for events from the root/main agent and session-level events.
+     */
+    agentId?: string;
+    data: SessionLimitsExhaustedCompletedData;
+    /**
+     * Always true for events that are transient and not persisted to the session event log on disk.
+     */
+    ephemeral: true;
+    /**
+     * Unique event identifier (UUID v4), generated when the event is emitted
+     */
+    id: string;
+    /**
+     * ID of the chronologically preceding event in the session, forming a linked chain. Null for the first event.
+     */
+    parentId: string | null;
+    /**
+     * ISO 8601 timestamp when the event was created
+     */
+    timestamp: string;
+    /**
+     * Type discriminator. Always "session_limits_exhausted.completed".
+     */
+    type: "session_limits_exhausted.completed";
+}
+/**
+ * Session limit exhaustion prompt completion notification.
+ */
+export interface SessionLimitsExhaustedCompletedData {
+    /**
+     * Request ID of the resolved request; clients should dismiss any UI for this request.
+     */
+    requestId: string;
+    response: SessionLimitsExhaustedResponse;
+}
+/**
+ * The user's selected action for an exhausted session limit.
+ */
+export interface SessionLimitsExhaustedResponse {
+    action: SessionLimitsExhaustedResponseAction;
+    /**
+     * AI Credits to add to the current max when action is 'add'.
+     */
+    additionalAiCredits?: number;
+    /**
+     * New absolute max AI Credits when action is 'set'.
+     */
+    maxAiCredits?: number;
+}
 /**
  * Session event "commands.changed". SDK command registration change notification
  */

package/dist/session.d.ts

@@ -41,6 +41,7 @@ export declare class CopilotSession {
     private bearerTokenProviders;
     private commandHandlers;
     private permissionHandler?;
+    private mcpAuthHandler?;
     private userInputHandler?;
     private elicitationHandler?;
     private exitPlanModeHandler?;

package/dist/session.js

@@ -27,11 +27,12 @@ class CopilotSession {
    * @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, connection, _workspacePath, traceContextProvider) {
+  constructor(sessionId, connection, _workspacePath, traceContextProvider, options) {
     this.sessionId = sessionId;
     this.connection = connection;
     this._workspacePath = _workspacePath;
     this.traceContextProvider = traceContextProvider;
+    this.mcpAuthHandler = options?.mcpAuthHandler;
   }
   sessionId;
   connection;
@@ -43,6 +44,7 @@ class CopilotSession {
   bearerTokenProviders = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
   permissionHandler;
+  mcpAuthHandler;
   userInputHandler;
   elicitationHandler;
   exitPlanModeHandler;
@@ -254,6 +256,18 @@ class CopilotSession {
       if (this.permissionHandler) {
         void this._executePermissionAndRespond(requestId, permissionRequest);
       }
+    } else if (event.type === "mcp.oauth_required") {
+      const data = event.data;
+      if (!data?.requestId) {
+        return;
+      }
+      if (!this.mcpAuthHandler) {
+        console.warn(
+          `Received MCP OAuth request without a registered MCP auth handler. SessionId=${this.sessionId}, RequestId=${data.requestId}`
+        );
+        return;
+      }
+      void this._executeMcpAuthAndRespond(data);
     } else if (event.type === "command.execute") {
       const { requestId, commandName, command, args } = event.data;
       void this._executeCommandAndRespond(requestId, commandName, command, args);
@@ -385,6 +399,31 @@ class CopilotSession {
       }
     }
   }
+  /**
+   * Executes an MCP auth handler and sends the result back via RPC.
+   * @internal
+   */
+  async _executeMcpAuthAndRespond(request) {
+    try {
+      const result = await this.mcpAuthHandler(request, { sessionId: this.sessionId });
+      const response = result && "accessToken" in result ? { kind: "token", ...result } : { kind: "cancelled" };
+      await this.rpc.mcp.oauth.handlePendingRequest({
+        requestId: request.requestId,
+        result: response
+      });
+    } catch (_error) {
+      try {
+        await this.rpc.mcp.oauth.handlePendingRequest({
+          requestId: request.requestId,
+          result: { kind: "cancelled" }
+        });
+      } catch (rpcError) {
+        if (!(rpcError instanceof ConnectionError || rpcError instanceof ResponseError)) {
+          throw rpcError;
+        }
+      }
+    }
+  }
   /**
    * Executes a command handler and sends the result back via RPC.
    * @internal