@github/copilot-sdk 1.0.28 → 1.0.29-preview.1

package/dist/cjs/generated/rpc.js

@@ -268,7 +268,7 @@ function createServerRpc(connection) {
       /**
        * Lists Copilot models available to the authenticated user.
        *
-       * @param params Optional opaque account selection or compatibility GitHub token used to list models.
+       * @param params Optional opaque account selection, compatibility GitHub token, or streamer-mode masking used to list models.
        *
        * @returns List of Copilot models available to the resolved user, including capabilities and billing metadata.
        */
@@ -282,7 +282,7 @@ function createServerRpc(connection) {
       /**
        * Reports the unit of each model's published token prices: AI Credits or nano-AIU. Pair these units with models.list prices by model ID and use identical account-selection options for both calls. When options are omitted, the current account and its model providers are used.
        *
-       * @param params Optional opaque account selection or compatibility GitHub token used to list models.
+       * @param params Optional opaque account selection, compatibility GitHub token, or streamer-mode masking used to list models.
        *
        * @returns Price units for every catalog model that publishes token prices.
        */
@@ -949,6 +949,15 @@ function createServerRpc(connection) {
       httpResponseChunk: async (params) => connection.sendRequest("llmInference.httpResponseChunk", params)
     },
     /** @experimental */
+    kerberosAuth: {
+      /**
+       * Registers the calling SDK client's Kerberos callback. The callback authenticates requests made for the client's sessions and, with `runtime` scope, the runtime's shared background traffic; only one connection may hold `runtime` scope. The registration ends when the connection closes.
+       *
+       * @param params Registers the calling SDK connection's Kerberos credential provider.
+       */
+      setProvider: async (params) => connection.sendRequest("kerberosAuth.setProvider", params)
+    },
+    /** @experimental */
     sessions: {
       /**
        * Creates or resumes a local session and returns the opened session ID.
@@ -1297,6 +1306,14 @@ function createInternalServerRpc(connection) {
        * @returns The startup warning, absent when the machine can run a sandbox.
        */
       getUnsupportedStartupNotice: async (params) => connection.sendRequest("sandbox.getUnsupportedStartupNotice", params),
+      /**
+       * The warning to show before a user adds a sandbox path grant, when the sandbox backend cannot honor it. On Windows a read/write grant on a drive root such as `C:\` or `V:\` is accepted but gives no access to the files inside it, so the warning steers the user to a specific folder. A read-only grant on a drive root works and gets no warning. The grant is still stored as written: this only advises. Returns no warning on other platforms and for paths that are not a drive root, so a host can call it unconditionally while the user types. A host must ask rather than test the path itself, because which volume shapes the backend honors is a property of the backend, and a host-side check goes stale when it changes.
+       *
+       * @param params The path a user is about to grant.
+       *
+       * @returns Advice for a path grant, when it needs any.
+       */
+      getPathGrantWarning: async (params) => connection.sendRequest("sandbox.getPathGrantWarning", params),
       /**
        * Whether one slash command stays reachable while sandbox enforcement is unavailable and the session is otherwise blocked. The permitted set is deliberately narrow — commands that only report state, and the few that let the user repair or leave the situation — and it is keyed on the arguments as well as the name, so `/sandbox status` is admitted where `/sandbox enable` is not. A host must ask rather than keep its own list: a command this returns false for is one the runtime would refuse anyway, and a divergent list either strands the user with no way out or admits a command that acts on an unenforced session.
        *
@@ -1752,6 +1769,16 @@ function createInternalServerRpc(connection) {
      */
     connect: async (params) => connection.sendRequest("connect", params),
     /** @experimental */
+    tools: {
+      /** @experimental */
+      largeOutput: {
+        /**
+         * Removes expired tool output files using the runtime's retention policy. Refuses extension callers.
+         */
+        cleanup: async () => connection.sendRequest("tools.largeOutput.cleanup", {})
+      }
+    },
+    /** @experimental */
     account: {
       /**
        * Renders the sign-in banner and the one-line account description the runtime uses for an authentication identity. The runtime words these in several places for its own callers, so a host that announces a sign-in or an account switch should render them from here rather than composing its own, which would let the two spellings drift apart.
@@ -1947,6 +1974,25 @@ function createInternalServerRpc(connection) {
       writeKey: async (params) => connection.sendRequest("globalState.writeKey", params)
     },
     /** @experimental */
+    settings: {
+      /**
+       * Removes one key from a settings file addressed by path, leaving every other key untouched. Takes the key exactly as written rather than a canonical setting path, because its purpose is to delete a key the loader refused: a misspelling, or a setting that no longer exists. Refuses rather than overwrites when the file does not parse, so a malformed file is never replaced by a rewrite that drops everything it could not read.
+       *
+       * @param params One key to remove from a settings file, named exactly as it appears in the file.
+       *
+       * @returns The outcome of the settings-file edit.
+       */
+      removeRawKey: async (params) => connection.sendRequest("settings.removeRawKey", params),
+      /**
+       * Replaces the secret-bearing parts of a settings value with a redacted placeholder, so the value can be shown to a user or written to a log. `basePath` is where the value sits in the settings tree, which is what decides whether a field is secret.
+       *
+       * @param params A settings value to redact before showing it.
+       *
+       * @returns A settings value with its secret-bearing parts replaced.
+       */
+      redactValueForDisplay: async (params) => connection.sendRequest("settings.redactValueForDisplay", params)
+    },
+    /** @experimental */
     gitHubRepository: {
       /**
        * Resolves the GitHub repository that owns a working-tree path by reading the selected git remote configured for it, preferring `origin`. Returns a null `repository` when the path is inside a git working tree but that selected remote does not resolve to a GitHub host. Fails when the path is not inside a git working tree at all, so a caller can tell 'not a repository' apart from 'a repository with no GitHub remote'.
@@ -2010,6 +2056,15 @@ function createInternalServerRpc(connection) {
       reposFromRemotes: async (params) => connection.sendRequest("git.reposFromRemotes", params)
     },
     /** @experimental */
+    runtime: {
+      /**
+       * Opens an authorization URL using the same browser policy as the runtime's OAuth flows, including BROWSER and COPILOT_DEBUG_BROWSER. Refuses extension callers.
+       *
+       * @param params An authorization URL for the host browser.
+       */
+      openBrowser: async (params) => connection.sendRequest("runtime.openBrowser", params)
+    },
+    /** @experimental */
     sessions: {
       /**
        * Reads lightweight persisted metadata for one local session without opening it.
@@ -2087,6 +2142,33 @@ function createInternalServerRpc(connection) {
        * @param params Params to attach or detach an in-process ExtensionController delegate.
        */
       configureSessionExtensions: async (params) => connection.sendRequest("sessions.configureSessionExtensions", params)
+    },
+    /** @experimental */
+    agentRegistry: {
+      /**
+       * Creates the local agent registry with mode 0700. Requires a trusted SDK host or runtime-direct caller.
+       *
+       * @param params The location of a local agent registry.
+       *
+       * @returns The resolved registry directory and any creation failure.
+       */
+      ensureDir: async (params) => connection.sendRequest("agentRegistry.ensureDir", params),
+      /**
+       * Removes a local agent entry. An absent entry succeeds. Requires a trusted SDK host or runtime-direct caller.
+       *
+       * @param params A local agent entry identified by its publisher.
+       *
+       * @returns The outcome of removing a registry entry, with no success payload.
+       */
+      removeEntry: async (params) => connection.sendRequest("agentRegistry.removeEntry", params),
+      /**
+       * Lists live local agents without connection credentials. Only stale entries are removed; dead-pid entries remain on disk. Requires a trusted SDK host or runtime-direct caller.
+       *
+       * @param params Options for local agent discovery.
+       *
+       * @returns Live agent metadata without connection credentials.
+       */
+      listEntries: async (params) => connection.sendRequest("agentRegistry.listEntries", params)
     }
   };
 }
@@ -3337,7 +3419,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Effective enterprise managed settings and contributing channels. Session events report applied policy; sessionless resolve reports an account/device snapshot, and compose reports a non-applying preview of candidate documents. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively. Session-local SDK-client policy is included only in session results. Marked experimental while the managed-settings surface stabilizes.
        */
-      get: async () => connection.sendRequest("session.managedSettings.get", { sessionId })
+      get: async () => connection.sendRequest("session.managedSettings.get", { sessionId }),
+      /**
+       * Runs a fresh Policy Helper evaluation for the live session's current account, registration, working directory, repository and client context, bypassing only a completed cached helper result for that exact context while coalescing an equivalent execution already in flight. The previous failure and safeguards remain active until fresh success is applied. Returns the same retained snapshot as session.managedSettings.get after the recheck settles.
+       *
+       * @returns Effective enterprise managed settings and contributing channels. Session events report applied policy; sessionless resolve reports an account/device snapshot, and compose reports a non-applying preview of candidate documents. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively. Session-local SDK-client policy is included only in session results. Marked experimental while the managed-settings surface stabilizes.
+       */
+      recheckPolicyHelper: async () => connection.sendRequest("session.managedSettings.recheckPolicyHelper", { sessionId })
     },
     /** @experimental */
     plugins: {
@@ -3494,6 +3582,12 @@ function createSessionRpc(connection, sessionId) {
     },
     /** @experimental */
     extensions: {
+      /**
+       * Returns the runtime-derived standalone extension admission policy for the session's actual project and managed-settings context. enforcementVersion 1 means this runtime enforces strictPluginOnlyCustomization for executable extensions. Hosts executing independent extension targets must deny standalone targets unless standalone is allowed; plugin_only requires runtime-verified eligible plugin provenance, not a caller-supplied source label or transport bridge. pending is not confirmed absence. Older runtimes return method-not-found and must not be represented as enforcing this restriction. Re-read on managed-settings changes; a snapshot is not a launch authorization token.
+       *
+       * @returns Runtime support and session-context standalone executable extension policy.
+       */
+      getPolicy: async () => connection.sendRequest("session.extensions.getPolicy", { sessionId }),
       /**
        * Lists extensions discovered for the session and their current status.
        *
@@ -3754,7 +3848,7 @@ function createSessionRpc(connection, sessionId) {
     /** @experimental */
     permissions: {
       /**
-       * Replaces selected permission policy fields (rules, paths, URLs, exclusions, allow-all flags) on the session.
+       * Replaces selected session permission fields, including rules, paths, URLs, exclusions, allow-all flags, user-authored judge instructions, bounded host-supplied advisory judge context, owner-authenticated session authority, and the owner's host-policy declaration for its own tools.
        *
        * @param params Patch of permission policy fields to apply (omit a field to leave it unchanged).
        *
@@ -3821,6 +3915,12 @@ function createSessionRpc(connection, sessionId) {
        * @returns Indicates whether the operation succeeded.
        */
       resetSessionApprovals: async (params) => connection.sendRequest("session.permissions.resetSessionApprovals", { ...params, sessionId }),
+      /**
+       * Clears, in memory only, the allow-all and assisted-approval posture that resuming the session restored from its history. No permission event is recorded, so a later resume restores the user's choice again. A headless caller, which has no one to approve requests, calls it before configuring permissions from its own flags.
+       *
+       * @returns Indicates whether the operation succeeded.
+       */
+      clearResumeEscalation: async () => connection.sendRequest("session.permissions.clearResumeEscalation", { sessionId }),
       /**
        * Notifies the runtime that a permission prompt UI has been shown to the user.
        *
@@ -4302,7 +4402,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Optional remote session mode ("off", "export", or "on"); defaults to enabling both export and remote steering.
        *
-       * @returns GitHub URL for the session and a flag indicating whether remote steering is enabled.
+       * @returns GitHub URL and remote export and steering state, with an optional warning when cloud session storage policy refuses export.
        */
       enable: async (params) => connection.sendRequest("session.remote.enable", { ...params, sessionId }),
       /**
@@ -4488,6 +4588,15 @@ function createInternalSessionRpc(connection, sessionId) {
       clearStartupSeed: async (params) => connection.sendRequest("session.model.clearStartupSeed", { ...params, sessionId })
     },
     /** @experimental */
+    autopilot: {
+      /**
+       * Applies the runtime-owned Autopilot continuation policy at the session-idle decision point and routes any admitted continuation through the normal session send lifecycle. Only the SDK connection that owns the session can invoke this method.
+       *
+       * @returns Result of applying the ordinary session-idle Autopilot continuation decision.
+       */
+      evaluateIdleContinuation: async () => connection.sendRequest("session.autopilot.evaluateIdleContinuation", { sessionId })
+    },
+    /** @experimental */
     mcp: {
       /**
        * Records the IDE the host is connected to, so the agent's system prompt can name it and its workspace folder. Null or an omitted `ide` clears the recorded value, which is how a host reports that it is disconnected; there is no separate clear method. Both `ideName` and `workspaceFolder` are required together, because half a state cannot be attributed to a project.
@@ -4525,6 +4634,20 @@ function createInternalSessionRpc(connection, sessionId) {
       unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { ...params, sessionId })
     },
     /** @experimental */
+    diagnostics: {
+      /** @experimental */
+      lifecycle: {
+        /**
+         * Reads a bounded page of retained experimental runtime lifecycle diagnostic events. The read is passive and never prepares conversation history or starts subsystem work.
+         *
+         * @param params Cursor-based request for experimental runtime lifecycle diagnostic events. The default max is 100 (maximum 500); the default waitMs is zero (maximum 30000).
+         *
+         * @returns One cursor-addressed page of retained experimental runtime lifecycle diagnostic events.
+         */
+        read: async (params) => connection.sendRequest("session.diagnostics.lifecycle.read", { ...params, sessionId })
+      }
+    },
+    /** @experimental */
     connectors: {
       /**
        * Reconciles the authoritative Connector catalog into the session MCP projection during startup with a bounded deadline and fail-closed cleanup.
@@ -4550,12 +4673,20 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @returns Whether finalizing the invocation effect succeeded, and the failure reason when it did not.
        */
-      finalizeInvocationEffect: async (params) => connection.sendRequest("session.commands.finalizeInvocationEffect", { ...params, sessionId })
+      finalizeInvocationEffect: async (params) => connection.sendRequest("session.commands.finalizeInvocationEffect", { ...params, sessionId }),
+      /**
+       * Reports that the host's execution of a queued command started or stopped waiting for runtime state, so lifecycle progress can attribute the wait. Observational only: it never changes command execution.
+       *
+       * @param params Host report that its execution of a queued command started or stopped waiting for runtime state. The report is observational and never changes command execution.
+       *
+       * @returns Whether the runtime recorded the queued-command wait.
+       */
+      reportQueuedCommandWait: async (params) => connection.sendRequest("session.commands.reportQueuedCommandWait", { ...params, sessionId })
     },
     /** @experimental */
     ui: {
       /**
-       * Resolves a pending elicitation request after direct interaction in the trusted in-process client. Only an accepted response to the built-in ask_user tool can become trusted human evidence.
+       * Resolves a pending elicitation request after direct interaction in the trusted in-process client or authenticated owning host. Only an accepted response to the built-in ask_user tool can become trusted human evidence.
        *
        * @param params Pending elicitation request ID and the user's response (accept/decline/cancel + form values).
        *
@@ -4563,7 +4694,7 @@ function createInternalSessionRpc(connection, sessionId) {
        */
       handleHumanAskUser: async (params) => connection.sendRequest("session.ui.handleHumanAskUser", { ...params, sessionId }),
       /**
-       * Resolves a pending `user_input.requested` event after direct interaction in the trusted in-process client.
+       * Resolves a pending `user_input.requested` event after direct interaction in the trusted in-process client or authenticated owning host.
        *
        * @param params Request ID of a pending `user_input.requested` event and the user's response.
        *
@@ -4571,7 +4702,7 @@ function createInternalSessionRpc(connection, sessionId) {
        */
       handleHumanUserInput: async (params) => connection.sendRequest("session.ui.handleHumanUserInput", { ...params, sessionId }),
       /**
-       * Resolves a pending `exit_plan_mode.requested` event after direct interaction in the trusted in-process client.
+       * Resolves a pending `exit_plan_mode.requested` event after direct interaction in the trusted in-process client or authenticated owning host.
        *
        * @param params Request ID of a pending `exit_plan_mode.requested` event and the user's response.
        *
@@ -4746,6 +4877,12 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
     return handler.readFileBytes(params);
   });
+  connection.onRequest("sessionFs.readFileRange", async (params) => {
+    const handler = getHandlers(params.sessionId).sessionFs;
+    if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
+    if (!handler.readFileRange) throw new Error("Optional client handler sessionFs.readFileRange is not implemented");
+    return handler.readFileRange(params);
+  });
   connection.onRequest("sessionFs.writeFile", async (params) => {
     const handler = getHandlers(params.sessionId).sessionFs;
     if (!handler) throw new Error(`No sessionFs handler registered for session: ${params.sessionId}`);
@@ -4838,6 +4975,11 @@ function registerClientGlobalApiHandlers(connection, handlers) {
     if (!handler) throw new Error("No extensionLaunchProvider client-global handler registered");
     return handler.resolve(params);
   });
+  connection.onRequest("kerberosAuth.acquire", async (params) => {
+    const handler = handlers.kerberosAuth;
+    if (!handler) throw new Error("No kerberosAuth client-global handler registered");
+    return handler.acquire(params);
+  });
   connection.onRequest("llmInference.httpRequestStart", async (params) => {
     const handler = handlers.llmInference;
     if (!handler) throw new Error("No llmInference client-global handler registered");
@@ -4858,6 +5000,11 @@ function registerClientGlobalApiHandlers(connection, handlers) {
     if (!handler) throw new Error("No gitHubToken client-global handler registered");
     return handler.getToken(params);
   });
+  connection.onRequest("entraToken.getToken", async (params) => {
+    const handler = handlers.entraToken;
+    if (!handler) throw new Error("No entraToken client-global handler registered");
+    return handler.getToken(params);
+  });
   connection.onRequest("uiThread.run", async (params) => {
     const handler = handlers.uiThread;
     if (!handler) throw new Error("No uiThread client-global handler registered");

package/dist/cjs/installationConfirmation.js

@@ -21,7 +21,7 @@ __export(installationConfirmation_exports, {
   createInstallationConfirmationAdapter: () => createInstallationConfirmationAdapter
 });
 module.exports = __toCommonJS(installationConfirmation_exports);
-var import_node = require("vscode-jsonrpc/node.js");
+var import_node = require("vscode-jsonrpc/node");
 function createInstallationConfirmationAdapter(connection, handler) {
   const closed = new import_node.CancellationTokenSource();
   const closeSubscription = connection.onClose(() => closed.cancel());

package/dist/cjs/jsonrpcTypes.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var jsonrpcTypes_exports = {};
+module.exports = __toCommonJS(jsonrpcTypes_exports);

package/dist/cjs/session.js

@@ -22,7 +22,7 @@ __export(session_exports, {
 });
 module.exports = __toCommonJS(session_exports);
 var import_node_async_hooks = require("node:async_hooks");
-var import_node = require("vscode-jsonrpc/node.js");
+var import_node = require("vscode-jsonrpc/node");
 var import_rpc = require("./generated/rpc.js");
 var import_canvas = require("./canvas.js");
 var import_telemetry = require("./telemetry.js");
@@ -258,6 +258,15 @@ function isWorkflowAbortError(error) {
 function isWorkflowFatalError(error) {
   return isWorkflowAbortError(error) || error instanceof import_node.ResponseError || error instanceof import_node.ConnectionError;
 }
+const MAX_TIMER_DELAY_MS = 2 ** 31 - 1;
+function setLongTimeout(callback, delayMs) {
+  let timer;
+  const arm = (remainingMs) => {
+    timer = remainingMs > MAX_TIMER_DELAY_MS ? setTimeout(() => arm(remainingMs - MAX_TIMER_DELAY_MS), MAX_TIMER_DELAY_MS) : setTimeout(callback, remainingMs);
+  };
+  arm(delayMs);
+  return () => clearTimeout(timer);
+}
 const TOOL_SEARCH_TOOL_NAME = "tool_search_tool";
 class CopilotSession {
   /**
@@ -668,11 +677,11 @@ class CopilotSession {
       else resolveOutcome({ kind: "error", error });
     };
     this.pendingResponseWaits.add(fail);
-    let timeoutId;
+    let cancelTimeout;
     let waiting = true;
     try {
       const timeoutPromise = new Promise((_, reject) => {
-        timeoutId = setTimeout(
+        cancelTimeout = setLongTimeout(
           () => reject(
             new Error(
               `Timeout after ${effectiveTimeout}ms waiting for response completion`
@@ -700,9 +709,7 @@ class CopilotSession {
       return outcome.message;
     } finally {
       waiting = false;
-      if (timeoutId !== void 0) {
-        clearTimeout(timeoutId);
-      }
+      cancelTimeout?.();
       unsubscribe();
       buffered.length = 0;
       this.pendingResponseWaits.delete(fail);
@@ -736,7 +743,7 @@ class CopilotSession {
       fail = reject;
     });
     this.pendingResponseWaits.add(fail);
-    const timer = setTimeout(
+    const cancelTimeout = setLongTimeout(
       () => fail(new Error(`Timeout after ${timeout}ms waiting for session.idle`)),
       timeout
     );
@@ -775,7 +782,7 @@ class CopilotSession {
     try {
       return await Promise.race([operation(), stopped]);
     } finally {
-      clearTimeout(timer);
+      cancelTimeout();
       unsubscribe();
       this.pendingResponseWaits.delete(fail);
       resolveDispatched();
@@ -833,7 +840,7 @@ class CopilotSession {
     });
     this.pendingStructuredWaits.add(fail);
     let waiting = true;
-    const timer = setTimeout(
+    const cancelTimeout = setLongTimeout(
       () => fail(new Error(`Timeout after ${timeout}ms waiting for the structured response`)),
       timeout
     );
@@ -860,7 +867,7 @@ class CopilotSession {
       return outcome.message;
     } finally {
       waiting = false;
-      clearTimeout(timer);
+      cancelTimeout();
       buffered.length = 0;
       unsubscribe();
       this.pendingStructuredWaits.delete(fail);
@@ -1017,12 +1024,23 @@ class CopilotSession {
         }
       }
     } else if (event.type === "permission.requested") {
-      const { requestId, permissionRequest, promptRequest, resolvedByHook } = event.data;
+      const {
+        requestId,
+        permissionRequest,
+        promptRequest,
+        assistedApprovalAssessment,
+        resolvedByHook
+      } = event.data;
       if (resolvedByHook) {
         return;
       }
       if (this.permissionHandler) {
-        void this._executePermissionAndRespond(requestId, permissionRequest, promptRequest);
+        void this._executePermissionAndRespond(
+          requestId,
+          permissionRequest,
+          promptRequest,
+          assistedApprovalAssessment
+        );
       }
     } else if (event.type === "mcp.oauth_required") {
       const data = event.data;
@@ -1041,15 +1059,7 @@ class CopilotSession {
       void this._executeCommandAndRespond(requestId, commandName, command, args);
     } else if (event.type === "elicitation.requested") {
       if (this.elicitationHandler) {
-        const {
-          message,
-          requestedSchema,
-          mode,
-          elicitationSource,
-          elicitationSourceDisplayName,
-          url,
-          requestId
-        } = event.data;
+        const { message, requestedSchema, mode, elicitationSource, url, requestId } = event.data;
         void this._handleElicitationRequest(
           {
             sessionId: this.sessionId,
@@ -1057,14 +1067,17 @@ class CopilotSession {
             requestedSchema,
             mode,
             elicitationSource,
-            elicitationSourceDisplayName,
             url
           },
           requestId
         );
       }
     } else if (event.type === "capabilities.changed") {
-      this._capabilities = { ...this._capabilities, ...event.data };
+      const { ui, ...changed } = event.data;
+      this._capabilities = { ...this._capabilities, ...changed };
+      if (ui) {
+        this._capabilities.ui = { ...this._capabilities.ui, ...ui };
+      }
     } else if (event.type === "session.canvas.opened") {
       this.upsertOpenCanvasFromEvent(event.data);
     } else if (event.type === "session.canvas.closed") {
@@ -1190,12 +1203,13 @@ class CopilotSession {
    * Executes a permission handler and sends the result back via RPC.
    * @internal
    */
-  async _executePermissionAndRespond(requestId, permissionRequest, promptRequest) {
+  async _executePermissionAndRespond(requestId, permissionRequest, promptRequest, assistedApprovalAssessment) {
     try {
       const invocation = {
         sessionId: this.sessionId,
         managedSettingsEnabled: this.managedSettingsEnabled,
-        ...promptRequest === void 0 ? {} : { promptRequest }
+        ...promptRequest === void 0 ? {} : { promptRequest },
+        ...assistedApprovalAssessment === void 0 ? {} : { assistedApprovalAssessment }
       };
       const handlerResult = await this.permissionHandler(permissionRequest, invocation);
       const isAttributed = (0, import_types.isAttributedPermissionResult)(handlerResult);

package/dist/cjs/sessionFsProvider.js

@@ -51,6 +51,34 @@ function normalizeSqliteParams(params) {
 }
 function createSessionFsAdapter(provider) {
   return {
+    readFileRange: async ({ path, offset, length }) => {
+      try {
+        if (!Number.isSafeInteger(offset) || offset < 0 || length !== void 0 && (!Number.isSafeInteger(length) || length < 0)) {
+          throw new RangeError(
+            "SessionFs byte offset and length must be non-negative safe integers"
+          );
+        }
+        if (!provider.readFileRange) {
+          throw new Error(
+            "Byte-range reads are not supported by this SessionFs provider"
+          );
+        }
+        const result = await provider.readFileRange(path, offset, length);
+        if (!Number.isSafeInteger(result.byteLength) || result.byteLength < 0) {
+          throw new Error("SessionFs byte length must be a non-negative safe integer");
+        }
+        const available = Math.max(0, result.byteLength - offset);
+        if (result.content.byteLength !== Math.min(length ?? available, available)) {
+          throw new Error("SessionFs returned an incorrect byte range length");
+        }
+        return {
+          content: Buffer.from(result.content).toString("base64"),
+          byteLength: result.byteLength
+        };
+      } catch (err) {
+        return { content: "", byteLength: 0, error: toSessionFsError(err) };
+      }
+    },
     readFile: async ({ path }) => {
       try {
         const content = await provider.readFile(path);

package/dist/cliVersion.d.ts

@@ -1,2 +1,2 @@
-export declare const COPILOT_CLI_VERSION = "1.0.105";
+export declare const COPILOT_CLI_VERSION = "1.0.106-2";
 export declare const COPILOT_CLI_USE_NPM_PACKAGE = false;

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.105";
+const COPILOT_CLI_VERSION = "1.0.106-2";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,

package/dist/client.d.ts

@@ -50,6 +50,7 @@ export declare class CopilotClient {
     private sessionFsConfig;
     private requestHandler;
     private extensionLaunchProvider?;
+    private readonly kerberosAuth?;
     private installationConfirmationHandler?;
     private builtinPluginDirectories;
     private onGitHubTelemetry?;