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

package/dist/cjs/decisions.js

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 decisions_exports = {};
+__export(decisions_exports, {
+  CopilotDecisions: () => CopilotDecisions,
+  decisionErrorData: () => decisionErrorData,
+  decisionErrorKind: () => decisionErrorKind
+});
+module.exports = __toCommonJS(decisions_exports);
+var import_node = require("vscode-jsonrpc/node");
+class CopilotDecisions {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  rpc;
+  /**
+   * The decision models the account can call: `models.list`'s `decisionModels`,
+   * or an empty list when the runtime does not report them (the feature is off).
+   */
+  async listModels(request, options) {
+    const list = await withAbort(() => this.rpc().models.list(request ?? {}), options?.signal);
+    return list.decisionModels ?? [];
+  }
+  /** Asks every question in `request` and returns the answers, also indexed by name. */
+  async ask(request, options) {
+    const result = await withAbort(() => this.rpc().decisions.ask(request), options?.signal);
+    return {
+      ...result,
+      byName: Object.fromEntries(result.answers.map((answer) => [answer.name, answer]))
+    };
+  }
+  /** Asks one yes/no question about `context`, which may be plain text or a structured context. */
+  async yesNo(question, context, options) {
+    const threshold = options?.threshold ?? 0.5;
+    const result = await this.ask(
+      {
+        context: typeof context === "string" ? { kind: "text", text: context } : context,
+        questions: [{ kind: "boolean", name: "answer", instructions: question }],
+        ...options?.selectionId !== void 0 ? { selectionId: options.selectionId } : {},
+        ...options?.gitHubToken !== void 0 ? { gitHubToken: options.gitHubToken } : {},
+        ...options?.model !== void 0 ? { model: options.model } : {},
+        ...options?.timeoutMs !== void 0 ? { timeoutMs: options.timeoutMs } : {},
+        ...options?.purpose !== void 0 ? { purpose: options.purpose } : {}
+      },
+      options
+    );
+    const answer = result.answers[0];
+    if (answer?.kind !== "boolean") {
+      return { refused: true };
+    }
+    return {
+      refused: false,
+      yes: answer.probability >= threshold,
+      probability: answer.probability
+    };
+  }
+}
+function decisionErrorData(error) {
+  if (!(error instanceof import_node.ResponseError)) {
+    return void 0;
+  }
+  const data = error.data;
+  if (typeof data !== "object" || data === null) {
+    return void 0;
+  }
+  const kind = data.kind;
+  if (typeof kind !== "string" || !DECISION_ERROR_KINDS.has(kind)) {
+    return void 0;
+  }
+  return data;
+}
+const DECISION_ERROR_KINDS = /* @__PURE__ */ new Set([
+  "notEnabled",
+  "noModel",
+  "unauthenticated",
+  "invalidRequest",
+  "tooLarge",
+  "upstreamProtocol",
+  "rateLimited",
+  "timeout",
+  "unavailable",
+  "overloaded"
+]);
+function decisionErrorKind(error) {
+  return decisionErrorData(error)?.kind;
+}
+function abortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error && reason.name === "AbortError") {
+    return reason;
+  }
+  const error = new Error("The decisions call was aborted");
+  error.name = "AbortError";
+  return error;
+}
+function withAbort(call, signal) {
+  if (!signal) {
+    return call();
+  }
+  if (signal.aborted) {
+    return Promise.reject(abortError(signal));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortError(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    call().then(
+      (value) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(value);
+      },
+      (error) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      }
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CopilotDecisions,
+  decisionErrorData,
+  decisionErrorKind
+});

package/dist/cjs/generated/rpc.js

@@ -289,6 +289,17 @@ function createServerRpc(connection) {
       listTokenPriceUnits: async (params) => connection.sendRequest("models.listTokenPriceUnits", params)
     },
     /** @experimental */
