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

package/dist/generated/rpc.d.ts

@@ -3,6 +3,13 @@
  * Generated from: api.schema.json
  */
 import type { MessageConnection } from "vscode-jsonrpc/node.js";
+/**
+ * Authentication type
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "AuthInfoType".
+ */
+export type AuthInfoType = "hmac" | "env" | "user" | "gh-cli" | "api-key" | "token" | "copilot-api-token";
 /**
  * Server transport type: stdio, http, sse, or memory (local configs are normalized to stdio)
  *
@@ -93,7 +100,21 @@ export type McpServerSource = "user" | "workspace" | "plugin" | "builtin";
  * via the `definition` "SessionMode".
  */
 export type SessionMode = "interactive" | "plan" | "autopilot";
-export type PermissionDecision = PermissionDecisionApproved | PermissionDecisionDeniedByRules | PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser | PermissionDecisionDeniedInteractivelyByUser | PermissionDecisionDeniedByContentExclusionPolicy | PermissionDecisionDeniedByPermissionRequestHook;
+export type PermissionDecision = PermissionDecisionApproveOnce | PermissionDecisionApproveForSession | PermissionDecisionApproveForLocation | PermissionDecisionReject | PermissionDecisionUserNotAvailable;
+/**
+ * The approval to add as a session-scoped rule
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "PermissionDecisionApproveForSessionApproval".
+ */
+export type PermissionDecisionApproveForSessionApproval = PermissionDecisionApproveForSessionApprovalCommands | PermissionDecisionApproveForSessionApprovalRead | PermissionDecisionApproveForSessionApprovalWrite | PermissionDecisionApproveForSessionApprovalMcp | PermissionDecisionApproveForSessionApprovalMcpSampling | PermissionDecisionApproveForSessionApprovalMemory | PermissionDecisionApproveForSessionApprovalCustomTool;
+/**
+ * The approval to persist for this location
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "PermissionDecisionApproveForLocationApproval".
+ */
+export type PermissionDecisionApproveForLocationApproval = PermissionDecisionApproveForLocationApprovalCommands | PermissionDecisionApproveForLocationApprovalRead | PermissionDecisionApproveForLocationApprovalWrite | PermissionDecisionApproveForLocationApprovalMcp | PermissionDecisionApproveForLocationApprovalMcpSampling | PermissionDecisionApproveForLocationApprovalMemory | PermissionDecisionApproveForLocationApprovalCustomTool;
 /**
  * Error classification
  *
@@ -140,6 +161,12 @@ export type UIElicitationSchemaPropertyNumberType = "number" | "integer";
  * via the `definition` "UIElicitationResponseAction".
  */
 export type UIElicitationResponseAction = "accept" | "decline" | "cancel";
+export interface AccountGetQuotaRequest {
+    /**
+     * GitHub token for per-user quota lookup. When provided, resolves this token to determine the user's quota instead of using the global auth.
+     */
+    gitHubToken?: string;
+}
 export interface AccountGetQuotaResult {
     /**
      * Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)
@@ -481,6 +508,18 @@ export interface McpServerConfigHttp {
     oauthClientId?: string;
     oauthPublicClient?: boolean;
 }
+export interface McpConfigDisableRequest {
+    /**
+     * Names of MCP servers to disable. Each server is added to the persisted disabled list so new sessions skip it. Already-disabled names are ignored. Active sessions keep their current connections until they end.
+     */
+    names: string[];
+}
+export interface McpConfigEnableRequest {
+    /**
+     * Names of MCP servers to enable. Each server is removed from the persisted disabled list so new sessions spawn it. Unknown or already-enabled names are ignored.
+     */
+    names: string[];
+}
 export interface McpConfigList {
     /**
      * All MCP servers from user config, keyed by name
@@ -528,6 +567,32 @@ export interface McpEnableRequest {
      */
     serverName: string;
 }
