@github/copilot-sdk-win32-x64 1.0.16 → 1.0.17-preview.1

package/copilot-sdk/generated/rpc.d.ts

@@ -1358,6 +1358,14 @@ export type ConnectorMcpStatus =
  | "disabled"
 /** The Connector currently has no live server configuration. */
  | "not_configured";
+/**
+ * Session account selection, or null.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ConnectorSessionAccountResult".
+ */
+/** @experimental */
+export type ConnectorSessionAccountResult = ConnectorSessionAccount | null;
 /**
  * Closed set of public task kinds a connection can negotiate.
  *
@@ -2516,6 +2524,32 @@ export type SessionLogLevel =
  | "warning"
 /** Error message describing a failure. */
  | "error";
+/**
+ * A channel accepted by managedSettings.compose.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsChannel".
+ */
+/** @experimental */
+export type ManagedSettingsChannel = 
+/** Device policy, the strongest channel. */
+"device"
+/** Account or organization policy. */
+ | "server"
+/** Session-local helper output, the weakest channel. */
+ | "policyHelper";
+/**
+ * Severity of a managed-settings validation finding.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsDiagnosticSeverity".
+ */
+/** @experimental */
+export type ManagedSettingsDiagnosticSeverity = 
+/** The runtime rejects the document. */
+"error"
+/** The runtime accepts the document but ignores the flagged content. */
+ | "warning";
 /**
  * UI theme preference per SEP-1865
  *
@@ -3255,6 +3289,18 @@ export type McpServerCardEmbeddedKind = "embedded";
  */
 /** @experimental */
 export type McpPlanInstallResult = McpPlanInstallPlanned | CatalogNegotiationRefusedError | CatalogHandleRejectedError | CatalogInvalidRequestError | CatalogAuthenticationRequiredError | CatalogPolicyRejectedError | CatalogNetworkFailureError | CatalogUnsafeRetrievalError | CatalogMalformedCardError | CatalogContractViolationError | CatalogUnavailableTransportError | CatalogNotInstallableError | CatalogUnavailableError;
+/**
+ * The sender role of an MCP prompt message.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptRole".
+ */
+/** @experimental */
+export type McpPromptRole = 
+/** A message from the user. */
+"user"
+/** A message from the assistant. */
+ | "assistant";
 /**
  * MCP server configuration (stdio, remote HTTP/SSE, or in-process)
  *
@@ -4110,7 +4156,7 @@ export type SandboxConfigSource =
 /** A repository policy selected the sandbox state. */
  | "repository_policy";
 /**
- * Extensible identifier of a sandbox policy feature whose availability varies between hosts. A plain string, so an older client decodes a name added by a newer runtime; ignore names you do not recognize. Known values: `network` — sandboxed commands can reach the network (`network.allowOutbound`, on by default); on Linux this needs the tooling for Bubblewrap's private network namespace, such as slirp4netns. `network_filtering` — host rules and the sandbox proxy (`network.allowedHosts`, `network.blockedHosts`, `network.proxy`); on Linux this needs the same tooling as `network`; on Windows it needs a version with Process Security Environment 1.1 host-loopback support, and a policy that uses it must also set `network.allowLocalNetwork`, because Windows reaches the local proxy only together with private-network access. `denied_paths` — native enforcement of `filesystem.deniedPaths`; on Windows this needs a version whose sandbox contract reports denied-path support. `shell` — shell commands inside the sandbox: bash on macOS and Linux, PowerShell on Windows; on Windows this needs a version with Process Security Environment 1.1 filesystem enumeration support.
+ * Extensible identifier of a sandbox policy feature whose availability varies between hosts. A plain string, so an older client decodes a name added by a newer runtime; ignore names you do not recognize. Known values: `network` — sandboxed commands can reach the network (`network.allowOutbound`, on by default); on Linux this needs the tooling for Bubblewrap's private network namespace, such as slirp4netns. `network_filtering` — host rules and the sandbox proxy (`network.allowedHosts`, `network.blockedHosts`, `network.proxy`); on Linux this needs the same tooling as `network`; on Windows it needs a version with Process Security Environment 1.1 host-loopback support, and a policy that uses it must also set `network.allowLocalNetwork`, because Windows reaches the local proxy only together with private-network access. `denied_paths` — native enforcement of `filesystem.deniedPaths`; on Windows this needs a version whose sandbox contract reports denied-path support. `shell` — shell commands inside the sandbox: bash on macOS and Linux, PowerShell on Windows. `filesystem_enumeration` — enumerate-only filesystem grants, which PowerShell's drive roots use on Windows; this needs a version with Process Security Environment 1.1 filesystem enumeration support. Without it, sandboxed PowerShell still runs, but `Get-Location` may report the drive root, `Set-Location` may fail, and relative paths may resolve against the drive root; the session also receives a `session.warning` with `warningType` `sandbox`. Other platforms always report it.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
  * via the `definition` "SandboxHostCapabilityName".
@@ -6949,6 +6995,24 @@ export interface AuthIdentity {
     registrationId?: string;
     copilotUser?: CopilotUserResponse;
 }
+/**
+ * Credential-free identity metadata.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "AuthIdentityMetadata".
+ */
+/** @experimental */
+export interface AuthIdentityMetadata {
+    type: AuthInfoType;
+    /**
+     * Identity host.
+     */
+    host: string;
+    /**
+     * User login.
+     */
+    login: string;
+}
 /**
  * Advance an in-flight login flow, optionally fulfilling an input-required step.
  *
@@ -9054,6 +9118,14 @@ export interface ConnectorCapabilities {
      * Whether callers select a host-owned GitHub account through an opaque selection ID rather than supplying a provider token.
      */
     opaqueAccountSelection: boolean;
