@github/copilot-sdk-win32-x64 1.0.15-preview.2 → 1.0.15-preview.4

package/copilot-sdk/index.js

@@ -115,7 +115,7 @@ var require_messages = __commonJS({
       ErrorCodes4.jsonrpcReservedErrorRangeEnd = -32e3;
       ErrorCodes4.serverErrorEnd = -32e3;
     })(ErrorCodes3 || (exports.ErrorCodes = ErrorCodes3 = {}));
-    var ResponseError3 = class _ResponseError extends Error {
+    var ResponseError4 = class _ResponseError extends Error {
       constructor(code, message, data) {
         super(message);
         this.code = is.number(code) ? code : ErrorCodes3.UnknownErrorCode;
@@ -133,7 +133,7 @@ var require_messages = __commonJS({
         return result;
       }
     };
-    exports.ResponseError = ResponseError3;
+    exports.ResponseError = ResponseError4;
     var ParameterStructures = class _ParameterStructures {
       constructor(kind) {
         this.kind = kind;
@@ -933,7 +933,7 @@ var require_cancellation = __commonJS({
         }
       }
     };
-    var CancellationTokenSource = class {
+    var CancellationTokenSource2 = class {
       get token() {
         if (!this._token) {
           this._token = new MutableToken();
@@ -955,7 +955,7 @@ var require_cancellation = __commonJS({
         }
       }
     };
-    exports.CancellationTokenSource = CancellationTokenSource;
+    exports.CancellationTokenSource = CancellationTokenSource2;
   }
 });
 
@@ -4031,7 +4031,7 @@ var init_ffiRuntimeHost = __esm({
 });
 
 // src/sdk/nodejs/dist/client.js
-var import_node2 = __toESM(require_node(), 1);
+var import_node3 = __toESM(require_node(), 1);
 import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync3 } from "node:fs";
@@ -4080,6 +4080,15 @@ function createServerRpc(connection) {
       getBuiltInCatalog: async () => connection.sendRequest("models.getBuiltInCatalog", {})
     },
     /** @experimental */
+    sandbox: {
+      /**
+       * Reports whether the host running this runtime can run the command sandbox, without starting a session or spawning a sandboxed command.
+       *
+       * @returns Whether the host running this runtime can run the command sandbox. The runtime checks `supported` once per process. A capability answer can change while the process runs, for example after the user installs a missing package.
+       */
+      getHostSupport: async () => connection.sendRequest("sandbox.getHostSupport", {})
+    },
+    /** @experimental */
     tools: {
       /**
        * Lists built-in tools available for a model.
@@ -4200,7 +4209,74 @@ function createServerRpc(connection) {
        *
        * @returns Outcome of an mcp.planInstall call: either a normalised plan, or one typed refusal. Nothing is written in either case.
        */
-      planInstall: async (params) => connection.sendRequest("mcp.planInstall", params)
+      planInstall: async (params) => connection.sendRequest("mcp.planInstall", params),
+      /**
+       * Consumes a bound catalogue plan and retains one exact fully resolved personal remote MCP operation requiring no supplied values or configured secrets. Returns its runtime operation ID and original expiry before any confirmation, activation, writer initialisation or installation effect. Register the original connection, operation and selected-session binding before calling applyInstall. Missing lower owned admission is unavailable, never a raw-config fallback.
+       *
+       * @param params Side-effect-free preparation of one original bound remote MCP choice.
+       *
+       * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+       */
+      prepareInstall: async (params) => connection.sendRequest("mcp.prepareInstall", params),
+      /**
+       * Consumes a retained prepared MCP operation once, revalidates its original authority, requests explicit human consent through installations.confirm on the original connection, then revalidates source and applies the sealed transaction. An uncertain result requires original-operation inspection or recovery, never replay.
+       *
+       * @param params Applies exactly one previously prepared operation on its original connection.
+       *
+       * @returns An installation result together with the exact honoured contract, or a negotiation refusal.
+       */
+      applyInstall: async (params) => connection.sendRequest("mcp.applyInstall", params),
+      /**
+       * Prepares a read-only removal plan for an exact owned receipt under the selected existing session. Returns the original operation ID before confirmation; neither planning nor abandonment changes configuration or shared OAuth credentials.
+       *
+       * @param params Read-only preparation of one owned removal under fresh selected-session authority.
+       *
+       * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+       */
+      planUninstall: async (params) => connection.sendRequest("mcp.planUninstall", params),
+      /**
+       * Consumes the original owned-removal plan once and requests fresh exact human confirmation on its original connection. Drift is refused; unrelated manual configuration and shared OAuth credentials are preserved.
+       *
+       * @param params One-use application of the exact retained removal plan.
+       *
+       * @returns An installation result together with the exact honoured contract, or a negotiation refusal.
+       */
+      applyUninstall: async (params) => connection.sendRequest("mcp.applyUninstall", params),
+      /** @experimental */
+      installations: {
+        /**
+         * Reads receipt-owned MCP inventory for the selected account and host without activating servers or reconstructing missing ownership. Configuration ownership does not prove session-specific usability.
+         *
+         * @param params New-work inventory or recovery request under an explicitly selected existing session.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        list: async (params) => connection.sendRequest("mcp.installations.list", params),
+        /**
+         * Reconciles already-confirmed durable MCP transactions, then inspects owned inventory. Does not replay apply or reconstruct deleted ownership metadata; unresolved or unsafe evidence remains an explicit refusal.
+         *
+         * @param params New-work inventory or recovery request under an explicitly selected existing session.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        recover: async (params) => connection.sendRequest("mcp.installations.recover", params),
+        /**
+         * Inspects a known operation only on its original connection. Remains available after account or selected-session loss; does not acquire new authority or rebind an operation.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        status: async (params) => connection.sendRequest("mcp.installations.status", params),
+        /**
+         * Requests cancellation of a known operation on its original connection, including before apply or confirmation. Already-started effects retain their transaction lease and report an honest terminal or recovery outcome.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Management result with contract receipt, or a typed request/negotiation refusal.
+         */
+        cancel: async (params) => connection.sendRequest("mcp.installations.cancel", params)
+      }
     },
     /** @experimental */
     extensions: {
@@ -4223,6 +4299,115 @@ function createServerRpc(connection) {
        */
       disable: async (params) => connection.sendRequest("extensions.disable", params)
     },
+    /** @experimental */
+    skills: {
+      /**
+       * Plans installation of a verified Agent Finder Skill candidate without writing files. The returned review is safe to present to a user and installing always leaves the Skill disabled until separately enabled.
+       *
+       * @param params Side-effect-free planning of one verified Agent Finder Skill candidate.
+       *
+       * @returns Skill installation management result with the honoured contract, or a typed refusal.
+       */
+      planInstall: async (params) => connection.sendRequest("skills.planInstall", params),
+      /**
+       * Consumes one verified Skill installation plan, requests explicit human consent through installations.confirm on the original connection, then revalidates and installs the Skill disabled.
+       *
+       * @param params Applies exactly one retained verified Skill installation plan.
+       *
+       * @returns Skill installation result with the honoured contract, or a typed request/negotiation refusal.
+       */
+      applyInstall: async (params) => connection.sendRequest("skills.applyInstall", params),
+      /** @experimental */
+      installations: {
+        /**
+         * Lists owned verified Agent Finder Skill installations for the selected existing session. Listing is never gated by the Skill-install feature flag.
+         *
+         * @param params Inventory request under an explicitly selected existing session.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        list: async (params) => connection.sendRequest("skills.installations.list", params),
+        /**
+         * Reconciles interrupted owned Skill installation work for the selected existing session, then inspects owned inventory. Recovery is never gated by the Skill-install feature flag.
+         *
+         * @param params Inventory request under an explicitly selected existing session.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        recover: async (params) => connection.sendRequest("skills.installations.recover", params),
+        /**
+         * Inspects a known Skill installation operation on its original runtime connection. Status is never gated by the Skill-install feature flag.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        status: async (params) => connection.sendRequest("skills.installations.status", params),
+        /**
+         * Requests cancellation of a known Skill installation operation before commit. Already-started durable work requires recovery instead of silent replay.
+         *
+         * @param params Existing-operation control. A new session selector is deliberately not accepted.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        cancel: async (params) => connection.sendRequest("skills.installations.cancel", params),
+        /**
+         * Atomically persists enablement for one owned Agent Finder Skill and reconciles the selected bound session. Enablement is installation-scoped by receipt identity and is never gated by the Skill-install feature flag.
+         *
+         * @param params Persisted enablement update for one owned Skill installation.
+         *
+         * @returns Skill installation management result with the honoured contract, or a typed refusal.
+         */
+        setEnabled: async (params) => connection.sendRequest("skills.installations.setEnabled", params)
+      },
+      /**
+       * Prepares a read-only removal plan for an owned verified Agent Finder Skill installation. Uninstall planning is never gated by the Skill-install feature flag.
+       *
+       * @param params Read-only preparation of one owned Skill removal under fresh selected-session authority.
+       *
+       * @returns Skill installation management result with the honoured contract, or a typed refusal.
+       */
+      planUninstall: async (params) => connection.sendRequest("skills.planUninstall", params),
+      /**
+       * Consumes an owned Skill removal plan, requests explicit human consent through installations.confirm, refuses drift, and removes the exact owned files through quarantine.
+       *
+       * @param params One-use application of the exact retained Skill removal plan.
+       *
+       * @returns Skill installation result with the honoured contract, or a typed request/negotiation refusal.
+       */
+      applyUninstall: async (params) => connection.sendRequest("skills.applyUninstall", params),
+      /** @experimental */
+      config: {
+        /**
+         * Replaces the global list of disabled skills.
+         *
+         * @param params Skill names to mark as disabled in global configuration, replacing any previous list.
+         */
+        setDisabledSkills: async (params) => connection.sendRequest("skills.config.setDisabledSkills", params),
+        /**
+         * Atomically adds or removes one skill from the disabled list.
+         *
+         * @param params Adds or removes a single skill from the global disabled list, leaving every other entry untouched.
+         */
+        setSkillDisabled: async (params) => connection.sendRequest("skills.config.setSkillDisabled", params)
+      },
+      /**
+       * Discovers skills across global and project sources.
+       *
+       * @param params Optional project paths and additional skill directories to include in discovery.
+       *
+       * @returns Skills discovered across global and project sources.
+       */
+      discover: async (params) => connection.sendRequest("skills.discover", params),
+      /**
+       * Returns the canonical directories where a client may create skills that the runtime will recognize, including ones that do not exist yet. Project directories become active once created.
+       *
+       * @param params Optional project paths to enumerate.
+       *
+       * @returns Canonical locations where skills can be created so the runtime will recognize them.
+       */
+      getDiscoveryPaths: async (params) => connection.sendRequest("skills.getDiscoveryPaths", params)
+    },
     /**
      * Registers the calling SDK client as the per-entrypoint extension launch provider. Call before creating any sessions. When omitted, the runtime uses its built-in extension launcher.
      *
@@ -4348,40 +4533,6 @@ function createServerRpc(connection) {
       }
     },
     /** @experimental */
-    skills: {
-      /** @experimental */
-      config: {
-        /**
-         * Replaces the global list of disabled skills.
-         *
-         * @param params Skill names to mark as disabled in global configuration, replacing any previous list.
-         */
-        setDisabledSkills: async (params) => connection.sendRequest("skills.config.setDisabledSkills", params),
-        /**
-         * Atomically adds or removes one skill from the disabled list.
-         *
-         * @param params Adds or removes a single skill from the global disabled list, leaving every other entry untouched.
-         */
-        setSkillDisabled: async (params) => connection.sendRequest("skills.config.setSkillDisabled", params)
-      },
-      /**
-       * Discovers skills across global and project sources.
-       *
-       * @param params Optional project paths and additional skill directories to include in discovery.
-       *
-       * @returns Skills discovered across global and project sources.
-       */
-      discover: async (params) => connection.sendRequest("skills.discover", params),
-      /**
-       * Returns the canonical directories where a client may create skills that the runtime will recognize, including ones that do not exist yet. Project directories become active once created.
-       *
-       * @param params Optional project paths to enumerate.
-       *
-       * @returns Canonical locations where skills can be created so the runtime will recognize them.
-       */
-      getDiscoveryPaths: async (params) => connection.sendRequest("skills.getDiscoveryPaths", params)
-    },
-    /** @experimental */
     agents: {
       /**
        * Discovers custom agents across user, project, plugin, and remote sources.
@@ -4786,6 +4937,17 @@ function createInternalServerRpc(connection) {
        * @param params Params to attach or detach an in-process ExtensionController delegate.
        */
       configureSessionExtensions: async (params) => connection.sendRequest("sessions.configureSessionExtensions", params)
+    },
+    /** @experimental */
+    accounts: {
+      /**
+       * Acquire a Microsoft Entra access token through the runtime's OneAuth broker. Account-scoped because it uses the same native broker as the account stack: a trusted host application mints a scoped Entra token for its own use, most notably to authenticate to a remote MCP server whose authorization server is Entra ID (in place of the generic browser-OAuth flow).
+       *
+       * @param params OneAuth token request supplied by a trusted host application.
+       *
+       * @returns Result of a OneAuth token acquisition.
+       */
+      acquireEntraToken: async (params) => connection.sendRequest("accounts.acquireEntraToken", params)
     }
   };
 }
@@ -4888,6 +5050,58 @@ function createSessionRpc(connection, sessionId) {
       setCredentials: async (params) => connection.sendRequest("session.gitHubAuth.setCredentials", { sessionId, ...params })
     },
     /** @experimental */
+    accounts: {
+      /**
+       * Enumerate a typed accounts collection: the signed-in accounts, or the providers offered for interactive login.
+       *
+       * @param params Enumerate request carrying the typed collection query.
+       *
+       * @returns The enumerated collection, keyed by the same selector as the query.
+       */
+      enumerate: async (params) => connection.sendRequest("session.accounts.enumerate", { sessionId, ...params }),
+      /**
+       * Read one typed accounts datum: the active account, a neutral status summary, or the last authentication errors.
+       *
+       * @param params Read request carrying the typed datum query.
+       *
+       * @returns The read result, keyed by the same selector as the query.
+       */
+      get: async (params) => connection.sendRequest("session.accounts.get", { sessionId, ...params }),
+      /**
+       * Apply one non-interactive accounts mutation: switch the active account, log an account out, or set credentials from a token.
+       *
+       * @param params Mutation request carrying the typed write command.
+       *
+       * @returns Result of a non-interactive accounts mutation.
+       */
+      set: async (params) => connection.sendRequest("session.accounts.set", { sessionId, ...params }),
+      /** @experimental */
+      login: {
+        /**
+         * Begin an interactive login flow for a provider kind (dispatch is kind-only) and return its opaque flow id and first step.
+         *
+         * @param params Begin an interactive login flow for a provider kind. Dispatch is kind-only.
+         *
+         * @returns A started login flow: its opaque id and first step.
+         */
+        begin: async (params) => connection.sendRequest("session.accounts.login.begin", { sessionId, ...params }),
+        /**
+         * Advance an in-flight login flow, optionally fulfilling an input-required step, and return the next step.
+         *
+         * @param params Advance an in-flight login flow, optionally fulfilling an input-required step.
+         *
+         * @returns One step in an interactive login flow. The consumer acts on the step and calls advance to proceed. Browser-open is encoded as two distinct steps by design: `open-url` is CONSUMER-driven (the provider surfaces the authorize URL and the consumer opens it — github.com/GHEC web), while `needs-interaction` is PROVIDER-driven (the provider opens the browser or broker UI itself and does not surface a URL — Entra).
+         */
+        advance: async (params) => connection.sendRequest("session.accounts.login.advance", { sessionId, ...params }),
+        /**
+         * Cancel an in-flight login flow and release its resources.
+         *
+         * @param params Cancel an in-flight login flow.
+         */
+        cancel: async (params) => connection.sendRequest("session.accounts.login.cancel", { sessionId, ...params })
+      }
+    },
+    /** @experimental */
     debug: {
       /**
        * Collects a session debug log bundle into a local archive or staging directory. Logs are redacted by default; redaction can be configured per caller-provided diagnostic entry. The runtime includes session-owned logs by default and accepts caller-provided diagnostic entries so host applications can add their own files without changing this API shape.
@@ -4939,108 +5153,6 @@ function createSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
-    factory: {
-      /**
-       * Runs a registered factory by name at the top level.
-       *
-       * @param params Parameters for invoking a registered factory.
-       *
-       * @returns Complete current or terminal factory run envelope.
-       */
-      run: async (params) => connection.sendRequest("session.factory.run", { sessionId, ...params }),
-      /**
-       * Resumes a factory run using its persisted name, arguments, journal, and accounting.
-       *
-       * @param params Parameters for resuming a factory run from its persisted identity.
-       *
-       * @returns Resolved persisted factory identity and resumed run envelope.
-       */
-      resume: async (params) => connection.sendRequest("session.factory.resume", { sessionId, ...params }),
-      /**
-       * Gets the current or settled envelope for a factory run.
-       *
-       * @param params Parameters for retrieving a factory run.
-       *
-       * @returns Complete current or terminal factory run envelope.
-       */
-      getRun: async (params) => connection.sendRequest("session.factory.getRun", { sessionId, ...params }),
-      /**
-       * Lists durable factory runs for this session in creation order.
-       *
-       * @param params Parameters for paging factory runs.
-       *
-       * @returns A page of factory runs in durable creation order.
-       */
-      listRuns: async (params) => connection.sendRequest("session.factory.listRuns", { sessionId, ...params }),
-      /**
-       * Gets durable and live observability detail for one factory run.
-       *
-       * @param params Parameters for retrieving a factory run.
-       *
-       * @returns Full factory run observability detail.
-       */
-      getRunDetail: async (params) => connection.sendRequest("session.factory.getRunDetail", { sessionId, ...params }),
-      /**
-       * Pages durable progress for one factory run.
-       *
-       * @param params Parameters for paging factory progress.
-       *
-       * @returns A bidirectional page of factory progress.
-       */
-      getRunProgress: async (params) => connection.sendRequest("session.factory.getRunProgress", { sessionId, ...params }),
-      /**
-       * Requests cancellation of a factory run and returns its run envelope.
-       *
-       * @param params Parameters for cancelling a factory run.
-       *
-       * @returns Complete current or terminal factory run envelope.
-       */
-      cancel: async (params) => connection.sendRequest("session.factory.cancel", { sessionId, ...params }),
-      /**
-       * Pauses a running factory and returns its settled run envelope.
-       *
-       * @param params Parameters for pausing a running factory.
-       *
-       * @returns Complete current or terminal factory run envelope.
-       */
-      pause: async (params) => connection.sendRequest("session.factory.pause", { sessionId, ...params }),
-      /**
-       * Records a batch of ordered factory progress lines.
-       *
-       * @param params Parameters for recording factory progress.
-       *
-       * @returns Acknowledgement that a factory request was accepted.
-       */
-      log: async (params) => connection.sendRequest("session.factory.log", { sessionId, ...params }),
-      /**
-       * Runs one factory-scoped subagent and returns its result.
-       *
-       * @param params Parameters for one factory-scoped subagent call.
-       *
-       * @returns Result of one factory-scoped subagent call.
-       */
-      agent: async (params) => connection.sendRequest("session.factory.agent", { sessionId, ...params }),
-      /** @experimental */
-      journal: {
-        /**
-         * Reads a memoized factory journal entry.
-         *
-         * @param params Parameters for reading a factory journal entry.
-         *
-         * @returns Result of reading a factory journal entry.
-         */
-        get: async (params) => connection.sendRequest("session.factory.journal.get", { sessionId, ...params }),
-        /**
-         * Stores a memoized factory journal entry.
-         *
-         * @param params Parameters for storing a factory journal entry.
-         *
-         * @returns Acknowledgement that a factory request was accepted.
-         */
-        put: async (params) => connection.sendRequest("session.factory.journal.put", { sessionId, ...params })
-      }
-    },
-    /** @experimental */
     workflow: {
       /**
        * Runs a registered dynamic workflow by name at the top level.
@@ -5438,7 +5550,20 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Instruction sources loaded for the session, in merge order.
        */
-      getSources: async () => connection.sendRequest("session.instructions.getSources", { sessionId })
+      getSources: async () => connection.sendRequest("session.instructions.getSources", { sessionId }),
+      /**
+       * Invalidates cached custom-instruction discovery so subsequent turns and source reads observe instruction files currently on disk.
+       */
+      reload: async () => connection.sendRequest("session.instructions.reload", { sessionId })
+    },
+    /** @experimental */
+    customizations: {
+      /**
+       * Reloads all repository and user customizations for the active session: instructions, plugins and their MCP servers and hooks, custom agents, extensions, and skills. Returns diagnostics from the final skill reload.
+       *
+       * @returns Diagnostics from reloading skill definitions, with warnings and errors as separate lists.
+       */
+      reload: async () => connection.sendRequest("session.customizations.reload", { sessionId })
     },
     /** @experimental */
     fleet: {
@@ -5737,7 +5862,15 @@ function createSessionRpc(connection, sessionId) {
          */
         authenticationStateChanged: async (params) => connection.sendRequest("session.mcp.oauth.authenticationStateChanged", { sessionId, ...params }),
         /**
-         * Starts OAuth authentication for a remote MCP server.
+         * Prepares an inert, expiring owned OAuth login bound to the original session requester and exact installation. Does not activate, connect, read credentials or open a browser.
+         *
+         * @param params Effect-free preparation bound to the existing local session, requester and installation, with frozen options.
+         *
+         * @returns An inert runtime-issued login handle. Preparation alone performs no activation or OAuth work.
+         */
+        prepareLogin: async (params) => connection.sendRequest("session.mcp.oauth.prepareLogin", { sessionId, ...params }),
+        /**
+         * Starts OAuth authentication for a remote MCP server. Owned servers require the original one-use prepareLogin handle and exact installation ID; manual servers retain the existing direct login behaviour.
          *
          * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.
          *
@@ -5752,6 +5885,14 @@ function createSessionRpc(connection, sessionId) {
          * @returns Passive MCP OAuth probe result. `authenticated` means the server accepted the probe request while an OAuth-origin access token was attached; it does not prove the server required or independently validated that token. The probe does not make a second unauthenticated request. Failed is an expected probe-domain outcome; JSON-RPC errors are reserved for API-call failures.
          */
         probe: async (params) => connection.sendRequest("session.mcp.oauth.probe", { sessionId, ...params }),
+        /**
+         * Cancels the exact owned OAuth login issued to this original session requester, without clearing shared credentials.
+         *
+         * @param params Targets only the original prepared/applying owned login on this exact session requester.
+         *
+         * @returns Honest terminal cancellation result; persistence or recovery failures remain RPC errors.
+         */
+        cancelLogin: async (params) => connection.sendRequest("session.mcp.oauth.cancelLogin", { sessionId, ...params }),
         /**
          * Responds to a pending MCP OAuth authorization request by its request id.
          *
@@ -5848,17 +5989,36 @@ function createSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
-    connectors: {
+    diagnostics: {
       /**
-       * Returns feature availability and bounded polling limits for the EXPERIMENTAL session connector API. This method never performs a Connector service request.
+       * Patches configured session diagnostic sources without restarting their producers. Setting a source level to off clears its retained diagnostics and invalidates cursors selecting that source.
        *
-       * @returns Feature detection and hard polling limits for the EXPERIMENTAL session connector API.
+       * @param params Patch session diagnostic thresholds for explicitly supplied sources.
+       *
+       * @returns Per-source session diagnostics configuration.
        */
-      getCapabilities: async () => connection.sendRequest("session.connectors.getCapabilities", { sessionId }),
+      configure: async (params) => connection.sendRequest("session.diagnostics.configure", { sessionId, ...params }),
       /**
-       * Returns authoritative session Connector state from current availability, pinned account selection, cached catalog, and live MCP projection without performing a Connector service request.
+       * Reads a bounded batch of retained session diagnostics for the selected sources. Records are never consumed and each reader advances independently through its opaque cursor.
        *
-       * @returns Authoritative session connector state. Account IDs are opaque routing identifiers and credentials are never included.
+       * @param params Cursor-based request for session diagnostics. The default limit is 100 (maximum 500); the default waitMs is zero (maximum 30000).
+       *
+       * @returns One cursor-addressed page of retained session diagnostics.
+       */
+      read: async (params) => connection.sendRequest("session.diagnostics.read", { sessionId, ...params })
+    },
+    /** @experimental */
+    connectors: {
+      /**
+       * Returns feature availability and bounded polling limits for the EXPERIMENTAL session connector API. This method never performs a Connector service request.
+       *
+       * @returns Feature detection and hard polling limits for the EXPERIMENTAL session connector API.
+       */
+      getCapabilities: async () => connection.sendRequest("session.connectors.getCapabilities", { sessionId }),
+      /**
+       * Returns authoritative session Connector state from current availability, pinned account selection, cached catalog, and live MCP projection without performing a Connector service request.
+       *
+       * @returns Authoritative session connector state. Account IDs are opaque routing identifiers and credentials are never included.
        */
       getStatus: async () => connection.sendRequest("session.connectors.getStatus", { sessionId }),
       /**
@@ -6727,11 +6887,11 @@ function createSessionRpc(connection, sessionId) {
        */
       updateText: async (params) => connection.sendRequest("session.queue.updateText", { sessionId, ...params }),
       /**
-       * Atomically withdraws an unchanged, unconsumed user message from the local queued or steering lane. A client retaining the original draft may restore it only when removed is true. Does not interrupt the running turn.
+       * Atomically withdraws an unchanged user message of a local session: from the queued or steering lane while unconsumed, or from the running turn it started while the model has not answered it and nothing the user sent after it is pending. Withdrawing from the running turn interrupts that turn and removes its events from history. A client retaining the original draft may restore it only when removed is true.
        *
-       * @param params Conditional withdrawal of a single user message, before the runtime claims it for delivery.
+       * @param params Conditional withdrawal of a single user message, from its queue or from the running turn it started.
        *
-       * @returns Result of removing a queued item.
+       * @returns Result of withdrawing a user message.
        */
       withdrawMessage: async (params) => connection.sendRequest("session.queue.withdrawMessage", { sessionId, ...params }),
       /**
@@ -6971,31 +7131,6 @@ function createInternalSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
-    factory: {
-      /**
-       * Internal tool-originated factory invocation.
-       *
-       * @param params Internal parameters for invoking a registered factory from a tool.
-       *
-       * @returns Complete current or terminal factory run envelope.
-       */
-      runFromTool: async (params) => connection.sendRequest("session.factory.runFromTool", { sessionId, ...params }),
-      /**
-       * Internal tool-originated factory resume.
-       *
-       * @param params Internal parameters for resuming a factory run from a tool.
-       *
-       * @returns Resolved persisted factory identity and resumed run envelope.
-       */
-      resumeFromTool: async (params) => connection.sendRequest("session.factory.resumeFromTool", { sessionId, ...params }),
-      /**
-       * Atomically pauses an owned factory attempt at a durable checkpoint.
-       *
-       * @param params Parameters for an owned durable pause checkpoint.
-       */
-      pauseAtCheckpoint: async (params) => connection.sendRequest("session.factory.pauseAtCheckpoint", { sessionId, ...params })
-    },
-    /** @experimental */
     workflow: {
       /**
        * Internal tool-originated dynamic workflow invocation.
@@ -7223,16 +7358,6 @@ function registerClientSessionApiHandlers(connection, getHandlers) {
     if (!handler) throw new Error(`No providerToken handler registered for session: ${params.sessionId}`);
     return handler.getToken(params);
   });
-  connection.onRequest("factory.execute", async (params) => {
-    const handler = getHandlers(params.sessionId).factory;
-    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
-    return handler.execute(params);
-  });
-  connection.onRequest("factory.abort", async (params) => {
-    const handler = getHandlers(params.sessionId).factory;
-    if (!handler) throw new Error(`No factory handler registered for session: ${params.sessionId}`);
-    return handler.abort(params);
-  });
   connection.onRequest("workflow.execute", async (params) => {
     const handler = getHandlers(params.sessionId).workflow;
     if (!handler) throw new Error(`No workflow handler registered for session: ${params.sessionId}`);
@@ -7355,6 +7480,11 @@ function registerClientGlobalApiHandlers(connection, handlers) {
     if (!handler) throw new Error("No gitHubToken client-global handler registered");
     return handler.getToken(params);
   });
+  connection.onRequest("installations.confirm", async (params) => {
+    const handler = handlers.installations;
+    if (!handler) throw new Error("No installations client-global handler registered");
+    return handler.confirm(params);
+  });
 }
 
 // src/sdk/nodejs/dist/sdkProtocolVersion.js
@@ -8483,107 +8613,6 @@ var DisableBypassPermissionsModes = {
   AllowAutoOnly: "allow-auto-only"
 };
 
-// src/sdk/nodejs/dist/factory.js
-var FACTORY_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
-  "completed",
-  "halted",
-  "paused",
-  "cancelled",
-  "error"
-]);
-function isFactoryRunTerminal(status) {
-  return FACTORY_TERMINAL_STATUSES.has(status);
-}
-var FACTORY_AGENT_OPTION_KEYS = [
-  "label",
-  "schema",
-  "model",
-  "reasoningEffort",
-  "contextTier",
-  "agent"
-];
-var FactoryResumeError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "FactoryResumeError";
-  }
-  code;
-};
-var factoryHandles = /* @__PURE__ */ new WeakMap();
-var MAX_FACTORY_TIMEOUT_SECONDS = 2147483647e-3;
-var NANO_AIU_PER_AIU = 1e9;
-function deepFreeze(value) {
-  if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
-    Object.freeze(value);
-    for (const nested of Object.values(value)) {
-      deepFreeze(nested);
-    }
-  }
-  return value;
-}
-function validateLimits(meta) {
-  const limits = meta.limits;
-  if (!limits) {
-    return;
-  }
-  for (const field of ["maxConcurrentSubagents", "maxTotalSubagents"]) {
-    const value = limits[field];
-    if (value !== void 0 && (!Number.isInteger(value) || value <= 0)) {
-      throw new Error(`Factory limit "${field}" must be a positive integer`);
-    }
-  }
-  if (limits.timeoutSeconds !== void 0 && (!Number.isFinite(limits.timeoutSeconds) || limits.timeoutSeconds <= 0)) {
-    throw new Error(
-      'Factory limit "timeoutSeconds" must be a positive, finite number of seconds'
-    );
-  }
-  if (limits.timeoutSeconds !== void 0 && limits.timeoutSeconds > MAX_FACTORY_TIMEOUT_SECONDS) {
-    throw new Error(
-      `Factory limit "timeoutSeconds" must not exceed ${MAX_FACTORY_TIMEOUT_SECONDS} seconds`
-    );
-  }
-  if (limits.maxAiCredits !== void 0) {
-    const maxNanoAiu = Math.round(limits.maxAiCredits * NANO_AIU_PER_AIU);
-    if (!Number.isFinite(limits.maxAiCredits) || limits.maxAiCredits <= 0 || !Number.isSafeInteger(maxNanoAiu) || maxNanoAiu < 1) {
-      throw new Error(
-        'Factory limit "maxAiCredits" must be a positive, finite number that rounds to a safe positive integer nano-AIU ceiling'
-      );
-    }
-  }
-}
-function validatePhases(meta) {
-  const titles = /* @__PURE__ */ new Set();
-  for (const phase of meta.phases) {
-    if (phase.title.trim().length === 0) {
-      throw new Error("Factory phase titles must not be empty");
-    }
-    if (titles.has(phase.title)) {
-      throw new Error(`Factory phase title "${phase.title}" is declared more than once`);
-    }
-    titles.add(phase.title);
-  }
-}
-function defineFactory(definition) {
-  const meta = deepFreeze(structuredClone(definition.meta));
-  validateLimits(meta);
-  validatePhases(meta);
-  const stored = {
-    meta,
-    run: definition.run
-  };
-  const handle = Object.freeze({ meta });
-  factoryHandles.set(handle, stored);
-  return handle;
-}
-function getFactoryDefinition(handle) {
-  const definition = factoryHandles.get(handle);
-  if (!definition) {
-    throw new Error("Invalid factory handle");
-  }
-  return definition;
-}
-
 // src/sdk/nodejs/dist/workflow.js
 var WORKFLOW_TERMINAL_STATUSES = /* @__PURE__ */ new Set([
   "completed",
@@ -8613,17 +8642,17 @@ var WorkflowResumeError = class extends Error {
 };
 var workflowHandles = /* @__PURE__ */ new WeakMap();
 var MAX_WORKFLOW_TIMEOUT_SECONDS = 2147483647e-3;
-var NANO_AIU_PER_AIU2 = 1e9;
-function deepFreeze2(value) {
+var NANO_AIU_PER_AIU = 1e9;
+function deepFreeze(value) {
   if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
     Object.freeze(value);
     for (const nested of Object.values(value)) {
-      deepFreeze2(nested);
+      deepFreeze(nested);
     }
   }
   return value;
 }
-function validateLimits2(meta) {
+function validateLimits(meta) {
   const limits = meta.limits;
   if (!limits) {
     return;
@@ -8645,7 +8674,7 @@ function validateLimits2(meta) {
     );
   }
   if (limits.maxAiCredits !== void 0) {
-    const maxNanoAiu = Math.round(limits.maxAiCredits * NANO_AIU_PER_AIU2);
+    const maxNanoAiu = Math.round(limits.maxAiCredits * NANO_AIU_PER_AIU);
     if (!Number.isFinite(limits.maxAiCredits) || limits.maxAiCredits <= 0 || !Number.isSafeInteger(maxNanoAiu) || maxNanoAiu < 1) {
       throw new Error(
         'Workflow limit "maxAiCredits" must be a positive, finite number that rounds to a safe positive integer nano-AIU ceiling'
@@ -8653,7 +8682,7 @@ function validateLimits2(meta) {
     }
   }
 }
-function validatePhases2(meta) {
+function validatePhases(meta) {
   const titles = /* @__PURE__ */ new Set();
   for (const phase of meta.phases) {
     if (phase.title.trim().length === 0) {
@@ -8666,9 +8695,9 @@ function validatePhases2(meta) {
   }
 }
 function defineWorkflow(definition) {
-  const meta = deepFreeze2(structuredClone(definition.meta));
-  validateLimits2(meta);
-  validatePhases2(meta);
+  const meta = deepFreeze(structuredClone(definition.meta));
+  validateLimits(meta);
+  validatePhases(meta);
   const stored = {
     meta,
     run: definition.run
@@ -8686,15 +8715,6 @@ function getWorkflowDefinition(handle) {
 }
 
 // src/sdk/nodejs/dist/session.js
-function isFactoryResumeErrorCode(value) {
-  return value === "not_found" || value === "non_resumable" || value === "already_active" || value === "factory_already_running" || value === "factory_limits_invalid" || value === "factory_session_disposed" || value === "factory_storage_unavailable" || value === "factory_storage_corrupt";
-}
-function copyDefinedFactoryAgentOption(source, target, key) {
-  const value = source[key];
-  if (value !== void 0) {
-    target[key] = value;
-  }
-}
 function isWorkflowResumeErrorCode(value) {
   return value === "not_found" || value === "non_resumable" || value === "workflow_run_not_resumable" || value === "already_active" || value === "workflow_already_running" || value === "workflow_limits_invalid" || value === "workflow_session_disposed" || value === "workflow_storage_unavailable" || value === "workflow_storage_corrupt";
 }
@@ -8704,14 +8724,6 @@ function copyDefinedWorkflowAgentOption(source, target, key) {
     target[key] = value;
   }
 }
-var factoryExecutionStore = new AsyncLocalStorage();
-function throwIfFactoryExecutionIsActive() {
-  if (factoryExecutionStore.getStore()?.active) {
-    throw new Error(
-      "factory.run, factory.resume, and factory.pause are not allowed while a factory body is running on this call path."
-    );
-  }
-}
 var workflowExecutionStore = new AsyncLocalStorage();
 function throwIfWorkflowExecutionIsActive() {
   if (workflowExecutionStore.getStore()?.active) {
@@ -8724,10 +8736,6 @@ function runInWorkflowHelperScope(helperScope, callback) {
   const current = workflowExecutionStore.getStore();
   return workflowExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
 }
-function runInFactoryHelperScope(helperScope, callback) {
-  const current = factoryExecutionStore.getStore();
-  return factoryExecutionStore.run({ active: current?.active ?? false, helperScope }, callback);
-}
 function deserializeHookInput(raw) {
   if (!raw || typeof raw !== "object" || typeof raw.timestamp !== "number") {
     return raw;
@@ -8750,68 +8758,20 @@ function isOpenCanvasInstance(value) {
 }
 var FACTORY_LOG_FLUSH_DELAY_MS = 10;
 var MAX_FACTORY_FANOUT_ITEMS = 4096;
-function assertFactoryFanoutSize(kind, size) {
+function assertWorkflowFanoutSize(kind, size) {
   if (size > MAX_FACTORY_FANOUT_ITEMS) {
     throw new Error(
       `${kind}() accepts at most ${MAX_FACTORY_FANOUT_ITEMS} items; got ${size}.`
     );
   }
 }
-async function runFactoryParallel(thunks) {
-  if (!Array.isArray(thunks)) {
-    throw new Error(
-      "parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)"
-    );
-  }
-  assertFactoryFanoutSize("parallel", thunks.length);
-  if (thunks.some((thunk) => typeof thunk !== "function")) {
-    throw new Error(
-      "parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)"
-    );
-  }
-  return Promise.all(
-    thunks.map(
-      (thunk) => Promise.resolve().then(() => runInFactoryHelperScope("parallel", thunk)).catch((error) => {
-        if (isFactoryFatalError(error)) {
-          throw error;
-        }
-        return null;
-      })
-    )
-  );
-}
-async function runFactoryPipeline(items, ...stages) {
-  if (!Array.isArray(items)) {
-    throw new Error("pipeline(items, ...stages): items must be an array");
-  }
-  assertFactoryFanoutSize("pipeline", items.length);
-  return Promise.all(
-    items.map(async (item, index) => {
-      let previous = item;
-      for (const stage of stages) {
-        try {
-          previous = await runInFactoryHelperScope(
-            "pipeline",
-            () => stage(previous, item, index)
-          );
-        } catch (error) {
-          if (isFactoryFatalError(error)) {
-            throw error;
-          }
-          return null;
-        }
-      }
-      return previous;
-    })
-  );
-}
 async function runWorkflowParallel(thunks) {
   if (!Array.isArray(thunks)) {
     throw new Error(
       "parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)"
     );
   }
-  assertFactoryFanoutSize("parallel", thunks.length);
+  assertWorkflowFanoutSize("parallel", thunks.length);
   if (thunks.some((thunk) => typeof thunk !== "function")) {
     throw new Error(
       "parallel() expects an array of functions, not promises. Wrap each call: () => agent(...)"
@@ -8820,7 +8780,7 @@ async function runWorkflowParallel(thunks) {
   return Promise.all(
     thunks.map(
       (thunk) => Promise.resolve().then(() => runInWorkflowHelperScope("parallel", thunk)).catch((error) => {
-        if (isFactoryFatalError(error)) {
+        if (isWorkflowFatalError(error)) {
           throw error;
         }
         return null;
@@ -8832,7 +8792,7 @@ async function runWorkflowPipeline(items, ...stages) {
   if (!Array.isArray(items)) {
     throw new Error("pipeline(items, ...stages): items must be an array");
   }
-  assertFactoryFanoutSize("pipeline", items.length);
+  assertWorkflowFanoutSize("pipeline", items.length);
   return Promise.all(
     items.map(async (item, index) => {
       let previous = item;
@@ -8843,7 +8803,7 @@ async function runWorkflowPipeline(items, ...stages) {
             () => stage(previous, item, index)
           );
         } catch (error) {
-          if (isFactoryFatalError(error)) {
+          if (isWorkflowFatalError(error)) {
             throw error;
           }
           return null;
@@ -8853,85 +8813,6 @@ async function runWorkflowPipeline(items, ...stages) {
     })
   );
 }
-var FactoryProgressBuffer = class {
-  constructor(send) {
-    this.send = send;
-  }
-  send;
-  nextSeq = 0;
-  pending = [];
-  flushTimer;
-  flushTail = Promise.resolve();
-  flushError;
-  flushFailed = false;
-  closed = false;
-  enqueue(kind, text) {
-    if (this.closed) {
-      throw new Error("Cannot log after the factory run has settled");
-    }
-    this.pending.push({ seq: this.nextSeq++, kind, text });
-    this.scheduleFlush();
-  }
-  async flush() {
-    this.clearFlushTimer();
-    const lines = this.pending.splice(0);
-    if (lines.length > 0) {
-      this.flushTail = this.flushTail.then(async () => {
-        try {
-          await this.send(lines);
-        } catch (error) {
-          if (!this.flushFailed) {
-            this.flushFailed = true;
-            this.flushError = error;
-          }
-        }
-      });
-    }
-    await this.flushTail;
-    if (this.flushFailed) {
-      throw this.flushError;
-    }
-  }
-  async close() {
-    this.closed = true;
-    this.clearFlushTimer();
-    const lines = this.pending.splice(0);
-    await this.flushTail;
-    if (this.flushFailed) {
-      console.warn(
-        "Ignoring a background factory progress flush failure after the factory body settled",
-        this.flushError
-      );
-    }
-    if (lines.length > 0) {
-      try {
-        await this.send(lines);
-      } catch (error) {
-        console.warn(
-          "Failed to flush final factory progress after the factory body settled",
-          error
-        );
-      }
-    }
-  }
-  scheduleFlush() {
-    if (this.flushTimer !== void 0) {
-      return;
-    }
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = void 0;
-      void this.flush().catch(() => {
-      });
-    }, FACTORY_LOG_FLUSH_DELAY_MS);
-    this.flushTimer.unref?.();
-  }
-  clearFlushTimer() {
-    if (this.flushTimer !== void 0) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = void 0;
-    }
-  }
-};
 var WorkflowProgressBuffer = class {
   constructor(send) {
     this.send = send;
@@ -9011,38 +8892,30 @@ var WorkflowProgressBuffer = class {
     }
   }
 };
-async function awaitFactoryOperation(operation, signal) {
+async function awaitWorkflowOperation(operation, signal) {
   let rejectAbort;
   const abortPromise = new Promise((_resolve, reject) => {
     rejectAbort = reject;
   });
-  const onAbort = () => rejectAbort?.(signal.reason ?? new DOMException("Factory run was aborted", "AbortError"));
+  const onAbort = () => rejectAbort?.(signal.reason ?? new DOMException("Workflow run was aborted", "AbortError"));
   signal.addEventListener("abort", onAbort, { once: true });
   try {
-    throwIfFactoryAborted(signal);
+    throwIfWorkflowAborted(signal);
     return await Promise.race([operation(), abortPromise]);
   } finally {
     signal.removeEventListener("abort", onAbort);
   }
 }
-async function awaitWorkflowOperation(operation, signal) {
-  return awaitFactoryOperation(operation, signal);
-}
-function throwIfFactoryAborted(signal) {
-  if (signal.aborted) {
-    throw signal.reason ?? new DOMException("Factory run was aborted", "AbortError");
-  }
-}
 function throwIfWorkflowAborted(signal) {
   if (signal.aborted) {
     throw signal.reason ?? new DOMException("Workflow run was aborted", "AbortError");
   }
 }
-function isFactoryAbortError(error) {
+function isWorkflowAbortError(error) {
   return typeof error === "object" && error !== null && "name" in error && error.name === "AbortError";
 }
-function isFactoryFatalError(error) {
-  return isFactoryAbortError(error) || error instanceof import_node.ResponseError || error instanceof import_node.ConnectionError;
+function isWorkflowFatalError(error) {
+  return isWorkflowAbortError(error) || error instanceof import_node.ResponseError || error instanceof import_node.ConnectionError;
 }
 var TOOL_SEARCH_TOOL_NAME = "tool_search_tool";
 var CopilotSession = class {
@@ -9074,8 +8947,6 @@ var CopilotSession = class {
   canvases = /* @__PURE__ */ new Map();
   bearerTokenProviders = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
-  factories = /* @__PURE__ */ new Map();
-  factoryAbortControllers = /* @__PURE__ */ new Map();
   workflows = /* @__PURE__ */ new Map();
   workflowAbortControllers = /* @__PURE__ */ new Map();
   permissionHandler;
@@ -9093,74 +8964,17 @@ var CopilotSession = class {
   _capabilities = {};
   openCanvasInstances = [];
   disconnected = false;
-  pendingStructuredWaits = /* @__PURE__ */ new Set();
-  disconnecting = false;
-  onDisconnected;
-  /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
-  clientSessionApis = {};
-  /**
-   * Friendly factory API for running registered factories by name or handle.
-   *
-   * @experimental Part of the experimental Agent Factories surface and may
-   * change or be removed in future SDK or CLI releases.
-   */
-  factory = {
-    run: (async (nameOrHandle, options) => {
-      throwIfFactoryExecutionIsActive();
-      const name = typeof nameOrHandle === "string" ? nameOrHandle : getFactoryDefinition(nameOrHandle).meta.name;
-      if (options?.resumeFromRunId !== void 0) {
-        return this.factory.resume(options.resumeFromRunId, {
-          limits: options.limits,
-          notifyOnComplete: options.notifyOnComplete,
-          logPhaseNames: options.logPhaseNames
-        });
-      }
-      const envelope = await this.rpc.factory.run({
-        name,
-        args: options?.args === void 0 ? {} : options.args,
-        options: {
-          limits: options?.limits,
-          notifyOnComplete: options?.notifyOnComplete,
-          logPhaseNames: options?.logPhaseNames
-        }
-      });
-      return this.settleFactoryRun(envelope);
-    }),
-    resume: (async (runId, options) => {
-      throwIfFactoryExecutionIsActive();
-      let response;
-      try {
-        response = await this.rpc.factory.resume({
-          runId,
-          limits: options?.limits,
-          notifyOnComplete: options?.notifyOnComplete,
-          logPhaseNames: options?.logPhaseNames
-        });
-      } catch (error) {
-        if (error instanceof import_node.ResponseError && typeof error.data === "object" && error.data !== null) {
-          const code = error.data.code;
-          if (isFactoryResumeErrorCode(code)) {
-            throw new FactoryResumeError(code, error.message);
-          }
-        }
-        throw error;
-      }
-      return this.settleFactoryRun(response.run);
-    }),
-    getRun: async (runId) => this.rpc.factory.getRun({ runId }),
-    waitForRun: (runId, options) => this.waitForFactoryRun(runId, options?.signal),
-    listRuns: (async (options) => {
-      const page = await this.rpc.factory.listRuns(options ?? {});
-      return options === void 0 ? page.runs : page;
-    }),
-    getRunDetail: (runId) => this.rpc.factory.getRunDetail({ runId }),
-    getRunProgress: (runId, options = {}) => this.rpc.factory.getRunProgress({ runId, ...options }),
-    pause: async (runId) => {
-      throwIfFactoryExecutionIsActive();
-      return this.rpc.factory.pause({ runId });
-    },
-    cancel: async (runId) => this.rpc.factory.cancel({ runId })
-  };
+  pendingStructuredWaits = /* @__PURE__ */ new Set();
+  disconnecting = false;
+  onDisconnected;
+  /** @internal Client session API handlers, populated by CopilotClient during create/resume. */
+  clientSessionApis = {};
+  /**
+   * Friendly workflow API for running registered workflows by name or handle.
+   *
+   * @experimental Part of the experimental Dynamic Workflows surface and may
+   * change or be removed in future SDK or CLI releases.
+   */
   workflow = {
     run: (async (nameOrHandle, options) => {
       throwIfWorkflowExecutionIsActive();
@@ -9211,93 +9025,6 @@ var CopilotSession = class {
     },
     cancel: async (runId) => this.rpc.workflow.cancel({ runId })
   };
-  /**
-   * Resolve a start/resume envelope into the terminal envelope callers expect.
-   *
-   * The CLI may answer `session.factory.run` and `session.factory.resume`
-   * before the run settles, so a non-terminal envelope is followed by a wait
-   * on the run's terminal state.
-   */
-  settleFactoryRun(envelope) {
-    if (isFactoryRunTerminal(envelope.status)) {
-      return Promise.resolve(envelope);
-    }
-    return this.waitForFactoryRun(envelope.runId);
-  }
-  /**
-   * Resolve when a factory run reaches a terminal status.
-   *
-   * The subscription is installed *before* the first read so a transition
-   * landing between the two cannot be missed, and re-reads are serialized so
-   * overlapping invalidation events cannot interleave — the run's revision
-   * advances once per operation, so a burst of events is common and must
-   * collapse into a single in-flight read. A bounded periodic re-read keeps a
-   * dropped invalidation from leaving the wait pending forever.
-   */
-  waitForFactoryRun(runId, signal) {
-    const abortError = () => signal?.reason ?? new DOMException("Factory run wait was aborted", "AbortError");
-    if (signal?.aborted === true) {
-      return Promise.reject(abortError());
-    }
-    return new Promise((resolve3, reject) => {
-      let settled = false;
-      let reading = false;
-      let rereadRequested = false;
-      let pollHandle;
-      let unsubscribe;
-      let onAbort;
-      const finish = (complete) => {
-        if (settled) {
-          return;
-        }
-        settled = true;
-        if (pollHandle !== void 0) {
-          clearInterval(pollHandle);
-        }
-        unsubscribe?.();
-        if (onAbort !== void 0) {
-          signal?.removeEventListener("abort", onAbort);
-        }
-        complete();
-      };
-      const read = async () => {
-        if (settled) {
-          return;
-        }
-        if (reading) {
-          rereadRequested = true;
-          return;
-        }
-        reading = true;
-        try {
-          do {
-            rereadRequested = false;
-            const envelope = await this.rpc.factory.getRun({ runId });
-            if (isFactoryRunTerminal(envelope.status)) {
-              finish(() => resolve3(envelope));
-              return;
-            }
-          } while (rereadRequested && !settled);
-        } catch (error) {
-          finish(() => reject(error));
-        } finally {
-          reading = false;
-        }
-      };
-      if (signal !== void 0) {
-        onAbort = () => finish(() => reject(abortError()));
-        signal.addEventListener("abort", onAbort, { once: true });
-      }
-      unsubscribe = this.on("factory.run_updated", (event) => {
-        if (event.data.runId === runId) {
-          void read();
-        }
-      });
-      pollHandle = setInterval(() => void read(), 5e3);
-      pollHandle.unref?.();
-      void read();
-    });
-  }
   settleWorkflowRun(envelope) {
     if (isWorkflowRunTerminal(envelope.status)) {
       return Promise.resolve(envelope);
@@ -9368,7 +9095,7 @@ var CopilotSession = class {
         onAbort = () => finish(() => reject(abortError()));
         signal.addEventListener("abort", onAbort, { once: true });
       }
-      unsubscribe = this.on("factory.run_updated", (event) => {
+      unsubscribe = this.on("workflow.run_updated", (event) => {
         if (event.data.runId === runId) {
           void read();
         }
@@ -9494,6 +9221,7 @@ var CopilotSession = class {
     });
     let lastAssistantMessage;
     const unsubscribe = this.on((event) => {
+      if (event.agentId) return;
       if (event.type === "assistant.message") {
         lastAssistantMessage = event;
       } else if (event.type === "session.idle" && event.data.mode !== "autopilot") {
@@ -9633,13 +9361,6 @@ var CopilotSession = class {
     this.autoModeSwitchHandler = void 0;
     this.commandHandlers.clear();
     this.canvases.clear();
-    this.factories.clear();
-    for (const controllersForRun of this.factoryAbortControllers.values()) {
-      for (const controller of controllersForRun.values()) {
-        controller.abort();
-      }
-    }
-    this.factoryAbortControllers.clear();
     this.workflows.clear();
     for (const controllersForRun of this.workflowAbortControllers.values()) {
       for (const controller of controllersForRun.values()) {
@@ -10094,192 +9815,6 @@ var CopilotSession = class {
       }
     };
   }
-  /**
-   * Registers factory closures and reverse-RPC handlers for this session.
-   *
-   * @param factories - Factory handles declared by the joining extension.
-   * @internal Called by the SDK when an extension joins a session.
-   */
-  registerFactories(factories) {
-    this.factories.clear();
-    if (!factories || factories.length === 0) {
-      delete this.clientSessionApis.factory;
-      return;
-    }
-    for (const handle of factories) {
-      const definition = getFactoryDefinition(handle);
-      if (this.factories.has(definition.meta.name)) {
-        throw new Error(
-          `Duplicate factory name "${definition.meta.name}". Factory names must be unique within a joinSession call.`
-        );
-      }
-      this.factories.set(definition.meta.name, definition);
-    }
-    const self = this;
-    this.clientSessionApis.factory = {
-      async execute(params) {
-        const definition = self.factories.get(params.name);
-        if (!definition) {
-          const message = `No factory registered with name "${params.name}"`;
-          throw new import_node.ResponseError(import_node.ErrorCodes.InvalidParams, message, {
-            code: "factory_not_found",
-            name: params.name
-          });
-        }
-        const controller = new AbortController();
-        let controllersForRun = self.factoryAbortControllers.get(params.runId);
-        if (controllersForRun === void 0) {
-          controllersForRun = /* @__PURE__ */ new Map();
-          self.factoryAbortControllers.set(params.runId, controllersForRun);
-        }
-        controllersForRun.set(params.executionToken, controller);
-        const progress = new FactoryProgressBuffer(async (lines) => {
-          await self.rpc.factory.log({
-            runId: params.runId,
-            executionToken: params.executionToken,
-            lines
-          });
-        });
-        try {
-          const context = {
-            runId: params.runId,
-            args: params.args,
-            session: self,
-            signal: controller.signal,
-            phase: (title) => {
-              throwIfFactoryAborted(controller.signal);
-              progress.enqueue("phase", title);
-            },
-            log: (message) => {
-              throwIfFactoryAborted(controller.signal);
-              progress.enqueue("log", message);
-            },
-            agent: async (prompt, options = {}) => {
-              await progress.flush();
-              const opts = {};
-              for (const key of FACTORY_AGENT_OPTION_KEYS) {
-                copyDefinedFactoryAgentOption(options, opts, key);
-              }
-              const response = await awaitFactoryOperation(
-                () => self.rpc.factory.agent({
-                  factoryRunId: params.runId,
-                  executionToken: params.executionToken,
-                  prompt,
-                  opts
-                }),
-                controller.signal
-              );
-              return response.result ?? null;
-            },
-            step: async (key, producer, options = {}) => {
-              await progress.flush();
-              if (options.volatile) {
-                throwIfFactoryAborted(controller.signal);
-                return producer();
-              }
-              const cached = await awaitFactoryOperation(
-                () => self.rpc.factory.journal.get({
-                  runId: params.runId,
-                  executionToken: params.executionToken,
-                  key
-                }),
-                controller.signal
-              );
-              if (cached.hit) {
-                if (cached.resultJson === void 0) {
-                  throw new Error(
-                    `step("${key}") journal returned a hit without a result`
-                  );
-                }
-                assertFactoryStepResult(cached.resultJson, key);
-                return cached.resultJson;
-              }
-              const result2 = await producer();
-              assertFactoryStepResult(result2, key);
-              await awaitFactoryOperation(
-                () => self.rpc.factory.journal.put({
-                  runId: params.runId,
-                  executionToken: params.executionToken,
-                  key,
-                  resultJson: result2
-                }),
-                controller.signal
-              );
-              return result2;
-            },
-            pause: async (key) => {
-              if (typeof key !== "string" || key.length === 0) {
-                throw new Error("Factory pause checkpoint key must not be empty");
-              }
-              const helperScope = factoryExecutionStore.getStore()?.helperScope;
-              if (helperScope !== void 0) {
-                throw new Error(
-                  `Factory pause checkpoints are not allowed inside ${helperScope}() branches`
-                );
-              }
-              await progress.flush();
-              const response = await awaitFactoryOperation(
-                () => self.internalRpc.factory.pauseAtCheckpoint({
-                  runId: params.runId,
-                  executionToken: params.executionToken,
-                  key
-                }),
-                controller.signal
-              );
-              switch (response.action) {
-                case "continue":
-                  return;
-                case "pause":
-                  await awaitFactoryOperation(
-                    () => new Promise(() => {
-                    }),
-                    controller.signal
-                  );
-              }
-            },
-            parallel: runFactoryParallel,
-            pipeline: runFactoryPipeline,
-            factory: async () => {
-              throw new Error("nested factories are not supported");
-            }
-          };
-          const execution = { active: true };
-          const result = await factoryExecutionStore.run(execution, async () => {
-            try {
-              return await definition.run(context);
-            } finally {
-              execution.active = false;
-            }
-          });
-          if (result === void 0) {
-            return {};
-          }
-          assertFactoryResult(result);
-          return { result };
-        } finally {
-          try {
-            await progress.close();
-          } finally {
-            const controllersForRun2 = self.factoryAbortControllers.get(params.runId);
-            if (controllersForRun2?.get(params.executionToken) === controller) {
-              controllersForRun2.delete(params.executionToken);
-              if (controllersForRun2.size === 0) {
-                self.factoryAbortControllers.delete(params.runId);
-              }
-            }
-          }
-        }
-      },
-      async abort(params) {
-        const controllersForRun = self.factoryAbortControllers.get(params.runId);
-        const controller = controllersForRun?.get(params.executionToken);
-        if (controller !== void 0) {
-          controller.abort(new DOMException("Factory run was aborted", "AbortError"));
-        }
-        return {};
-      }
-    };
-  }
   /**
    * Registers workflow closures and reverse-RPC handlers for this session.
    *
@@ -11146,20 +10681,6 @@ function assertStrictJson(value, context) {
   };
   visit(value, "$", context.allowTopLevelUndefined);
 }
-function assertFactoryResult(value) {
-  assertStrictJson(value, {
-    code: "factory_result_not_json",
-    label: "Factory result",
-    allowTopLevelUndefined: true
-  });
-}
-function assertFactoryStepResult(value, key) {
-  assertStrictJson(value, {
-    code: "factory_step_not_json",
-    label: `Factory step "${key}" result`,
-    allowTopLevelUndefined: false
-  });
-}
 function assertWorkflowResult(value) {
   assertStrictJson(value, {
     code: "workflow_result_not_json",
@@ -11390,6 +10911,79 @@ async function ensureRuntimeBundle(version2, options = {}) {
   return wrapper;
 }
 
+// src/sdk/nodejs/dist/installationConfirmation.js
+var import_node2 = __toESM(require_node(), 1);
+function createInstallationConfirmationAdapter(connection, handler) {
+  const closed = new import_node2.CancellationTokenSource();
+  const closeSubscription = connection.onClose(() => closed.cancel());
+  const disposeSubscription = connection.onDispose(() => {
+    closed.cancel();
+    closed.dispose();
+    closeSubscription.dispose();
+    disposeSubscription.dispose();
+  });
+  return {
+    async confirm(request, token) {
+      if (!token) {
+        throw new Error("Installation confirmation request cancellation is unavailable");
+      }
+      const { confirmationId, reviewFingerprint } = request;
+      const combined = new import_node2.CancellationTokenSource();
+      const subscriptions = [];
+      const cancelRequest = () => combined.cancel();
+      const cancelConnection = () => combined.cancel();
+      const checkCancellation = () => {
+        if (closed.token.isCancellationRequested) {
+          throw new Error("Installation confirmation connection closed");
+        }
+        if (token.isCancellationRequested) {
+          throw new import_node2.ResponseError(-32800, "Installation confirmation request cancelled");
+        }
+      };
+      try {
+        subscriptions.push(
+          token.onCancellationRequested(cancelRequest),
+          closed.token.onCancellationRequested(cancelConnection)
+        );
+        if (token.isCancellationRequested || closed.token.isCancellationRequested) {
+          combined.cancel();
+        }
+        checkCancellation();
+        const cancelled = new Promise((_resolve, reject) => {
+          subscriptions.push(
+            token.onCancellationRequested(
+              () => reject(
+                new import_node2.ResponseError(
+                  -32800,
+                  "Installation confirmation request cancelled"
+                )
+              )
+            ),
+            closed.token.onCancellationRequested(
+              () => reject(new Error("Installation confirmation connection closed"))
+            )
+          );
+        });
+        const decision = await Promise.race([
+          Promise.resolve().then(() => {
+            checkCancellation();
+            return handler(request, combined.token);
+          }),
+          cancelled
+        ]);
+        checkCancellation();
+        if (decision !== "confirm" && decision !== "decline" && decision !== "cancel") {
+          throw new Error("Invalid installation confirmation decision");
+        }
+        return { confirmationId, reviewFingerprint, decision };
+      } finally {
+        for (const subscription of subscriptions) subscription.dispose();
+        combined.dispose();
+      }
+    }
+  };
+}
+
 // src/sdk/nodejs/dist/toolSet.js
 var VALID_TOOL_NAME = /^[a-zA-Z0-9_-]+$/;
 function validateName(kind, name) {
@@ -11632,7 +11226,7 @@ function getNodeExecPath() {
 function getBundledRuntimePath() {
   return ensureRuntimeBundle(COPILOT_CLI_VERSION);
 }
-var TeardownResilientStreamMessageWriter = class extends import_node2.StreamMessageWriter {
+var TeardownResilientStreamMessageWriter = class extends import_node3.StreamMessageWriter {
   suppressWriteErrors = false;
   async write(msg) {
     try {
@@ -11688,6 +11282,7 @@ var CopilotClient = class _CopilotClient {
   sessionFsConfig = null;
   requestHandler = null;
   extensionLaunchProvider;
+  installationConfirmationHandler;
   builtinPluginDirectories = [];
   onGitHubTelemetry;
   clientGlobalHandlers = {};
@@ -11846,6 +11441,7 @@ var CopilotClient = class _CopilotClient {
     this.sessionFsConfig = options.sessionFs ?? null;
     this.requestHandler = options.requestHandler ?? null;
     this.extensionLaunchProvider = options.extensionLaunchProvider;
+    this.installationConfirmationHandler = options.installationConfirmationHandler;
     this.onGitHubTelemetry = options.onGitHubTelemetry;
     this.setupClientGlobalHandlers();
     const connEnv = conn.kind === "stdio" || conn.kind === "tcp" ? conn.env : void 0;
@@ -12660,6 +12256,7 @@ var CopilotClient = class _CopilotClient {
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
+        ...config.diagnostics !== void 0 ? { diagnostics: config.diagnostics } : {},
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
@@ -12669,6 +12266,7 @@ var CopilotClient = class _CopilotClient {
         agent: config.agent,
         configDir: config.configDirectory,
         enableConfigDiscovery: config.enableConfigDiscovery,
+        refreshCustomInstructions: config.refreshCustomInstructions,
         skipEmbeddingRetrieval: config.skipEmbeddingRetrieval,
         embeddingCacheStorage: config.embeddingCacheStorage,
         organizationCustomInstructions: config.organizationCustomInstructions,
@@ -12760,14 +12358,12 @@ var CopilotClient = class _CopilotClient {
   async resumeSession(sessionId, config) {
     return this.resumeSessionInternal(sessionId, config);
   }
+  /** @internal */
   async resumeSessionForExtension(sessionId, config, contributions = {}, extensionOptions) {
     return this.resumeSessionInternal(sessionId, config, contributions, extensionOptions);
   }
   async resumeSessionInternal(sessionId, config, contributions = {}, extensionOptions) {
-    const { factories, workflows } = Array.isArray(contributions) ? { factories: contributions, workflows: void 0 } : contributions;
-    if (factories !== void 0 && workflows !== void 0) {
-      throw new Error("Session configuration cannot include both factories and workflows");
-    }
+    const { workflows } = contributions;
     if (config.gitHubToken !== void 0 && config.gitHubTokenProvider !== void 0) {
       throw new Error("gitHubToken and gitHubTokenProvider are mutually exclusive");
     }
@@ -12787,7 +12383,6 @@ var CopilotClient = class _CopilotClient {
     session.registerTools(config.tools);
     session.registerCanvases(config.canvases);
     session.registerCommands(config.commands);
-    session.registerFactories(factories);
     session.registerWorkflows(workflows);
     const {
       wireProvider: bearerWireProvider,
@@ -12869,7 +12464,6 @@ var CopilotClient = class _CopilotClient {
         })),
         toolSearch: config.toolSearch,
         canvases: config.canvases?.map((canvas) => canvas.declaration),
-        factories: factories?.map((factory) => factory.meta),
         workflows: workflows?.map((workflow) => workflow.meta),
         requestCanvasRenderer: config.requestCanvasRenderer,
         requestExtensions: config.requestExtensions,
@@ -12911,6 +12505,7 @@ var CopilotClient = class _CopilotClient {
         includeSubAgentStreamingEvents: config.includeSubAgentStreamingEvents ?? true,
         ...this.onGitHubTelemetry != null ? { enableGitHubTelemetryForwarding: true } : {},
         mcpServers: toWireMcpServers(config.mcpServers),
+        ...config.diagnostics !== void 0 ? { diagnostics: config.diagnostics } : {},
         mcpOAuthTokenStorage: config.mcpOAuthTokenStorage,
         authClientIdMetadataUrl: config.authClientIdMetadataUrl,
         envValueMode: "direct",
@@ -13091,7 +12686,7 @@ var CopilotClient = class _CopilotClient {
       const result = await raceAgainstExit(this.internalRpc.connect(connectParams));
       serverVersion = result.protocolVersion;
     } catch (err) {
-      if (err instanceof import_node2.ResponseError && (err.code === import_node2.ErrorCodes.MethodNotFound || err.message === "Unhandled method connect")) {
+      if (err instanceof import_node3.ResponseError && (err.code === import_node3.ErrorCodes.MethodNotFound || err.message === "Unhandled method connect")) {
         serverVersion = (await raceAgainstExit(this.ping())).protocolVersion;
       } else {
         throw err;
@@ -13331,6 +12926,9 @@ var CopilotClient = class _CopilotClient {
     if (this.options.mode === "empty") {
       env.COPILOT_DISABLE_KEYTAR = "1";
     }
+    if (this.options.mode !== "empty") {
+      env.COPILOT_RUNTIME_PROCESS_FILE_LOGGING = "1";
+    }
     if (this.options.telemetry) {
       const t = this.options.telemetry;
       env.COPILOT_OTEL_ENABLED = "true";
@@ -13566,8 +13164,8 @@ stderr: ${stderrOutput}`
       throw new Error("In-process FFI runtime host not started");
     }
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.ffiHost.sendStream);
-    this.connection = (0, import_node2.createMessageConnection)(
-      new import_node2.StreamMessageReader(this.ffiHost.receiveStream),
+    this.connection = (0, import_node3.createMessageConnection)(
+      new import_node3.StreamMessageReader(this.ffiHost.receiveStream),
       this.messageWriter
     );
     this.attachConnectionHandlers();
@@ -13620,8 +13218,8 @@ stderr: ${stderrOutput}` : ""}`
       }
     });
     this.messageWriter = new TeardownResilientStreamMessageWriter(this.cliProcess.stdin);
-    this.connection = (0, import_node2.createMessageConnection)(
-      new import_node2.StreamMessageReader(this.cliProcess.stdout),
+    this.connection = (0, import_node3.createMessageConnection)(
+      new import_node3.StreamMessageReader(this.cliProcess.stdout),
       this.messageWriter
     );
     this.attachConnectionHandlers();
@@ -13635,8 +13233,8 @@ stderr: ${stderrOutput}` : ""}`
       throw new Error("CLI child process was unexpectedly started in parent process mode");
     }
     this.messageWriter = new TeardownResilientStreamMessageWriter(process.stdout);
-    this.connection = (0, import_node2.createMessageConnection)(
-      new import_node2.StreamMessageReader(process.stdin),
+    this.connection = (0, import_node3.createMessageConnection)(
+      new import_node3.StreamMessageReader(process.stdin),
       this.messageWriter
     );
     this.attachConnectionHandlers();
@@ -13658,8 +13256,8 @@ stderr: ${stderrOutput}` : ""}`
       this.socket.connect(this.runtimePort, this.actualHost, () => {
         clearTimeout(connectionTimeout);
         this.messageWriter = new TeardownResilientStreamMessageWriter(this.socket);
-        this.connection = (0, import_node2.createMessageConnection)(
-          new import_node2.StreamMessageReader(this.socket),
+        this.connection = (0, import_node3.createMessageConnection)(
+          new import_node3.StreamMessageReader(this.socket),
           this.messageWriter
         );
         this.attachConnectionHandlers();
@@ -13705,6 +13303,16 @@ stderr: ${stderrOutput}` : ""}`
       return session.clientSessionApis;
     });
     registerClientGlobalApiHandlers(this.connection, this.clientGlobalHandlers);
+    if (this.installationConfirmationHandler) {
+      const confirmation = createInstallationConfirmationAdapter(
+        this.connection,
+        this.installationConfirmationHandler
+      );
+      this.connection.onRequest(
+        "installations.confirm",
+        (params, token) => confirmation.confirm(params, token)
+      );
+    }
     this.connection.onRequest(
       "hooks.invoke",
       async (params) => {
@@ -13853,7 +13461,6 @@ export {
   CopilotWebSocketForwarder,
   CopilotWebSocketHandler,
   DisableBypassPermissionsModes,
-  FactoryResumeError,
   RuntimeConnection,
   SYSTEM_MESSAGE_SECTIONS,
   SessionFsSqliteTransactionFailure,
@@ -13864,9 +13471,7 @@ export {
   createAttributedPermissionResult,
   createCanvas,
   createSessionFsAdapter,
-  defineFactory,
   defineTool,
   defineWorkflow,
-  isFactoryRunTerminal,
   isWorkflowRunTerminal
 };