+/** @experimental */
+export interface McpOauthLoginRequest {
+    /**
+     * Name of the remote MCP server to authenticate
+     */
+    serverName: string;
+    /**
+     * When true, clears any cached OAuth token for the server and runs a full new authorization. Use when the user explicitly wants to switch accounts or believes their session is stuck.
+     */
+    forceReauth?: boolean;
+    /**
+     * Optional override for the OAuth client display name shown on the consent screen. Applies to newly registered dynamic clients only — existing registrations keep the name they were created with. When omitted, the runtime applies a neutral fallback; callers driving interactive auth should pass their own surface-specific label so the consent screen matches the product the user sees.
+     */
+    clientName?: string;
+    /**
+     * Optional override for the body text shown on the OAuth loopback callback success page. When omitted, the runtime applies a neutral fallback; callers driving interactive auth should pass surface-specific copy telling the user where to return.
+     */
+    callbackSuccessMessage?: string;
+}
+/** @experimental */
+export interface McpOauthLoginResult {
+    /**
+     * URL the caller should open in a browser to complete OAuth. Omitted when cached tokens were still valid and no browser interaction was needed — the server is already reconnected in that case. When present, the runtime starts the callback listener before returning and continues the flow in the background; completion is signaled via session.mcp_server_status_changed.
+     */
+    authorizationUrl?: string;
+}
 export interface McpServer {
     /**
      * Server name (config key)
@@ -649,7 +714,7 @@ export interface ModelPolicy {
     /**
      * Usage terms or conditions for this model
      */
-    terms: string;
+    terms?: string;
 }
 /**
  * Billing information
@@ -718,6 +783,12 @@ export interface ModelList {
      */
     models: Model[];
 }
+export interface ModelsListRequest {
+    /**
+     * GitHub token for per-user model listing. When provided, resolves this token to determine the user's Copilot plan and available models instead of using the global auth.
+     */
+    gitHubToken?: string;
+}
 export interface ModelSwitchToRequest {
     /**
      * Model identifier to switch to
@@ -750,76 +821,128 @@ export interface NameSetRequest {
      */
     name: string;
 }