+    /**
+     * Whether getAccount is supported. Absence means false.
+     */
+    sessionAccountSelection?: boolean;
+    /**
+     * Whether reconcile accepts forceConnectorName. Absence means false.
+     */
+    targetedReconcile?: boolean;
     /**
      * Maximum accepted polling attempts for one continuation call.
      */
@@ -9087,6 +9159,18 @@ export interface ConnectorCatalogEntry {
      * Untrusted service description, when present.
      */
     description?: string;
+    /**
+     * Optional catalog logo.
+     */
+    logo?: string;
+    /**
+     * Optional catalog tier.
+     */
+    tier?: string;
+    /**
+     * Optional catalog release tag.
+     */
+    releaseTag?: string;
     status: ConnectorCatalogStatus;
     /**
      * Opaque stable runtime IDs currently projected into the session for this Connector.
@@ -9232,6 +9316,24 @@ export interface ConnectorReconcileRequest {
      * When true, refresh the catalog before reconciling. A disabled Connector API performs no service request.
      */
     refreshCatalog?: boolean;
+    /**
+     * Optional Connector name to reinitialize. Requires the targetedReconcile capability.
+     */
+    forceConnectorName?: string;
+}
+/**
+ * Session account selection.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ConnectorSessionAccount".
+ */
+/** @experimental */
+export interface ConnectorSessionAccount {
+    /**
+     * Opaque session-scoped account selection ID.
+     */
+    accountId: string;
+    authInfo: AuthIdentityMetadata;
 }
 /**
  * Remote session connection parameters.
@@ -12795,6 +12897,130 @@ export interface ManagedMcpServerConfig {
      */
     headersRefreshTtlMs?: number;
 }
