@github/copilot-sdk 1.0.29-preview.9 → 1.0.30-preview.0

package/dist/cjs/client.js

@@ -31,6 +31,7 @@ __export(client_exports, {
   CopilotClient: () => CopilotClient
 });
 module.exports = __toCommonJS(client_exports);
+var import_node_async_hooks = require("node:async_hooks");
 var import_node_child_process = require("node:child_process");
 var import_node_crypto = require("node:crypto");
 var import_node_fs = require("node:fs");
@@ -38,6 +39,7 @@ var import_node_net = require("node:net");
 var import_node_path = require("node:path");
 var import_node = require("vscode-jsonrpc/node");
 var import_rpc = require("./generated/rpc.js");
+var import_decisions = require("./decisions.js");
 var import_sdkProtocolVersion = require("./sdkProtocolVersion.js");
 var import_session = require("./session.js");
 var import_host = require("./host.js");
@@ -54,6 +56,20 @@ var import_types = require("./types.js");
 const MIN_PROTOCOL_VERSION = 3;
 const RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
 const CLOUD_SESSION_CLEANUP_TIMEOUT_MS = 1e4;
+const AUTO_MODE_RECOVERY_CLEANUP_TIMEOUT_MS = 1e4;
+function sessionIdsOverlap(left, right) {
+  if (left === right) return true;
+  if (!isUuidSessionId(left) || !isUuidSessionId(right)) return false;
+  const normalizedLeft = left.toLowerCase();
+  const normalizedRight = right.toLowerCase();
+  return normalizedLeft.startsWith(normalizedRight) || normalizedRight.startsWith(normalizedLeft);
+}
+function isAbbreviatedUuidPrefix(sessionId) {
+  return /^[0-9a-f]{7}[0-9a-f-]{0,28}$/i.test(sessionId);
+}
+function isUuidSessionId(sessionId) {
+  return isAbbreviatedUuidPrefix(sessionId) || /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(sessionId);
+}
 const messageEncodeErrors = /* @__PURE__ */ new WeakSet();
 const jsonMessageEncoder = {
   name: "application/json",
@@ -67,11 +83,12 @@ const jsonMessageEncoder = {
     }
   }
 };
