@codingame/monaco-vscode-chat-service-override 36.2.7 → 37.1.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.d.ts

@@ -1,11 +1,17 @@
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
 import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { type Customization, type RootConfigState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
-import { AgentCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IAgentHostResourceUriMapper } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri";
+import { IAgentHostConnectionsService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConnectionsService.service";
+import { CustomizationEnablementKind, McpServerCustomization, type Customization, type CustomizationEnablement, type PluginCustomization, type RootConfigState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { AgentCustomization, type ISessionFolderPickerDecision } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { IMcpServerConfiguration } from "@codingame/monaco-vscode-api/vscode/vs/platform/mcp/common/mcpPlatformTypes";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+import { IAgentHostActiveClientService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service";
 import { IAgentHostMcpServer } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostMcpServer";
 import { IAgentHostCustomizationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.service";
 export declare class NullAgentHostCustomizationService implements IAgentHostCustomizationService {
@@ -14,22 +20,34 @@ export declare class NullAgentHostCustomizationService implements IAgentHostCust
     readonly onDidChangeCustomizations: Event<any>;
     getCustomAgents(_sessionResource: URI): readonly AgentCustomization[];
     getCustomizations(_sessionResource: URI): readonly Customization[];
+    whenCustomizationsReady(_sessionResource: URI, _token?: CancellationToken): Promise<void>;
+    getFolderPickerDecision(_sessionResource: URI): ISessionFolderPickerDecision | undefined;
     getWorkingDirectory(sessionResource: URI): string | undefined;
+    getWorkingDirectories(_sessionResource: URI): readonly string[];
+    getClientWorkingDirectoryUris(_sessionResource: URI): readonly URI[];
     getMcpServers(_sessionResource: URI): readonly IAgentHostMcpServer[];
     addMcpServer(_sessionResource: URI, _name: string, _config: IMcpServerConfiguration): void;
     authenticateMcpServer(_sessionResource: URI, _serverId: string): Promise<boolean>;
+    setCustomizationEnablement(_sessionResource: URI, _customizationId: string, _currentEnablement: readonly CustomizationEnablement[] | undefined, _kind: CustomizationEnablementKind, _enabled: boolean): void;
+    showMcpServerLog(_sessionResource: URI, _serverId: string, beforeShow?: () => Promise<void>): Promise<void>;
 }
 export interface IAgentHostCustomizationTarget {
     readonly customizations: readonly Customization[];
+    readonly resourceUris: IAgentHostResourceUriMapper;
+    readonly folderPickerDecision?: ISessionFolderPickerDecision;
     readonly workingDirectory?: string;
-    readonly logOutputChannelId?: string;
+    /** Host-side URI strings, also used in protocol enablement decisions. */
+    readonly workingDirectories?: readonly string[];
     readonly rootConfig?: RootConfigState;
+    isBundledMcpServer(pluginUri: string, serverName: string): boolean;
     authenticate(request: {
         resource: string;
         scopes?: readonly string[];
         token: string;
     }): Promise<unknown>;
-    setCustomizationEnabled(rawId: string, enabled: boolean): void;
+    setCustomizationEnablement(rawId: string, enablement: readonly CustomizationEnablement[]): void;
+    startMcpServer(rawId: string): Promise<void>;
+    stopMcpServer(rawId: string): Promise<void>;
     setRootConfigValue(property: string, value: unknown): void;
 }
 export declare abstract class AbstractAgentHostCustomizationService extends Disposable implements IAgentHostCustomizationService {
@@ -40,18 +58,107 @@ export declare abstract class AbstractAgentHostCustomizationService extends Disp
     private readonly _onDidChangeCustomizations;
     readonly onDidChangeCustomAgents: Event<void>;
     readonly onDidChangeCustomizations: Event<void>;
+    private readonly _mcpLogRegistry;
+    /**
+     * Sessions whose MCP diagnostics we mirror into per-server Output channels.
+     * A session is tracked once the user reveals a server's output; from then
+     * on every state change is recorded via {@link onDidChangeCustomizations},
+     * so subsequent failures and recoveries land in the channel history.
+     */
+    private readonly _mcpDiagnosticSessions;
     protected constructor(_instantiationService: IInstantiationService, _logService: ILogService);
     protected abstract _resolveTarget(sessionResource: URI): IAgentHostCustomizationTarget | undefined;
     getCustomAgents(sessionResource: URI): readonly AgentCustomization[];
     getCustomizations(sessionResource: URI): readonly Customization[];
+    /**
+     * Targets resolved by this base are backed by already-materialized provider
+     * state, so a snapshot is available as soon as the target resolves.
+     */
+    whenCustomizationsReady(_sessionResource: URI, _token?: CancellationToken): Promise<void>;
+    getFolderPickerDecision(sessionResource: URI): ISessionFolderPickerDecision | undefined;
     getWorkingDirectory(sessionResource: URI): string | undefined;
+    getWorkingDirectories(sessionResource: URI): readonly string[];
+    getClientWorkingDirectoryUris(sessionResource: URI): readonly URI[];
     getMcpServers(sessionResource: URI): readonly IAgentHostMcpServer[];
+    showMcpServerLog(sessionResource: URI, serverId: string, beforeShow?: () => Promise<void>): Promise<void>;
+    /**
+     * Registers `sessionResource` for MCP diagnostics mirroring and records the
+     * currently-observed state of each of its servers. Idempotent: registering
+     * an already-tracked session simply re-records (dedup'd by state signature).
+     */
+    private _trackMcpDiagnostics;
+    /** Re-records every tracked session's MCP server states (on any customizations change). */
+    private _recordMcpDiagnostics;
+    /** Stops mirroring and disposes all MCP diagnostics channels for a session that is going away. */
+    protected _disposeMcpDiagnostics(sessionResource: URI): void;
     addMcpServer(sessionResource: URI, name: string, config: IMcpServerConfiguration): void;
     authenticateMcpServer(sessionResource: URI, serverId: string): Promise<boolean>;
+    setCustomizationEnablement(sessionResource: URI, customizationId: string, currentEnablement: readonly CustomizationEnablement[] | undefined, kind: CustomizationEnablementKind, enabled: boolean): void;
+    private _workspaceEnablementEntry;
     protected _fireCustomAgentsChanged(): void;
     protected _fireCustomizationsChanged(): void;
-    private _flattenMcpServers;
     private _findMcpServer;
+    private _findCustomization;
     protected _scopedMcpServerId(sessionResource: URI, rawId: string): string;
     private _isScopedMcpServerIdForRawId;
 }
+/** One MCP server customization, with the position it was published at. */
+export interface IMcpServerCustomizationEntry {
+    readonly server: McpServerCustomization;
+    /**
+     * The plugin that declares this server. Absent both for a server published at the top level
+     * and for one declared by a {@link CustomizationType.Directory} container, so it says nothing
+     * about where in the tree the server sits -- use {@link isTopLevel} for that.
+     */
+    readonly plugin?: PluginCustomization;
+    /** Whether the agent host published this server as a customization of the session itself. */
+    readonly isTopLevel: boolean;
+}
+/** Every MCP server customization in a session, including duplicates of the same server. */
+export declare function flattenMcpServerCustomizations(customizations: readonly Customization[]): readonly IMcpServerCustomizationEntry[];
+/**
+ * The MCP servers to *show* for a session: one entry per server.
+ *
+ * A session can carry two customizations for one server: the declaration, published as a child of
+ * whatever declared it, and a top-level entry the agent host mints for a server the SDK reports
+ * before that child resolves by name. A child is dropped when a top-level customization already
+ * speaks for its name, because the top-level copy is the one the host keeps live and resolves for
+ * lifecycle and enablement.
+ *
+ * Tree position is the signal, not the shape of the minted id and not the absence of an owning
+ * plugin -- a directory-declared child has none either. Only presentation dedupes; lookups
+ * elsewhere walk every customization, so an id from either copy still resolves. Servers of the
+ * same name from different containers are left alone, because they are different servers.
+ */
+export declare function getPresentableMcpServerCustomizations(customizations: readonly Customization[]): readonly IMcpServerCustomizationEntry[];
+export declare class WorkbenchAgentHostCustomizationService extends AbstractAgentHostCustomizationService {
+    private readonly _connectionsService;
+    private readonly _provisionalSessionService;
+    private readonly _chatService;
+    private readonly _activeClientService;
+    private readonly _sessionStateSubscriptions;
+    /** Overridable so tests can exercise the timeout without real-time waits. */
+    protected readonly _snapshotTimeoutMs: number;
+    constructor(_connectionsService: IAgentHostConnectionsService, _provisionalSessionService: IAgentHostUntitledProvisionalSessionService, instantiationService: IInstantiationService, logService: ILogService, _chatService: IChatService, _activeClientService: IAgentHostActiveClientService);
+    protected _resolveTarget(sessionResource: URI): IAgentHostCustomizationTarget | undefined;
+    /**
+     * Session state arrives asynchronously over the protocol, so a freshly
+     * created subscription reports `undefined` until its first snapshot lands.
+     *
+     * The wait is memoized per subscription so that the many source-folder
+     * queries behind a single migration hint observe one shared deadline rather
+     * than restarting it per prompt type. It is bounded because the chat request
+     * path blocks on this before sending the user's message: once it elapses,
+     * callers fall back to the current (possibly empty) snapshot rather than
+     * stalling the send again on every subsequent query.
+     */
+    whenCustomizationsReady(sessionResource: URI, token?: CancellationToken): Promise<void>;
+    private _awaitFirstSnapshot;
+    private _ensureSessionStateSubscription;
+    /**
+     * Resolves a chat session resource to the backend agent-session URI plus
+     * the {@link IAgentConnection} (local or remote) that owns it. Returns
+     * `undefined` for sessions not backed by an agent host.
+     */
+    private _resolveSessionTarget;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.js

@@ -1,25 +1,35 @@
 
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
 import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '../../../../../../platform/agentHost/common/agentHostSchema.js';
-import '../../../../../../platform/agentHost/common/agentService.js';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/remoteAgentHostService';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-automation-run/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import '@codingame/monaco-vscode-api/vscode/vs/nls';
 import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/oauth';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/charCode';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/arrays';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 
 class NullAgentHostCustomizationService {
     constructor() {
@@ -32,9 +42,21 @@ class NullAgentHostCustomizationService {
     getCustomizations(_sessionResource) {
         return [];
     }
+    whenCustomizationsReady(_sessionResource, _token) {
+        return Promise.resolve();
+    }
+    getFolderPickerDecision(_sessionResource) {
+        return undefined;
+    }
     getWorkingDirectory(sessionResource) {
         return undefined;
     }
+    getWorkingDirectories(_sessionResource) {
+        return [];
+    }
+    getClientWorkingDirectoryUris(_sessionResource) {
+        return [];
+    }
     getMcpServers(_sessionResource) {
         return [];
     }
@@ -42,6 +64,10 @@ class NullAgentHostCustomizationService {
     authenticateMcpServer(_sessionResource, _serverId) {
         return Promise.resolve(false);
     }
+    setCustomizationEnablement(_sessionResource, _customizationId, _currentEnablement, _kind, _enabled) {}
+    async showMcpServerLog(_sessionResource, _serverId, beforeShow) {
+        await beforeShow?.();
+    }
 }
 
 export { NullAgentHostCustomizationService };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostDownloadProgress.d.ts

@@ -0,0 +1,35 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type ProgressParams } from "../../../../../../platform/agentHost/common/state/sessionActions.js";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IProgressService } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service";
+/**
+ * Renders agent-host `progress` notifications as notification progress bars.
+ *
+ * Shared by the Agents window (via `BaseAgentHostSessionsProvider`) and the
+ * editor window (via `AgentHostContribution`) so both surfaces render the
+ * agent host's lazy, first-use SDK download identically.
+ *
+ * Progress is correlated by {@link ProgressParams.progressToken}; today's only
+ * producer is the SDK download, which the host surfaces as a single stream per
+ * provider keyed by the download's own stable identity — so one indicator per
+ * download regardless of how many sessions await it. Determinate when the host
+ * knows the `total` (`Content-Length`), or a byte-count spinner otherwise. The
+ * operation is complete — and the notification dismissed — once
+ * `progress >= total`. The human-readable brand noun rides on
+ * {@link ProgressParams.message}.
+ */
+export declare class AgentHostDownloadProgress extends Disposable {
+    private readonly _progressService;
+    private readonly _configurationService;
+    /**
+     * Active progress indicators keyed by `progressToken`. The host emits a
+     * single stream per download keyed by the download's own stable identity
+     * (so distinct sessions of a provider share one indicator). Each entry owns
+     * one long-running notification progress (opened on the first frame), driven
+     * via {@link IActiveDownload.report} and dismissed via
+     * {@link IActiveDownload.complete} once `progress >= total`.
+     */
+    private readonly _activeDownloads;
+    constructor(_progressService: IProgressService, _configurationService: IConfigurationService);
+    handleProgress(progress: ProgressParams): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostDownloadProgress.js

@@ -0,0 +1,73 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatAIDisabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/chatSettings';
+
+let AgentHostDownloadProgress = class AgentHostDownloadProgress extends Disposable {
+    constructor(_progressService, _configurationService) {
+        super();
+        this._progressService = _progressService;
+        this._configurationService = _configurationService;
+        this._activeDownloads = ( new Map());
+        this._register(toDisposable(() => {
+            for (const download of ( this._activeDownloads.values())) {
+                download.complete();
+            }
+            this._activeDownloads.clear();
+        }));
+    }
+    handleProgress(progress) {
+        if (this._configurationService.getValue(ChatAIDisabledSettingId)) {
+            return;
+        }
+        const isComplete = progress.total !== undefined && progress.progress >= progress.total;
+        if (isComplete) {
+            this._activeDownloads.get(progress.progressToken)?.complete();
+            this._activeDownloads.delete(progress.progressToken);
+            return;
+        }
+        let entry = this._activeDownloads.get(progress.progressToken);
+        if (!entry) {
+            const deferred = ( new DeferredPromise());
+            let report;
+            const title = progress.message ?? ( localize(6013, "Downloading"));
+            this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title
+            }, p => {
+                report = step => p.report(step);
+                return deferred.p;
+            });
+            entry = {
+                lastPercent: 0,
+                report: step => report?.(step),
+                complete: () => deferred.complete()
+            };
+            this._activeDownloads.set(progress.progressToken, entry);
+        }
+        if (progress.total && progress.total > 0) {
+            const percent = Math.max(0, Math.min(100, Math.round((progress.progress / progress.total) * 100)));
+            const increment = percent - entry.lastPercent;
+            entry.lastPercent = percent;
+            entry.report({
+                message: ( localize(6014, "{0}%", percent)),
+                increment: increment > 0 ? increment : 0,
+                total: 100
+            });
+        } else {
+            const megabytes = (progress.progress / (1024 * 1024)).toFixed(1);
+            entry.report({
+                message: ( localize(6015, "{0} MB", megabytes))
+            });
+        }
+    }
+};
+AgentHostDownloadProgress = ( __decorate([( __param(0, IProgressService)), ( __param(1, IConfigurationService))], AgentHostDownloadProgress));
+
+export { AgentHostDownloadProgress };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostExistingSessionHarnessPickerEnablement.d.ts

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
+/**
+ * Resolves the strictly hidden editor harness-picker setting against its experiment treatment.
+ * Hidden settings are excluded from the generic configuration experiment resolver.
+ */
+export declare class AgentHostExistingSessionHarnessPickerEnablement extends Disposable implements IWorkbenchContribution {
+    private readonly configurationService;
+    private readonly assignmentService;
+    private readonly logService;
+    static readonly ID = "workbench.contrib.agentHostExistingSessionHarnessPickerEnablement";
+    private readonly enabledContext;
+    private updateRequest;
+    constructor(configurationService: IConfigurationService, contextKeyService: IContextKeyService, assignmentService: IWorkbenchAssignmentService, logService: ILogService);
+    private update;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostExistingSessionHarnessPickerEnablement.js

@@ -0,0 +1,61 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { AgentHostExistingSessionHarnessPickerEnabledSettingId, AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService';
+import { isConfigured } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+
+const treatmentId = `config.${AgentHostExistingSessionHarnessPickerEnabledSettingId}`;
+let AgentHostExistingSessionHarnessPickerEnablement = class AgentHostExistingSessionHarnessPickerEnablement extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostExistingSessionHarnessPickerEnablement";
+    }
+    constructor(configurationService, contextKeyService, assignmentService, logService) {
+        super();
+        this.configurationService = configurationService;
+        this.assignmentService = assignmentService;
+        this.logService = logService;
+        this.updateRequest = 0;
+        this.enabledContext = AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY.bindTo(contextKeyService);
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(AgentHostExistingSessionHarnessPickerEnabledSettingId)) {
+                void this.update();
+            }
+        }));
+        this._register(this.assignmentService.onDidRefetchAssignments(() => void this.update()));
+        void this.update();
+    }
+    async update() {
+        const request = ++this.updateRequest;
+        const inspection = this.configurationService.inspect(AgentHostExistingSessionHarnessPickerEnabledSettingId);
+        if (isConfigured(inspection)) {
+            this.enabledContext.set(inspection.value === true);
+            return;
+        }
+        let enabled = false;
+        try {
+            enabled = (await this.assignmentService.getTreatment(treatmentId)) === true;
+        } catch (error) {
+            if (this._store.isDisposed || request !== this.updateRequest) {
+                return;
+            }
+            this.logService.warn(
+                `[AgentHostExistingSessionHarnessPickerEnablement] Failed to resolve treatment '${treatmentId}'.`,
+                error
+            );
+        }
+        if (this._store.isDisposed || request !== this.updateRequest) {
+            return;
+        }
+        const currentInspection = this.configurationService.inspect(AgentHostExistingSessionHarnessPickerEnabledSettingId);
+        this.enabledContext.set(
+            isConfigured(currentInspection) ? currentInspection.value === true : enabled
+        );
+    }
+};
+AgentHostExistingSessionHarnessPickerEnablement = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IContextKeyService)), ( __param(2, IWorkbenchAssignmentService)), ( __param(3, ILogService))], AgentHostExistingSessionHarnessPickerEnablement));
+
+export { AgentHostExistingSessionHarnessPickerEnablement };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostImportConversationStore.d.ts