+/**
+ * Lock state and provenance of one managed setting.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingMeta".
+ */
+/** @experimental */
+export interface ManagedSettingMeta {
+    /**
+     * Whether users and repositories may choose a different value. `false` means policy locks the value.
+     */
+    overridable: boolean;
+    /**
+     * Channel that supplied this scalar value, matching a `layers[].source`: `device`, `server`, or `policyHelper`. These scalar defaults select one winning channel, not a mixed source. Treat unknown values as additional channels; more may be added.
+     */
+    source: string;
+}
+/**
+ * One candidate channel; absent settings represents a channel that delivered no document.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsComposeLayer".
+ */
+/** @experimental */
+export interface ManagedSettingsComposeLayer {
+    source: ManagedSettingsChannel;
+    /**
+     * Candidate managed-settings document. Omit when the channel delivered none, as in resolve output.
+     */
+    settings?: JsonValue;
+}
+/**
+ * Candidate managed-settings documents to merge without applying them.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsComposeRequest".
+ */
+/** @experimental */
+export interface ManagedSettingsComposeRequest {
+    /**
+     * One entry per channel. `source` must be `device`, `server`, or `policyHelper`, each at most once (checked at runtime); order does not matter, because channel precedence is fixed. To preview documents from resolve output, map recognized source strings to ManagedSettingsChannel and copy their settings; generated resolve and compose layer types are distinct. Omitted settings means this channel delivered no document. Supplied documents must be valid within the preview limits; warnings are returned in diagnostics. Compose does not reproduce source-failure state or retained enforcement floors from resolve.
+     */
+    layers: ManagedSettingsComposeLayer[];
+}
+/**
+ * The effective managed settings the runtime would enforce for the given documents, in the same shape `managedSettings.resolve` returns.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsComposeResult".
+ */
+/** @experimental */
+export interface ManagedSettingsComposeResult {
+    resolved: ManagedSettingsResolvedData;
+    values?: ManagedSettingsValues;
+    meta?: ManagedSettingsMeta;
+    /**
+     * Only the supplied channels, strongest first, with canonical documents. Empty canonical documents are represented as absent settings, as in live resolution.
+     */
+    layers: ManagedSettingsLayer[];
+    /**
+     * Warnings about ignored content, with paths prefixed by the channel name.
+     */
+    diagnostics: ManagedSettingsDiagnostic[];
+}
+/**
+ * Typed effective values of managed settings. Each field mirrors the managed-settings schema key of the same name; more keys are added as they are typed.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsValues".
+ */
+/** @experimental */
+export interface ManagedSettingsValues {
+    /**
+     * Managed default model identifier, as configured. New sessions start with it; it can name a model the account cannot use, so hosts match it against the listed models.
+     */
+    model?: string;
+    autoTier?: AutoTier;
+}
+/**
+ * Per-key lock state and provenance for `ManagedSettingsValues`, with the same field names. Producers emit each typed key in values and meta together; both outer objects are omitted when no typed key is set.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsMeta".
+ */
+/** @experimental */
+export interface ManagedSettingsMeta {
+    model?: ManagedSettingMeta;
+    autoTier?: ManagedSettingMeta;
+}
+/**
+ * One managed-settings channel and the document it delivered.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsLayer".
+ */
+/** @experimental */
+export interface ManagedSettingsLayer {
+    /**
+     * Channel identifier: `device` (MDM, plist, registry, or managed file), `server` (account or organization policy), or `policyHelper` (session-local helper output, supported by compose). Treat unknown output values as additional channels; more may be added.
+     */
+    source: string;
+    /**
+     * Validated managed-settings document this channel delivered. Absent when the channel delivered none.
+     */
+    settings?: JsonValue;
+}
+/**
+ * One validation finding for a managed-settings document.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsDiagnostic".
+ */
+/** @experimental */
+export interface ManagedSettingsDiagnostic {
+    /**
+     * Dot-separated path of the offending setting, such as `autoTier.overridable`. Empty for the document as a whole.
+     */
+    path: string;
+    severity: ManagedSettingsDiagnosticSeverity;
+    /**
+     * Human-readable description of the finding.
+     */
+    message: string;
+}
 /**
  * Validated device-managed settings discovered before a session exists.
  *
@@ -12812,6 +13038,100 @@ export interface ManagedSettingsReadResult {
      */
     errorMessage?: string;
 }
