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

package/dist/cjs/generated/rpc.js

@@ -841,9 +841,17 @@ function createServerRpc(connection) {
        *
        * @param params A bounded catalog search. Both the query length and the result count are capped by the schema so a caller cannot request an unbounded scan.
        *
-       * @returns Outcome of a catalog.search call: either bounded inert candidates, or one typed refusal. Never a partial success.
+       * @returns Outcome of catalog.search or catalog.recommend: either bounded inert candidates, or one typed refusal. Never a partial success.
        */
       search: async (params) => connection.sendRequest("catalog.search", params),
+      /**
+       * Requests the initial page of at most ten official-product recommendations for a complete task and product, bound to an existing attached local session. Requires catalog-recommend, catalog-search-session-bound and catalog-search-credential-required. Uses the selected GitHub.com user credential on the fixed Agent Finder recommendations route; successful capability negotiation does not establish service acceptance. Returns the existing inert catalog candidates and retained install references with the typed catalog refusal union. No anonymous retry, unfiltered search fallback or continuation is performed. Server-owned product approvals establish provenance, not task suitability. Read-only: nothing is installed, configured or persisted.
+       *
+       * @param params Initial-page official-product recommendations for a complete task. The runtime fixes recommendationPolicy to official-product and pageSize to 10; callers cannot override the policy, request pagination or fall back to search.
+       *
+       * @returns Outcome of catalog.search or catalog.recommend: either bounded inert candidates, or one typed refusal. Never a partial success.
+       */
+      recommend: async (params) => connection.sendRequest("catalog.recommend", params),
       /**
        * Retrieves one saved feed by its opaque ID, optionally filtered by trust tier. Requires catalog-feeds and catalog-search-credential-required, and uses the same authority, credential policy, optional session binding and candidate projection as catalog.search, so available entries are the same inert candidates, with the same installability, handles and display metadata, and install through the same confirmed flows. Entries keep the feed's order; an entry the runtime cannot present is returned as unavailable with a reason rather than failing the feed. No anonymous retry. Read-only: nothing is installed, configured, or persisted.
        *
@@ -1809,7 +1817,23 @@ function createInternalServerRpc(connection) {
        *
        * @returns The environment variable supplying a classic personal access token, when one is set.
        */
-      getTokenEnvVar: async () => connection.sendRequest("account.getTokenEnvVar", {})
+      getTokenEnvVar: async () => connection.sendRequest("account.getTokenEnvVar", {}),
+      /**
+       * Enrolls the supplied identity in Copilot Free. A host offers this when a signed-in user has no Copilot subscription, so that signing up does not mean leaving for a browser. The runtime resolves the identity's credential itself, so the caller sends none. Read `kind` before `status`: an identity whose credential cannot be resolved answers `no-token` rather than failing the call, because that asks the user to sign in again rather than reporting that enrollment broke. Enrolling an already-enrolled account succeeds and reports `already_subscribed`. This does not refresh the caller's cached account state; a host that shows subscription status should re-read it afterwards.
+       *
+       * @param params The authentication identity to enroll in Copilot Free.
+       *
+       * @returns What came of a Copilot Free enrollment attempt.
+       */
+      subscribeCopilotFree: async (params) => connection.sendRequest("account.subscribeCopilotFree", params),
+      /**
+       * Resolves the base URL of the GitHub host from its configured names, normalizing a bare hostname into an `https://` URL and falling back to the public github.com host when neither name is set. Unlike `account.getWebUrl` this needs no identity, so a host can reach it before anyone has signed in -- which is when an enterprise instance must already be known.
+       *
+       * @param params Configured names of the GitHub host to resolve.
+       *
+       * @returns Absolute base URL of the GitHub host.
+       */
+      getHostUrl: async (params) => connection.sendRequest("account.getHostUrl", params)
     },
     /** @experimental */
     mcp: {
@@ -2001,7 +2025,23 @@ function createInternalServerRpc(connection) {
        *
        * @returns The GitHub repository that owns the requested path, when the selected remote (`origin`, else the first) is on a GitHub host.
        */
-      atPath: async (params) => connection.sendRequest("gitHubRepository.atPath", params)
+      atPath: async (params) => connection.sendRequest("gitHubRepository.atPath", params),
+      /**
+       * Resolves the owner and name of a GitHub repository from its numeric repository id, by asking the GitHub API under the supplied credential. Returns a null `repository` when the id names nothing the credential can see, which the API reports as a 404, so a caller can tell 'no such visible repository' apart from a request that failed. The host queried is derived from `authInfo` rather than supplied separately, so the lookup always runs against the account's own GitHub host.
+       *
+       * @param params Selects a GitHub repository by its numeric repository id, and the credential to look it up under.
+       *
+       * @returns The repository the requested id names, when the credential can see one.
+       */
+      getById: async (params) => connection.sendRequest("gitHubRepository.getById", params),
+      /**
+       * Finds the pull request a branch is open against, searching every repository in `baseRepositories` so a fork's branch finds the pull request it opened upstream. A candidate is discarded unless `headOwner` owns its head branch, because a branch name alone is ambiguous across forks. `status` separates 'not authenticated', 'no such pull request' and 'the search failed', so a caller can tell a conclusive absence apart from an unknown one. The host queried is derived from `authInfo` rather than supplied separately, so the lookup always runs against the account's own GitHub host.
+       *
+       * @param params Selects the pull request a branch is open against, and the credential to look it up under. The branch is searched across every repository in `baseRepositories`, which lets a fork's branch find the pull request it opened against upstream.
+       *
+       * @returns Outcome of a branch pull-request lookup. `status` carries why, because 'not authenticated', 'no pull request' and 'the search failed' are three different answers and only the first two are conclusive.
+       */
+      lookupBranchPullRequest: async (params) => connection.sendRequest("gitHubRepository.lookupBranchPullRequest", params)
     },
     /** @experimental */
     gitHubOwners: {
@@ -2169,11 +2209,242 @@ function createInternalServerRpc(connection) {
        * @returns Live agent metadata without connection credentials.
        */
       listEntries: async (params) => connection.sendRequest("agentRegistry.listEntries", params)
+    },
+    /** @experimental */
+    gitHubFetch: {
+      /**
+       * Registers one authenticated GitHub API request before it starts, so cancellation can name the operation. Each request claims its id once. Refused for extensions.
+       *
+       * @returns One registered GitHub request, shared by execution and cancellation.
+       */
+      allocateRequestId: async () => connection.sendRequest("gitHubFetch.allocateRequestId", {}),
+      /**
+       * Calls the GitHub API with session credentials, or process credentials when sessionId is absent. A bound host can select its existing auth handle with authOwnerId. The URL must match that identity's API origin or the runtime's explicit debug API origin. Retries and eligible redirects resolve the current credential again. Explicit caller Authorization remains unchanged; cross-origin redirects discard credentials without restoring them on later hops. Release asset bodies require gitHubRelease.downloadAsset. JSON asset metadata and other response bodies remain supported. The runtime supplies a default User-Agent and records request diagnostics. Extensions cannot use this method.
+       *
+       * @param params A GitHub API request without caller-supplied auth identity or credential fields.
+       *
+       * @returns The HTTP response or a classified request failure.
+       */
+      request: async (params) => connection.sendRequest("gitHubFetch.request", params),
+      /**
+       * Executes a named GitHub or Copilot job operation. The runtime derives its URL, headers, retry policy, and credential. sessionId selects session auth; omission selects process auth. A bound host connection can select its existing auth handle with authOwnerId. Retries and eligible redirects resolve the current credential again. Cross-origin redirects discard credentials without restoring them on later hops. Non-success HTTP responses include the formatted error for the host. Extensions cannot use this method.
+       *
+       * @param params Arguments for a named authenticated operation.
+       *
+       * @returns The HTTP response or a classified request failure.
+       */
+      executeOperation: async (params) => connection.sendRequest("gitHubFetch.executeOperation", params),
+      /**
+       * Cancels a registered GitHub request. False means the id is no longer registered. Uses the same runtime request registry as request and executeOperation. Refused for extensions.
+       *
+       * @param params One registered GitHub request, shared by execution and cancellation.
+       *
+       * @returns Whether cancellation reached a registered GitHub request.
+       */
+      cancel: async (params) => connection.sendRequest("gitHubFetch.cancel", params)
+    },
+    /** @experimental */
+    gitHubRelease: {
+      /**
+       * Allocates a connection-owned request id before a release lookup, snapshot, or asset download starts. Use the id to cancel that operation. A snapshot retains its allocation until disposal or connection close.
+       *
+       * @returns A freshly registered request id. Registering it before the work starts is what lets a cancel that races the request still find something to cancel.
+       */
+      allocateRequestId: async () => connection.sendRequest("gitHubRelease.allocateRequestId", {}),
+      /**
+       * Retires an unused allocation that this caller will never dispatch. Only an unclaimed id on this connection with no active guard is eligible. Active, foreign, unknown and previously retired ids return abandoned: false. Ordinary cancellation still preserves the first canceled claim. This cleanup remains available during shutdown and is refused for extensions.
+       *
+       * @param params An unused release allocation that this caller will never dispatch. This is separate from cancellation before a request arrives.
+       *
+       * @returns Whether the runtime retired an unused allocation without affecting active work.
+       */
+      abandonRequest: async (params) => connection.sendRequest("gitHubRelease.abandonRequest", params),
+      /**
+       * Looks up a published release or release list. A bound host connection uses its original auth source. Other SDK callers keep the existing authInfo path. The runtime resolves credentials for each request and redirect. Public releases also permit anonymous access. The kind field distinguishes a result, a missing tag, no release, a rate limit, and failure. This raw lookup does not return a shared snapshot.
+       *
+       * @param params Which release to look up, the credential to look it up under, and the request id that makes the lookup cancellable.
+       *
+       * @returns Outcome of a release lookup. `releaseJson` is present only for `found`, and `message` only for the kinds that carry an explanation.
+       */
+      lookup: async (params) => connection.sendRequest("gitHubRelease.lookup", params),
+      /**
+       * Loads one immutable release snapshot for an update client or SDK host. The runtime retains the original credential source and resolves it for each request. Calls with the same allocated request id and options share one lookup and result. A dropped waiter does not cancel that lookup. Use gitHubRelease.cancel to dispose the operation. The runtime admits one failure report before it publishes a failed result. Extensions cannot use this method.
+       *
+       * @param params Immutable options for one connection-owned release snapshot.
+       *
+       * @returns The shared release result with its original lookup duration. Runtime worker faults remain RPC errors.
+       */
+      getSnapshot: async (params) => connection.sendRequest("gitHubRelease.getSnapshot", params),
+      /**
+       * Cancels an allocated operation on this connection. For a snapshot, disposal also waits for its owned lookup and retires its credential authority. It does not delete completed caller-owned downloads. An unknown or foreign id returns canceled: false. A completed download still returns its owned file, which the caller must dispose.
+       *
+       * @param params The release lookup or asset download to abandon.
+       *
+       * @returns Whether the cancel reached live work.
+       */
+      cancel: async (params) => connection.sendRequest("gitHubRelease.cancel", params),
+      /**
+       * Streams a published Copilot release asset to a private file and computes its SHA-256. The URL must name an HTTPS release download in a supported repository. A snapshotRequestId retains that snapshot's original credential source. Otherwise, a bound host uses its original owner, and other SDK callers keep the authInfo path. Each request and redirect resolves credentials again. Revocation fails without an auth fallback. Ordinary credential rejection and transport fallback keep their existing behavior. A digest mismatch removes the file. The result contains file metadata, not archive bytes. The caller must dispose the completed file after use. The download's own requestId controls progress and cancellation. Extensions cannot use this method.
+       *
+       * @param params Which release asset to download, the credential to download it under, and the request id that makes the download cancellable.
+       *
+       * @returns Outcome of an asset download. Each field is present only for the kinds its description names.
+       */
+      downloadAsset: async (params) => connection.sendRequest("gitHubRelease.downloadAsset", params),
+      /**
+       * Reports how many bytes a running `gitHubRelease.downloadAsset` has written, for a progress display. The runtime sends no progress notification for a download, so a host polls this while the download runs. An id with no running download reports zero bytes and no total, which is the normal answer before the body starts and after the download ends.
+       *
+       * @param params The download whose progress to report.
+       *
+       * @returns Byte progress of a running download.
+       */
+      getDownloadProgress: async (params) => connection.sendRequest("gitHubRelease.getDownloadProgress", params)
+    },
+    /** @experimental */
+    cloudTasks: {
+      /**
+       * Starts a cloud coding-agent task, the remote run whose record `cloudTasks.get` later reads. Answered above any session because the task it creates is not a background task inside one. Hosts other than the CLI want this: a GitHub App or an SDK consumer that hands work to a cloud agent creates the same task under the same credential, and resolving it here keeps one credential, endpoint and validation path. Target the task either by repository, supplying both `repositoryOwner` and `repositoryName`, or by `owner` alone for an account-level run. The result separates a rejected request from a failed one: when `ok` is false, `reason` categorises the rejection and `message` carries the explanation to show, while `failure` describes the HTTP call itself and is present only when one was actually made.
+       *
+       * @param params Describes the cloud coding-agent task to start and the credential to start it under. Target it either by repository, supplying both `repositoryOwner` and `repositoryName`, or by `owner` alone for an account-level run.
+       *
+       * @returns The outcome of starting a cloud task. A rejected request and a failed one are reported separately: `reason` and `message` describe a request the service declined, while `statusCode` and `errorMessage` describe the HTTP call itself and appear only when one was actually made.
+       */
+      create: async (params) => connection.sendRequest("cloudTasks.create", params),
+      /**
+       * Deletes one cloud coding-agent task, the remote run `cloudTasks.create` started. The deletion is a soft one: the service withdraws the task from its listings rather than destroying the record, so a host removing a run from its own UI is the intended caller. Answered above any session for the same reason as `cloudTasks.get` -- the task is remote and has no local counterpart. Hosts other than the CLI want this: a GitHub App or an SDK consumer that manages cloud agent runs withdraws the same record under the same credential, and resolving it here keeps one credential-resolution and endpoint path. The runtime resolves each token from `authInfo` or `authContextId`. A host may preserve an explicit `baseUrl`; omission derives the endpoint from `authInfo`. The result is the HTTP outcome rather than a bare success flag: the call returns no body, so `ok` alone describes a success, while a failure is reported through `statusCode`, `errorMessage` and `errorPayloadJson` instead of being raised as an error.
+       *
+       * @param params Identifies one cloud coding-agent task to delete, and the credential to delete it under.
+       *
+       * @returns The HTTP outcome of deleting a cloud task. The deletion returns no body, so a successful call carries nothing beyond `ok`; a failed one is described by the remaining fields rather than raised as an error, so a caller can surface the service's own explanation.
+       */
+      delete: async (params) => connection.sendRequest("cloudTasks.delete", params),
+      /**
+       * Reads one cloud coding-agent task from the Copilot API. This is the task a cloud agent runs on a host's behalf, not a background task inside a session, so it is answered above any session and the `tasks` group does not cover it. Hosts other than the CLI want this: a GitHub App or an SDK consumer that shows the state of a cloud agent run must read the same task record, and resolving it here keeps one credential-resolution, task-URL and circuit-breaker path instead of each host rebuilding them. The result is the HTTP outcome rather than the task itself: a caller must read `ok` and `statusCode` before `payloadJson`, because a 404 is reported as a non-ok result rather than an error, which is what lets a caller tell "no such task" apart from "the API call failed".
+       *
+       * @param params Identifies one cloud coding-agent task and the credential to read it under.
+       *
+       * @returns The HTTP outcome of reading a cloud task, rather than the task alone. A 404 arrives here as a non-ok result with `statusCode` 404, not as an error, so a caller can tell an absent task apart from a failed call.
+       */
+      get: async (params) => connection.sendRequest("cloudTasks.get", params),
+      /**
+       * Reads the logs a cloud coding-agent session produced, from the Copilot API. Answered above any session, for the same reason as `cloudTasks.get`: the session being asked about runs remotely and has no local counterpart. Read `resolved` first. It is false when no Copilot API URL could be resolved for the credential, which is a different outcome from a request that was made and failed, and a caller that treats the two alike will report a transport error for an account that simply has no API endpoint. When `resolved` is true, `debugMessages` carries the diagnostics the fetch produced and should be logged whatever the outcome, `errorString` reports a retrieval fault, and only then do `ok` and `statusCode` describe the HTTP result.
+       *
+       * @param params Identifies one cloud coding-agent session whose logs are to be read, and the credential to read them under.
+       *
+       * @returns The outcome of reading a cloud session's logs. `resolved` distinguishes "this credential has no Copilot API endpoint" from "the request was made and failed"; every other field describes a request that was actually attempted.
+       */
+      getSessionLogs: async (params) => connection.sendRequest("cloudTasks.getSessionLogs", params),
+      /**
+       * Reconstructs the session a cloud coding-agent task recorded, by reading that task's events and ordering them for replay. Answered above any session, for the same reason as `cloudTasks.get`: the session being rebuilt ran remotely and has no local counterpart. Hosts other than the CLI want this: an SDK consumer attaching to a run in progress, an ACP client resuming one, or a GitHub App rendering a task's transcript all rebuild the same history from the same events, and resolving it here keeps one credential, endpoint, ordering and anchor-detection path. A newly created task has no events yet, so this polls for them and fails once they do not arrive. Read `preStart` before either list: when it is true the session has not started, `replayEventsJson` is deliberately empty because there is no history to reconstruct, and only `observedEventsJson` is meaningful.
+       *
+       * @param params Identifies one cloud coding-agent task whose recorded session is to be replayed, and the credential to read it under.
+       *
+       * @returns A cloud task's recorded events, ordered for replay. Read `preStart` first: it selects which of the two event lists a caller should use, and they differ deliberately.
+       */
+      getSessionReplay: async (params) => connection.sendRequest("cloudTasks.getSessionReplay", params),
+      /**
+       * Reads whether one cloud coding-agent task is shared, from the Mission Control service. Answered above any session, for the same reason as `cloudTasks.get`: the task is a remote record with no local counterpart. Hosts other than the CLI want this: an SDK consumer or a GitHub App that offers a "share this run" affordance must read the same flag from the same service, and resolving it here keeps one credential-resolution and endpoint path. The credential is resolved from `authInfo` inside the runtime rather than being carried across the door, so no caller handles a raw token. Read `credentialResolved` first: it is false when the account has no usable credential, in which case no request was made at all, which a caller must not report as a failed request.
+       *
+       * @param params Identifies one cloud coding-agent task whose sharing status is to be read, and the credential to read it under.
+       *
+       * @returns The sharing status a cloud task carries after the call. Read `credentialResolved` first: when it is false no request was attempted at all, which is a different outcome from a request the service declined.
+       */
+      getSharingStatus: async (params) => connection.sendRequest("cloudTasks.getSharingStatus", params),
+      /**
+       * Changes whether one cloud coding-agent task is shared, through the Mission Control service, and reports the status the task carries afterwards. The companion to `cloudTasks.getSharingStatus` and answered above any session for the same reason. The status is sent verbatim and is not narrowed to a closed set, because the service owns these values. The credential is resolved from `authInfo` inside the runtime rather than being carried across the door. Read `credentialResolved` first: it is false when the account has no usable credential, in which case nothing was changed and no request was made.
+       *
+       * @param params Identifies one cloud coding-agent task whose sharing status is to be changed, the status to set, and the credential to change it under.
+       *
+       * @returns The sharing status a cloud task carries after the call. Read `credentialResolved` first: when it is false no request was attempted at all, which is a different outcome from a request the service declined.
+       */
+      setSharingStatus: async (params) => connection.sendRequest("cloudTasks.setSharingStatus", params),
+      /**
+       * Finds the session a caller should open for one cloud coding-agent task. A task identifier alone does not say what to open: the run may already exist locally, it may exist only in the cloud, or it may be a task that cannot be resumed at all. Resolving that needs a local session scan and a Mission Control lookup that agree on identity, which is why it is answered here rather than left to each host. Hosts other than the CLI want it: an IDE or a GitHub App that opens a run from a task link faces the same three outcomes. Read `kind` before any other field. `local-session` carries `sessionId`, `remote-session` carries `metadataJson`, `unresumable-task` means the task exists but cannot be continued, and `none` means no session matched. A failed service call is reported as `error` rather than raised, so a caller can surface the service's own message. Pass every local session identifier already rejected in `ignoredLocalSessionIds` and call again to get the next candidate; that is how a host skips a local session it could not load.
+       *
+       * @param params Identifies one cloud coding-agent task to resolve to an openable session, the credential to resolve it under, and the local candidates the caller has already rejected.
+       *
+       * @returns What a caller should open for the task. The four outcomes are distinct and carry different payloads, so read `kind` before any other field.
+       */
+      resolveTaskId: async (params) => connection.sendRequest("cloudTasks.resolveTaskId", params)
+    },
+    /** @experimental */
+    cafeMetrics: {
+      /**
+       * Starts anonymous CAFE metrics for this process. The runtime selects the endpoint from COPILOT_CAFE_METRICS_URL or this connection's original auth owner. Offline and unsupported platforms refuse startup. Release eligibility must resolve before samples are sent. Requires the private trusted CLI host capability.
+       *
+       * @param params Versions and provider configuration for CAFE.
+       *
+       * @returns CAFE startup result.
+       */
+      start: async (params) => connection.sendRequest("cafeMetrics.start", params),
+      /**
+       * Resolves release eligibility once from the immutable release lookup shared with auto-update. Requires the private trusted CLI host capability.
+       *
+       * @param params Immutable release lookup result.
+       *
+       * @returns Admission result.
+       */
+      resolveAdmission: async (params) => connection.sendRequest("cafeMetrics.resolveAdmission", params),
+      /**
+       * Records one terminal resume result. Does nothing before startup. Requires the private trusted CLI host capability.
+       *
+       * @param params Terminal result of one resume attempt.
+       */
+      recordResumeResult: async (params) => connection.sendRequest("cafeMetrics.recordResumeResult", params),
+      /**
+       * Stops recording and drains within one 1.5-second deadline. flushOnly sends at most one batch without stopping recording. Requires the private trusted CLI host capability.
+       *
+       * @param params Preliminary flush or final disposal.
+       */
+      shutdown: async (params) => connection.sendRequest("cafeMetrics.shutdown", params)
     }
   };
 }
 function createSessionRpc(connection, sessionId) {
   return {
+    /** @experimental */
+    management: {
+      /**
+       * Updates opt-in session management policy live. Enabling the master enables all tools before applying individual overrides. Opt-in is scoped to the session's configuration directory.
+       *
+       * @param params Updates the session's live policy without changing persistent host settings.
+       *
+       * @returns Opt-in policy for local session management.
+       */
+      configure: async (params) => connection.sendRequest("session.management.configure", { ...params, sessionId }),
+      /**
+       * Lists other live, opted-in sessions in the same configuration directory. Requires the list tool to be enabled.
+       *
+       * @param params Lists opted-in local peers. The caller is omitted.
+       *
+       * @returns Eligible live peers reported by their owning runtimes.
+       */
+      list: async (params) => connection.sendRequest("session.management.list", { ...params, sessionId }),
+      /**
+       * Injects peer text into an opted-in session. Wakes an idle agent and safely queues delivery to a busy agent. Acceptance does not imply an answer or completed task.
+       *
+       * @param params Sends peer text, never human approval, to another opted-in session.
+       *
+       * @returns Acceptance is not a completed turn or a reply.
+       */
+      message: async (params) => connection.sendRequest("session.management.message", { ...params, sessionId }),
+      /**
+       * Asks the owning host to create and supervise a separate session, preserving permissions and model restrictions. Omitted model, reasoning effort, context tier and cwd inherit the caller's current values; explicit overrides use normal model validation and workspace trust. Records durable creation lineage before delivering the initial task as peer text. Returns the new session ID, not task completion. Requires the create tool and a host creation handler.
+       *
+       * @param params Requests a separate session. Omitted launch options inherit the caller's current configuration.
+       *
+       * @returns Identifies a session owned and supervised by the creating host.
+       */
+      create: async (params) => connection.sendRequest("session.management.create", { ...params, sessionId }),
+      /**
+       * Closes a live opted-in session created by the caller or one of its descendants, preserving saved history and leaving descendants open. Requires the close capability to be enabled. Self, ancestors, siblings and unrelated sessions cannot be closed.
+       *
+       * @param params Closes one live opted-in descendant without deleting its saved history or closing its children.
+       *
+       * @returns Completion of the existing non-deleting close lifecycle.
+       */
+      close: async (params) => connection.sendRequest("session.management.close", { ...params, sessionId })
+    },
     /** @experimental */
     providers: {
       /**
@@ -2357,7 +2628,7 @@ function createSessionRpc(connection, sessionId) {
       /** @experimental */
       login: {
         /**
-         * Begin an interactive login flow for a provider kind (dispatch is kind-only) and return its opaque flow id and first step.
+         * Begin an interactive login flow for a provider kind, optionally selecting how to authorize (`method`: `web` by default, or `device-code`), and return its opaque flow id and first step.
          *
          * @param params Begin an interactive login flow for a provider kind, optionally reusing a cached base identity or explicitly requesting provider account selection.
          *
@@ -2369,7 +2640,7 @@ function createSessionRpc(connection, sessionId) {
          *
          * @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).
+         * @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). A device-code flow surfaces its one-time code as `device-code`; the consumer shows the code, may open the verification URI, and calls advance, which resolves once the user has authorized the device.
          */
         advance: async (params) => connection.sendRequest("session.accounts.login.advance", { ...params, sessionId }),
         /**
@@ -2811,7 +3082,13 @@ function createSessionRpc(connection, sessionId) {
        *
        * @returns Canonical runtime state for the session's current autopilot objective.
        */
-      getState: async () => connection.sendRequest("session.autopilotObjective.getState", { sessionId })
+      getState: async () => connection.sendRequest("session.autopilotObjective.getState", { sessionId }),
+      /**
+       * Sets whether completing or pausing this session's objective preserves autopilot mode. This in-memory preference defaults to true and must be reapplied when attaching a client.
+       *
+       * @param params Client-resolved preference for retaining autopilot mode after objective completion or pause.
+       */
+      setStayInAutopilot: async (params) => connection.sendRequest("session.autopilotObjective.setStayInAutopilot", { ...params, sessionId })
     },
     /** @experimental */
     completions: {
@@ -3551,6 +3828,12 @@ function createSessionRpc(connection, sessionId) {
        * @returns The selectable model entries and selection ids synthesized for the synchronized BYOK models.
        */
       sync: async (params) => connection.sendRequest("session.provider.sync", { ...params, sessionId }),
+      /**
+       * Returns credential-free provider configuration status for the selected model. This does not validate provider credentials or contact the provider.
+       *
+       * @returns Credential-free provider configuration status for the selected model.
+       */
+      getStatus: async () => connection.sendRequest("session.provider.getStatus", { sessionId }),
       /**
        * Withdraws named host-managed models from the session's BYOK registry, leaving every other entry untouched. The scoped counterpart to `provider.sync`: a snapshot can only describe entries the caller knows about, so using it to remove one model silently withdraws rows registered by another source, such as a plugin calling `provider.add` at runtime. Naming what to remove leaves unrelated entries alone. Selection ids that are not registered are ignored, so withdrawal is idempotent. A provider is removed only when one of the withdrawn models was the last entry referencing it; a provider that simply has no models, which is the normal state while its rows are supplied by catalog discovery, is left in place.
        *
@@ -3891,6 +4174,12 @@ function createSessionRpc(connection, sessionId) {
        * @returns Current permission mode.
        */
       getMode: async () => connection.sendRequest("session.permissions.getMode", { sessionId }),
+      /**
+       * Returns the approval modes currently available under the session's feature and managed permission policy. This read does not change permissions; mutations must still check their authoritative result because policy may change.
+       *
+       * @returns Available permission modes, derived from current session policy.
+       */
+      getCapabilities: async () => connection.sendRequest("session.permissions.getCapabilities", { sessionId }),
       /**
        * Adds or removes session-scoped or location-scoped permission rules.
        *
@@ -4211,6 +4500,12 @@ function createSessionRpc(connection, sessionId) {
        * @returns Indicates whether an in-progress background compaction was cancelled.
        */
       cancelBackgroundCompaction: async () => connection.sendRequest("session.history.cancelBackgroundCompaction", { sessionId }),
+      /**
+       * Replaces this local session's compaction settings: the model, prompt and reasoning effort its automatic and manual compactions use. Each call replaces all three: an omitted field returns to its default. Settings are held in memory only, so re-apply them after resuming the session in a new process. A change applies to compactions that start afterwards, except that automatic compactions keep the model the running turn already chose for them until that turn ends; a compaction already in progress may still pick up a new reasoning effort. Rejects on a remote session.
+       *
+       * @param params Compaction settings for this session. Each call replaces the previous settings: an omitted field returns to its default. Settings live in memory until the session ends; re-apply them after resuming a session in a new process.
+       */
+      setCompactionConfig: async (params) => connection.sendRequest("session.history.setCompactionConfig", { ...params, sessionId }),
       /**
        * Aborts any in-progress manual compaction on a local session.
        *
@@ -4548,6 +4843,15 @@ function createInternalSessionRpc(connection, sessionId) {
       }
     },
     /** @experimental */
+    canvasSource: {
+      /**
+       * Closes a canvas through its original session source. Requires the privately admitted in-process CLI host.
+       *
+       * @param params Closes a canvas through its original owned or attached session namespace.
+       */
+      close: async (params) => connection.sendRequest("session.canvasSource.close", { ...params, sessionId })
+    },
+    /** @experimental */
     workflow: {
       /**
        * Internal tool-originated dynamic workflow invocation.
@@ -4843,6 +5147,17 @@ function createInternalSessionRpc(connection, sessionId) {
        * @returns Result of registering or re-arming a scheduled prompt.
        */
       rearmSelfPaced: async (params) => connection.sendRequest("session.schedule.rearmSelfPaced", { ...params, sessionId })
+    },
+    /** @experimental */
+    cafeMetrics: {
+      /**
+       * Records live model-call events, including subagents, and root compaction events. Replaces any earlier recorder. Requires the private trusted CLI host capability.
+       */
+      attach: async () => connection.sendRequest("session.cafeMetrics.attach", { sessionId }),
+      /**
+       * Stops recording this session. Does nothing if it has no recorder. Requires the private trusted CLI host capability.
+       */
+      detach: async () => connection.sendRequest("session.cafeMetrics.detach", { sessionId })
     }
   };
 }

package/dist/cjs/session.js

@@ -170,6 +170,11 @@ class WorkflowProgressBuffer {
     if (this.closed) {
       throw new Error("Cannot log after the workflow run has settled");
     }
+    if (typeof text !== "string") {
+      throw new TypeError(
+        `${kind}() expects a string; got ${text === null ? "null" : typeof text}.`
+      );
+    }
     this.pending.push({ seq: this.nextSeq++, kind, text });
     this.scheduleFlush();
   }
@@ -297,6 +302,7 @@ class CopilotSession {
   /** Settles once every earlier `setTools` call has finished. */
   setToolsQueue = Promise.resolve();
   pendingExternalTools = /* @__PURE__ */ new Map();
+  pendingSessionCreations = /* @__PURE__ */ new Set();
   canvases = /* @__PURE__ */ new Map();
   bearerTokenProviders = /* @__PURE__ */ new Map();
   commandHandlers = /* @__PURE__ */ new Map();
@@ -309,6 +315,7 @@ class CopilotSession {
   exitPlanModeHandler;
   autoModeSwitchHandler;
   skillProvider;
+  sessionCreationHandler;
   hooks;
   transformCallbacks;
   _rpc = null;
@@ -896,6 +903,10 @@ class CopilotSession {
       controller.abort();
     }
     this.pendingExternalTools.clear();
+    for (const controller of this.pendingSessionCreations) {
+      controller.abort();
+    }
+    this.pendingSessionCreations.clear();
     this.eventHandlers.clear();
     this.typedEventHandlers.clear();
     this.toolHandlers.clear();
@@ -906,6 +917,7 @@ class CopilotSession {
     this.exitPlanModeHandler = void 0;
     this.autoModeSwitchHandler = void 0;
     this.skillProvider = void 0;
+    this.sessionCreationHandler = void 0;
     this.hooks = void 0;
     this.traceContextProvider = void 0;
     this.bearerTokenProviders.clear();
@@ -1165,6 +1177,13 @@ class CopilotSession {
       } else if (typeof rawResult === "string") {
         result = rawResult;
       } else if (isToolResultObject(rawResult)) {
+        try {
+          JSON.stringify(rawResult.toolTelemetry);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          throw new Error(`failed to serialize tool telemetry: ${message}`);
+        }
+        JSON.stringify(rawResult);
         result = rawResult;
       } else {
         result = JSON.stringify(rawResult);
@@ -1177,7 +1196,10 @@ class CopilotSession {
       if (!this._claimExternalTool(requestId, controller)) {
         return;
       }
-      const message = error instanceof Error ? error.message : String(error);
+      let message = error instanceof Error ? error.message : String(error);
+      if (!message) {
+        message = error instanceof Error && error.name || "Error";
+      }
       try {
         await this.rpc.tools.handlePendingToolCall({ requestId, error: message });
       } catch (rpcError) {
@@ -1575,6 +1597,7 @@ class CopilotSession {
           assertWorkflowResult(result);
           return { result };
         } finally {
+          controller.abort(new DOMException("Workflow run has settled", "AbortError"));
           try {
             await progress.close();
           } finally {
@@ -1869,6 +1892,41 @@ class CopilotSession {
     this.assertConnected();
     this.skillProvider = provider;
   }
+  /**
+   * Registers the host's creation callback without enabling the tool group.
+   * Enable it separately with `session.rpc.management.configure({ enabled: true })`.
+   */
+  async setSessionCreationHandler(handler) {
+    this.assertConnected();
+    const previous = this.sessionCreationHandler;
+    this.sessionCreationHandler = handler;
+    try {
+      return await this.rpc.management.configure({ hasCreateHandler: handler !== void 0 });
+    } catch (error) {
+      if (this.sessionCreationHandler === handler) this.sessionCreationHandler = previous;
+      throw error;
+    }
+  }
+  /** @internal */
+  async _handleSessionManagementCreate(request, token) {
+    this.assertConnected();
+    const handler = this.sessionCreationHandler;
+    if (!handler || request.parentSessionId !== this.sessionId || request.sessionId !== this.sessionId) {
+      throw new Error("Session creation handler is unavailable");
+    }
+    const controller = new AbortController();
+    this.pendingSessionCreations.add(controller);
+    const subscription = token.onCancellationRequested(() => controller.abort());
+    if (token.isCancellationRequested) controller.abort();
+    try {
+      return await handler(request, { signal: controller.signal });
+    } catch {
+      throw new Error("Session creation callback failed");
+    } finally {
+      subscription.dispose();
+      this.pendingSessionCreations.delete(controller);
+    }
+  }
   /**
    * Handles a `skillProvider.list` request from the runtime.
    *

package/dist/cjs/types.js

@@ -71,11 +71,9 @@ const RuntimeConnection = {
   /**
    * Host the runtime in-process over the native runtime library's C ABI (FFI).
    *
-   * @experimental Per-client options lowered to environment variables (`env`,
-   * `telemetry`, `gitHubToken`, `baseDirectory`) are **not** honored in-process;
-   * the worker inherits the host process's ambient environment. Set the
-   * corresponding environment variables on the host process instead. See
-   * https://github.com/github/copilot-sdk/issues/1934.
+   * @experimental Runtime configuration from `gitHubToken` and
+   * `baseDirectory` is scoped to this host, not the process environment.
+   * Client-level `env`, `telemetry` and `workingDirectory` are unsupported.
    */
   forInProcess(options = {}) {
     return { kind: "inprocess", ...options };

package/dist/cliVersion.d.ts

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

package/dist/cliVersion.js

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

package/dist/client.d.ts

@@ -38,7 +38,6 @@ export declare class CopilotClient {
     private onListModels?;
     private onGetTraceContext?;
     private modelsCache;
-    private modelsCacheLock;
     private sessionLifecycleHandlers;
     private typedLifecycleHandlers;
     private _rpc;
@@ -140,12 +139,17 @@ export declare class CopilotClient {
      * Stops the CLI server and closes all active sessions.
      *
      * This method performs graceful cleanup:
-     * 1. Closes all active sessions (releases in-memory resources)
+     * 1. Closes all active sessions (releases in-memory resources); detach
+     *    requests share one shutdown timeout
      * 2. Requests runtime shutdown for SDK-owned CLI processes
      * 3. Closes the JSON-RPC connection
      * 4. Signals EOF to an owned stdio process and waits for host cleanup, then
      *    terminates the process if it does not exit within the shutdown timeout
      *
+     * In-process connections first abort active turns without a timeout. That
+     * step is outside the detach deadline, so in-process stop() can still wait
+     * indefinitely if the runtime stops answering abort requests.
+     *
      * Note: session data on disk is preserved, so sessions can be resumed later.
      * To permanently remove session data before stopping, call
      * {@link deleteSession} for each session first.
@@ -470,11 +474,8 @@ export declare class CopilotClient {
      */
     onLifecycle(handler: SessionLifecycleHandler): () => void;
     /**
-     * Builds the environment for the spawned runtime child process (stdio/TCP): applies
-     * the auth token, connection token, `COPILOT_HOME`, keychain setting, and telemetry
-     * variables on top of the effective env. Not used by the in-process (FFI) transport,
-     * whose worker inherits the host process's ambient environment
-     * (see {@link CopilotClient.startInProcessFfi}).
+     * Builds runtime configuration for child processes and the per-host FFI snapshot.
+     * Typed auth, home, keychain, and telemetry options override the effective env.
      */
     private buildRuntimeEnv;
     /**