-export interface PermissionDecisionApproved {
+export interface PermissionDecisionApproveOnce {
     /**
-     * The permission request was approved
+     * The permission request was approved for this one instance
      */
-    kind: "approved";
+    kind: "approve-once";
 }
-export interface PermissionDecisionDeniedByRules {
+export interface PermissionDecisionApproveForSession {
     /**
-     * Denied because approval rules explicitly blocked it
+     * Approved and remembered for the rest of the session
      */
-    kind: "denied-by-rules";
+    kind: "approve-for-session";
+    approval: PermissionDecisionApproveForSessionApproval;
+}
+export interface PermissionDecisionApproveForSessionApprovalCommands {
+    kind: "commands";
+    commandIdentifiers: string[];
+}
+export interface PermissionDecisionApproveForSessionApprovalRead {
+    kind: "read";
+}
+export interface PermissionDecisionApproveForSessionApprovalWrite {
+    kind: "write";
+}
+export interface PermissionDecisionApproveForSessionApprovalMcp {
+    kind: "mcp";
+    serverName: string;
+    toolName: string | null;
+}
+export interface PermissionDecisionApproveForSessionApprovalMcpSampling {
+    kind: "mcp-sampling";
+    serverName: string;
+}
+export interface PermissionDecisionApproveForSessionApprovalMemory {
+    kind: "memory";
+}
+export interface PermissionDecisionApproveForSessionApprovalCustomTool {
+    kind: "custom-tool";
+    toolName: string;
+}
+export interface PermissionDecisionApproveForLocation {
     /**
-     * Rules that denied the request
+     * Approved and persisted for this project location
      */
-    rules: unknown[];
-}
-export interface PermissionDecisionDeniedNoApprovalRuleAndCouldNotRequestFromUser {
+    kind: "approve-for-location";
+    approval: PermissionDecisionApproveForLocationApproval;
     /**
-     * Denied because no approval rule matched and user confirmation was unavailable
+     * The location key (git root or cwd) to persist the approval to
      */
-    kind: "denied-no-approval-rule-and-could-not-request-from-user";
+    locationKey: string;
+}
+export interface PermissionDecisionApproveForLocationApprovalCommands {
+    kind: "commands";
+    commandIdentifiers: string[];
+}
+export interface PermissionDecisionApproveForLocationApprovalRead {
+    kind: "read";
+}
+export interface PermissionDecisionApproveForLocationApprovalWrite {
+    kind: "write";
+}
+export interface PermissionDecisionApproveForLocationApprovalMcp {
+    kind: "mcp";
+    serverName: string;
+    toolName: string | null;
 }
-export interface PermissionDecisionDeniedInteractivelyByUser {
+export interface PermissionDecisionApproveForLocationApprovalMcpSampling {
+    kind: "mcp-sampling";
+    serverName: string;
+}
+export interface PermissionDecisionApproveForLocationApprovalMemory {
+    kind: "memory";
+}
+export interface PermissionDecisionApproveForLocationApprovalCustomTool {
+    kind: "custom-tool";
+    toolName: string;
+}
+export interface PermissionDecisionReject {
     /**
      * Denied by the user during an interactive prompt
      */
-    kind: "denied-interactively-by-user";
+    kind: "reject";
     /**
      * Optional feedback from the user explaining the denial
      */
     feedback?: string;
 }
-export interface PermissionDecisionDeniedByContentExclusionPolicy {
-    /**
-     * Denied by the organization's content exclusion policy
-     */
-    kind: "denied-by-content-exclusion-policy";
+export interface PermissionDecisionUserNotAvailable {
     /**
-     * File path that triggered the exclusion
+     * Denied because user confirmation was unavailable
      */
-    path: string;
-    /**
-     * Human-readable explanation of why the path was excluded
-     */
-    message: string;
+    kind: "user-not-available";
 }
-export interface PermissionDecisionDeniedByPermissionRequestHook {
+export interface PermissionDecisionRequest {
     /**
-     * Denied by a permission request hook registered by an extension or plugin
+     * Request ID of the pending permission request
      */
-    kind: "denied-by-permission-request-hook";
+    requestId: string;
+    result: PermissionDecision;
+}
+export interface PermissionRequestResult {
     /**
-     * Optional message from the hook explaining the denial
+     * Whether the permission request was handled successfully
      */
-    message?: string;
+    success: boolean;
+}
+export interface PermissionsResetSessionApprovalsRequest {
+}
+export interface PermissionsResetSessionApprovalsResult {
     /**
-     * Whether to interrupt the current agent turn
+     * Whether the operation succeeded
      */
-    interrupt?: boolean;
+    success: boolean;
 }
-export interface PermissionDecisionRequest {
+export interface PermissionsSetApproveAllRequest {
     /**
-     * Request ID of the pending permission request
+     * Whether to auto-approve all tool permission requests
      */
-    requestId: string;
-    result: PermissionDecision;
+    enabled: boolean;
 }
-export interface PermissionRequestResult {
+export interface PermissionsSetApproveAllResult {
     /**
-     * Whether the permission request was handled successfully
+     * Whether the operation succeeded
      */
     success: boolean;
 }
@@ -924,6 +1047,29 @@ export interface ServerSkillList {
      */
     skills: ServerSkill[];
 }
+export interface SessionAuthStatus {
+    /**
+     * Whether the session has resolved authentication
+     */
+    isAuthenticated: boolean;
+    authType?: AuthInfoType;
+    /**
+     * Authentication host URL
+     */
+    host?: string;
+    /**
+     * Authenticated login/username, if available
+     */
+    login?: string;
+    /**
+     * Human-readable authentication status description
+     */
+    statusMessage?: string;
+    /**
+     * Copilot plan tier (e.g., individual_pro, business)
+     */
+    copilotPlan?: string;
+}
 export interface SessionFsAppendFileRequest {
     /**
      * Target session identifier
@@ -1622,13 +1768,13 @@ export interface WorkspacesReadFileResult {
 export declare function createServerRpc(connection: MessageConnection): {
     ping: (params: PingRequest) => Promise<PingResult>;
     models: {
-        list: () => Promise<ModelList>;
+        list: (params?: ModelsListRequest) => Promise<ModelList>;
     };
     tools: {
         list: (params: ToolsListRequest) => Promise<ToolList>;
     };
     account: {
-        getQuota: () => Promise<AccountGetQuotaResult>;
+        getQuota: (params?: AccountGetQuotaRequest) => Promise<AccountGetQuotaResult>;
     };
     mcp: {
         config: {
@@ -1636,6 +1782,8 @@ export declare function createServerRpc(connection: MessageConnection): {
             add: (params: McpConfigAddRequest) => Promise<void>;
             update: (params: McpConfigUpdateRequest) => Promise<void>;
             remove: (params: McpConfigRemoveRequest) => Promise<void>;
+            enable: (params: McpConfigEnableRequest) => Promise<void>;
+            disable: (params: McpConfigDisableRequest) => Promise<void>;
         };
         discover: (params: McpDiscoverRequest) => Promise<McpDiscoverResult>;
     };
@@ -1655,57 +1803,64 @@ export declare function createServerRpc(connection: MessageConnection): {
 };
 /** Create typed session-scoped RPC methods. */
 export declare function createSessionRpc(connection: MessageConnection, sessionId: string): {
+    auth: {
+        getStatus: () => Promise<SessionAuthStatus>;
+    };
     model: {
         getCurrent: () => Promise<CurrentModel>;
-        switchTo: (params: Omit<ModelSwitchToRequest, "sessionId">) => Promise<ModelSwitchToResult>;
+        switchTo: (params: ModelSwitchToRequest) => Promise<ModelSwitchToResult>;
     };
     mode: {
         get: () => Promise<SessionMode>;
-        set: (params: Omit<ModeSetRequest, "sessionId">) => Promise<void>;
+        set: (params: ModeSetRequest) => Promise<void>;
     };
     name: {
         get: () => Promise<NameGetResult>;
-        set: (params: Omit<NameSetRequest, "sessionId">) => Promise<void>;
+        set: (params: NameSetRequest) => Promise<void>;
     };
     plan: {
         read: () => Promise<PlanReadResult>;
-        update: (params: Omit<PlanUpdateRequest, "sessionId">) => Promise<void>;
+        update: (params: PlanUpdateRequest) => Promise<void>;
         delete: () => Promise<void>;
     };
     workspaces: {
         getWorkspace: () => Promise<WorkspacesGetWorkspaceResult>;
         listFiles: () => Promise<WorkspacesListFilesResult>;
-        readFile: (params: Omit<WorkspacesReadFileRequest, "sessionId">) => Promise<WorkspacesReadFileResult>;
-        createFile: (params: Omit<WorkspacesCreateFileRequest, "sessionId">) => Promise<void>;
+        readFile: (params: WorkspacesReadFileRequest) => Promise<WorkspacesReadFileResult>;
+        createFile: (params: WorkspacesCreateFileRequest) => Promise<void>;
     };
     instructions: {
         getSources: () => Promise<InstructionsGetSourcesResult>;
     };
     /** @experimental */
     fleet: {
-        start: (params: Omit<FleetStartRequest, "sessionId">) => Promise<FleetStartResult>;
+        start: (params: FleetStartRequest) => Promise<FleetStartResult>;
     };
     /** @experimental */
     agent: {
         list: () => Promise<AgentList>;
         getCurrent: () => Promise<AgentGetCurrentResult>;
-        select: (params: Omit<AgentSelectRequest, "sessionId">) => Promise<AgentSelectResult>;
+        select: (params: AgentSelectRequest) => Promise<AgentSelectResult>;
         deselect: () => Promise<void>;
         reload: () => Promise<AgentReloadResult>;
     };
     /** @experimental */
     skills: {
         list: () => Promise<SkillList>;
-        enable: (params: Omit<SkillsEnableRequest, "sessionId">) => Promise<void>;
-        disable: (params: Omit<SkillsDisableRequest, "sessionId">) => Promise<void>;
+        enable: (params: SkillsEnableRequest) => Promise<void>;
+        disable: (params: SkillsDisableRequest) => Promise<void>;
         reload: () => Promise<void>;
     };
     /** @experimental */
     mcp: {
         list: () => Promise<McpServerList>;
-        enable: (params: Omit<McpEnableRequest, "sessionId">) => Promise<void>;
-        disable: (params: Omit<McpDisableRequest, "sessionId">) => Promise<void>;
+        enable: (params: McpEnableRequest) => Promise<void>;
+        disable: (params: McpDisableRequest) => Promise<void>;
         reload: () => Promise<void>;
+        /** @experimental */
+        oauth: {
+            login: (params: McpOauthLoginRequest) => Promise<McpOauthLoginResult>;
+        };
     };
     /** @experimental */
     plugins: {
@@ -1714,32 +1869,34 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
     /** @experimental */
     extensions: {
         list: () => Promise<ExtensionList>;
-        enable: (params: Omit<ExtensionsEnableRequest, "sessionId">) => Promise<void>;
-        disable: (params: Omit<ExtensionsDisableRequest, "sessionId">) => Promise<void>;
+        enable: (params: ExtensionsEnableRequest) => Promise<void>;
+        disable: (params: ExtensionsDisableRequest) => Promise<void>;
         reload: () => Promise<void>;
     };
     tools: {
-        handlePendingToolCall: (params: Omit<ToolsHandlePendingToolCallRequest, "sessionId">) => Promise<HandleToolCallResult>;
+        handlePendingToolCall: (params: ToolsHandlePendingToolCallRequest) => Promise<HandleToolCallResult>;
     };
     commands: {
-        handlePendingCommand: (params: Omit<CommandsHandlePendingCommandRequest, "sessionId">) => Promise<CommandsHandlePendingCommandResult>;
+        handlePendingCommand: (params: CommandsHandlePendingCommandRequest) => Promise<CommandsHandlePendingCommandResult>;
     };
     ui: {
-        elicitation: (params: Omit<UIElicitationRequest, "sessionId">) => Promise<UIElicitationResponse>;
-        handlePendingElicitation: (params: Omit<UIHandlePendingElicitationRequest, "sessionId">) => Promise<UIElicitationResult>;
+        elicitation: (params: UIElicitationRequest) => Promise<UIElicitationResponse>;
+        handlePendingElicitation: (params: UIHandlePendingElicitationRequest) => Promise<UIElicitationResult>;
     };
     permissions: {
-        handlePendingPermissionRequest: (params: Omit<PermissionDecisionRequest, "sessionId">) => Promise<PermissionRequestResult>;
+        handlePendingPermissionRequest: (params: PermissionDecisionRequest) => Promise<PermissionRequestResult>;
+        setApproveAll: (params: PermissionsSetApproveAllRequest) => Promise<PermissionsSetApproveAllResult>;
+        resetSessionApprovals: () => Promise<PermissionsResetSessionApprovalsResult>;
     };
-    log: (params: Omit<LogRequest, "sessionId">) => Promise<LogResult>;
+    log: (params: LogRequest) => Promise<LogResult>;
     shell: {
-        exec: (params: Omit<ShellExecRequest, "sessionId">) => Promise<ShellExecResult>;
-        kill: (params: Omit<ShellKillRequest, "sessionId">) => Promise<ShellKillResult>;
+        exec: (params: ShellExecRequest) => Promise<ShellExecResult>;
+        kill: (params: ShellKillRequest) => Promise<ShellKillResult>;
     };
     /** @experimental */
     history: {
         compact: () => Promise<HistoryCompactResult>;
-        truncate: (params: Omit<HistoryTruncateRequest, "sessionId">) => Promise<HistoryTruncateResult>;
+        truncate: (params: HistoryTruncateRequest) => Promise<HistoryTruncateResult>;
     };
     /** @experimental */
     usage: {

package/dist/generated/rpc.js

@@ -2,20 +2,22 @@ function createServerRpc(connection) {
   return {
     ping: async (params) => connection.sendRequest("ping", params),
     models: {
-      list: async () => connection.sendRequest("models.list", {})
+      list: async (params) => connection.sendRequest("models.list", params)
     },
     tools: {
       list: async (params) => connection.sendRequest("tools.list", params)
     },
     account: {
-      getQuota: async () => connection.sendRequest("account.getQuota", {})
+      getQuota: async (params) => connection.sendRequest("account.getQuota", params)
     },
     mcp: {
       config: {
         list: async () => connection.sendRequest("mcp.config.list", {}),
         add: async (params) => connection.sendRequest("mcp.config.add", params),
         update: async (params) => connection.sendRequest("mcp.config.update", params),
-        remove: async (params) => connection.sendRequest("mcp.config.remove", params)
+        remove: async (params) => connection.sendRequest("mcp.config.remove", params),
+        enable: async (params) => connection.sendRequest("mcp.config.enable", params),
+        disable: async (params) => connection.sendRequest("mcp.config.disable", params)
       },
       discover: async (params) => connection.sendRequest("mcp.discover", params)
     },
@@ -36,6 +38,9 @@ function createServerRpc(connection) {
 }
 function createSessionRpc(connection, sessionId) {
   return {
+    auth: {
+      getStatus: async () => connection.sendRequest("session.auth.getStatus", { sessionId })
+    },
     model: {
       getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
       switchTo: async (params) => connection.sendRequest("session.model.switchTo", { sessionId, ...params })
@@ -86,7 +91,11 @@ function createSessionRpc(connection, sessionId) {
       list: async () => connection.sendRequest("session.mcp.list", { sessionId }),
       enable: async (params) => connection.sendRequest("session.mcp.enable", { sessionId, ...params }),
       disable: async (params) => connection.sendRequest("session.mcp.disable", { sessionId, ...params }),
-      reload: async () => connection.sendRequest("session.mcp.reload", { sessionId })
+      reload: async () => connection.sendRequest("session.mcp.reload", { sessionId }),
+      /** @experimental */
+      oauth: {
+        login: async (params) => connection.sendRequest("session.mcp.oauth.login", { sessionId, ...params })
+      }
     },
     /** @experimental */
     plugins: {
@@ -110,7 +119,9 @@ function createSessionRpc(connection, sessionId) {
       handlePendingElicitation: async (params) => connection.sendRequest("session.ui.handlePendingElicitation", { sessionId, ...params })
     },
     permissions: {
-      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params })
+      handlePendingPermissionRequest: async (params) => connection.sendRequest("session.permissions.handlePendingPermissionRequest", { sessionId, ...params }),
+      setApproveAll: async (params) => connection.sendRequest("session.permissions.setApproveAll", { sessionId, ...params }),
+      resetSessionApprovals: async () => connection.sendRequest("session.permissions.resetSessionApprovals", { sessionId })
     },
     log: async (params) => connection.sendRequest("session.log", { sessionId, ...params }),
     shell: {