+/** @experimental */
+export interface ManagedSettingsResolveRequest {
+    /**
+     * Opaque account identifier returned by `account.getAllUsers`. When omitted, the current account is used, or device policy only when no account is signed in.
+     */
+    selectionId?: string;
+    /**
+     * GitHub token to resolve instead of the current account. The call fails when the token cannot be resolved.
+     */
+    gitHubToken?: string;
+    /**
+     * Embedding client identity for server policy requests, as in session creation. Omit for the CLI identity.
+     */
+    clientName?: string;
+}
+/**
+ * Effective enterprise managed settings for an account, resolved without a session.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsResolveResult".
+ */
+/** @experimental */
+export interface ManagedSettingsResolveResult {
+    /**
+     * Printable opaque identity of the account the settings were resolved for, suitable for comparison and storage, not an account selectionId. Absent when no account was available, in which case only device policy is reported.
+     */
+    account?: string;
+    resolved: ManagedSettingsResolvedData;
+    values?: ManagedSettingsValues;
+    meta?: ManagedSettingsMeta;
+    /**
+     * Each managed-settings channel consulted, strongest first, with the validated document it delivered before merging. `resolved.settings` is the merged result. More channels may be added over time.
+     */
+    layers: ManagedSettingsLayer[];
+    /**
+     * Warnings about unavailable policy sources or a failed refresh served from cache. A cached response is not proof of a successful live fetch; `resolved.failClosed` separately describes enforcement.
+     */
+    diagnostics: ManagedSettingsDiagnostic[];
+}
+/**
+ * The authoring JSON schema for managed settings recognized by this runtime.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsSchemaResult".
+ */
+/** @experimental */
+export interface ManagedSettingsSchemaResult {
+    /**
+     * JSON schema (draft 2020-12) with descriptive shared `x-composition` annotations, not a complete runtime composition contract. Model, effortLevel, and contextTier remain coupled; use `managedSettings.compose` for the runtime's effective result.
+     */
+    schema: JsonValue;
+    /**
+     * Version of the runtime that owns this schema.
+     */
+    runtimeVersion: string;
+}
+/**
+ * A candidate managed-settings document to validate without applying it.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsValidateRequest".
+ */
+/** @experimental */
+export interface ManagedSettingsValidateRequest {
+    /**
+     * The document to validate: a JSON object, or a string containing the document's JSON text. Preview documents are limited to 1 MiB and 64 levels of nesting, a stricter resource limit than delivered-policy parsing; violations are returned as diagnostics.
+     */
+    content: JsonValue;
+    /**
+     * Channel the document is meant for (`device`, `server`, or `policyHelper`). Some keys are only honored in some channels; for example, a `policyHelper` registration is ignored in policy-helper output. When omitted, no channel-specific checks run.
+     */
+    layer?: string;
+}
+/**
+ * Result of validating a managed-settings document.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "ManagedSettingsValidateResult".
+ */
+/** @experimental */
+export interface ManagedSettingsValidateResult {
+    /**
+     * Whether the runtime would accept the document within the preview resource limits. Always equals whether `settings` is present. An invalid document is rejected as a whole.
+     */
+    valid: boolean;
+    /**
+     * Canonical form of the document the runtime would apply, with unrecognized keys removed. Absent when the document is invalid.
+     */
+    settings?: JsonValue;
+    /**
+     * Errors that reject the document and warnings about content the runtime ignores.
+     */
+    diagnostics: ManagedSettingsDiagnostic[];
+}
 /**
  * Result of registering a new marketplace.
  *
@@ -14167,6 +14487,23 @@ export interface McpOauthCancelLoginResult {
      */
     cancelled: boolean;
 }
+/**
+ * Host-delivered callback for a runtime-managed MCP OAuth login.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpOauthCompleteRequest".
+ */
+/** @experimental */
+export interface McpOauthCompleteRequest {
+    /**
+     * Opaque identifier returned by session.mcp.oauth.login for the pending external callback.
+     */
+    authorizationId: string;
+    /**
+     * Full externally visible HTTPS callback URL received by the host, including the authorization response query parameters. Applications behind a reverse proxy must reconstruct the public URL rather than passing an internal proxy URL.
+     */
+    callbackUrl: string;
+}
 /**
  * Pending MCP OAuth request ID and host-provided token or cancellation response.
  *
@@ -14195,7 +14532,7 @@ export interface McpOauthHandlePendingResult {
     success: boolean;
 }
 /**
- * Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.
+ * Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback handling, and static OAuth client selection.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
  * via the `definition` "McpOauthLoginRequest".
@@ -14231,6 +14568,10 @@ export interface McpOauthLoginRequest {
      */
     publicClient?: boolean;
     grantType?: McpOauthLoginGrantType;
+    /**
+     * Optional externally visible HTTPS redirect URI for a host-managed callback endpoint. When supplied, the runtime still owns discovery, PKCE, token exchange, persistence, and reconnect, but does not bind a loopback listener or terminate HTTPS. The URI must not contain query parameters or a fragment and must be registered for the selected CIMD, DCR, or static OAuth client.
+     */
+    redirectUri?: string;
     /**
      * Required for owned login. Consumes the exact prepareLogin handle once.
      * Set forceReauth and display options during preparation, not consumption.
@@ -14255,9 +14596,13 @@ export interface McpOauthLoginResult {
     loginId?: string;
     status?: McpOwnedOauthLoginStatus;
     /**
-     * URL the caller should open in a browser to complete OAuth. Omitted when cached tokens were still valid and no browser interaction was needed — the server is already reconnected in that case. When present, the runtime starts the callback listener before returning and continues the flow in the background; completion is signaled via session.mcp_server_status_changed.
+     * URL the caller should open in a browser to complete OAuth. Omitted when cached tokens were still valid and no browser interaction was needed — the server is already reconnected in that case. For the default loopback flow, the runtime starts its listener before returning. With redirectUri, the host receives the callback and completes it through session.mcp.oauth.complete. The runtime continues the flow in the background and signals completion via session.mcp_server_status_changed.
      */
     authorizationUrl?: string;
