@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/platform/agentHost/common/agentService.js

@@ -0,0 +1,50 @@
+
+import { isWindows } from '../../../base/common/platform.js';
+import { AgentSandboxSettingId } from '../../sandbox/common/settings.js';
+export { AgentSession, CODEX_AGENT_PROVIDER_ID, SubagentChatSignal, subagentChatTitle } from './agent.js';
+
+var AgentHostIpcChannels;
+(function(AgentHostIpcChannels) {
+    AgentHostIpcChannels["AgentHost"] = "agentHost";
+    AgentHostIpcChannels["Logger"] = "agentHostLogger";
+    AgentHostIpcChannels["ConnectionTracker"] = "agentHostConnectionTracker";
+    AgentHostIpcChannels["Protocol"] = "agentHostProtocol";
+    AgentHostIpcChannels["Management"] = "agentHostManagement";
+    AgentHostIpcChannels["RemoteProxy"] = "agentHostProxy";
+})(AgentHostIpcChannels || (AgentHostIpcChannels = {}));
+const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
+const AGENT_HOST_DEBUG_LOGS_MAX_ENTRIES = 1000;
+const AGENT_HOST_DEBUG_LOGS_CHUNK_BYTES = 1024 * 1024;
+const AgentHostSystemProxyEnabledSettingId = "chat.agentHost.systemProxy.enabled";
+const AgentHostGitHubMcpServerEnabledSettingId = "chat.agentHost.githubMcpServer.enabled";
+const AgentHostActiveAgentTitleGenerationSettingId = "chat.agentHost.experimental.activeAgentTitleGeneration";
+const AgentHostMarkdownPlanRichLinksEnabledSettingId = "chat.agentHost.experimental.markdownPlanRichLinks";
+const ArtifactToolsSettingId = "chat.artifactTools.enabled";
+const AgentHostAutoAttachPullRequestsSettingId = "chat.agentHost.experimental.autoAttachPullRequests";
+const AgentHostCopilotMultiRootEnabledSettingId = "chat.agentHost.copilotAgent.multiRootEnabled";
+const AgentHostClaudeMultiRootEnabledSettingId = "chat.agentHost.claudeAgent.multiRootEnabled";
+const AgentHostCodexMultiRootEnabledSettingId = "chat.agentHost.codexAgent.multiRootEnabled";
+const AgentHostAllowSignedOutWhenUsableSettingId = "chat.agentHost.allowSignedOutWhenUsable";
+const AgentHostClaudeAgentEnabledSettingId = "chat.agentHost.claudeAgent.enabled";
+const AgentHostCodexAgentEnabledSettingId = "chat.agentHost.codexAgent.enabled";
+const AgentHostByokModelsEnabledSettingId = "chat.agentHost.byokModels.enabled";
+const AgentHostSdkSandboxEnabledSettingId = "chat.agentHost.sdkSandbox.enabled";
+const AgentHostSdkSandboxWindowsEnabledSettingId = "chat.agentHost.sdkSandbox.enabledWindows";
+function getAgentHostCopilotSandboxSettingId(windows = isWindows) {
+    return windows ? AgentSandboxSettingId.AgentSandboxWindowsEnabled : AgentSandboxSettingId.AgentSandboxEnabled;
+}
+const CodexPreferAgentHostEditorSettingId = "chat.editor.codex.preferAgentHost";
+const AgentHostCodexAgentSdkRootSettingId = "chat.agentHost.codexAgent.sdkRoot";
+const AgentHostCodexAgentCodexHomeSettingId = "chat.agentHost.codexAgent.codexHome";
+const AgentHostCodexAgentBinaryArgsSettingId = "chat.agentHost.codexAgent.binaryArgs";
+const AgentHostOTelEnabledSettingId = "chat.agentHost.otel.enabled";
+const AgentHostOTelExporterTypeSettingId = "chat.agentHost.otel.exporterType";
+const AgentHostOTelOtlpProtocolSettingId = "chat.agentHost.otel.otlpProtocol";
+const AgentHostOTelOtlpEndpointSettingId = "chat.agentHost.otel.otlpEndpoint";
+const AgentHostOTelCaptureContentSettingId = "chat.agentHost.otel.captureContent";
+const AgentHostOTelOutfileSettingId = "chat.agentHost.otel.outfile";
+const AgentHostOTelServiceNameSettingId = "chat.agentHost.otel.serviceName";
+const AgentHostOTelResourceAttributesSettingId = "chat.agentHost.otel.resourceAttributes";
+const AgentHostOTelDbSpanExporterEnabledSettingId = "chat.agentHost.otel.dbSpanExporter.enabled";
+
+export { AGENT_HOST_DEBUG_LOGS_CHUNK_BYTES, AGENT_HOST_DEBUG_LOGS_MAX_ENTRIES, AgentHostActiveAgentTitleGenerationSettingId, AgentHostAhpJsonlLoggingSettingId, AgentHostAllowSignedOutWhenUsableSettingId, AgentHostAutoAttachPullRequestsSettingId, AgentHostByokModelsEnabledSettingId, AgentHostClaudeAgentEnabledSettingId, AgentHostClaudeMultiRootEnabledSettingId, AgentHostCodexAgentBinaryArgsSettingId, AgentHostCodexAgentCodexHomeSettingId, AgentHostCodexAgentEnabledSettingId, AgentHostCodexAgentSdkRootSettingId, AgentHostCodexMultiRootEnabledSettingId, AgentHostCopilotMultiRootEnabledSettingId, AgentHostGitHubMcpServerEnabledSettingId, AgentHostIpcChannels, AgentHostMarkdownPlanRichLinksEnabledSettingId, AgentHostOTelCaptureContentSettingId, AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelEnabledSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelOtlpProtocolSettingId, AgentHostOTelOutfileSettingId, AgentHostOTelResourceAttributesSettingId, AgentHostOTelServiceNameSettingId, AgentHostSdkSandboxEnabledSettingId, AgentHostSdkSandboxWindowsEnabledSettingId, AgentHostSystemProxyEnabledSettingId, ArtifactToolsSettingId, CodexPreferAgentHostEditorSettingId, getAgentHostCopilotSandboxSettingId };