-function createMessageConnection(reader, writer) {
+function createMessageConnection(reader, writer, sessionInitializationContext) {
   let dispatch;
   let finishDrain;
   let drained;
   let disposed = false;
+  const callbacks = /* @__PURE__ */ new Map();
   const barrier = { jsonrpc: "2.0", method: "$/sdkDrain" };
   const connection = (0, import_node.createMessageConnection)(
     {
@@ -84,7 +101,22 @@ function createMessageConnection(reader, writer) {
       },
       dispose: () => reader.dispose()
     },
-    writer,
+    {
+      onError: writer.onError,
+      onClose: writer.onClose,
+      write: (message) => {
+        if (import_node.Message.isResponse(message)) {
+          const context = callbacks.get(message.id);
+          if (context) {
+            context.active = false;
+            callbacks.delete(message.id);
+          }
+        }
+        return writer.write(message);
+      },
+      end: () => writer.end(),
+      dispose: () => writer.dispose()
+    },
     void 0,
     {
       messageStrategy: {
@@ -92,7 +124,14 @@ function createMessageConnection(reader, writer) {
           if (message === barrier) {
             finishDrain?.();
           } else {
-            next(message);
+            const request = import_node.Message.isRequest(message) ? message : void 0;
+            const params = request?.params;
+            const sessionId = params && typeof params === "object" && "sessionId" in params && typeof params.sessionId === "string" ? params.sessionId : void 0;
+            const context = sessionId === void 0 ? void 0 : { sessionId, active: true };
+            if (request && context) {
+              callbacks.set(request.id, context);
+            }
+            sessionInitializationContext.run(context, next, message);
           }
         }
       }
@@ -100,6 +139,10 @@ function createMessageConnection(reader, writer) {
   );
   connection.onDispose(() => {
     disposed = true;
+    for (const context of callbacks.values()) {
+      context.active = false;
+    }
+    callbacks.clear();
     finishDrain?.();
   });
   return Object.assign(connection, {
@@ -162,8 +205,8 @@ async function waitForChildExit(child, timeoutMs) {
     }
   });
 }
-async function acquireKerberosToken(connection, callback, request, token) {
-  const ended = () => token.isCancellationRequested ? new import_node.ResponseError(-32800, "Kerberos auth request cancelled") : new Error("Kerberos auth connection closed");
+async function runCancellableCallback(connection, label, token, invoke) {
+  const ended = () => token.isCancellationRequested ? new import_node.ResponseError(-32800, `${label} request cancelled`) : new Error(`${label} connection closed`);
   if (token.isCancellationRequested) {
     throw ended();
   }
@@ -178,14 +221,47 @@ async function acquireKerberosToken(connection, callback, request, token) {
     connection.onDispose(abort)
   ];
   try {
-    const lookup = Promise.resolve().then(() => callback(request, controller.signal));
-    return { token: await Promise.race([lookup, abandoned]) };
+    const lookup = Promise.resolve().then(() => {
+      if (controller.signal.aborted) {
+        throw ended();
+      }
+      return invoke(controller.signal);
+    });
+    return await Promise.race([lookup, abandoned]);
   } finally {
     for (const subscription of subscriptions) {
       subscription.dispose();
     }
   }
 }
+function snapshotNetworkConfig(network) {
+  const { scope, resolveProxy, authenticateNegotiate } = network;
+  return {
+    scope,
+    resolveProxy: resolveProxy && ((request, signal) => resolveProxy.call(network, request, signal)),
+    authenticateNegotiate: authenticateNegotiate && ((request, signal) => authenticateNegotiate.call(network, request, signal))
+  };
+}
+async function resolveClientProxy(connection, callback, request, token) {
+  return {
+    proxy: await runCancellableCallback(
+      connection,
+      "Proxy resolution",
+      token,
+      (signal) => callback(request, signal)
+    )
+  };
+}
+async function authenticateClientNegotiate(connection, callback, request, token) {
+  return {
+    token: await runCancellableCallback(
+      connection,
+      "Negotiate authentication",
+      token,
+      (signal) => callback(request, signal)
+    )
+  };
+}
 const DEFAULT_PROVIDER_NAME = "default";
 function extractBearerTokenProviders(provider, providers) {
   const callbacks = /* @__PURE__ */ new Map();
@@ -224,6 +300,18 @@ function toWireMcpServers(mcpServers) {
     })
   );
 }
+function requestedMemoryStore(memory) {
+  if (!memory?.storeMemory) return void 0;
+  if (memory.enabled !== true) {
+    throw new Error("memory.storeMemory requires memory.enabled to be true.");
+  }
+  return memory.storeMemory;
+}
+function toWireMemoryConfiguration(memory) {
+  if (!memory) return memory;
+  const { storeMemory: _storeMemory, ...wire } = memory;
+  return wire;
+}
 function toWireCustomAgents(agents) {
   if (!agents) return void 0;
   return agents.map((agent) => {
@@ -326,6 +414,7 @@ class CopilotClient {
   ffiHost = null;
   connection = null;
   requestAdapter = null;
+  pendingMemoryStores = /* @__PURE__ */ new Set();
   messageWriter = null;
   connectionClosed = false;
   connectionEpoch = 0;
@@ -335,7 +424,16 @@ class CopilotClient {
   state = "disconnected";
   /** Shared in-flight start; concurrent callers await it instead of spawning another CLI. */
   startPromise = null;
+  shutdownCanceledStartup = null;
+  stopPromise = null;
+  forceStopPromise = null;
   sessions = /* @__PURE__ */ new Map();
+  pendingSessionResumes = /* @__PURE__ */ new Map();
+  sessionInitializations = /* @__PURE__ */ new Map();
+  failedAutoModeRecoveryCleanups = /* @__PURE__ */ new WeakMap();
+  sessionInitializationContext = new import_node_async_hooks.AsyncLocalStorage();
+  sessionInitializationLifetime = new AbortController();
+  sessionInitializationGeneration = 0;
   hostExitCallbacks = /* @__PURE__ */ new Map();
   hostSessionFactories = /* @__PURE__ */ new Map();
   hostAuthenticators = /* @__PURE__ */ new Map();
@@ -364,6 +462,7 @@ class CopilotClient {
   typedLifecycleHandlers = /* @__PURE__ */ new Map();
   _rpc = null;
   _internalRpc = null;
+  _decisions;
   processExitPromise = null;
   // Rejects when CLI process exits
   processTransportError = null;
@@ -372,7 +471,7 @@ class CopilotClient {
   sessionFsConfig = null;
   requestHandler = null;
   extensionLaunchProvider;
-  kerberosAuth;
+  network;
   installationConfirmationHandler;
   builtinPluginDirectories = [];
   onGitHubTelemetry;
@@ -391,6 +490,16 @@ class CopilotClient {
     }
     return this._rpc;
   }
+  /**
+   * One-off yes/no, pick-one and rating questions answered by Copilot decision
+   * models. Requires the runtime's `DECISIONS_API` feature flag.
+   *
+   * @experimental
+   */
+  get decisions() {
+    this._decisions ??= new import_decisions.CopilotDecisions(() => this.rpc);
+    return this._decisions;
+  }
   /**
    * Internal RPC surface (e.g. handshake helpers). Not part of the public API.
    * @internal
@@ -535,7 +644,7 @@ class CopilotClient {
     this.sessionFsConfig = options.sessionFs ?? null;
     this.requestHandler = options.requestHandler ?? null;
     this.extensionLaunchProvider = options.extensionLaunchProvider;
-    this.kerberosAuth = options.kerberosAuth;
+    this.network = options.network ? snapshotNetworkConfig(options.network) : void 0;
     this.installationConfirmationHandler = options.installationConfirmationHandler;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
@@ -578,10 +687,15 @@ class CopilotClient {
   connectionExtraArgs = [];
   /**
    * Parse CLI URL into host and port
-   * Supports formats: "host:port", "[ipv6]:port", "http://host:port", "https://host:port", or just "port"
+   * Supports raw TCP addresses: "host:port", "[ipv6]:port", "http://host:port", or just "port"
    */
   parseCliUrl(url) {
-    const cleanUrl = url.replace(/^https?:\/\//, "");
+    if (/^https:\/\//i.test(url)) {
+      throw new Error(
+        "HTTPS runtime connections are not supported: this transport uses plaintext TCP, not TLS"
+      );
+    }
+    const cleanUrl = url.replace(/^http:\/\//, "");
     if (/^\d+$/.test(cleanUrl)) {
       return { host: "localhost", port: parseInt(cleanUrl, 10) };
     }
@@ -753,20 +867,38 @@ class CopilotClient {
    * ```
    */
   async start() {
+    if (this.forceStopPromise || this.stopPromise && !this.forceStopping) {
+      throw new Error("Client disconnected during session initialization");
+    }
+    const startup = this.startPromise;
+    if (startup && startup === this.shutdownCanceledStartup) {
+      const generation = this.sessionInitializationGeneration;
+      await Promise.allSettled([startup, this.stopPromise]);
+      if (generation !== this.sessionInitializationGeneration) {
+        throw new Error("Client disconnected during session initialization");
+      }
+      return this.start();
+    }
+    if (startup && !this.stopPromise) {
+      return startup;
+    }
+    if (this.stopPromise || this.connection && this.sessionInitializationLifetime.signal.aborted) {
+      throw new Error("Client disconnected during session initialization");
+    }
     if (this.state === "connected") {
       return;
     }
-    if (this.startPromise) {
-      return this.startPromise;
-    }
     this.startPromise = this.doStart();
     try {
       await this.startPromise;
     } finally {
       this.startPromise = null;
+      this.shutdownCanceledStartup = null;
     }
   }
   async doStart() {
+    this.sessionInitializationLifetime = new AbortController();
+    const signal = this.sessionInitializationLifetime.signal;
     this.forceStopping = false;
     this.connectionEpoch++;
     this.connectionClosed = false;
@@ -778,24 +910,25 @@ class CopilotClient {
       } else if (!this.isExternalServer) {
         await this.startCLIServer();
       }
+      signal.throwIfAborted();
       await this.connectToServer();
+      signal.throwIfAborted();
       await this.verifyProtocolVersion();
-      if (this.kerberosAuth) {
-        const { mode, scope } = this.kerberosAuth;
-        await this.rpc.kerberosAuth.setProvider(scope ? { mode, scope } : { mode });
+      if (this.network?.resolveProxy || this.network?.authenticateNegotiate) {
+        const { scope, resolveProxy, authenticateNegotiate } = this.network;
+        await this.rpc.network.setProvider({
+          ...scope ? { scope } : {},
+          ...resolveProxy ? { resolveProxy: {} } : {},
+          ...authenticateNegotiate ? { authenticateNegotiate: {} } : {}
+        });
       }
       if (this.extensionLaunchProvider) {
         await this.rpc.registerExtensionLaunchProvider();
       }
       if (this.builtinPluginDirectories.length > 0) {
-        try {
-          await this.connection.sendRequest("plugins.builtin.set", {
-            paths: this.builtinPluginDirectories
-          });
-        } catch (error) {
-          await this.forceStop();
-          throw error;
-        }
+        await this.connection.sendRequest("plugins.builtin.set", {
+          paths: this.builtinPluginDirectories
+        });
       }
       if (this.sessionFsConfig) {
         await this.connection.sendRequest("sessionFs.setProvider", {
@@ -811,10 +944,14 @@ class CopilotClient {
       if (this.connectionClosed) {
         throw new Error("CLI server connection closed during startup");
       }
+      signal.throwIfAborted();
       this.state = "connected";
     } catch (error) {
       const startupError = this.processTransportError ?? error;
-      await this.forceStop();
+      if (!signal.aborted) {
+        this.invalidateSessionInitializations();
+      }
+      await this.doForceStop();
       this.state = "error";
       throw startupError;
     }
@@ -850,6 +987,21 @@ class CopilotClient {
    * ```
    */
   async stop() {
+    if (this.stopPromise) {
+      return this.stopPromise;
+    }
+    if (!this.sessionInitializationLifetime.signal.aborted) {
+      this.shutdownCanceledStartup = this.startPromise;
+    }
+    this.invalidateSessionInitializations();
+    this.stopPromise = this.doStop(this.startPromise);
+    try {
+      return await this.stopPromise;
+    } finally {
+      this.stopPromise = null;
+    }
+  }
+  async doStop(startup) {
     const errors = [];
     const activeSessions = [...this.sessions.values()];
     if (this.connectionConfig.kind === "inprocess") {
@@ -909,6 +1061,7 @@ class CopilotClient {
     this.sessions.clear();
     this.githubTokenProviders.clear();
     this.requestAdapter?.cancelPending();
+    this.abortPendingMemoryStores();
     if (this.connection && !this.connectionClosed && (this.cliProcess || this.ffiHost) && !this.isExternalServer) {
       const runtimeShutdownStart = Date.now();
       const shutdownPromise = this.rpc.runtime.shutdown();
@@ -1044,6 +1197,9 @@ class CopilotClient {
       clearTimeout(this.cliStartTimeout);
       this.cliStartTimeout = null;
     }
+    if (startup) {
+      await Promise.allSettled([startup]);
+    }
     this.state = "disconnected";
     this.runtimePort = null;
     this.stderrBuffer = "";
@@ -1075,7 +1231,8 @@ class CopilotClient {
    * - Sends SIGKILL to the CLI process (if spawned by this client)
    * - Waits for the spawned CLI process to exit
    *
-   * @returns A promise that resolves when the force stop is complete
+   * @returns Resolves after disconnection and spawned-process exit; later starts
+   * wait for pending startup cleanup.
    * @throws If the spawned CLI process cannot be terminated
    *
    * @example
@@ -1094,6 +1251,21 @@ class CopilotClient {
    * ```
    */
   async forceStop() {
+    if (this.forceStopPromise) {
+      return this.forceStopPromise;
+    }
+    if (!this.sessionInitializationLifetime.signal.aborted) {
+      this.shutdownCanceledStartup = this.startPromise;
+    }
+    this.invalidateSessionInitializations();
+    this.forceStopPromise = this.doForceStop();
+    try {
+      await this.forceStopPromise;
+    } finally {
+      this.forceStopPromise = null;
+    }
+  }
+  async doForceStop() {
     this.forceStopping = true;
     this.disconnectHosts();
     for (const session of this.sessions.values()) {
@@ -1102,6 +1274,7 @@ class CopilotClient {
     this.sessions.clear();
     this.githubTokenProviders.clear();
     this.requestAdapter?.cancelPending();
+    this.abortPendingMemoryStores();
     if (this.messageWriter) {
       this.messageWriter.suppressWriteErrors = true;
     }
@@ -1313,15 +1486,112 @@ class CopilotClient {
     }
   }
   async createSession(config) {
+    if (config.autoModeRecovery && typeof config.onAutoModeSwitchRequest !== "function") {
+      throw new Error("autoModeRecovery requires onAutoModeSwitchRequest");
+    }
     if (config.gitHubToken !== void 0 && config.gitHubTokenProvider !== void 0) {
       throw new Error("gitHubToken and gitHubTokenProvider are mutually exclusive");
     }
     if (config.cloud != null && config.skillProvider) {
       throw new Error("Skill providers are not supported for cloud sessions.");
     }
-    if (!this.connection || this.startPromise) {
-      await this.start();
+    const storeMemory = requestedMemoryStore(config.memory);
+    if (config.cloud != null && storeMemory) {
+      throw new Error("Memory stores are not supported for cloud sessions.");
+    }
+    const signal = await this.getSessionInitializationSignal();
+    const sessionId = config.sessionId ?? (config.cloud != null ? void 0 : (0, import_node_crypto.randomUUID)());
+    if (sessionId === void 0) {
+      return this.createSessionInternal(config, signal);
+    }
+    const release = await this.acquireSessionInitialization(sessionId, signal);
+    try {
+      signal.throwIfAborted();
+      return await this.createSessionInternal({ ...config, sessionId }, signal);
+    } finally {
+      release();
+    }
+  }
+  invalidateSessionInitializations() {
+    this.sessionInitializationGeneration++;
+    this.sessionInitializationLifetime.abort(
+      new Error("Client disconnected during session initialization")
+    );
+  }
+  async getSessionInitializationSignal() {
+    const generation = this.sessionInitializationGeneration;
+    const starting = !this.connection || this.startPromise ? this.start() : void 0;
+    await starting;
+    if (generation !== this.sessionInitializationGeneration) {
+      throw new Error("Client disconnected during session initialization");
+    }
+    const signal = this.sessionInitializationLifetime.signal;
+    signal.throwIfAborted();
+    return signal;
+  }
+  async runInitializationCallback(sessionId, callback) {
+    const context = sessionId === void 0 ? void 0 : { sessionId, active: true };
+    try {
+      return await this.sessionInitializationContext.run(context, callback);
+    } finally {
+      if (context) context.active = false;
+    }
+  }
+  async acquireSessionInitialization(sessionId, signal) {
+    signal.throwIfAborted();
+    const predecessors = [...this.sessionInitializations].filter(([id]) => sessionIdsOverlap(id, sessionId)).map(([, pending]) => pending);
+    const previous = predecessors.length ? Promise.all(predecessors).then(() => {
+    }) : void 0;
+    const context = this.sessionInitializationContext.getStore();
+    if (previous && context?.active && sessionIdsOverlap(context.sessionId, sessionId)) {
+      throw new Error(
+        `Cannot re-enter session initialization for ${sessionId} from its callback`
+      );
+    }
+    let finish;
+    const current = new Promise((resolve2) => {
+      finish = resolve2;
+    });
+    const tail = previous ? previous.then(() => current) : current;
+    this.sessionInitializations.set(sessionId, tail);
+    void tail.then(() => {
+      if (this.sessionInitializations.get(sessionId) === tail) {
+        this.sessionInitializations.delete(sessionId);
+      }
+    });
+    try {
+      if (previous) {
+        let cancel;
+        try {
+          await new Promise((resolve2, reject) => {
+            cancel = () => reject(signal.reason);
+            signal.addEventListener("abort", cancel, { once: true });
+            void previous.then(resolve2);
+          });
+        } finally {
+          signal.removeEventListener("abort", cancel);
+        }
+      }
+      signal.throwIfAborted();
+      const cleanupError = this.connection ? [...this.failedAutoModeRecoveryCleanups.get(this.connection) ?? []].find(
+        ([id]) => sessionIdsOverlap(id, sessionId)
+      )?.[1] : void 0;
+      if (cleanupError) {
+        throw new Error(
+          `Cannot initialize session ${sessionId} after failed Auto recovery cleanup; stop and restart the client before retrying`,
+          { cause: cleanupError }
+        );
+      }
+      return finish;
+    } catch (error) {
+      finish();
+      throw error;
     }
+  }
+  async createSessionInternal(config, signal) {
+    signal.throwIfAborted();
+    const connection = this.connection;
+    const storeMemory = requestedMemoryStore(config.memory);
     const modeDefaults = this.configDefaultsForMode();
     config = { ...modeDefaults, ...config };
     config.customAgentsLocalOnly ??= modeDefaults.customAgentsLocalOnly;
@@ -1343,19 +1613,11 @@ class CopilotClient {
       config.systemMessage
     );
     const initializeSession = (sessionId) => {
-      const s = new import_session.CopilotSession(
-        sessionId,
-        this.connection,
-        void 0,
-        this.onGetTraceContext,
-        {
-          mcpAuthHandler: config.onMcpAuthRequest,
-          managedSettingsEnabled: config.enableManagedSettings === true || config.managedSettings !== void 0,
-          onDisconnected: gitHubTokenProviderRegistrationId === void 0 ? void 0 : () => this.githubTokenProviders.delete(
-            gitHubTokenProviderRegistrationId
-          )
-        }
-      );
+      const s = new import_session.CopilotSession(sessionId, connection, void 0, this.onGetTraceContext, {
+        mcpAuthHandler: config.onMcpAuthRequest,
+        managedSettingsEnabled: config.enableManagedSettings === true || config.managedSettings !== void 0,
+        onDisconnected: gitHubTokenProviderRegistrationId === void 0 ? void 0 : () => this.githubTokenProviders.delete(gitHubTokenProviderRegistrationId)
+      });
       s.registerTools(config.tools);
       s.registerCanvases(config.canvases);
       s.registerCommands(config.commands);
@@ -1381,6 +1643,7 @@ class CopilotClient {
       if (config.skillProvider) {
         s.registerSkillProvider(config.skillProvider);
       }
+      s._registerMemoryStore(storeMemory);
       if (transformCallbacks) {
         s.registerTransformCallbacks(transformCallbacks);
       }
@@ -1388,12 +1651,14 @@ class CopilotClient {
         s.on(config.onEvent);
       }
       this.setupSessionFs(s, config);
+      signal.throwIfAborted();
       this.sessions.set(sessionId, s);
       return s;
     };
     let session;
     let registeredId;
     let uninitializedCloudSessionId;
+    let releaseCloudInitialization;
     if (localSessionId !== void 0) {
       try {
         session = initializeSession(localSessionId);
@@ -1406,14 +1671,20 @@ class CopilotClient {
       }
     }
     try {
-      const response = await this.connection.sendRequest("session.create", {
-        ...await (0, import_telemetry.getTraceContext)(this.onGetTraceContext),
+      const traceContext = await this.runInitializationCallback(
+        localSessionId,
+        () => (0, import_telemetry.getTraceContext)(this.onGetTraceContext)
+      );
+      signal.throwIfAborted();
+      const response = await connection.sendRequest("session.create", {
+        ...traceContext,
         model: config.model,
         allowedModels: config.allowedModels,
         sessionId: localSessionId,
         name: config.name,
         clientName: config.clientName,
         reasoningEffort: config.reasoningEffort,
+        allowMultipleToolCalls: config.allowMultipleToolCalls,
         reasoningSummary: config.reasoningSummary,
         isExperimentalMode: this.experimentalModeForMode(config.enableExperimentalMode),
         contextTier: config.contextTier,
@@ -1464,6 +1735,7 @@ class CopilotClient {
         ...config.githubMcpToolConfig != null ? { githubMcpToolConfig: config.githubMcpToolConfig } : {},
         requestExitPlanMode: !!config.onExitPlanModeRequest,
         requestAutoModeSwitch: !!config.onAutoModeSwitchRequest,
+        ...config.autoModeRecovery ? { requestAutoModeRecovery: true } : {},
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
         workingDirectory: config.workingDirectory,
         trustWorkingDirectory: config.trustWorkingDirectory,
@@ -1494,6 +1766,7 @@ class CopilotClient {
         enableSkills: config.enableSkills,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        ...storeMemory ? { hasMemoryStore: true } : {},
         agentDirectories: config.agentDirectories,
         hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
@@ -1502,7 +1775,7 @@ class CopilotClient {
         disabledMcpServers: config.disabledMcpServers,
         sandboxConfig: config.sandboxConfig,
         infiniteSessions: config.infiniteSessions,
-        memory: config.memory,
+        memory: toWireMemoryConfiguration(config.memory),
         gitHubToken: config.gitHubToken,
         gitHubTokenProviderRegistrationId,
         cloud: config.cloud,
@@ -1512,12 +1785,14 @@ class CopilotClient {
         excludedManagedSettings: config.excludedManagedSettings,
         enforceManagedModelDefaults: config.enforceManagedModelDefaults,
         interactiveUser: config.interactiveUser,
+        permissionMode: config.permissionMode,
         managedSettings: config.managedSettings
       });
       const {
         sessionId: returnedSessionId,
         workspacePath,
-        capabilities
+        capabilities,
+        permissionModeResult
       } = response;
       if (!returnedSessionId) {
         throw new Error("session.create response did not include a sessionId");
@@ -1529,24 +1804,37 @@ class CopilotClient {
       }
       if (session === void 0) {
         uninitializedCloudSessionId = returnedSessionId;
+      }
+      signal.throwIfAborted();
+      if (session === void 0) {
+        releaseCloudInitialization = await this.acquireSessionInitialization(
+          returnedSessionId,
+          signal
+        );
+        signal.throwIfAborted();
         session = initializeSession(returnedSessionId);
-        uninitializedCloudSessionId = void 0;
         registeredId = returnedSessionId;
       }
       this.assignGitHubTokenProvider(gitHubTokenProviderRegistrationId, returnedSessionId);
+      session.setCapabilities(capabilities);
+      if (config.autoModeRecovery) {
+        await this.requireAutoModeRecovery(session, connection);
+      }
       if (config.onMcpAuthRequest) {
-        await this.connection.sendRequest("session.eventLog.registerInterest", {
+        await connection.sendRequest("session.eventLog.registerInterest", {
           sessionId: returnedSessionId,
           eventType: "mcp.oauth_required"
         });
       }
       session["_workspacePath"] = workspacePath;
-      session.setCapabilities(capabilities);
+      session.setPermissionModeResult(permissionModeResult);
       await this.updateSessionOptionsForMode(session, config);
+      signal.throwIfAborted();
+      uninitializedCloudSessionId = void 0;
       this.commitGitHubTokenProvider(returnedSessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
       session?._markDisconnected();
-      if (registeredId !== void 0) {
+      if (registeredId !== void 0 && this.sessions.get(registeredId) === session) {
         this.sessions.delete(registeredId);
       }
       if (gitHubTokenProviderRegistrationId !== void 0) {
@@ -1555,18 +1843,28 @@ class CopilotClient {
       if (uninitializedCloudSessionId !== void 0) {
         try {
           await withTimeout(
-            this.deleteSession(uninitializedCloudSessionId),
+            this.requestSessionDeletion(connection, uninitializedCloudSessionId),
             CLOUD_SESSION_CLEANUP_TIMEOUT_MS,
             `session.delete timed out after ${CLOUD_SESSION_CLEANUP_TIMEOUT_MS}ms`
           );
         } catch (cleanupError) {
-          throw new AggregateError(
+          const failure = new AggregateError(
             [e, cleanupError],
-            "Failed to initialize and delete cloud session"
+            `Failed to initialize and delete cloud session ${uninitializedCloudSessionId}`
           );
+          if (config.autoModeRecovery) {
+            this.recordFailedAutoModeRecoveryCleanup(
+              connection,
+              uninitializedCloudSessionId,
+              failure
+            );
+          }
+          throw failure;
         }
       }
       throw e;
+    } finally {
+      releaseCloudInitialization?.();
     }
     for (const entry of this.hostHandoffs.values()) {
       if (entry.requestedSessionId === session.sessionId) {
@@ -1607,16 +1905,52 @@ class CopilotClient {
     return this.resumeSessionInternal(sessionId, config, contributions, extensionOptions);
   }
   async resumeSessionInternal(sessionId, config, contributions = {}, extensionOptions) {
-    const { workflows } = contributions;
+    if (config.autoModeRecovery && typeof config.onAutoModeSwitchRequest !== "function") {
+      throw new Error("autoModeRecovery requires onAutoModeSwitchRequest");
+    }
     if (config.gitHubToken !== void 0 && config.gitHubTokenProvider !== void 0) {
       throw new Error("gitHubToken and gitHubTokenProvider are mutually exclusive");
     }
-    if (!this.connection || this.startPromise) {
-      await this.start();
+    requestedMemoryStore(config.memory);
+    const signal = await this.getSessionInitializationSignal();
+    const release = await this.acquireSessionInitialization(sessionId, signal);
+    try {
+      signal.throwIfAborted();
+      return await this.resumeSessionWithInitialization(
+        sessionId,
+        config,
+        contributions,
+        signal,
+        extensionOptions
+      );
+    } finally {
+      release();
+    }
+  }
+  async resumeSessionWithInitialization(sessionId, config, contributions, signal, extensionOptions) {
+    const { workflows } = contributions;
+    const storeMemory = requestedMemoryStore(config.memory);
+    signal.throwIfAborted();
+    const connection = this.connection;
+    const resolveAliases = config.autoModeRecovery === true && !this.sessionFsConfig;
+    if (resolveAliases && isAbbreviatedUuidPrefix(sessionId)) {
+      const resolved = await connection.sendRequest(
+        "sessions.findByPrefix",
+        { prefix: sessionId, configDir: config.configDirectory }
+      );
+      const canonicalId = resolved?.sessionId;
+      if (typeof canonicalId !== "string" || canonicalId.length === 0) {
+        throw new Error(`No unique session matches prefix ${sessionId}`);
+      }
+      if (!canonicalId.toLowerCase().startsWith(sessionId.toLowerCase())) {
+        throw new Error(`Runtime returned an unrelated session ID for prefix ${sessionId}`);
+      }
+      sessionId = canonicalId;
+      signal.throwIfAborted();
     }
     const session = new import_session.CopilotSession(
       sessionId,
-      this.connection,
+      connection,
       void 0,
       this.onGetTraceContext,
       {
@@ -1655,6 +1989,7 @@ class CopilotClient {
     if (config.skillProvider) {
       session.registerSkillProvider(config.skillProvider);
     }
+    session._registerMemoryStore(storeMemory);
     const modeDefaults = this.configDefaultsForMode();
     config = { ...modeDefaults, ...config };
     config.customAgentsLocalOnly ??= modeDefaults.customAgentsLocalOnly;
@@ -1670,8 +2005,12 @@ class CopilotClient {
     }
     const toolFilterOptions = this.resolveToolFilterOptions(config);
     this.setupSessionFs(session, config);
-    const replacedSession = this.sessions.get(sessionId);
-    this.sessions.set(sessionId, session);
+    signal.throwIfAborted();
+    const requestedSessionId = sessionId;
+    let replacedRequestedSession;
+    let replacedSession;
+    let releaseCanonicalInitialization;
+    let keepResumedSessionOnRecoveryRejection = false;
     const gitHubTokenProviderRegistrationId = this.registerGitHubTokenProvider(
       config.gitHubTokenProvider,
       sessionId
@@ -1682,14 +2021,29 @@ class CopilotClient {
       );
     }
     try {
-      const response = await this.connection.sendRequest("session.resume", {
+      const traceContext = await this.runInitializationCallback(
+        sessionId,
+        () => (0, import_telemetry.getTraceContext)(this.onGetTraceContext)
+      );
+      signal.throwIfAborted();
+      replacedRequestedSession = this.sessions.get(sessionId);
+      replacedSession = replacedRequestedSession;
+      this.sessions.set(sessionId, session);
+      this.pendingSessionResumes.set(requestedSessionId, {
+        session,
+        connection,
+        gitHubTokenProviderRegistrationId,
+        resolveAliases
+      });
+      const response = await connection.sendRequest("session.resume", {
         allowedModels: config.allowedModels,
-        ...await (0, import_telemetry.getTraceContext)(this.onGetTraceContext),
+        ...traceContext,
         sessionId,
         allowTranscriptRecovery: config.allowTranscriptRecovery,
         clientName: config.clientName,
         model: config.model,
         reasoningEffort: config.reasoningEffort,
+        allowMultipleToolCalls: config.allowMultipleToolCalls,
         reasoningSummary: config.reasoningSummary,
         isExperimentalMode: this.experimentalModeForMode(config.enableExperimentalMode),
         contextTier: config.contextTier,
@@ -1741,6 +2095,7 @@ class CopilotClient {
         ...config.githubMcpToolConfig != null ? { githubMcpToolConfig: config.githubMcpToolConfig } : {},
         requestExitPlanMode: !!config.onExitPlanModeRequest,
         requestAutoModeSwitch: !!config.onAutoModeSwitchRequest,
+        ...config.autoModeRecovery ? { requestAutoModeRecovery: true } : {},
         hooks: !!(config.hooks && Object.values(config.hooks).some(Boolean)),
         workingDirectory: config.workingDirectory,
         additionalDirectories: config.additionalDirectories,
@@ -1769,6 +2124,7 @@ class CopilotClient {
         agent: config.agent,
         skillDirectories: config.skillDirectories,
         ...config.skillProvider ? { hasSkillProvider: true } : {},
+        ...storeMemory ? { hasMemoryStore: true } : {},
         agentDirectories: config.agentDirectories,
         hookDirectories: config.hookDirectories,
         pluginDirectories: config.pluginDirectories,
@@ -1777,7 +2133,7 @@ class CopilotClient {
         disabledMcpServers: config.disabledMcpServers,
         sandboxConfig: config.sandboxConfig,
         infiniteSessions: config.infiniteSessions,
-        memory: config.memory,
+        memory: toWireMemoryConfiguration(config.memory),
         disableResume: config.suppressResumeEvent,
         continuePendingWork: config.continuePendingWork,
         gitHubToken: config.gitHubToken,
@@ -1789,11 +2145,34 @@ class CopilotClient {
         excludedManagedSettings: config.excludedManagedSettings,
         enforceManagedModelDefaults: config.enforceManagedModelDefaults,
         interactiveUser: config.interactiveUser,
+        permissionMode: config.permissionMode,
         managedSettings: config.managedSettings,
         ...extensionOptions?.requestedEnvironmentVariables ? {
           requestedEnvironmentVariables: extensionOptions.requestedEnvironmentVariables
         } : {}
       });
+      const { sessionId: returnedSessionId } = response;
+      if (returnedSessionId && returnedSessionId !== sessionId) {
+        if (!sessionIdsOverlap(requestedSessionId, returnedSessionId)) {
+          releaseCanonicalInitialization = await this.acquireSessionInitialization(
+            returnedSessionId,
+            signal
+          );
+        }
+        replacedSession = this.sessions.get(returnedSessionId);
+        if (this.sessions.get(requestedSessionId) === session) {
+          if (replacedRequestedSession) {
+            this.sessions.set(requestedSessionId, replacedRequestedSession);
+          } else {
+            this.sessions.delete(requestedSessionId);
+          }
+        }
+        session._setSessionId(returnedSessionId);
+        sessionId = returnedSessionId;
+        this.sessions.set(sessionId, session);
+        this.assignGitHubTokenProvider(gitHubTokenProviderRegistrationId, sessionId);
+      }
+      signal.throwIfAborted();
       if (extensionOptions?.requestedEnvironmentVariables) {
         const requested = new Set(extensionOptions.requestedEnvironmentVariables);
         const { grantedEnvironmentVariables } = response;
@@ -1803,32 +2182,59 @@ class CopilotClient {
           }
         }
       }
-      const { workspacePath, capabilities, openCanvases, transcriptRecovery } = response;
+      const {
+        workspacePath,
+        capabilities,
+        openCanvases,
+        transcriptRecovery,
+        permissionModeResult
+      } = response;
       session["_workspacePath"] = workspacePath;
       session.setCapabilities(capabilities);
+      if (config.autoModeRecovery) {
+        keepResumedSessionOnRecoveryRejection = replacedSession !== void 0 && session.capabilities.ui?.autoModeRecovery !== true;
+        await this.requireAutoModeRecovery(
+          session,
+          connection,
+          replacedSession === void 0
+        );
+      }
       session.setOpenCanvases(openCanvases ?? []);
       session.setTranscriptRecovery(transcriptRecovery);
+      session.setPermissionModeResult(permissionModeResult);
       if (config.onMcpAuthRequest) {
-        await this.connection.sendRequest("session.eventLog.registerInterest", {
+        await connection.sendRequest("session.eventLog.registerInterest", {
           sessionId,
           eventType: "mcp.oauth_required"
         });
       }
       await this.updateSessionOptionsForMode(session, config);
+      signal.throwIfAborted();
       this.commitGitHubTokenProvider(sessionId, gitHubTokenProviderRegistrationId);
     } catch (e) {
-      session._markDisconnected();
+      if (!keepResumedSessionOnRecoveryRejection) {
+        session._markDisconnected();
+      }
       if (this.sessions.get(sessionId) === session) {
-        if (replacedSession) {
+        if (replacedSession && !keepResumedSessionOnRecoveryRejection) {
           this.sessions.set(sessionId, replacedSession);
-        } else {
+        } else if (!keepResumedSessionOnRecoveryRejection) {
           this.sessions.delete(sessionId);
         }
       }
       if (gitHubTokenProviderRegistrationId !== void 0) {
-        this.githubTokenProviders.delete(gitHubTokenProviderRegistrationId);
+        if (keepResumedSessionOnRecoveryRejection) {
+          this.commitGitHubTokenProvider(sessionId, gitHubTokenProviderRegistrationId);
+        } else {
+          this.githubTokenProviders.delete(gitHubTokenProviderRegistrationId);
+        }
       }
       throw e;
+    } finally {
+      if (this.pendingSessionResumes.get(requestedSessionId)?.session === session) {
+        this.pendingSessionResumes.delete(requestedSessionId);
+      }
+      releaseCanonicalInitialization?.();
     }
     for (const entry of this.hostHandoffs.values()) {
       if (entry.requestedSessionId === session.sessionId) {
@@ -1837,6 +2243,47 @@ class CopilotClient {
     }
     return session;
   }
+  async requireAutoModeRecovery(session, connection, detachOnFailure = true) {
+    if (session.capabilities.ui?.autoModeRecovery === true) {
+      return;
+    }
+    const error = new Error("The runtime does not support autoModeRecovery");
+    if (!detachOnFailure) {
+      throw error;
+    }
+    const cancellation = new import_node.CancellationTokenSource();
+    try {
+      const response = await withTimeout(
+        connection.sendRequest(
+          "session.detach",
+          { sessionId: session.sessionId },
+          cancellation.token
+        ),
+        AUTO_MODE_RECOVERY_CLEANUP_TIMEOUT_MS,
+        `session.detach timed out after ${AUTO_MODE_RECOVERY_CLEANUP_TIMEOUT_MS}ms`
+      );
+      if (!response.success) {
+        throw new Error(`Failed to detach session: ${response.error || "Unknown error"}`);
+      }
+    } catch (cleanupError) {
+      const failure = new AggregateError([error, cleanupError], error.message);
+      this.recordFailedAutoModeRecoveryCleanup(connection, session.sessionId, failure);
+      throw failure;
+    } finally {
+      cancellation.cancel();
+      cancellation.dispose();
+      session._markDisconnected();
+    }
+    throw error;
+  }
+  recordFailedAutoModeRecoveryCleanup(connection, sessionId, failure) {
+    let failed = this.failedAutoModeRecoveryCleanups.get(connection);
+    if (!failed) {
+      failed = /* @__PURE__ */ new Map();
+      this.failedAutoModeRecoveryCleanups.set(connection, failed);
+    }
+    failed.set(sessionId, failure);
+  }
   /**
    * Start a complete AHP listener hosted in-process by this runtime.
    *
@@ -1948,6 +2395,12 @@ class CopilotClient {
       }
     }
   }
+  abortPendingMemoryStores() {
+    for (const controller of this.pendingMemoryStores) {
+      controller.abort();
+    }
+    this.pendingMemoryStores.clear();
+  }
   disconnectHosts() {
     for (const hostId of /* @__PURE__ */ new Set([
       ...this.hostExitCallbacks.keys(),
@@ -2279,16 +2732,34 @@ class CopilotClient {
     if (!this.connection) {
       throw new Error("Client not connected");
     }
-    const response = await this.connection.sendRequest("session.delete", {
-      sessionId
-    });
+    const signal = await this.getSessionInitializationSignal();
+    const release = await this.acquireSessionInitialization(sessionId, signal);
+    try {
+      signal.throwIfAborted();
+      const connection = this.connection;
+      const session = this.sessions.get(sessionId);
+      await this.requestSessionDeletion(connection, sessionId);
+      signal.throwIfAborted();
+      if (this.sessions.get(sessionId) === session) {
+        this.sessions.delete(sessionId);
+        session?._clearMemoryStore();
+        session?._runOnDisconnected();
+      }
+    } finally {
+      release();
+    }
+  }
+  async requestSessionDeletion(connection, sessionId) {
+    const response = await connection.sendRequest(
+      "session.delete",
+      {
+        sessionId
+      }
+    );
     const { success, error } = response;
     if (!success) {
       throw new Error(`Failed to delete session ${sessionId}: ${error || "Unknown error"}`);
     }
-    const session = this.sessions.get(sessionId);
-    this.sessions.delete(sessionId);
-    session?._runOnDisconnected();
   }
   /**
    * List all available sessions.
@@ -2745,7 +3216,8 @@ stderr: ${this.stderrBuffer.trim().slice(-8192) || "(empty)"}`
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.ffiHost.sendStream);
     this.connection = createMessageConnection(
       new import_node.StreamMessageReader(this.ffiHost.receiveStream),
-      this.messageWriter
+      this.messageWriter,
+      this.sessionInitializationContext
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -2805,7 +3277,8 @@ stderr: ${stderrOutput}` : ""}`
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.cliProcess.stdin);
     this.connection = createMessageConnection(
       new import_node.StreamMessageReader(this.cliProcess.stdout),
-      this.messageWriter
+      this.messageWriter,
+      this.sessionInitializationContext
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -2820,7 +3293,8 @@ stderr: ${stderrOutput}` : ""}`
     this.messageWriter = new TeardownResilientStreamMessageWriter(process.stdout);
     this.connection = createMessageConnection(
       new import_node.StreamMessageReader(process.stdin),
-      this.messageWriter
+      this.messageWriter,
+      this.sessionInitializationContext
     );
     this.attachConnectionHandlers();
     this.connection.listen();
@@ -2843,7 +3317,8 @@ stderr: ${stderrOutput}` : ""}`
         this.messageWriter = new TeardownResilientStreamMessageWriter(this.socket);
         this.connection = createMessageConnection(
           new import_node.StreamMessageReader(this.socket),
-          this.messageWriter
+          this.messageWriter,
+          this.sessionInitializationContext
         );
         this.attachConnectionHandlers();
         this.connection.listen();
@@ -2881,9 +3356,8 @@ stderr: ${stderrOutput}` : ""}`
       "systemMessage.transform",
       async (params) => await this.handleSystemMessageTransform(params)
     );
-    const sessions = this.sessions;
     (0, import_rpc.registerClientSessionApiHandlers)(this.connection, (sessionId) => {
-      const session = sessions.get(sessionId);
+      const session = this.resolveSessionCallback(sessionId);
       if (!session) throw new Error(`No session found for sessionId: ${sessionId}`);
       return session.clientSessionApis;
     });
@@ -2901,12 +3375,20 @@ stderr: ${stderrOutput}` : ""}`
         (params, token) => confirmation.confirm(params, token)
       );
     }
-    if (this.kerberosAuth) {
-      const { callback } = this.kerberosAuth;
+    const resolveProxy = this.network?.resolveProxy;
+    if (resolveProxy) {
+      const connection2 = this.connection;
+      this.connection.onRequest(
+        "network.resolveProxy",
+        (params, token) => resolveClientProxy(connection2, resolveProxy, params, token)
+      );
+    }
+    const authenticateNegotiate = this.network?.authenticateNegotiate;
+    if (authenticateNegotiate) {
       const connection2 = this.connection;
       this.connection.onRequest(
-        "kerberosAuth.acquire",
-        (params, token) => acquireKerberosToken(connection2, callback, params, token)
+        "network.authenticateNegotiate",
+        (params, token) => authenticateClientNegotiate(connection2, authenticateNegotiate, params, token)
       );
     }
     this.connection.onRequest(
@@ -2977,11 +3459,29 @@ stderr: ${stderrOutput}` : ""}`
     this.connection.onRequest(
       "sessionManagement.create",
       async (params, token) => {
-        const session = this.sessions.get(params.sessionId);
+        const session = this.resolveSessionCallback(params.sessionId);
         if (!session) throw new Error("Session creation owner is unavailable");
         return await session._handleSessionManagementCreate(params, token);
       }
     );
+    this.connection.onRequest(
+      "memoryStore.store",
+      async (params, token) => {
+        const session = this.sessions.get(params?.sessionId);
+        if (!session) throw new Error("Memory store owner is unavailable");
+        const controller = new AbortController();
+        this.pendingMemoryStores.add(controller);
+        const subscription = token.onCancellationRequested(() => controller.abort());
+        if (token.isCancellationRequested) controller.abort();
+        try {
+          await session._handleMemoryStore(params, controller.signal);
+        } finally {
+          this.pendingMemoryStores.delete(controller);
+          subscription.dispose();
+        }
+        return null;
+      }
+    );
     this.connection.onRequest(
       "skillProvider.read",
       async (params, token) => {
@@ -3013,6 +3513,7 @@ stderr: ${stderrOutput}` : ""}`
       this.sessions.clear();
       this.githubTokenProviders.clear();
       this.requestAdapter?.cancelPending();
+      this.abortPendingMemoryStores();
       connection.dispose();
       this.socket?.destroy();
       this.connection = null;
@@ -3032,6 +3533,7 @@ stderr: ${stderrOutput}` : ""}`
       }
       if (disconnecting) return;
       disconnecting = true;
+      this.invalidateSessionInitializations();
       this.connectionClosed = true;
       if (messageWriter) messageWriter.suppressWriteErrors = true;
       void connection.drain().then(markDisconnected);
@@ -3063,11 +3565,34 @@ stderr: ${stderrOutput}` : ""}`
       }
     });
   }
+  resolveSessionCallback(sessionId) {
+    let selected;
+    let selectedPrefixLength = -1;
+    for (const [prefix, pending] of this.pendingSessionResumes) {
+      if (pending.connection !== this.connection || !pending.resolveAliases && prefix !== sessionId || prefix.length <= selectedPrefixLength || !(sessionIdsOverlap(prefix, sessionId) && sessionId.length >= prefix.length))
+        continue;
+      const knownOwners = new Set(
+        [...this.sessions.values()].filter(
+          (owner) => owner !== pending.session && sessionIdsOverlap(prefix, owner.sessionId) && owner.sessionId.length >= prefix.length
+        )
+      );
+      if (knownOwners.size > 1) continue;
+      if (pending.session.sessionId !== sessionId) {
+        pending.session._setSessionId(sessionId);
+      }
+      this.assignGitHubTokenProvider(pending.gitHubTokenProviderRegistrationId, sessionId);
+      selected = pending.session;
+      selectedPrefixLength = prefix.length;
+    }
+    return selected ?? this.sessions.get(sessionId);
+  }
   handleSessionEventNotification(notification) {
     if (typeof notification !== "object" || !notification || !("sessionId" in notification) || typeof notification.sessionId !== "string" || !("event" in notification)) {
       return;
     }
-    const session = this.sessions.get(notification.sessionId);
+    const session = this.resolveSessionCallback(
+      notification.sessionId
+    );
     const event = notification.event;
     if (session) {
       session._dispatchEvent(event);
@@ -3111,7 +3636,7 @@ stderr: ${stderrOutput}` : ""}`
     if (!params || typeof params.sessionId !== "string" || typeof params.question !== "string") {
       throw new Error("Invalid user input request payload");
     }
-    const session = this.sessions.get(params.sessionId);
+    const session = this.resolveSessionCallback(params.sessionId);
     if (!session) {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
@@ -3127,7 +3652,7 @@ stderr: ${stderrOutput}` : ""}`
     if (!params || typeof params.sessionId !== "string" || typeof params.summary !== "string" || !Array.isArray(params.actions) || typeof params.recommendedAction !== "string") {
       throw new Error("Invalid exit plan mode request payload");
     }
-    const session = this.sessions.get(params.sessionId);
+    const session = this.resolveSessionCallback(params.sessionId);
     if (!session) {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
@@ -3143,13 +3668,14 @@ stderr: ${stderrOutput}` : ""}`
     if (!params || typeof params.sessionId !== "string") {
       throw new Error("Invalid auto mode switch request payload");
     }
-    const session = this.sessions.get(params.sessionId);
+    const session = this.resolveSessionCallback(params.sessionId);
     if (!session) {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
     const response = await session._handleAutoModeSwitchRequest({
       errorCode: params.errorCode,
-      retryAfterSeconds: params.retryAfterSeconds
+      retryAfterSeconds: params.retryAfterSeconds,
+      ...params.autoModeRecovery === void 0 ? {} : { autoModeRecovery: params.autoModeRecovery }
     });
     return { response };
   }
@@ -3157,7 +3683,7 @@ stderr: ${stderrOutput}` : ""}`
     if (!params || typeof params.sessionId !== "string") {
       throw new Error("Invalid skillProvider payload");
     }
-    const session = this.sessions.get(params.sessionId);
+    const session = this.resolveSessionCallback(params.sessionId);
     if (!session) {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
@@ -3167,7 +3693,7 @@ stderr: ${stderrOutput}` : ""}`
     if (!params || typeof params.sessionId !== "string" || typeof params.hookType !== "string") {
       throw new Error("Invalid hooks invoke payload");
     }
-    const session = this.sessions.get(params.sessionId);
+    const session = this.resolveSessionCallback(params.sessionId);
     if (!session) {
       throw new Error(`Session not found: ${params.sessionId}`);
     }
@@ -3178,7 +3704,7 @@ stderr: ${stderrOutput}` : ""}`
     if (!params || typeof params.sessionId !== "string" || !params.sections || typeof params.sections !== "object") {
       throw new Error("Invalid systemMessage.transform payload");
     }
-    const session = this.sessions.get(params.sessionId);
+    const session = this.resolveSessionCallback(params.sessionId);
     if (!session) {
       throw new Error(`Session not found: ${params.sessionId}`);
     }