+    /**
+     * Opaque authorization identifier returned only for a host-managed redirect URI. The runtime also sends it as the OAuth state value, so the callback endpoint can read state and pass it with the full callback URL to session.mcp.oauth.complete.
+     */
+    authorizationId?: string;
 }
 /**
  * Effect-free preparation bound to the existing local session, requester and installation, with frozen options.
@@ -14490,6 +14835,235 @@ export interface McpPrepareInstallRequest {
     source: McpServerCardReference;
     secretStorage: McpInstallationSecretStorage;
 }
+/**
+ * An MCP prompt descriptor. Server-provided non-standard fields are exposed under `additionalProperties`.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPrompt".
+ */
+/** @experimental */
+export interface McpPrompt {
+    /**
+     * The programmatic name of the prompt
+     */
+    name: string;
+    /**
+     * Human-readable display title
+     */
+    title?: string;
+    /**
+     * Description of what this prompt provides
+     */
+    description?: string;
+    /**
+     * Arguments accepted by the prompt
+     */
+    arguments?: McpPromptArgument[];
+    /**
+     * Icons associated with this prompt
+     */
+    icons?: McpPromptIcon[];
+    /**
+     * Prompt-level metadata
+     */
+    _meta?: {
+        [k: string]: JsonValue | undefined;
+    };
+    /**
+     * Server-provided non-standard descriptor fields
+     */
+    additionalProperties?: {
+        [k: string]: JsonValue | undefined;
+    };
+}
+/**
+ * An argument accepted by an MCP prompt.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptArgument".
+ */
+/** @experimental */
+export interface McpPromptArgument {
+    /**
+     * Name of the argument
+     */
+    name: string;
+    /**
+     * Description of the argument
+     */
+    description?: string;
+    /**
+     * Whether the argument is required; omission is distinct from false
+     */
+    required?: boolean;
+    /**
+     * Argument-level metadata
+     */
+    _meta?: {
+        [k: string]: JsonValue | undefined;
+    };
+    /**
+     * Server-provided non-standard argument fields
+     */
+    additionalProperties?: {
+        [k: string]: JsonValue | undefined;
+    };
+}
+/**
+ * An MCP prompt icon with standard size hints and preserved non-standard fields.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptIcon".
+ */
+/** @experimental */
+export interface McpPromptIcon {
+    /**
+     * Icon URI
+     */
+    src: string;
+    /**
+     * Icon MIME type, when known
+     */
+    mimeType?: string;
+    /**
+     * Icon sizes, such as `48x48` or `any`
+     */
+    sizes?: string[];
+    /**
+     * Theme hint for this icon
+     */
+    theme?: string;
+    /**
+     * Server-provided non-standard icon fields
+     */
+    additionalProperties?: {
+        [k: string]: JsonValue | undefined;
+    };
+}
+/**
+ * An MCP prompt message with opaque JSON content preserved without flattening or content-type filtering.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptMessage".
+ */
+/** @experimental */
+export interface McpPromptMessage {
+    role: McpPromptRole;
+    /**
+     * The original MCP content block, including nested metadata and unfamiliar content types
+     */
+    content: JsonValue;
+    /**
+     * Message-level metadata
+     */
+    _meta?: {
+        [k: string]: JsonValue | undefined;
+    };
+    /**
+     * Server-provided non-standard message fields
+     */
+    additionalProperties?: {
+        [k: string]: JsonValue | undefined;
+    };
+}
+/**
+ * MCP server, prompt name, and optional string-valued arguments.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptsGetRequest".
+ */
+/** @experimental */
+export interface McpPromptsGetRequest {
+    /**
+     * Name of the MCP server hosting the prompt
+     */
+    serverName: string;
+    /**
+     * The programmatic name of the prompt
+     */
+    promptName: string;
+    /**
+     * String-valued arguments to pass to the prompt
+     */
+    arguments?: {
+        [k: string]: string | undefined;
+    };
+}
+/**
+ * Prompt messages returned by the MCP server without sending them to the model.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptsGetResult".
+ */
+/** @experimental */
+export interface McpPromptsGetResult {
+    /**
+     * Description of the prompt
+     */
+    description?: string;
+    /**
+     * Ordered prompt messages
+     */
+    messages: McpPromptMessage[];
+    /**
+     * MCP result metadata
+     */
+    _meta?: {
+        [k: string]: JsonValue | undefined;
+    };
+    /**
+     * Server-provided non-standard result fields
+     */
+    additionalProperties?: {
+        [k: string]: JsonValue | undefined;
+    };
+}
+/**
+ * MCP server whose prompts to enumerate.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptsListRequest".
+ */
+/** @experimental */
+export interface McpPromptsListRequest {
+    /**
+     * Name of the MCP server whose prompts to enumerate
+     */
+    serverName: string;
+    /**
+     * Opaque MCP pagination cursor from a prior `nextCursor` value
+     */
+    cursor?: string;
+}
+/**
+ * One page of prompts advertised by the named MCP server.
+ *
+ * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
+ * via the `definition` "McpPromptsListResult".
+ */
+/** @experimental */
+export interface McpPromptsListResult {
+    /**
+     * Prompts advertised by the server
+     */
+    prompts: McpPrompt[];
+    /**
+     * Opaque cursor for the next page, if the server has more prompts
+     */
+    nextCursor?: string;
+    /**
+     * MCP result metadata
+     */
+    _meta?: {
+        [k: string]: JsonValue | undefined;
+    };
+    /**
+     * Server-provided non-standard result fields
+     */
+    additionalProperties?: {
+        [k: string]: JsonValue | undefined;
+    };
+}
 /**
  * Indicates whether the auto-managed `github` MCP server was removed (false when nothing to remove).
  *
@@ -20255,7 +20829,7 @@ export interface SandboxGrantPathForRequestResult {
     success: boolean;
 }
 /**
- * Whether this host can run one sandbox policy feature. A session whose effective policy uses an unsupported feature fails each sandboxed command with `reason`.
+ * Whether this host can run one sandbox policy feature. A session whose effective policy uses an unsupported feature fails each sandboxed command with `reason`, except `filesystem_enumeration`, whose absence degrades sandboxed PowerShell instead of failing it.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
  * via the `definition` "SandboxHostCapability".
@@ -23624,7 +24198,7 @@ export interface ShellCancelUserRequestedRequest {
     requestId: string;
 }
 /**
- * Shell command to run, with optional working directory and timeout in milliseconds.
+ * Shell command to run, with optional working directory and timeout in milliseconds. Spawn failures return an RPC error.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
  * via the `definition` "ShellExecRequest".
@@ -23645,7 +24219,7 @@ export interface ShellExecRequest {
     timeout?: number;
 }
 /**
- * Identifier of the spawned process, used to correlate streamed output and exit notifications.
+ * Identifier of the spawned shell process, usable with shell.kill while the process is running.
  *
  * This interface was referenced by `_RpcSchemaRoot`'s JSON-Schema
  * via the `definition` "ShellExecResult".
@@ -23653,7 +24227,7 @@ export interface ShellExecRequest {
 /** @experimental */
 export interface ShellExecResult {
     /**
-     * Unique identifier for tracking streamed output
+     * Identifier usable with shell.kill while the process is running
      */
     processId: string;
 }
