@codingame/monaco-vscode-api 36.2.7 → 37.1.0

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

@@ -0,0 +1,68 @@
+
+import { isWindows } from '../../../base/common/platform.js';
+import { AgentSandboxSettingId } from '../../sandbox/common/settings.js';
+import { CODEX_AGENT_PROVIDER_ID, CLAUDE_AGENT_PROVIDER_ID } from './agent.js';
+export { AgentSession, GITHUB_COPILOT_PROTECTED_RESOURCE, SubagentChatSignal, protectedResourcesRequireGitHubCopilotSignIn, 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";
+function affectsAgentHostProviderPreference(event, isSessionsWindow) {
+    return event.affectsConfiguration(AgentHostClaudeAgentEnabledSettingId) || event.affectsConfiguration(
+        isSessionsWindow ? AgentHostCodexAgentEnabledSettingId : CodexPreferAgentHostEditorSettingId
+    );
+}
+function shouldSurfaceLocalAgentHostProvider(provider, configurationService, isSessionsWindow) {
+    switch (provider) {
+    case CLAUDE_AGENT_PROVIDER_ID:
+        return configurationService.getValue(AgentHostClaudeAgentEnabledSettingId) !== false;
+    case CODEX_AGENT_PROVIDER_ID:
+        return configurationService.getValue(
+            isSessionsWindow ? AgentHostCodexAgentEnabledSettingId : CodexPreferAgentHostEditorSettingId
+        ) === true;
+    default:
+        return true;
+    }
+}
+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, CLAUDE_AGENT_PROVIDER_ID, CODEX_AGENT_PROVIDER_ID, CodexPreferAgentHostEditorSettingId, affectsAgentHostProviderPreference, getAgentHostCopilotSandboxSettingId, shouldSurfaceLocalAgentHostProvider };

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,69 @@
+
+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 getCustomizationDisabledReason(customization, plugin) {
+    const decision = getCustomizationEnablementDecision(customization);
+    return decision?.enabled === false ? {
+        source: "scope",
+        scope: decision.kind
+    } : undefined;
+}
+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, getCustomizationDisabledReason, getCustomizationEnablementDecision, getCustomizationScopeEnablement, isCustomizationEnabled, sortCustomizationEnablement, withCustomizationEnablement };

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/agentWorkspaceContinuationMeta.js

@@ -0,0 +1,8 @@
+
+
+const AGENT_WORKSPACE_CONTINUATION_META_KEY = 'vscode.chat.workspaceContinuation';
+function isAgentWorkspaceContinuationMessage(source) {
+    return source._meta?.[AGENT_WORKSPACE_CONTINUATION_META_KEY] === true;
+}
+
+export { isAgentWorkspaceContinuationMessage };

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;

package/vscode/src/vs/platform/agentHost/common/meta/codexAccount.js