+    decisions: {
+      /**
+       * Asks a decision model yes/no, pick-one, or rating questions about shared context and returns normalized probabilities. Sessionless, so a host can classify or route a request before any session exists. Requires the `DECISIONS_API` feature flag. A failed request is a JSON-RPC error whose `data` is a `DecisionErrorData`.
+       *
+       * @param params One request to a decision model: shared context plus the questions to answer about it.
+       *
+       * @returns The decision model's answers.
+       */
+      ask: async (params) => connection.sendRequest("decisions.ask", params)
+    },
+    /** @experimental */
     azureMl: {
       /**
        * Lists eligible Azure ML local models and redacted warnings before a chat session exists.
@@ -957,13 +968,13 @@ function createServerRpc(connection) {
       httpResponseChunk: async (params) => connection.sendRequest("llmInference.httpResponseChunk", params)
     },
     /** @experimental */
-    kerberosAuth: {
+    network: {
       /**
-       * 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.
+       * Registers the calling SDK client's network callbacks, replacing any previous registration. With `resolveProxy`, the client decides the proxies for every request the runtime would otherwise route by ambient proxy settings (proxy environment variables, `NO_PROXY` and operating-system settings), or leaves a request to that routing; requests with an explicitly configured proxy and loopback targets never consult it. With `authenticateNegotiate`, the client supplies the Kerberos tokens for Negotiate proxy challenges instead of native credential lookup. The callbacks serve requests made for the client's sessions and, with `runtime` scope, the runtime's shared traffic, which includes background requests and remote MCP server connections; 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.
+       * @param params Registers the calling SDK connection's network callbacks, replacing any previous registration.
        */
-      setProvider: async (params) => connection.sendRequest("kerberosAuth.setProvider", params)
+      setProvider: async (params) => connection.sendRequest("network.setProvider", params)
     },
     /** @experimental */
     sessions: {
@@ -1205,6 +1216,17 @@ function createServerRpc(connection) {
        * @returns Entries for the selected account.
        */
       refresh: async (params) => connection.sendRequest("connectors.refresh", params)
+    },
+    /** @experimental */
+    lsp: {
+      /**
+       * Reads the process-wide language-server inventory for a working directory without starting servers. Uses the host configuration home and persisted workspace trust.
+       *
+       * @param params Parameters for a process-wide, read-only language-server inventory.
+       *
+       * @returns Runtime-owned configuration inventory and configuration diagnostics.
+       */
+      list: async (params) => connection.sendRequest("lsp.list", params)
     }
   };
 }
@@ -1506,6 +1528,12 @@ function createInternalServerRpc(connection) {
          * @returns Outcome of validating and writing one top-level setting subtree.
          */
         applyTopKey: async (params) => connection.sendRequest("user.settings.applyTopKey", params),
+        /**
+         * Writes or removes one raw user setting under the settings transaction and file locks. Preserves unrelated keys and legacy spellings, and records explicit mutations so startup cleanup cannot delete the user's choice. Unlike applyTopKey, this operation does not validate or canonicalize settings. Invalid or unreadable files are replaced by default, matching the existing raw writer; set refuseOnReadFailure=true to reject instead. Deletion requires delete=true; otherwise value must be present.
+         *
+         * @param params A raw top-level setting edit with explicit read-failure behavior.
+         */
+        writeKey: async (params) => connection.sendRequest("user.settings.writeKey", params),
         /**
          * Replaces the user settings file's entire content in one write. A key absent from `settings` is removed, which is what distinguishes this from `user.settings.set`: that one merges, so it can never clear a key the caller has dropped. For a caller saving the result of a raw edit, a merge would silently resurrect every key the user deleted. Records the same one-time mutation marks a per-key write records, so a setting the user has now chosen explicitly stops being migrated for them.
          *
@@ -2812,6 +2840,14 @@ function createSessionRpc(connection, sessionId) {
        * @returns The session's authoritative model snapshot. Auto preference fields are configuration for the virtual `auto` model and do not change the selected model identifier. The context tier reflects `Session.getContextTier()`, restored from the session journal on resume.
        */
       getCurrent: async () => connection.sendRequest("session.model.getCurrent", { sessionId }),
+      /**
+       * Reads the session's cached startup model state without fetching a catalog or resolving credentials. An interactive host can claim the one-time enablement prompt after applying its startup configuration. Claims remain shared with the owning host and are scoped to this session's lifetime.
+       *
+       * @param params Options for a host's startup model admission check.
+       *
+       * @returns A cached startup model snapshot and an optional one-time enablement prompt. This check never resolves credentials or fetches a catalog.
+       */
+      startupAdmission: async (params) => connection.sendRequest("session.model.startupAdmission", { ...params, sessionId }),
       /**
        * Switches the session to a model and optional reasoning configuration.
        *
@@ -2841,7 +2877,7 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Reasoning effort level to apply to the currently selected model.
        *
-       * @returns Update the session's reasoning effort without changing the selected model. Use `switchTo` instead when you also need to change the model. The runtime stores the effort on the session and applies it to subsequent turns.
+       * @returns Update the session's reasoning effort without changing the selected model. Use `switchTo` instead when you also need to change the model. The runtime applies the effort to the next new model request, including tool continuations, without changing retries of an already-started request.
        */
       setReasoningEffort: async (params) => connection.sendRequest("session.model.setReasoningEffort", { ...params, sessionId }),
       /**
@@ -3787,6 +3823,12 @@ function createSessionRpc(connection, sessionId) {
          */
         refresh: async (params) => connection.sendRequest("session.plugins.marketplaces.refresh", { ...params, sessionId })
       },
+      /**
+       * Reads Team and managed soft plugin defaults for the live session. Does not install plugins or persist user preferences.
+       *
+       * @returns Soft plugin defaults for this session, without persistent user preferences or hard policy.
+       */
+      getDefaults: async () => connection.sendRequest("session.plugins.getDefaults", { sessionId }),
       /**
        * Reloads the session's plugin set, refreshing MCP servers, custom agents, hooks, and skills cache so SDK-driven changes via `server.plugins.*` take effect immediately.
        *
@@ -3861,7 +3903,41 @@ function createSessionRpc(connection, sessionId) {
        *
        * @param params Parameters for (re)loading the merged LSP configuration set.
        */
-      initialize: async (params) => connection.sendRequest("session.lsp.initialize", { ...params, sessionId })
+      initialize: async (params) => connection.sendRequest("session.lsp.initialize", { ...params, sessionId }),
+      /**
+       * Reads language-server configuration and diagnostics using the session's settings and active plugins. Explicit force reloads the files from disk.
+       *
+       * @param params Parameters for (re)loading the merged LSP configuration set.
+       *
+       * @returns Runtime-owned configuration inventory and configuration diagnostics.
+       */
+      list: async (params) => connection.sendRequest("session.lsp.list", { ...params, sessionId }),
+      /**
+       * Initializes and retains configured language servers under the session's effective LSP sandbox policy. The runtime owns client leases, callbacks, and process lifetime.
+       *
+       * @param params Parameters for (re)loading the merged LSP configuration set.
+       *
+       * @returns The servers retained by the session after warmup.
+       */
+      start: async (params) => connection.sendRequest("session.lsp.start", { ...params, sessionId }),
+      /**
+       * Stops the session's language-server clients without changing another session or the process-wide inventory.
+       */
+      stop: async () => connection.sendRequest("session.lsp.stop", { sessionId }),
+      /**
+       * Probes one configured language-server process under the session's effective LSP sandbox policy, then terminates the probe process.
+       *
+       * @param params A server selected for a startup probe.
+       *
+       * @returns Result of a language-server startup probe.
+       */
+      diagnose: async (params) => connection.sendRequest("session.lsp.diagnose", { ...params, sessionId }),
+      /**
+       * Persists a user-level language-server enable override in the session's configuration home. Reload configuration to apply it.
+       *
+       * @param params A persistent user-level server toggle.
+       */
+      set: async (params) => connection.sendRequest("session.lsp.set", { ...params, sessionId })
     },
     /** @experimental */
     extensions: {
@@ -4114,11 +4190,13 @@ function createSessionRpc(connection, sessionId) {
        */
       handlePendingExitPlanMode: async (params) => connection.sendRequest("session.ui.handlePendingExitPlanMode", { ...params, sessionId }),
       /**
-       * Registers an in-process handler for auto-mode-switch requests so the server bridge skips dispatch.
+       * Registers an in-process handler for auto-mode-switch requests so the server bridge skips dispatch. Set `autoModeRecovery` to also handle Auto recovery consent offers.
+       *
+       * @param params Optional recovery-aware enrollment for an in-process Auto-switch handler.
        *
-       * @returns Register an in-process handler for `auto_mode_switch.requested` events. The caller still attaches the actual listener via the standard event-subscription mechanism; this registration solely tells the server bridge to skip its own dispatch (so a remote client doesn't race the in-process handler for the same requestId).
+       * @returns Registers an in-process Auto-switch responder and suppresses server-bridge dispatch to avoid competing responders for the same requestId. When requested, also enrolls the responder for active-request Auto recovery and acknowledges support. Attach the actual listener separately through standard event subscriptions before starting a turn, and release the handle when the responder is removed.
        */
-      registerDirectAutoModeSwitchHandler: async () => connection.sendRequest("session.ui.registerDirectAutoModeSwitchHandler", { sessionId }),
+      registerDirectAutoModeSwitchHandler: async (params) => connection.sendRequest("session.ui.registerDirectAutoModeSwitchHandler", { ...params, sessionId }),
       /**
        * Unregisters a previously-registered in-process auto-mode-switch handler by its opaque handle.
        *
@@ -4935,7 +5013,74 @@ function createInternalSessionRpc(connection, sessionId) {
        *
        * @param params Server name identifying the external client to remove.
        */
-      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { ...params, sessionId })
+      unregisterExternalClient: async (params) => connection.sendRequest("session.mcp.unregisterExternalClient", { ...params, sessionId }),
+      /** @experimental */
+      oauth: {
+        /**
+         * Reserves a host-driven OAuth flow identity before authentication or cancellation.
+         *
+         * @param params Correlation identity reserved before an effectful authentication request.
+         */
+        prepareFlow: async (params) => connection.sendRequest("session.mcp.oauth.prepareFlow", { ...params, sessionId }),
+        /**
+         * Cancels an exact host-driven OAuth flow on its original session requester.
+         *
+         * @param params Correlation identity reserved before an effectful authentication request.
+         */
+        cancelFlow: async (params) => connection.sendRequest("session.mcp.oauth.cancelFlow", { ...params, sessionId }),
+        /**
+         * Authenticates an arbitrary MCP URL through the original session credential owner, with correlated host progress and authorization callbacks.
+         *
+         * @param params Full host-driven authentication for an arbitrary, possibly unsaved, MCP URL.
+         *
+         * @returns Token projection for the existing host-delegated provider.
+         */
+        authenticate: async (params) => connection.sendRequest("session.mcp.oauth.authenticate", { ...params, sessionId }),
+        /**
+         * Checks whether the selected MCP credential owner has a valid access token.
+         *
+         * @param params A narrow token-validity query against the chosen credential owner.
+         *
+         * @returns Whether the credential operation succeeded.
+         */
+        hasValidTokens: async (params) => connection.sendRequest("session.mcp.oauth.hasValidTokens", { ...params, sessionId }),
+        /**
+         * Attempts silent MCP token refresh without opening a browser.
+         *
+         * @param params A narrow token-validity query against the chosen credential owner.
+         *
+         * @returns Whether the credential operation succeeded.
+         */
+        tryRefreshTokens: async (params) => connection.sendRequest("session.mcp.oauth.tryRefreshTokens", { ...params, sessionId }),
+        /**
+         * Stores a confidential MCP client's static secret in its selected credential owner.
+         *
+         * @param params Persist a confidential client's static secret without exposing token-store CRUD.
+         */
+        saveStaticClientSecret: async (params) => connection.sendRequest("session.mcp.oauth.saveStaticClientSecret", { ...params, sessionId }),
+        /**
+         * Releases an explicit host-owned MCP OAuth store on its original session requester.
+         *
+         * @param params Dispose an explicit host store without altering the session authorizer's owner.
+         */
+        disposeStore: async (params) => connection.sendRequest("session.mcp.oauth.disposeStore", { ...params, sessionId }),
+        /**
+         * Completes a tokenless initialize handshake for an unsaved remote MCP URL, preserving session egress and the refusing authentication challenge.
+         *
+         * @param params Tokenless initialize handshake for a possibly unsaved remote MCP server.
+         *
+         * @returns Outcome of the tokenless handshake, with the original challenge when available.
+         */
+        testConnection: async (params) => connection.sendRequest("session.mcp.oauth.testConnection", { ...params, sessionId }),
+        /**
+         * Derives an MCP credential key through the selected session account and store owner.
+         *
+         * @param params Derive a credential key through the selected account and store owner.
+         *
+         * @returns The selected owner's OAuth credential key.
+         */
+        storeKey: async (params) => connection.sendRequest("session.mcp.oauth.storeKey", { ...params, sessionId })
+      }
     },
     /** @experimental */
     diagnostics: {
@@ -5290,10 +5435,15 @@ 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("network.resolveProxy", async (params) => {
+    const handler = handlers.network;
+    if (!handler) throw new Error("No network client-global handler registered");
+    return handler.resolveProxy(params);
+  });
+  connection.onRequest("network.authenticateNegotiate", async (params) => {
+    const handler = handlers.network;
+    if (!handler) throw new Error("No network client-global handler registered");
+    return handler.authenticateNegotiate(params);
   });
   connection.onRequest("llmInference.httpRequestStart", async (params) => {
     const handler = handlers.llmInference;

package/dist/cjs/index.js

@@ -23,6 +23,7 @@ __export(index_exports, {
   Canvas: () => import_canvas.Canvas,
   CanvasError: () => import_canvas.CanvasError,
   CopilotClient: () => import_client.CopilotClient,
+  CopilotDecisions: () => import_decisions.CopilotDecisions,
   CopilotRequestHandler: () => import_types2.CopilotRequestHandler,
   CopilotSession: () => import_session.CopilotSession,
   CopilotWebSocketCloseStatus: () => import_types2.CopilotWebSocketCloseStatus,
@@ -40,12 +41,15 @@ __export(index_exports, {
   createAttributedPermissionResult: () => import_types2.createAttributedPermissionResult,
   createCanvas: () => import_canvas.createCanvas,
   createSessionFsAdapter: () => import_types2.createSessionFsAdapter,
+  decisionErrorData: () => import_decisions.decisionErrorData,
+  decisionErrorKind: () => import_decisions.decisionErrorKind,
   defineTool: () => import_types2.defineTool,
   defineWorkflow: () => import_workflow.defineWorkflow,
   isWorkflowRunTerminal: () => import_workflow.isWorkflowRunTerminal
 });
 module.exports = __toCommonJS(index_exports);
 var import_client = require("./client.js");
+var import_decisions = require("./decisions.js");
 var import_host = require("./host.js");
 var import_types = require("./types.js");
 var import_toolSet = require("./toolSet.js");
@@ -60,6 +64,7 @@ var import_types2 = require("./types.js");
   Canvas,
   CanvasError,
   CopilotClient,
+  CopilotDecisions,
   CopilotRequestHandler,
   CopilotSession,
   CopilotWebSocketCloseStatus,
@@ -77,6 +82,8 @@ var import_types2 = require("./types.js");
   createAttributedPermissionResult,
   createCanvas,
   createSessionFsAdapter,
+  decisionErrorData,
+  decisionErrorKind,
   defineTool,
   defineWorkflow,
   isWorkflowRunTerminal

package/dist/cjs/session.js

@@ -283,8 +283,8 @@ class CopilotSession {
    * @param traceContextProvider - Optional callback to get W3C Trace Context for outbound RPCs
    * @internal This constructor is internal. Use {@link CopilotClient.createSession} to create sessions.
    */
-  constructor(sessionId, connection, _workspacePath, traceContextProvider, options) {
-    this.sessionId = sessionId;
+  constructor(_sessionId, connection, _workspacePath, traceContextProvider, options) {
+    this._sessionId = _sessionId;
     this.connection = connection;
     this._workspacePath = _workspacePath;
     this.traceContextProvider = traceContextProvider;
@@ -292,10 +292,11 @@ class CopilotSession {
     this.managedSettingsEnabled = options?.managedSettingsEnabled === true;
     this.onDisconnected = options?.onDisconnected;
   }
-  sessionId;
+  _sessionId;
   connection;
   _workspacePath;
   _transcriptRecovery;
+  _permissionModeResult;
   eventHandlers = /* @__PURE__ */ new Set();
   typedEventHandlers = /* @__PURE__ */ new Map();
   toolHandlers = /* @__PURE__ */ new Map();
@@ -316,6 +317,7 @@ class CopilotSession {
   autoModeSwitchHandler;
   skillProvider;
   sessionCreationHandler;
+  memoryStoreHandler;
   hooks;
   transformCallbacks;
   _rpc = null;
@@ -468,6 +470,15 @@ class CopilotSession {
       void read();
     });
   }
+  get sessionId() {
+    return this._sessionId;
+  }
+  /** @internal */
+  _setSessionId(sessionId) {
+    this._sessionId = sessionId;
+    this._rpc = null;
+    this._internalRpc = null;
+  }
   /**
    * Typed session-scoped RPC methods.
    */
@@ -500,6 +511,18 @@ class CopilotSession {
   setTranscriptRecovery(recovery) {
     this._transcriptRecovery = recovery;
   }
+  /**
+   * Outcome of the `permissionMode` requested when this session was created
+   * or resumed: whether it was applied, and the authoritative mode the
+   * session started in. Undefined when no mode was requested.
+   */
+  get permissionModeResult() {
+    return this._permissionModeResult;
+  }
+  /** @internal */
+  setPermissionModeResult(result) {
+    this._permissionModeResult = result;
+  }
   /**
    * Host capabilities reported when the session was created or resumed.
    * Use this to check feature support before calling capability-gated APIs.
@@ -548,6 +571,7 @@ class CopilotSession {
       prompt: options.prompt,
       source: options.source,
       displayPrompt: options.displayPrompt,
+      clientTurnId: options.clientTurnId,
       attachments: options.attachments,
       mode: options.mode,
       agentMode: options.agentMode,
@@ -907,6 +931,7 @@ class CopilotSession {
       controller.abort();
     }
     this.pendingSessionCreations.clear();
+    this._clearMemoryStore();
     this.eventHandlers.clear();
     this.typedEventHandlers.clear();
     this.toolHandlers.clear();
@@ -918,6 +943,7 @@ class CopilotSession {
     this.autoModeSwitchHandler = void 0;
     this.skillProvider = void 0;
     this.sessionCreationHandler = void 0;
+    this.memoryStoreHandler = void 0;
     this.hooks = void 0;
     this.traceContextProvider = void 0;
     this.bearerTokenProviders.clear();
@@ -1135,6 +1161,7 @@ class CopilotSession {
       return;
     }
     this.pendingExternalTools.set(requestId, controller);
+    let claimed = false;
     try {
       let availableTools;
       if (toolName === TOOL_SEARCH_TOOL_NAME) {
@@ -1191,17 +1218,45 @@ class CopilotSession {
       if (!this._claimExternalTool(requestId, controller)) {
         return;
       }
+      claimed = true;
       await this.rpc.tools.handlePendingToolCall({ requestId, result });
     } catch (error) {
-      if (!this._claimExternalTool(requestId, controller)) {
+      if (claimed) {
+        if (this.disconnected) {
+          return;
+        }
+        console.error("External tool result delivery failed", {
+          sessionId: this.sessionId,
+          requestId,
+          toolName,
+          error
+        });
+      } else if (!this._claimExternalTool(requestId, controller)) {
         return;
       }
-      const message = error instanceof Error ? error.message : String(error);
-      try {
-        await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
-      } catch (rpcError) {
-        if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
-          throw rpcError;
+      let message = error instanceof Error ? error.message : String(error);
+      if (!message) {
+        message = error instanceof Error && error.name || "Error";
+      }
+      for (let attempt = 0; attempt < (claimed ? 1 : 2); attempt++) {
+        try {
+          await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
+          return;
+        } catch (rpcError) {
+          const retryable = !claimed && attempt === 0 && !this.disconnected;
+          if (!retryable) {
+            if (!(rpcError instanceof import_node.ConnectionError || rpcError instanceof import_node.ResponseError)) {
+              throw rpcError;
+            }
+            return;
+          }
+          console.error("External tool error delivery failed", {
+            sessionId: this.sessionId,
+            requestId,
+            toolName,
+            error: rpcError
+          });
+          message = (rpcError instanceof Error ? rpcError.message || rpcError.name : "") || String(rpcError) || "Error";
         }
       }
     } finally {
@@ -1904,6 +1959,43 @@ class CopilotSession {
       throw error;
     }
   }
+  /**
+   * Registers the callback the runtime calls through `memoryStore.store`.
+   * Registered before create or resume declares `hasMemoryStore`.
+   * @internal
+   */
+  _registerMemoryStore(handler) {
+    this.assertConnected();
+    this.memoryStoreHandler = handler;
+  }
+  /** @internal */
+  _clearMemoryStore() {
+    this.memoryStoreHandler = void 0;
+  }
+  /** @internal */
+  async _handleMemoryStore(memory, signal) {
+    this.assertConnected();
+    const handler = this.memoryStoreHandler;
+    if (!handler) throw new Error("No memory store is registered");
+    try {
+      await handler(
+        {
+          sessionId: memory.sessionId,
+          subject: memory.subject,
+          fact: memory.fact,
+          citations: memory.citations,
+          reason: memory.reason
+        },
+        { signal }
+      );
+    } catch (error) {
+      if (signal.aborted) {
+        throw new import_node.ResponseError(-32800, "Memory store call cancelled");
+      }
+      console.warn("Memory store callback failed", error);
+      throw new Error("Memory store callback failed");
+    }
+  }
   /** @internal */
   async _handleSessionManagementCreate(request, token) {
     this.assertConnected();

package/dist/cliVersion.d.ts

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

package/dist/cliVersion.js

@@ -1,4 +1,4 @@
-const COPILOT_CLI_VERSION = "1.0.106-10";
+const COPILOT_CLI_VERSION = "1.0.108-0";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 export {
   COPILOT_CLI_USE_NPM_PACKAGE,