@@ -29048,15 +29622,45 @@ export declare function createServerRpc(connection: MessageConnection): {
     /** @experimental */
     managedSettings: {
         /**
-         * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session.
+         * Discovers device-managed settings from production MDM and managed-file sources, validates them against the runtime-owned managed-settings schema, and returns the canonical JSON without requiring a session. `managedSettings.resolve` returns the same device settings together with the account's server policy.
          *
          * @returns Validated device-managed settings discovered before a session exists.
          */
         read: () => Promise<ManagedSettingsReadResult>;
         /**
-         * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
+         * Force-refreshes enterprise managed settings for every account: wipes the persistent server-policy cache (the whole `<cacheHome>/managed-settings` directory) and drops this runtime process's in-memory retained server policy. It does not itself fetch policy — the effect is that the next time a session resolves managed settings for an account, that resolution re-fetches the account's org policy from the network instead of serving a cached response. Note that `managedSettings.read` returns only device/MDM settings and never triggers the account server-policy fetch, so a host implementing "sync account policy" should call `managedSettings.resolve` or start a fresh session resolution rather than treat a subsequent `managedSettings.read` as the refreshed org policy. Mirrors the invalidation a sign-out performs, broadened from the one signing-out account to all of them; device/MDM layers describe the machine, not the account, and are left untouched. Rejects if the on-disk cache cannot be removed.
          */
         clearCache: () => Promise<void>;
+        /**
+         * Resolves the effective enterprise managed settings without a session, from the device channel and, when an account is available, the account's server policy through the same per-account cache sessions use. A cached server policy less than an hour old is used without a fetch; otherwise the policy is fetched, and when the fetch fails a cached policy up to 24 hours old is used instead, unless `forceRemoteSettingsRefresh` requires a live fetch. With no account requested or signed in, it reports device policy only; signing out removes the account's cached policy. It can fetch server policy over the network when the cache is stale, so call it off latency-critical paths such as startup rather than before listing models. The policy helper is not run. `layers` lists each channel's document before merging, and `values` and `meta` carry typed effective values and their lock state for the keys typed so far.
+         *
+         * @param params Optional opaque account selection or GitHub token whose managed settings are resolved.
+         *
+         * @returns Effective enterprise managed settings for an account, resolved without a session.
+         */
+        resolve: (params: ManagedSettingsResolveRequest) => Promise<ManagedSettingsResolveResult>;
+        /**
+         * Returns the managed-settings authoring JSON schema with descriptive `x-composition` annotations aligned with the shared settings-engine vocabulary. These annotations are not a complete runtime composition contract: model, effortLevel, and contextTier remain coupled. Use `managedSettings.compose` for the runtime's effective result. Performs no I/O.
+         *
+         * @returns The authoring JSON schema for managed settings recognized by this runtime.
+         */
+        schema: () => Promise<ManagedSettingsSchemaResult>;
+        /**
+         * Validates a candidate managed-settings document the way the runtime validates delivered policy, without applying it. Reports errors that would reject the document, warnings for content the runtime ignores, and the canonical document it would apply. Document text nested more than 64 levels deep is rejected. Performs no I/O.
+         *
+         * @param params A candidate managed-settings document to validate without applying it.
+         *
+         * @returns Result of validating a managed-settings document.
+         */
+        validate: (params: ManagedSettingsValidateRequest) => Promise<ManagedSettingsValidateResult>;
+        /**
+         * Merges candidate managed-settings documents for the device, server, and policy-helper channels into the effective settings the runtime would enforce on this host, using the same precedence and composition rules as live resolution, without applying them. Like live resolution, a server's advisory sandbox force-enable is declined on a host that cannot run the sandbox. Does not fetch policy or read policy files, but may perform blocking OS or subprocess probes for sandbox support. Preview documents are limited to 1 MiB and 64 levels of nesting.
+         *
+         * @param params Candidate managed-settings documents to merge without applying them.
+         *
+         * @returns The effective managed settings the runtime would enforce for the given documents, in the same shape `managedSettings.resolve` returns.
+         */
+        compose: (params: ManagedSettingsComposeRequest) => Promise<ManagedSettingsComposeResult>;
     };
     /** @experimental */
     runtime: {
@@ -30241,11 +30845,17 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
             /**
              * Starts OAuth authentication for a remote MCP server. Owned servers require the original one-use prepareLogin handle and exact installation ID; manual servers retain the existing direct login behaviour.
              *
-             * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback success-page copy, and static OAuth client selection.
+             * @param params Remote MCP server name and optional overrides controlling reauthentication, OAuth client display name, callback handling, and static OAuth client selection.
              *
              * @returns OAuth authorization URL the caller should open, or empty when cached tokens already authenticated the server.
              */
             login: (params: McpOauthLoginRequest) => Promise<McpOauthLoginResult>;
+            /**
+             * Completes a runtime-managed MCP OAuth login after the authorization server redirects to a host-managed callback URL.
+             *
+             * @param params Host-delivered callback for a runtime-managed MCP OAuth login.
+             */
+            complete: (params: McpOauthCompleteRequest) => Promise<void>;
             /**
              * Passively probes a configured remote MCP server to classify whether OAuth is required or a cached/override token is accepted. Does not start OAuth, emit pending OAuth requests, or mutate MCP connection state.
              *
@@ -30356,6 +30966,25 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
              */
             listTemplates: (params: McpResourcesListTemplatesRequest) => Promise<McpResourcesListTemplatesResult>;
         };
+        /** @experimental */
+        prompts: {
+            /**
+             * Enumerate one page of prompts a connected MCP server exposes (proxies MCP `prompts/list`). Pass `cursor` to continue from a prior result's `nextCursor`.
+             *
+             * @param params MCP server whose prompts to enumerate.
+             *
+             * @returns One page of prompts advertised by the named MCP server.
+             */
+            list: (params: McpPromptsListRequest) => Promise<McpPromptsListResult>;
+            /**
+             * Get a prompt's messages from a connected MCP server (proxies MCP `prompts/get`). Content is preserved as opaque JSON. Does not send messages to the model, execute tools, or fetch referenced resources.
+             *
+             * @param params MCP server, prompt name, and optional string-valued arguments.
+             *
+             * @returns Prompt messages returned by the MCP server without sending them to the model.
+             */
+            get: (params: McpPromptsGetRequest) => Promise<McpPromptsGetResult>;
+        };
     };
     /** @experimental */
     diagnostics: {
@@ -30384,6 +31013,12 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
          * @returns Feature detection and hard polling limits for the EXPERIMENTAL session connector API.
          */
         getCapabilities: () => Promise<ConnectorCapabilities>;
+        /**
+         * Returns the session account selection, or null.
+         *
+         * @returns Session account selection, or null.
+         */
+        getAccount: () => Promise<ConnectorSessionAccountResult>;
         /**
          * Returns authoritative session Connector state from current availability, pinned account selection, cached catalog, and live MCP projection without performing a Connector service request.
          *
@@ -30452,7 +31087,7 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
         /**
          * Waits for the live session's in-flight managed-settings application, then returns the retained effective snapshot used by runtime enforcement and by `session.managed_settings_resolved`. It does not perform another account, device, or server resolution, and rejects when resolution has not produced a snapshot.
          *
-         * @returns Enterprise managed-settings resolution: the effective managed settings the session applied and which channels contributed, so SDK clients can show users what is enterprise-managed. Fires whenever managed policy is (re)applied — at session start, on resume, and on account switch. This is an ephemeral live snapshot (delivered to subscribers but not persisted to the session event log), because at session start it resolves before `session.start` is emitted. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively across device, server, policy-helper, and SDK-client layers. The account-scoped `getManagedSettings()` API does not include session-local client injection. Marked experimental while the managed-settings surface stabilizes.
+         * @returns Effective enterprise managed settings and contributing channels. Session events report applied policy; sessionless resolve reports an account/device snapshot, and compose reports a non-applying preview of candidate documents. Device values take precedence over server values, then the policy helper, per ordinary key, while permissions compose restrictively. Session-local SDK-client policy is included only in session results. Marked experimental while the managed-settings surface stabilizes.
          */
         get: () => Promise<ManagedSettingsResolvedData>;
     };