@@ -0,0 +1,69 @@
+
+import { URI } from '../../../../base/common/uri.js';
+
+const CODEX_ACCOUNT_META_KEY = "vscode.codexAccount";
+const CODEX_ACCOUNT_SIGN_IN_REQUEST_KEY = "vscode.codexAccount.signInRequest";
+const CODEX_ACCOUNT_SIGN_OUT_REQUEST_KEY = "vscode.codexAccount.signOutRequest";
+const CODEX_PROFILE_IMAGE_SCHEME = "vscode-codex-profile-image";
+const MAX_CODEX_PROFILE_IMAGE_BYTES = 1024 * 1024;
+const SUPPORTED_CODEX_PROFILE_IMAGE_MEDIA_TYPES = ( new Set(["image/avif", "image/gif", "image/jpeg", "image/png", "image/webp"]));
+function readCodexAccountInfo(state) {
+    const metaValue = state?._meta?.[CODEX_ACCOUNT_META_KEY];
+    const value = state?.config?.values[CODEX_ACCOUNT_META_KEY] ?? metaValue;
+    if (!value || typeof value !== "object") {
+        return {
+            status: "unknown"
+        };
+    }
+    const account = value;
+    if (account.status !== "unknown" && account.status !== "downloading" && account.status !== "signedIn" && account.status !== "signedOut" && account.status !== "unavailable" && account.status !== "error") {
+        return {
+            status: "unknown"
+        };
+    }
+    const rateLimit = account.rateLimit;
+    const validRateLimit = rateLimit && typeof rateLimit === "object" && typeof rateLimit.usedPercent === "number" && Number.isFinite(rateLimit.usedPercent) && rateLimit.usedPercent >= 0 && rateLimit.usedPercent <= 100 && (rateLimit.windowDurationMins === undefined || (typeof rateLimit.windowDurationMins === "number" && Number.isFinite(rateLimit.windowDurationMins) && rateLimit.windowDurationMins > 0)) && (rateLimit.resetsAt === undefined || (typeof rateLimit.resetsAt === "number" && Number.isFinite(rateLimit.resetsAt) && rateLimit.resetsAt > 0));
+    return {
+        status: account.status,
+        email: typeof account.email === "string" ? account.email : undefined,
+        planType: typeof account.planType === "string" ? account.planType : undefined,
+        profileImage: readProfileImageReference(account.profileImage),
+        requiresOpenaiAuth: typeof account.requiresOpenaiAuth === "boolean" ? account.requiresOpenaiAuth : undefined,
+        rateLimit: validRateLimit ? {
+            usedPercent: rateLimit.usedPercent,
+            windowDurationMins: rateLimit.windowDurationMins,
+            resetsAt: rateLimit.resetsAt
+        } : undefined,
+        authUrl: typeof account.authUrl === "string" ? account.authUrl : undefined,
+        authUrlNonce: typeof account.authUrlNonce === "string" ? account.authUrlNonce : undefined
+    };
+}
+function readProfileImageReference(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const reference = value;
+    if (typeof reference.contentType !== "string" || !( SUPPORTED_CODEX_PROFILE_IMAGE_MEDIA_TYPES.has(reference.contentType)) || typeof reference.sizeHint !== "number" || !Number.isInteger(reference.sizeHint) || reference.sizeHint <= 0 || reference.sizeHint > MAX_CODEX_PROFILE_IMAGE_BYTES || typeof reference.nonce !== "string" || !/^[a-f0-9]{64}$/.test(reference.nonce) || !isProfileImageResourceUri(reference.uri, reference.contentType, reference.nonce)) {
+        return undefined;
+    }
+    return {
+        uri: reference.uri,
+        contentType: reference.contentType,
+        sizeHint: reference.sizeHint,
+        nonce: reference.nonce
+    };
+}
+function isProfileImageResourceUri(value, contentType, nonce) {
+    if (typeof value !== "string") {
+        return false;
+    }
+    try {
+        const uri = ( URI.parse(value));
+        const extension = contentType === "image/jpeg" ? "jpg" : contentType.slice("image/".length);
+        return uri.scheme === CODEX_PROFILE_IMAGE_SCHEME && !uri.authority && uri.path === `/profile-${nonce}.${extension}` && !uri.query && !uri.fragment;
+    } catch {
+        return false;
+    }
+}
+
+export { CODEX_ACCOUNT_META_KEY, CODEX_ACCOUNT_SIGN_IN_REQUEST_KEY, CODEX_ACCOUNT_SIGN_OUT_REQUEST_KEY, CODEX_PROFILE_IMAGE_SCHEME, MAX_CODEX_PROFILE_IMAGE_BYTES, readCodexAccountInfo };

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