@@ -0,0 +1,20 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import type { Turn } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import type { ModelSelection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { IAgentHostImportConversationStore } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostImportConversationStore.service";
+/**
+ * A conversation being imported ("Continue in…") into a new agent-host session:
+ * the translated {@link Turn}s plus the source session's selected model, so the
+ * new session resumes on the same model instead of the host's default.
+ */
+export interface IAgentHostImportConversation {
+    readonly turns: readonly Turn[];
+    readonly model?: ModelSelection;
+}
+export declare class AgentHostImportConversationStore implements IAgentHostImportConversationStore {
+    readonly _serviceBrand: undefined;
+    private readonly _pending;
+    set(resource: URI, conversation: IAgentHostImportConversation): void;
+    take(resource: URI): IAgentHostImportConversation | undefined;
+    rename(oldResource: URI, newResource: URI): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostImportConversationStore.js

@@ -0,0 +1,26 @@
+
+
+class AgentHostImportConversationStore {
+    constructor() {
+        this._pending = ( new Map());
+    }
+    set(resource, conversation) {
+        if (conversation.turns.length > 0) {
+            this._pending.set(( resource.toString()), conversation);
+        }
+    }
+    take(resource) {
+        const key = ( resource.toString());
+        const conversation = this._pending.get(key);
+        this._pending.delete(key);
+        return conversation;
+    }
+    rename(oldResource, newResource) {
+        const conversation = this.take(oldResource);
+        if (conversation) {
+            this._pending.set(( newResource.toString()), conversation);
+        }
+    }
+}
+
+export { AgentHostImportConversationStore };

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostLanguageModelProvider.d.ts

@@ -0,0 +1,112 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { SessionModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { ILanguageModelChatMetadataAndIdentifier, ILanguageModelChatProvider } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+/**
+ * Returns whether an agent host provider exposes a synthetic "Auto" model to
+ * fall back to.
+ *
+ * Today only the Copilot CLI harness exposes an Auto selection and can run
+ * without an explicit model, so it shows "Auto" rather than a "No models
+ * available" state when no models are listed. Other harnesses (Claude,
+ * Codex, …) require an explicit model.
+ *
+ * `provider` is the underlying agent provider id (e.g. `'copilotcli'`,
+ * `'claude'`, `'codex'`), not the `agent-host-<provider>` session type.
+ *
+ * TODO: hoist this capability onto the agent host protocol (e.g. a
+ * `supportsAutoModel?: boolean` on `IAgentDescriptor` / `AgentInfo`) so each
+ * agent declares its own value instead of this allow-list living in core.
+ */
+export declare function agentHostProviderSupportsAutoModel(provider: string): boolean;
+/**
+ * Read-only view of the workbench model catalogue an agent host's models are enriched from.
+ *
+ * Narrowed to the reads {@link AgentHostLanguageModelProvider} performs (all plain lookups into
+ * already-registered models, so none of them re-enter a provider) plus the change signal, both so
+ * the dependency stays obviously side-effect free and so tests can supply a small fake.
+ */
+export type IAgentHostModelCatalogue = Pick<ILanguageModelsService, "getLanguageModelIds" | "lookupLanguageModel" | "onDidChangeLanguageModels">;
+/**
+ * Exposes models available from the agent host process as selectable
+ * language models in the chat model picker. Models are provided from
+ * root state (via {@link AgentInfo.models}) rather than via RPC.
+ */
+export declare class AgentHostLanguageModelProvider extends Disposable implements ILanguageModelChatProvider {
+    private readonly _sessionType;
+    private readonly _vendor;
+    private readonly _catalogue?;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private _models;
+    constructor(_sessionType: string, _vendor: string, _catalogue?: IAgentHostModelCatalogue | undefined);
+    /**
+     * Called by {@link AgentHostContribution} when models change in root state.
+     */
+    updateModels(models: readonly SessionModelInfo[]): void;
+    provideLanguageModelChatInfo(_options: unknown, _token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
+    /**
+     * The workbench catalogue entry describing the same model, when one is known.
+     *
+     * A host driving the Copilot SDK advertises no billing and, where the SDK omits them, no token
+     * limits — so the CAPI-backed Copilot catalogue fills the gaps.
+     *
+     * Matching by raw model id does not prove the two describe the same offering — they can differ
+     * by entitlement, policy, rollout or billing route — so this is restricted to models billed
+     * through Copilot and only ever fills fields the host left absent.
+     *
+     * The token-limit half is a shim: those are native protocol fields, and a host that populates
+     * them makes the fallback dead. The billing half is not. Pricing is deliberately kept off the
+     * agent host protocol as operator-sensitive, so a client that wants to show it has to source it
+     * itself. Removing this join therefore means dropping pricing for these models, which is a
+     * product decision rather than a cleanup.
+     */
+    private _catalogueEntryFor;
+    /**
+     * Translate a host's model {@link ConfigSchema} into the picker's schema shape.
+     *
+     * Values and display text belong to the producer; the workbench only picks the group
+     * ({@link _groupForConfigKey}). The one exception is a reasoning-effort enum with no display
+     * text at all, labelled locally rather than rendering raw values like `xhigh`.
+     *
+     * A property is never dropped for want of local enrichment: a host advertises one because it
+     * will honour it, and a new model, a staged rollout and an unresolved catalogue all look
+     * identical from here.
+     */
+    private _toLanguageModelConfigurationSchema;
+    /** Config keys whose enum values are reasoning-effort levels, whatever the producer named them. */
+    private static readonly _reasoningEffortKeys;
+    /**
+     * Localized labels and descriptions for a reasoning-effort enum whose producer supplied none.
+     *
+     * A host that derives its schema from an upstream SDK advertises the accepted effort values
+     * without display text, because it has none the SDK did not give it — the Copilot agent host
+     * inside a cloud sandbox does exactly that. Deriving the text here keeps the picker from
+     * rendering raw values like `xhigh`, and matches what the agents that build their schema
+     * locally already emit.
+     *
+     * Only synthesized when every enum value is a string, since labels align with `enum` by index
+     * and a partial list would mislabel the rest.
+     *
+     * No `default` is synthesized: schema defaults are merged into the configuration that is sent
+     * (see `resolveModelConfiguration`), so inventing one would send an explicit effort where the
+     * host expects the value omitted and the backend to choose.
+     */
+    private static _reasoningEffortDisplay;
+    private static _groupForConfigKey;
+    /**
+     * Derives the picker group id for a model — the vendor its models are bucketed
+     * under. A producer may pin the group id explicitly in `_meta` (e.g. Claude
+     * stamps its transport vendor — `copilot`/`anthropic` — there while keeping
+     * `provider` as the `claude` routing owner); that wins. Otherwise BYOK models
+     * are surfaced by the agent host under the `vendor/[group/]id` selection id (see
+     * `resolveByokSessionConfig`), so their upstream vendor is the id prefix; native
+     * harness models have no prefix and group under their `provider` (the harness,
+     * e.g. `copilotcli`). The picker resolves the display name from the vendor
+     * registry — no name mapping lives here.
+     */
+    private _modelGroupFor;
+    sendChatRequest(): Promise<never>;
+    provideTokenCount(): Promise<number>;
+}