@@ -31124,11 +31759,11 @@ export declare function createSessionRpc(connection: MessageConnection, sessionI
     /** @experimental */
     shell: {
         /**
-         * Starts a shell command and streams output through session notifications. The command runs as the leader of its own process group (POSIX) or in a dedicated job object (Windows), so a forced termination — via "shell.kill", the request timeout, or session disposal — signals that whole group/job rather than only the direct child. Two gaps are worth planning for: a command that exits on its own does not trigger that teardown, and on POSIX a descendant that moves itself into a new session or process group (for example via "setsid") leaves the signalled group, so either can leave a background process running.
+         * Starts a shell command, returning an RPC error if it cannot be spawned. The command runs as the leader of its own process group (POSIX) or in a dedicated job object (Windows), so a forced termination — via "shell.kill", the request timeout, or session disposal — signals that whole group/job rather than only the direct child. Two gaps are worth planning for: a command that exits on its own does not trigger that teardown, and on POSIX a descendant that moves itself into a new session or process group (for example via "setsid") leaves the signalled group, so either can leave a background process running.
          *
-         * @param params Shell command to run, with optional working directory and timeout in milliseconds.
+         * @param params Shell command to run, with optional working directory and timeout in milliseconds. Spawn failures return an RPC error.
          *
-         * @returns Identifier of the spawned process, used to correlate streamed output and exit notifications.
+         * @returns Identifier of the spawned shell process, usable with shell.kill while the process is running.
          */
         exec: (params: ShellExecRequest) => Promise<ShellExecResult>;
         /**