@@ -0,0 +1,29 @@
+/** How a remote agent host kind should be re-established after its transport drops. */
+export interface IRemoteAgentHostReconnectPolicy {
+    /**
+     * Whether a dropped transport may be restored automatically, with no user intent.
+     * `false` means the connection is surfaced as lost and recovery waits for an explicit user action.
+     */
+    readonly autoRestore: boolean;
+    /** First retry delay, in milliseconds. */
+    readonly initialDelayMs: number;
+    /** Ceiling for exponential backoff, in milliseconds. */
+    readonly maxDelayMs: number;
+    /**
+     * Consecutive failed attempts before automatic restore gives up. Exhaustion is
+     * terminal for the automatic path; recovery falls back to an explicit user action.
+     */
+    readonly maxAttempts: number;
+}
+/** Default automatic reconnect policy for remote agent hosts. */
+export declare const DEFAULT_RECONNECT_POLICY: IRemoteAgentHostReconnectPolicy;
+/**
+ * Computes a retry delay after a failed automatic reconnect attempt.
+ * `attempt` is 1-based: pass 1 after the first failure, 2 after the second, and so on.
+ */
+export declare function computeReconnectDelay(policy: IRemoteAgentHostReconnectPolicy, attempt: number): number;
+/**
+ * Whether automatic reconnect has reached its failure limit.
+ * `attempt` is the 1-based count of consecutive failed automatic reconnect attempts.
+ */
+export declare function hasExhaustedReconnectAttempts(policy: IRemoteAgentHostReconnectPolicy, attempt: number): boolean;

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

@@ -0,0 +1,16 @@
+
+
+const DEFAULT_RECONNECT_POLICY = {
+    autoRestore: true,
+    initialDelayMs: 1000,
+    maxDelayMs: 30_000,
+    maxAttempts: 10,
+};
+function computeReconnectDelay(policy, attempt) {
+    return Math.min(policy.initialDelayMs * Math.pow(2, attempt - 1), policy.maxDelayMs);
+}
+function hasExhaustedReconnectAttempts(policy, attempt) {
+    return attempt >= policy.maxAttempts;
+}
+
+export { DEFAULT_RECONNECT_POLICY, computeReconnectDelay, hasExhaustedReconnectAttempts };

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

@@ -0,0 +1,37 @@
+import { Disposable } from "../../../base/common/lifecycle.js";
+import { ILogService } from "../../log/common/log.service.js";
+import type { AgentHostClientConnectionKind } from "./agentHostTelemetry.js";
+import type { AhpServerNotification, JsonRpcNotification, JsonRpcParseErrorResponse, JsonRpcRequest, JsonRpcResponse, ProtocolMessage } from "./state/sessionProtocol.js";
+import type { IClientTransport, IProtocolTransport } from "./state/sessionTransport.js";
+/**
+ * A connected transport and the optional owner-specific resource teardown for its establishment attempt.
+ */
+export interface IEstablishedTransport {
+    /** The live inner transport to route traffic through. */
+    readonly transport: IProtocolTransport;
+    /** Tear down whatever this attempt established. Omitted when the caller owns teardown. */
+    close?(): Promise<void>;
+}
+/**
+ * Establishes an inner transport on demand and forwards its protocol traffic.
+ */
+export declare class ReconnectingTransport extends Disposable implements IClientTransport {
+    private readonly _establish;
+    private readonly _logService;
+    private readonly _logPrefix;
+    readonly clientConnectionKind: AgentHostClientConnectionKind | undefined;
+    private readonly _sendBeforeConnectWarning;
+    private readonly _onMessage;
+    readonly onMessage: import("../../../base/common/event.js").Event<ProtocolMessage>;
+    private readonly _onClose;
+    readonly onClose: import("../../../base/common/event.js").Event<void>;
+    private readonly _establishedTransport;
+    private _connectPromise;
+    constructor(_establish: () => Promise<IEstablishedTransport>, _logService: ILogService, _logPrefix: string, clientConnectionKind?: AgentHostClientConnectionKind | undefined, _sendBeforeConnectWarning?: string);
+    /** Establishes and adopts the inner transport. */
+    connect(): Promise<void>;
+    /** Routes a protocol message through the established inner transport. */
+    send(message: ProtocolMessage | AhpServerNotification | JsonRpcNotification | JsonRpcParseErrorResponse | JsonRpcResponse | JsonRpcRequest): void;
+    private _establishTransport;
+    private _disposeEstablishedTransport;
+}