@github/copilot-sdk 1.0.29-preview.5 → 1.0.29-preview.6

package/README.md

@@ -469,6 +469,8 @@ List all available sessions. Optionally filter by working directory context.
 - `summary?: string` - Optional session summary
 - `isRemote: boolean` - Whether the session is remote
 - `context?: SessionContext` - Working directory context from session creation
+- `clientName?: string` - Client that created the session (for example `github/cli`)
+- `lastClientName?: string` - Client that most recently ran the session: the client that created it, or a client that resumed it and then ran it. Resuming a session only to observe it does not change it. Omitted when unknown, such as for sessions persisted before this field existed.
 
 **SessionContext:**
 
@@ -620,6 +622,10 @@ sends do not inherit it. Ordinary immediate steering inherits the active schema
 and originating message ID, even when it arrives too late for the current model
 request and is promoted into a follow-up run. Specifying a schema with
 `mode: "immediate"` is rejected, even while idle.
+Provider schema restrictions still apply, and schemas are not rewritten. Strict
+OpenAI output needs an object root with every property listed in `required`.
+Zod leaves `.optional()` properties out of `required`, so use `.nullable()` for a
+field the model may leave empty.
 The generated `session.rpc.send` and `session.rpc.sendMessages` wrappers expose
 the full `responseFormat` contract when you need to set its name, description,
 or strict option rather than using the convenience defaults (`name: "response"`,
@@ -788,10 +794,6 @@ Capabilities may update during the session. For example, when another client joi
 
 Interactive UI methods for showing dialogs to the user. Only available when the CLI host supports elicitation (`session.capabilities.ui?.elicitation === true`). See [UI Elicitation](#ui-elicitation) for full details.
 
-##### `destroy(): Promise<void>` _(deprecated)_
-
-Deprecated — use `disconnect()` instead.
-
 ---
 
 ## Event Types
@@ -1746,6 +1748,17 @@ Callbacks receive optional derived prompt context as `invocation.promptRequest`.
 
 Use the built-in `approveAll` helper when managed settings are disabled:
 
+<!-- docs-validate: strict -->
+<!-- docs-validate: hidden -->
+```typescript
+import { approveAll } from "@github/copilot-sdk";
+
+const session = await client.createSession({
+    model: "gpt-5",
+    onPermissionRequest: approveAll,
+});
+```
+<!-- /docs-validate: hidden -->
 ```typescript
 import { CopilotClient, approveAll } from "@github/copilot-sdk";
 
@@ -1761,6 +1774,7 @@ When `enableManagedSettings` is true for the session, `approveAll` throws. Use a
 
 Provide your own function to inspect each request and apply custom logic. Check `managedApprovalRequired` before any automatic approval:
 
+<!-- docs-validate: strict -->
 ```typescript
 import type { PermissionRequest, PermissionRequestResult } from "@github/copilot-sdk";
 
@@ -1834,6 +1848,26 @@ Recheck requires session opt-in through `enableManagedSettings: true`.
 Treat helper text as untrusted plain text, keep `diagnostic` secondary,
 and sanitize `helpLink` before navigation.
 
+<!-- docs-validate: strict -->
+<!-- docs-validate: hidden -->
+```typescript
+import type { CopilotSession } from "@github/copilot-sdk";
+
+declare const session: CopilotSession;
+
+const snapshot = await session.rpc.managedSettings.get();
+
+if (snapshot.policyHelperFailure) {
+    console.warn(snapshot.policyHelperFailure.message);
+}
+
+if (snapshot.policyHelperCapabilities?.recheck === true) {
+    const refreshed = await session.rpc.managedSettings.recheckPolicyHelper();
+    // Only a current capable snapshot without policyHelperFailure establishes recovery.
+    console.log(refreshed.policyHelperFailure ?? "Policy Helper recovered");
+}
+```
+<!-- /docs-validate: hidden -->
 ```typescript
 const snapshot = await session.rpc.managedSettings.get();
 
@@ -1872,6 +1906,16 @@ The handler must return one of the `PermissionDecision` shapes (or `{ kind: "no-
 
 You may pass `onPermissionRequest` when resuming a session too:
 
+<!-- docs-validate: strict -->
+<!-- docs-validate: hidden -->
+```typescript
+import { approveAll } from "@github/copilot-sdk";
+
+const session = await client.resumeSession("session-id", {
+    onPermissionRequest: approveAll,
+});
+```
+<!-- /docs-validate: hidden -->
 ```typescript
 const session = await client.resumeSession("session-id", {
     onPermissionRequest: approveAll,

package/dist/cjs/cliVersion.js

@@ -22,7 +22,7 @@ __export(cliVersion_exports, {
   COPILOT_CLI_VERSION: () => COPILOT_CLI_VERSION
 });
 module.exports = __toCommonJS(cliVersion_exports);
-const COPILOT_CLI_VERSION = "1.0.106-6";
+const COPILOT_CLI_VERSION = "1.0.106-7";
 const COPILOT_CLI_USE_NPM_PACKAGE = false;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/client.js

@@ -54,6 +54,19 @@ var import_types = require("./types.js");
 const MIN_PROTOCOL_VERSION = 3;
 const RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
 const CLOUD_SESSION_CLEANUP_TIMEOUT_MS = 1e4;
+const messageEncodeErrors = /* @__PURE__ */ new WeakSet();
+const jsonMessageEncoder = {
+  name: "application/json",
+  encode: (msg, options) => {
+    try {
+      return Promise.resolve(Buffer.from(JSON.stringify(msg), options.charset));
+    } catch (thrown) {
+      const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+      messageEncodeErrors.add(error);
+      return Promise.reject(error);
+    }
+  }
+};
 function createMessageConnection(reader, writer) {
   let dispatch;
   let finishDrain;
@@ -290,6 +303,9 @@ function getBundledRuntimePath() {
 }
 class TeardownResilientStreamMessageWriter extends import_node.StreamMessageWriter {
   suppressWriteErrors = false;
+  constructor(writable) {
+    super(writable, { contentTypeEncoder: jsonMessageEncoder });
+  }
   async write(msg) {
     try {
       await super.write(msg);
@@ -2315,7 +2331,9 @@ class CopilotClient {
         gitRoot: context.gitRoot,
         repository: context.repository,
         branch: context.branch
-      } : void 0
+      } : void 0,
+      clientName: raw.clientName,
+      lastClientName: raw.lastClientName
     };
   }
   /**
@@ -2972,7 +2990,10 @@ stderr: ${stderrOutput}` : ""}`
         exitFallback.unref?.();
       });
     }
-    this.connection.onError(() => {
+    this.connection.onError(([error]) => {
+      if (messageEncodeErrors.has(error)) {
+        return;
+      }
       if (connectionEpoch === this.connectionEpoch && this.connection === connection) {
         this.state = "disconnected";
       }

package/dist/cjs/generated/rpc.js

@@ -1817,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: {
@@ -2009,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: {
@@ -2177,6 +2209,194 @@ 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)
     }
   };
 }
@@ -4912,6 +5132,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/cliVersion.d.ts

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

package/dist/cliVersion.js

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

package/dist/client.js

@@ -36,6 +36,19 @@ import { defaultJoinSessionPermissionHandler } from "./types.js";
 const MIN_PROTOCOL_VERSION = 3;
 const RUNTIME_SHUTDOWN_TIMEOUT_MS = 1e4;
 const CLOUD_SESSION_CLEANUP_TIMEOUT_MS = 1e4;
+const messageEncodeErrors = /* @__PURE__ */ new WeakSet();
+const jsonMessageEncoder = {
+  name: "application/json",
+  encode: (msg, options) => {
+    try {
+      return Promise.resolve(Buffer.from(JSON.stringify(msg), options.charset));
+    } catch (thrown) {
+      const error = thrown instanceof Error ? thrown : new Error(String(thrown));
+      messageEncodeErrors.add(error);
+      return Promise.reject(error);
+    }
+  }
+};
 function createMessageConnection(reader, writer) {
   let dispatch;
   let finishDrain;
@@ -272,6 +285,9 @@ function getBundledRuntimePath() {
 }
 class TeardownResilientStreamMessageWriter extends StreamMessageWriter {
   suppressWriteErrors = false;
+  constructor(writable) {
+    super(writable, { contentTypeEncoder: jsonMessageEncoder });
+  }
   async write(msg) {
     try {
       await super.write(msg);
@@ -2297,7 +2313,9 @@ class CopilotClient {
         gitRoot: context.gitRoot,
         repository: context.repository,
         branch: context.branch
-      } : void 0
+      } : void 0,
+      clientName: raw.clientName,
+      lastClientName: raw.lastClientName
     };
   }
   /**
@@ -2954,7 +2972,10 @@ stderr: ${stderrOutput}` : ""}`
         exitFallback.unref?.();
       });
     }
-    this.connection.onError(() => {
+    this.connection.onError(([error]) => {
+      if (messageEncodeErrors.has(error)) {
+        return;
+      }
       if (connectionEpoch === this.connectionEpoch && this.connection === connection) {
         this.state = "disconnected";
       }

package/dist/generated/rpc.d.ts

@@ -15119,6 +15119,40 @@ export interface FolderTrustCheckResult {
      */
     trusted: boolean;
 }
+/**
+ * A pre-resolved address for a GitHub request.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "GitHubFetchPinnedAddress".
+ */
+/** @experimental */
+export interface GitHubFetchPinnedAddress {
+    /**
+     * Address the network transport must use.
+     */
+    address: string;
+}
+/**
+ * Proxy environment for one authenticated GitHub request.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "GitHubFetchProxyEnvironment".
+ */
+/** @experimental */
+export interface GitHubFetchProxyEnvironment {
+    /**
+     * Proxy for HTTP requests.
+     */
+    httpProxy?: string;
+    /**
+     * Proxy for HTTPS requests.
+     */
+    httpsProxy?: string;
+    /**
+     * Hosts that bypass the proxy.
+     */
+    noProxy?: string;
+}
 /**
  * Owner, name, and host of a GitHub repository, as resolved from a git remote URL.
  *
@@ -17557,7 +17591,7 @@ export interface LocalSessionMetadataValue {
      */
     name?: string;
     /**
-     * Runtime client name that created/last resumed this session
+     * Runtime client name that created this session
      */
     clientName?: string;
     /**
@@ -17576,6 +17610,10 @@ export interface LocalSessionMetadataValue {
      * GitHub task ID, when this local session is bound to one. Only present for local sessions exported to remote control.
      */
     mcTaskId?: string;
+    /**
+     * Runtime client name that most recently ran this session: the client that created it, or a client that resumed it and then ran it. Resuming a session only to observe it does not change this. Omitted when unknown, such as for sessions persisted before this field existed.
+     */
+    lastClientName?: string;
 }
 /**
  * Pre-resolved working-directory context for session startup.
@@ -18214,6 +18252,10 @@ export interface MarketplaceInfo {
      * Whether the managed marketplace currently resolved into the runtime marketplace registry. Set to false when the desired managed entry is retained for governance visibility after loading or reconciliation failed.
      */
     available?: boolean;
+    /**
+     * True when the signed-in account's GitHub Team provides this marketplace and no user, repository, or default entry of the same name exists. Team marketplaces are not persisted, so they cannot be removed.
+     */
+    team?: boolean;
 }
 /**
  * All registered marketplaces, including built-in defaults.

package/dist/generated/rpc.js

@@ -1789,7 +1789,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: {
@@ -1981,7 +1997,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: {
@@ -2149,6 +2181,194 @@ 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)
     }
   };
 }
@@ -4884,6 +5104,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/generated/session-events.d.ts

@@ -5802,6 +5802,10 @@ export interface UserMessageData {
      * Files, selections, or GitHub references attached to the message
      */
     attachments?: Attachment[];
+    /**
+     * IDs of accepted assistant messages that caused this delivered inter-agent prompt, referring to assistant.message.data.messageId across the agent tree. Captured when sending and retained through queued or immediate delivery. An empty list means no model-produced dependency; absence means provenance is unavailable.
+     */
+    causalDependencies?: string[];
     /**
      * The user's message text as displayed in the timeline
      */
@@ -8986,6 +8990,10 @@ export interface ToolExecutionCompleteEvent {
  * Tool execution completion results including success status, detailed output, and error information
  */
 export interface ToolExecutionCompleteData {
+    /**
+     * IDs of accepted assistant messages whose output this tool result consumed, referring to assistant.message.data.messageId across the agent tree. Captured from the returned snapshot, including partial agent reads. An empty list means no model-produced dependency; absence means provenance is unavailable.
+     */
+    causalDependencies?: string[];
     /**
      * Error details when the tool execution failed
      */
@@ -10772,6 +10780,10 @@ export interface SystemNotificationEvent {
  * System-generated notification for runtime events like background task completion
  */
 export interface SystemNotificationData {
+    /**
+     * IDs of accepted assistant messages whose output this notification consumed, referring to assistant.message.data.messageId across the agent tree. Captured from the delivered snapshot, not the sender's later state. An empty list means no model-produced dependency; absence means provenance is unavailable.
+     */
+    causalDependencies?: string[];
     /**
      * The notification text, typically wrapped in <system_notification> XML tags
      */

package/dist/session.d.ts

@@ -159,6 +159,7 @@ export declare class CopilotSession {
      * Events are still delivered to handlers registered via {@link on} while waiting.
      * Sub-agent events with a non-empty `agentId` do not complete the wait or supply its reply.
      * With a schema as the second argument, returns its parsed, validated result.
+     * Provider schema restrictions apply to that schema; see {@link MessageOptions.responseSchema}.
      * Structured waits select only root-agent output originating from this send;
      * other queued work may delay session.idle but cannot replace the result.
      *

package/dist/types.d.ts

@@ -3285,6 +3285,9 @@ export interface MessageOptions {
      * sendAndWait still returns an assistant message event. For a typed result, pass a
      * Zod-compatible schema as sendAndWait's second argument instead.
      * Streaming events remain text and may include intermediate messages.
+     * Sent with strict: true and not rewritten, so provider schema restrictions apply: strict
+     * OpenAI output needs an object root with every property required (use Zod's .nullable()
+     * rather than .optional()).
      * Use rpc.send's responseFormat for provider-specific name, description and strict options.
      */
     responseSchema?: ZodSchema | Record<string, unknown>;
@@ -3383,6 +3386,18 @@ export interface SessionMetadata {
     isRemote: boolean;
     /** Working directory context (working directory, git info) from session creation */
     context?: SessionContext;
+    /**
+     * Name of the client that created the session (for example `github/cli`). Omitted when
+     * unknown.
+     */
+    clientName?: string;
+    /**
+     * Name of the client that most recently ran the session: the client that created it, or a
+     * client that resumed it and then ran it. Resuming a session only to observe it does not
+     * change this. Omitted when unknown, such as for sessions persisted before this field
+     * existed.
+     */
+    lastClientName?: string;
 }
 /**
  * Response from status.get

package/package.json

@@ -5,8 +5,8 @@
         "url": "https://github.com/github/copilot-agent-runtime.git",
         "directory": "src/sdk/nodejs"
     },
-    "version": "1.0.29-preview.5",
-    "copilotCliVersion": "1.0.106-6",
+    "version": "1.0.29-preview.6",
+    "copilotCliVersion": "1.0.106-7",
     "description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
     "main": "./dist/cjs/index.js",
     "types": "./dist/index.d.ts",
@@ -117,18 +117,18 @@
         "README.md"
     ],
     "copilotRuntime": {
-        "sourceSha": "499e74e4fa51da808a2c3c6c6c27ba946167e27a",
-        "version": "1.0.106-6",
+        "sourceSha": "231e2021c92dbec223006702f867d8c29cae2f54",
+        "version": "1.0.106-7",
         "visibility": "public"
     },
     "optionalDependencies": {
-        "@github/copilot-sdk-darwin-arm64": "1.0.29-preview.5",
-        "@github/copilot-sdk-darwin-x64": "1.0.29-preview.5",
-        "@github/copilot-sdk-linux-arm64": "1.0.29-preview.5",
-        "@github/copilot-sdk-linux-x64": "1.0.29-preview.5",
-        "@github/copilot-sdk-linuxmusl-arm64": "1.0.29-preview.5",
-        "@github/copilot-sdk-linuxmusl-x64": "1.0.29-preview.5",
-        "@github/copilot-sdk-win32-arm64": "1.0.29-preview.5",
-        "@github/copilot-sdk-win32-x64": "1.0.29-preview.5"
+        "@github/copilot-sdk-darwin-arm64": "1.0.29-preview.6",
+        "@github/copilot-sdk-darwin-x64": "1.0.29-preview.6",
+        "@github/copilot-sdk-linux-arm64": "1.0.29-preview.6",
+        "@github/copilot-sdk-linux-x64": "1.0.29-preview.6",
+        "@github/copilot-sdk-linuxmusl-arm64": "1.0.29-preview.6",
+        "@github/copilot-sdk-linuxmusl-x64": "1.0.29-preview.6",
+        "@github/copilot-sdk-win32-arm64": "1.0.29-preview.6",
+        "@github/copilot-sdk-win32-x64": "1.0.29-preview.6"
     }
 }