package/vscode/src/vs/platform/agentHost/common/agentService.service.d.ts

@@ -1,10 +1,12 @@
 import { Event } from "../../../base/common/event.js";
 import { IObservable } from "../../../base/common/observable.js";
 import { URI } from "../../../base/common/uri.js";
-import { AuthenticateParams, AuthenticateResult, IAgentHostAuthTokenRequest, IAgentSessionMetadata, IAgentCreateSessionConfig, IAgentCreateChatOptions, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IMcpNotification, type IAgentConnection, type IAgentHostInspectInfo, type IAgentHostSocketInfo } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/agentService";
-import { ResolveSessionConfigResult, SessionConfigCompletionsResult, CompletionsParams, CompletionsResult, CreateTerminalParams, InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "./state/protocol/commands.js";
-import { ActionEnvelope, INotification, SessionAction, ChatAction, TerminalAction, ClientAnnotationsAction, IRootConfigChangedAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
-import { IStateSnapshot, ResourceListResult, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult, ResourceResolveParams, ResourceResolveResult, ResourceMkdirParams, ResourceMkdirResult, CreateResourceWatchParams, CreateResourceWatchResult, ResourceWatchState } from "./state/sessionProtocol.js";
+import { AuthenticateParams, AuthenticateResult, IAgentSessionMetadata, IAgentCreateSessionConfig, IAgentCreateChatRequestOptions, IAgentResolveSessionConfigParams, IAgentSessionConfigCompletionsParams, IMcpNotification } from "./agent.js";
+import { IAgentHostClientTelemetryContext } from "./agentHostTelemetry.js";
+import { IAgentHostNetworkDiagnosticsInfo, IAgentHostManagedSettingsDiagnostics, IAgentHostNetworkFetchResult, AgentHostDebugLogsArtifactKind, IAgentHostDebugLogsArtifact, IAgentHostDebugLogsChunk, type IAgentConnection, type IAgentHostInspectInfo, type IAgentHostSocketInfo } from "./agentService.js";
+import { ResolveSessionConfigResult, SessionConfigCompletionsResult, CompletionsParams, CompletionsResult, CreateTerminalParams, InvokeChangesetOperationParams, InvokeChangesetOperationResult, AutomationCapabilities, ListAutomationTriggerDefinitionsParams, ListAutomationTriggerDefinitionsResult, RunAutomationParams, RunAutomationResult, FetchAutomationRunsParams, FetchAutomationRunsResult } from "./state/protocol/commands.js";
+import { ActionEnvelope, INotification, SessionAction, ChatAction, TerminalAction, ClientChangesetAction, ClientAnnotationsAction, IRootConfigChangedAction, ClientAutomationAction, ClientAutomationRunAction } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/sessionActions";
+import { IStateSnapshot, ResourceListResult, ContentEncoding, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult, ResourceResolveParams, ResourceResolveResult, ResourceMkdirParams, ResourceMkdirResult, CreateResourceWatchParams, CreateResourceWatchResult, ResourceWatchState } from "./state/sessionProtocol.js";
 export declare const IAgentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentService>;
 /**
 * Service contract for communicating with the agent host process. Methods here
@@ -23,19 +25,26 @@ export interface IAgentService {
     * bearer token delivery.
     */
     authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
-    /** Return a bearer token previously supplied via {@link authenticate}. */
-    getAuthToken(request: IAgentHostAuthTokenRequest): string | undefined;
     /** List all available sessions from the Copilot CLI. */
     listSessions(): Promise<IAgentSessionMetadata[]>;
-    /** Create a new session. Returns the session URI. */
     createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
+    /** Removes a recorded artifact or reference, awaiting host metadata persistence. */
+    removeSessionArtifact?(session: URI, artifactId: string): Promise<void>;
+    createDetachedWorktree?(session: URI, prompt: string): Promise<{
+        handle: string;
+        worktree: URI;
+    }>;
+    claimDetachedWorktree?(handle: string): Promise<void>;
+    setDetachedWorktreeArchived?(handle: string, archived: boolean): Promise<void>;
+    deleteDetachedWorktree?(handle: string): Promise<void>;
+    reconcileDetachedWorktrees?(scope: string, activeHandles: readonly string[]): Promise<void>;
     /**
     * Create an additional chat within an existing session. Spins up the
     * backing chat in the harness (sharing the session's session) and
     * registers the chat in the session's catalog so subscribers observe a
     * `session/chatAdded` action. The `chat` URI is the client-chosen channel.
     */
-    createChat(session: URI, chat: URI, options?: IAgentCreateChatOptions): Promise<void>;
+    createChat(session: URI, chat: URI, options?: IAgentCreateChatRequestOptions): Promise<void>;
     /** Dispose an additional chat created via {@link createChat}. */
     disposeChat(session: URI, chat: URI): Promise<void>;
     /** Resolve the dynamic configuration schema for creating a session. */
@@ -63,17 +72,16 @@ export interface IAgentService {
     getCompletionTriggerCharacters(): Promise<readonly string[]>;
     /** Dispose a session in the agent host, freeing SDK resources. */
     disposeSession(session: URI): Promise<void>;
-    /** Create a new terminal on the agent host. */
     createTerminal(params: CreateTerminalParams): Promise<void>;
     /** Dispose a terminal and kill its process if still running. */
     disposeTerminal(terminal: URI): Promise<void>;
-    /** Invoke a server-defined changeset operation. */
     invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
     /**
     * Routes a request received on an `mcp://` AHP side channel to the
     * MCP server implementation owned by the appropriate agent. The
-    * channel URI shape is `mcp://<providerId>/<sessionId>/<serverName>`
-    * (the latter two segments URL-encoded), matching the
+    * channel URI shape is `mcp://<providerId>/<chatUri>/<serverName>`
+    * (the latter two segments URL-encoded), where `chatUri` is the concrete
+    * `ahp-chat://` URI, matching the
     * {@link McpServerCustomization.channel | channel} the agent host
     * advertises while the server is in
     * {@link McpServerStatus.Ready | `Ready`}.
@@ -98,14 +106,33 @@ export interface IAgentService {
     /** Gracefully shut down all sessions and the underlying client. */
     shutdown(): Promise<void>;
     /**
+    * Host-level network context for diagnostics — agent host version, OS/arch,
+    * account, proxy settings/env, and the endpoints worth probing (which
+    * callers probe via {@link diagnosticsFetch}, plus any additional URLs).
+    */
+    getNetworkDiagnosticsInfo(): Promise<IAgentHostNetworkDiagnosticsInfo>;
+    /** Resolve managed settings through each provider's native SDK/runtime implementation. */
+    getManagedSettingsDiagnostics(): Promise<readonly IAgentHostManagedSettingsDiagnostics[]>;
+    /**
+    * Probe connectivity from the agent host process to a single `url`,
+    * resolving the proxy and timing DNS + reachability. Used by the "Network
+    * Diagnostics" developer command.
+    */
+    diagnosticsFetch(url: string): Promise<IAgentHostNetworkFetchResult>;
+    getSessionStateFile?(session: URI, chat?: URI): Promise<URI | undefined>;
+    collectDebugLogs?(session: URI | undefined, kind: AgentHostDebugLogsArtifactKind, chat?: URI): Promise<IAgentHostDebugLogsArtifact>;
+    readDebugLogsChunk?(resource: URI, position: number): Promise<IAgentHostDebugLogsChunk>;
+    /**
     * Subscribe to state at the given URI. Returns a snapshot of the current
     * state and the serverSeq at snapshot time. Subsequent actions for this
     * resource arrive via {@link onDidAction}. Registers `clientId` against
     * the resource so the server-side refcount knows who is watching, so the
     * caller does not need to invoke {@link addSubscriber} separately. Pair
-    * with {@link unsubscribe} when the subscription is released.
+    * with {@link unsubscribe} when the subscription is released. When
+    * provided, `isActive` is checked before registering the subscriber so a
+    * request cancelled during asynchronous resolution cannot pin the resource.
     */
-    subscribe(resource: URI, clientId: string): Promise<IStateSnapshot>;
+    subscribe(resource: URI, clientId: string, isActive?: () => boolean): Promise<IStateSnapshot>;
     /**
     * Counterpart to {@link subscribe}. Drops `clientId` from the refcount
     * for `resource`; when the last subscriber is removed, idle session state
@@ -131,6 +158,10 @@ export interface IAgentService {
     * (e.g. sessionAdded, sessionRemoved).
     */
     readonly onDidNotification: Event<INotification>;
+    readonly automationCapabilities: AutomationCapabilities | undefined;
+    listAutomationTriggerDefinitions(params: ListAutomationTriggerDefinitionsParams): Promise<ListAutomationTriggerDefinitionsResult>;
+    runAutomation(params: RunAutomationParams): Promise<RunAutomationResult>;
+    fetchAutomationRuns(params: FetchAutomationRunsParams): Promise<FetchAutomationRunsResult>;
     /**
     * Dispatch a client-originated action to the server. The server applies
     * it to state, triggers side effects, and echoes it back via
@@ -142,7 +173,7 @@ export interface IAgentService {
     * rather than {@link URI} objects so that authority-less scheme URIs
     * like `ahp-root://` survive the wire format without normalization.
     */
-    dispatchAction(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientAnnotationsAction | IRootConfigChangedAction, clientId: string, clientSeq: number): void;
+    dispatchAction(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientChangesetAction | ClientAnnotationsAction | IRootConfigChangedAction | ClientAutomationAction | ClientAutomationRunAction, clientId: string, clientSeq: number, clientContext?: IAgentHostClientTelemetryContext): void;
     /**
     * List the contents of a directory on the agent host's filesystem.
     * Used by the client to drive a remote folder picker before session creation.
@@ -152,31 +183,18 @@ export interface IAgentService {
     * Read stored content by URI from the agent host (e.g. file edit snapshots,
     * or reading files from the remote filesystem).
     */
-    resourceRead(uri: URI): Promise<ResourceReadResult>;
+    resourceRead(uri: URI, encoding?: ContentEncoding): Promise<ResourceReadResult>;
     /**
     * Write content to a file on the agent host's filesystem.
     * Used for undo/redo operations on file edits.
     */
     resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
-    /**
-    * Copy a resource from one URI to another on the agent host's filesystem.
-    */
     resourceCopy(params: ResourceCopyParams): Promise<ResourceCopyResult>;
-    /**
-    * Delete a resource at a URI on the agent host's filesystem.
-    */
     resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
-    /**
-    * Move (rename) a resource from one URI to another on the agent host's filesystem.
-    */
     resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
-    /**
-    * Resolve a resource (stat + realpath) on the agent host's filesystem.
-    */
+    /** Resolve a resource (stat + realpath). */
     resourceResolve(params: ResourceResolveParams): Promise<ResourceResolveResult>;
-    /**
-    * Create a directory (mkdir -p semantics) on the agent host's filesystem.
-    */
+    /** Create a directory (`mkdir -p` semantics). */
     resourceMkdir(params: ResourceMkdirParams): Promise<ResourceMkdirResult>;
     /**
     * Create a resource watcher on the agent host's filesystem. Returns the
@@ -206,8 +224,7 @@ export interface IAgentService {
 }
 export declare const IAgentHostService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IAgentHostService>;
 /**
-* The local wrapper around the agent host process (manages lifecycle, restart,
-* exposes the proxied service). Consumed by the main process and workbench.
+* The ambient Agent Host connection used by workbench surfaces.
 */
 export interface IAgentHostService extends IAgentConnection {
     readonly _serviceBrand: undefined;
@@ -226,6 +243,9 @@ export interface IAgentHostService extends IAgentConnection {
     readonly authenticationPending: IObservable<boolean>;
     /** Update {@link authenticationPending}. Internal — only the auth driver should call this. */
     setAuthenticationPending(pending: boolean): void;
+    /** Start connecting to the agent host if it has not already started. */
+    startAgentHost(): void;
+    /** Restart the agent host process, if this connection owns its lifecycle. */
     restartAgentHost(): Promise<void>;
     startWebSocketServer(): Promise<IAgentHostSocketInfo>;
     /**

package/vscode/src/vs/platform/agentHost/common/codexAccount.d.ts

@@ -0,0 +1 @@
+export * from "./meta/codexAccount.js";

package/vscode/src/vs/platform/agentHost/common/copilotHome.d.ts

@@ -0,0 +1,3 @@
+import { IProcessEnvironment } from "../../../base/common/platform.js";
+export declare function getCopilotHomePath(userHomePath: string, environment: IProcessEnvironment): string;
+export declare function getCopilotRootPaths(userHomePath: string, environment: IProcessEnvironment): string[];

package/vscode/src/vs/platform/agentHost/common/copilotHome.js

@@ -0,0 +1,8 @@
+
+import { join } from '../../../base/common/path.js';
+
+function getCopilotHomePath(userHomePath, environment) {
+    return environment["COPILOT_HOME"] || join(userHomePath, ".copilot");
+}
+
+export { getCopilotHomePath };

package/vscode/src/vs/platform/agentHost/common/customizationEnablement.d.ts

@@ -0,0 +1,63 @@
+import { CustomizationEnablementKind, type CustomizationEnablement, type SkillCustomization } from "./state/protocol/state.js";
+/**
+ * Effective enablement when no explicit decision exists at any scope. It is
+ * also the value compared before persisting a decision, so decisions matching
+ * their inherited value are never written.
+ */
+export declare const DEFAULT_CUSTOMIZATION_ENABLED = true;
+export type CustomizationDisabledReason = {
+    readonly source: "scope";
+    readonly scope: CustomizationEnablementKind;
+} | {
+    readonly source: "plugin";
+    readonly plugin: {
+        readonly id: string;
+        readonly name: string;
+        readonly uri: string;
+        readonly clientId?: string;
+        readonly enablement?: readonly CustomizationEnablement[];
+    };
+};
+/** Returns the decisive explicit enablement decision, if one exists. */
+export declare function getCustomizationEnablementDecision(customization: {
+    readonly enablement?: readonly CustomizationEnablement[];
+}): CustomizationEnablement | undefined;
+/**
+ * Effective enablement of a customization, derived from its explicit decisions.
+ * The most specific decision is first, so `enablement[0]` decides; no explicit
+ * decision anywhere means enabled.
+ */
+export declare function isCustomizationEnabled(customization: {
+    readonly enablement?: readonly CustomizationEnablement[];
+}): boolean;
+/** Returns whether a skill should be offered for direct user invocation. */
+export declare function isSkillEligibleForUserInvocation(skill: SkillCustomization): boolean;
+export interface ICustomizationScopeEnablement {
+    readonly global: boolean;
+    readonly workspace: boolean;
+    readonly session: boolean;
+}
+/**
+ * Resolves the value each scope would inherit if it had no explicit decision.
+ */
+export declare function getCustomizationScopeEnablement(customization: {
+    readonly enablement?: readonly CustomizationEnablement[];
+}): ICustomizationScopeEnablement;
+/**
+ * Returns the published reason when a customization or its containing plugin is
+ * disabled. The plugin takes precedence because its child cannot take effect
+ * until the plugin is enabled again.
+ */
+export declare function getCustomizationDisabledReason(customization: {
+    readonly enablement?: readonly CustomizationEnablement[];
+}, plugin?: {
+    readonly id: string;
+    readonly name: string;
+    readonly uri: string;
+    readonly clientId?: string;
+    readonly enablement?: readonly CustomizationEnablement[];
+}): CustomizationDisabledReason | undefined;
+/** Sorts enablement decisions from most to least specific, stably within each scope. */
+export declare function sortCustomizationEnablement(enablement: readonly CustomizationEnablement[]): CustomizationEnablement[];
+/** Replaces all decisions for one scope and returns the complete sorted decision set. */
+export declare function withCustomizationEnablement(current: readonly CustomizationEnablement[] | undefined, kind: CustomizationEnablementKind, entry: CustomizationEnablement | readonly CustomizationEnablement[] | undefined): CustomizationEnablement[];

package/vscode/src/vs/platform/agentHost/common/customizationEnablement.js

@@ -0,0 +1,62 @@
+
+import './state/protocol/channels-root/state.js';
+import { CustomizationEnablementKind } from './state/protocol/channels-session/state.js';
+import './state/protocol/channels-chat/state.js';
+import './state/protocol/channels-terminal/state.js';
+import './state/protocol/channels-changeset/state.js';
+import './state/protocol/channels-resource-watch/state.js';
+import './state/protocol/channels-automation/state.js';
+import './state/protocol/channels-automation-run/state.js';
+
+const DEFAULT_CUSTOMIZATION_ENABLED = true;
+function getCustomizationEnablementDecision(customization) {
+    return customization.enablement?.[0];
+}
+function isCustomizationEnabled(customization) {
+    return getCustomizationEnablementDecision(customization)?.enabled ?? DEFAULT_CUSTOMIZATION_ENABLED;
+}
+function getCustomizationScopeEnablement(customization) {
+    const global = customization.enablement?.find(decision => decision.kind === CustomizationEnablementKind.Global)?.enabled ?? DEFAULT_CUSTOMIZATION_ENABLED;
+    const workspace = customization.enablement?.find(decision => decision.kind === CustomizationEnablementKind.Workspace)?.enabled ?? global;
+    return {
+        global,
+        workspace,
+        session: isCustomizationEnabled(customization)
+    };
+}
+function customizationEnablementOrder(kind) {
+    switch (kind) {
+    case CustomizationEnablementKind.Session:
+        return 0;
+    case CustomizationEnablementKind.Workspace:
+        return 1;
+    case CustomizationEnablementKind.Global:
+        return 2;
+    default:
+        {
+            const exhaustiveKind = kind;
+            return exhaustiveKind;
+        }
+    }
+}
+function sortCustomizationEnablement(enablement) {
+    return ( ( enablement.map((decision, index) => ({
+        decision,
+        index
+    }))).sort(
+        (a, b) => customizationEnablementOrder(a.decision.kind) - customizationEnablementOrder(b.decision.kind) || a.index - b.index
+    ).map((
+        {
+            decision
+        }
+    ) => decision));
+}
+function withCustomizationEnablement(current, kind, entry) {
+    const replacement = entry === undefined ? [] : Array.isArray(entry) ? entry : [entry];
+    return sortCustomizationEnablement([
+        ...([]),
+        ...replacement
+    ]);
+}
+
+export { DEFAULT_CUSTOMIZATION_ENABLED, getCustomizationEnablementDecision, getCustomizationScopeEnablement, isCustomizationEnabled, sortCustomizationEnablement, withCustomizationEnablement };

package/vscode/src/vs/platform/agentHost/common/meta/agentFeedbackAnnotations.d.ts

@@ -0,0 +1,128 @@
+import type { Annotation, AnnotationEntry } from "../state/protocol/state.js";
+/**
+ * Shared convention for carrying agent-feedback semantics inside an
+ * {@link Annotation._meta} on the agent host annotations channel.
+ *
+ * Feedback items round-trip as annotations on `<session>/annotations`; the
+ * annotation's own fields cover id / resource / range / resolved, and
+ * everything else (lifecycle state, origin kind, code context, PR linkage)
+ * lives under {@link FEEDBACK_ANNOTATION_META_KEY}. This module is the single
+ * place both the server (agent host, which writes feedback annotations from
+ * its server tools) and the client (agents window, which reads them back)
+ * agree on the key and shape, so the two sides cannot drift.
+ */
+/** Namespaced key under {@link Annotation._meta} carrying feedback semantics. */
+export declare const FEEDBACK_ANNOTATION_META_KEY = "vscode.agentFeedback";
+/**
+ * Name of the agent host server tool that reveals review comments the user has
+ * not accepted yet. Shared here (in the layer-neutral `common` module) so the
+ * node-side server tool implementation and the browser-side chat adapter that
+ * renders its confirmation agree on the name without drifting. The agent sees
+ * this name directly (Copilot) or prefixed as `mcp__host__<name>` (Claude).
+ */
+export declare const VIEW_UNREVIEWED_COMMENTS_TOOL_NAME = "viewUnreviewedComments";
+/**
+ * Name of the agent host server tool that adds a comment (agent feedback) to a
+ * file range. Shared here (in the layer-neutral `common` module) so the
+ * node-side server tool implementation and the browser-side chat adapter that
+ * renders its tool call agree on the name without drifting. The agent sees this
+ * name directly (Copilot) or prefixed as `mcp__host__<name>` (Claude).
+ */
+export declare const ADD_COMMENT_TOOL_NAME = "addComment";
+/**
+ * Whether {@link toolName} (a tool name as seen on a tool call) refers to the
+ * {@link VIEW_UNREVIEWED_COMMENTS_TOOL_NAME} server tool. Accepts both the bare
+ * name and the Claude `mcp__<server>__<name>` prefixed form.
+ */
+export declare function isViewUnreviewedCommentsTool(toolName: string): boolean;
+/**
+ * Whether {@link toolName} (a tool name as seen on a tool call) refers to the
+ * {@link ADD_COMMENT_TOOL_NAME} server tool. Accepts both the bare name and the
+ * Claude `mcp__<server>__<name>` prefixed form.
+ */
+export declare function isAddCommentTool(toolName: string): boolean;
+/**
+ * Origin of a feedback item. String values match the client-side
+ * `AgentFeedbackKind` enum so a value written by either side decodes on the
+ * other without translation.
+ */
+export type AgentFeedbackKindValue = "user" | "codeReview" | "prReview";
+/**
+ * Lifecycle state of a feedback item. String values match the client-side
+ * `AgentFeedbackState` enum.
+ */
+export type AgentFeedbackStateValue = "created" | "accepted" | "submitted" | "resolved";
+/** Pull request that originated a PR-review feedback item. */
+export interface IFeedbackPullRequest {
+    readonly owner: string;
+    readonly repo: string;
+    readonly number: number;
+}
+/**
+ * Feedback semantics carried in an annotation's {@link Annotation._meta}.
+ *
+ * The optional client-only fields ({@link suggestion}, {@link codeSelection},
+ * {@link diffHunks}, {@link sourcePRReviewCommentId}, {@link sourcePullRequest}) are populated when a
+ * feedback item is converted from a code- or PR-review comment on the client;
+ * server tools only ever write {@link kind} / {@link state} /
+ * {@link sessionResource}. {@link suggestion} is typed loosely here because
+ * its concrete shape lives in the client (sessions) layer.
+ */
+export interface IFeedbackAnnotationMeta {
+    readonly kind: AgentFeedbackKindValue;
+    readonly state: AgentFeedbackStateValue;
+    readonly sessionResource: string;
+    readonly suggestion?: unknown;
+    readonly codeSelection?: string;
+    readonly diffHunks?: string;
+    readonly sourcePRReviewCommentId?: string;
+    readonly sourcePullRequest?: IFeedbackPullRequest;
+    /**
+     * Transient marker set by the client when the user reveals this comment to
+     * the agent via the `viewUnreviewedComments` tool. The marker persists until
+     * the server tool delivers the comment, so an interrupted execution does not
+     * lose the user's selection. The server tool clears it after delivery.
+     */
+    readonly pendingAgentReveal?: boolean;
+}
+/**
+ * Who wrote a specific {@link AnnotationEntry} within a feedback comment.
+ *
+ * A comment's origin ({@link AgentFeedbackKindValue}) describes where the
+ * thread came from; an author describes each individual message in it, so a
+ * thread the user started can carry agent replies and vice versa. `unknown` is
+ * used when provenance cannot be established rather than assuming the user.
+ */
+export type AgentFeedbackAuthorValue = "user" | "agent" | "prReviewer" | "unknown";
+/** Author semantics carried in an {@link AnnotationEntry._meta}. */
+export interface IFeedbackAnnotationEntryMeta {
+    readonly author: AgentFeedbackAuthorValue;
+}
+/**
+ * The author of a comment's opening entry, derived from the thread's origin:
+ * code review comments are written by an agent and PR review comments by a
+ * reviewer.
+ */
+export declare function authorForFeedbackKind(kind: AgentFeedbackKindValue | undefined): AgentFeedbackAuthorValue;
+/** Builds the `_meta` bag stamping {@link author} onto an annotation entry. */
+export declare function feedbackAnnotationEntryMeta(author: AgentFeedbackAuthorValue): Record<string, unknown>;
+/**
+ * Reads the author stamped onto an annotation entry, or `undefined` for
+ * entries written before authors were recorded.
+ */
+export declare function readFeedbackAnnotationEntryAuthor(entry: AnnotationEntry): AgentFeedbackAuthorValue | undefined;
+/**
+ * Resolves the author of the entry at {@link index} within a comment of
+ * {@link kind}. Entries written before authors were recorded fall back to the
+ * thread's origin for the opening entry and to the user for replies — at that
+ * time replies could only be typed by the user.
+ */
+export declare function resolveFeedbackEntryAuthor(entry: AnnotationEntry, index: number, kind: AgentFeedbackKindValue | undefined): AgentFeedbackAuthorValue;
+/**
+ * Reads the well-known {@link IFeedbackAnnotationMeta} from an annotation's
+ * `_meta` bag (under {@link FEEDBACK_ANNOTATION_META_KEY}). The annotations
+ * channel is shared, so this validates the required `kind` / `state` /
+ * `sessionResource` fields and returns `undefined` for annotations that aren't
+ * feedback items. Read through this rather than casting the namespaced slot.
+ */
+export declare function readFeedbackAnnotationMeta(annotation: Annotation): IFeedbackAnnotationMeta | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/agentToolCallMeta.d.ts

@@ -0,0 +1,81 @@
+/** Anything carrying a tool call's `_meta` bag (persisted state or wire actions). */
+interface IHasToolCallMeta {
+    readonly _meta?: Record<string, unknown>;
+}
+/**
+ * Well-known typed view over a tool call's open `_meta` bag. Producers and
+ * consumers agree on these keys here so the two sides can't drift; always read
+ * the bag through {@link readToolCallMeta}, which validates each field and drops
+ * wrong-typed values.
+ */
+export interface IToolCallMeta {
+    readonly "agentHost.sandboxBypass"?: boolean;
+    /**
+     * VS Code rendering hint. `terminal` routes the call to the command/output
+     * renderer, `subagent` to the subagent UI, `search` to the search renderer,
+     * and `read` keeps incomplete resource arguments out of streaming display;
+     * everything else falls through to the generic invocation renderer. Set by
+     * the agent adapter, never matched on raw tool name by the renderer.
+     */
+    readonly toolKind?: ToolKind;
+    /** Shell language for a `terminal` tool call (drives syntax highlighting). */
+    readonly language?: string;
+    /** Short task description for a `subagent` tool call (e.g. "Find related files"). */
+    readonly subagentDescription?: string;
+    /** Agent name for a `subagent` tool call (e.g. "explore"). */
+    readonly subagentAgentName?: string;
+    /** Chat URI of the subagent this tool call spawns, stamped by the host (see {@link buildSubagentChatUri}); the resource may not be registered yet. */
+    readonly subagentChatUri?: string;
+    /** Originating MCP server name, when the call came from an MCP server. */
+    readonly mcpServerName?: string;
+    /** Originating MCP tool name, when the call came from an MCP server. */
+    readonly mcpToolName?: string;
+    /** MCP App render data, when the call exposes an interactive App surface. */
+    readonly ui?: IToolCallUiMeta;
+    /**
+     * Set by the host's side-effect layer when the call was auto-approved
+     * because of an `autoApprove` session-config setting (rather than an
+     * explicit user action), so the client can render it as setting-driven.
+     */
+    readonly autoApproveBySetting?: boolean;
+    /** Whether adding a persistent terminal auto-approve rule can suppress future prompts for this confirmation. */
+    readonly autoApproveRuleResolvable?: boolean;
+    /** Transient runtime corpus for the local client tool-search invocation. */
+    readonly toolSearchCandidates?: readonly IToolSearchCandidate[];
+    /** Latest progress message from a running tool; transient, meaningful only while Running. */
+    readonly progressMessage?: string;
+}
+/** Minimal metadata needed to embed and rank a deferred tool. */
+export interface IToolSearchCandidate {
+    readonly name: string;
+    readonly description: string;
+}
+/**
+ * The set of VS Code-recognized tool-call rendering kinds. Add a new value here
+ * (and teach the renderer to handle it) rather than matching on tool name.
+ */
+export type ToolKind = "terminal" | "subagent" | "search" | "read";
+/**
+ * MCP App render data carried under {@link IToolCallMeta.ui}. Clients gate
+ * mounting the App webview on both a `resourceUri` and a `channel` being
+ * present.
+ */
+export interface IToolCallUiMeta {
+    /** The MCP App's UI resource URI (an `ui://` resource the App renders). */
+    readonly resourceUri: string;
+    /** AHP `mcp://` channel the App's sub-RPCs route back through, when ready. */
+    readonly channel?: string;
+}
+/**
+ * Reads the well-known {@link IToolCallMeta} keys from a tool call's `_meta`
+ * bag, dropping unknown keys and wrong-typed values.
+ */
+export declare function readToolCallMeta(source: IHasToolCallMeta): IToolCallMeta;
+/**
+ * Serializes a typed {@link IToolCallMeta} into the `_meta` record, dropping
+ * `undefined` entries and returning `undefined` when empty. Build a tool call's
+ * `_meta` through this so producers stay in lock-step with
+ * {@link readToolCallMeta}.
+ */
+export declare function toToolCallMeta(meta: IToolCallMeta): Record<string, unknown> | undefined;
+export {};

package/vscode/src/vs/platform/agentHost/common/meta/agentWorkspaceContinuationMeta.d.ts

@@ -0,0 +1,8 @@
+interface IHasAgentWorkspaceContinuationMeta {
+    readonly _meta?: Record<string, unknown>;
+}
+/** Whether the message is the internal request that resumes a turn after workspace conversion. */
+export declare function isAgentWorkspaceContinuationMessage(source: IHasAgentWorkspaceContinuationMeta): boolean;
+/** Serializes the workspace-continuation marker for the open protocol bag. */
+export declare function toAgentWorkspaceContinuationMessageMeta(): Record<string, unknown>;
+export {};

package/vscode/src/vs/platform/agentHost/common/meta/codexAccount.d.ts

@@ -0,0 +1,28 @@
+import type { RootState } from "../state/protocol/state.js";
+export declare const CODEX_ACCOUNT_META_KEY = "vscode.codexAccount";
+export declare const CODEX_ACCOUNT_SIGN_IN_REQUEST_KEY = "vscode.codexAccount.signInRequest";
+export declare const CODEX_ACCOUNT_SIGN_OUT_REQUEST_KEY = "vscode.codexAccount.signOutRequest";
+export declare const CODEX_PROFILE_IMAGE_SCHEME = "vscode-codex-profile-image";
+export declare const MAX_CODEX_PROFILE_IMAGE_BYTES: number;
+export interface ICodexProfileImageReference {
+    readonly uri: string;
+    readonly contentType: string;
+    readonly sizeHint: number;
+    readonly nonce: string;
+}
+export interface ICodexAccountRateLimitInfo {
+    readonly usedPercent: number;
+    readonly windowDurationMins?: number;
+    readonly resetsAt?: number;
+}
+export interface ICodexAccountInfo {
+    readonly status: "unknown" | "downloading" | "signedIn" | "signedOut" | "unavailable" | "error";
+    readonly email?: string;
+    readonly planType?: string;
+    readonly profileImage?: ICodexProfileImageReference;
+    readonly requiresOpenaiAuth?: boolean;
+    readonly rateLimit?: ICodexAccountRateLimitInfo;
+    readonly authUrl?: string;
+    readonly authUrlNonce?: string;
+}
+export declare function readCodexAccountInfo(state: RootState | undefined): ICodexAccountInfo;