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

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

@@ -0,0 +1,219 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { AgentHostAllowSignedOutWhenUsableSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+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 { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { ChatEntitlementContextKeys, ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { hasVisibleByokModelsTargetingSessionType } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/sessionTypeAvailability';
+import { ChatSetupDialogVisibleContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatSetup/chatSetup';
+import { ChatInputNotificationActionKind, ChatInputNotificationSeverity } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
+import { SessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { MANAGE_CHAT_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { COPILOT_VENDOR_ID } 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';
+import { ILanguageModelsConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration.service';
+
+const SIGNED_OUT_MODELS_NOTIFICATION_ID = "agentHost.signedOutModels.copilot";
+const SIGN_IN_COMMAND_ID = "workbench.action.chat.triggerSetup";
+const COPILOT_AGENT_HOST_PROVIDER_ID = "copilotcli";
+const NOTIFICATION_CONTEXT_KEYS = ( new Set([
+    ChatEntitlementContextKeys.clientByokEnabled.key,
+    ChatSetupDialogVisibleContext.key
+]));
+const NOTIFICATION_GRACE_PERIOD_MS = 5_000;
+var SignedOutModelsNotificationState;
+(function(SignedOutModelsNotificationState) {
+    SignedOutModelsNotificationState[SignedOutModelsNotificationState["Hidden"] = 0] = "Hidden";
+    SignedOutModelsNotificationState[SignedOutModelsNotificationState["Waiting"] = 1] = "Waiting";
+    SignedOutModelsNotificationState[SignedOutModelsNotificationState["Visible"] = 2] = "Visible";
+})(
+    SignedOutModelsNotificationState || (SignedOutModelsNotificationState = {})
+);
+function getSignedOutModelsNotificationState(options) {
+    if (options.setupDialogVisible || !options.allowSignedOutWhenUsable || !options.accountResolved || !options.entitlementResolved || options.signedIn || !options.hasCopilotHarness || options.hasModels) {
+        return SignedOutModelsNotificationState.Hidden;
+    }
+    return options.localModelsLoaded || options.gracePeriodElapsed ? SignedOutModelsNotificationState.Visible : SignedOutModelsNotificationState.Waiting;
+}
+function areLocalModelsLoaded(
+    extensionsRegistered,
+    configurationLoaded,
+    configuredByokVendors,
+    hasResolvedVendor
+) {
+    return extensionsRegistered && configurationLoaded && configuredByokVendors.every(hasResolvedVendor);
+}
+let AgentHostSignedOutModelsNotificationContribution = class AgentHostSignedOutModelsNotificationContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostSignedOutModelsNotification";
+    }
+    constructor(
+        _chatInputNotificationService,
+        _defaultAccountService,
+        _languageModelsService,
+        _languageModelsConfigurationService,
+        _agentHostService,
+        _configurationService,
+        _chatEntitlementService,
+        _contextKeyService,
+        extensionService
+    ) {
+        super();
+        this._chatInputNotificationService = _chatInputNotificationService;
+        this._defaultAccountService = _defaultAccountService;
+        this._languageModelsService = _languageModelsService;
+        this._languageModelsConfigurationService = _languageModelsConfigurationService;
+        this._agentHostService = _agentHostService;
+        this._configurationService = _configurationService;
+        this._chatEntitlementService = _chatEntitlementService;
+        this._contextKeyService = _contextKeyService;
+        this._notificationShown = false;
+        this._accountResolved = false;
+        this._extensionsRegistered = false;
+        this._configurationLoaded = false;
+        this._gracePeriodElapsed = false;
+        this._gracePeriod = this._register(( new MutableDisposable()));
+        this._register(this._defaultAccountService.onDidChangeDefaultAccount(() => {
+            this._accountResolved = true;
+            this._update();
+        }));
+        this._defaultAccountService.getDefaultAccount().then(() => {
+            if (!this._store.isDisposed) {
+                this._accountResolved = true;
+                this._update();
+            }
+        });
+        this._register(Event.any(
+            this._chatEntitlementService.onDidChangeEntitlement,
+            this._languageModelsService.onDidChangeLanguageModels,
+            this._languageModelsService.onDidChangeModelVisibility,
+            this._languageModelsConfigurationService.onDidChangeLanguageModelGroups,
+            Event.filter(
+                this._contextKeyService.onDidChangeContext,
+                event => event.affectsSome(NOTIFICATION_CONTEXT_KEYS)
+            )
+        )(() => this._update()));
+        this._register(this._configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(AgentHostAllowSignedOutWhenUsableSettingId)) {
+                this._update();
+            }
+        }));
+        extensionService.whenInstalledExtensionsRegistered().then(() => {
+            if (!this._store.isDisposed) {
+                this._extensionsRegistered = true;
+                this._update();
+            }
+        });
+        this._languageModelsConfigurationService.whenReady.then(() => {
+            if (!this._store.isDisposed) {
+                this._configurationLoaded = true;
+                this._update();
+            }
+        });
+        const rootStateListeners = this._register(( new DisposableStore()));
+        const bindRootState = () => {
+            rootStateListeners.clear();
+            rootStateListeners.add(this._agentHostService.rootState.onDidChange(() => this._update()));
+            if (this._agentHostService.rootState.onDidError) {
+                rootStateListeners.add(this._agentHostService.rootState.onDidError(() => this._update()));
+            }
+            this._update();
+        };
+        bindRootState();
+        this._register(this._agentHostService.onAgentHostStart(bindRootState));
+    }
+    _update() {
+        const allowSignedOutWhenUsable = this._configurationService.getValue(AgentHostAllowSignedOutWhenUsableSettingId) === true;
+        const entitlement = this._chatEntitlementService.entitlement;
+        const entitlementResolved = entitlement !== ChatEntitlement.Unresolved;
+        const signedIn = this._defaultAccountService.currentDefaultAccount !== null || (entitlementResolved && entitlement !== ChatEntitlement.Unknown);
+        const configuredByokVendors = ( new Set(( this._languageModelsConfigurationService.getLanguageModelsProviderGroups().map(group => group.vendor)).filter(vendor => vendor !== COPILOT_VENDOR_ID)));
+        const localModelsLoaded = areLocalModelsLoaded(
+            this._extensionsRegistered,
+            this._configurationLoaded,
+            [...configuredByokVendors],
+            vendor => this._languageModelsService.hasResolvedVendor(vendor)
+        );
+        const rootState = this._agentHostService.rootState.value;
+        const hasCopilotHarness = !!rootState && !(rootState instanceof Error) && ( rootState.agents.some(agent => agent.provider === COPILOT_AGENT_HOST_PROVIDER_ID));
+        const hasModels = this._chatEntitlementService.clientByokEnabled && hasVisibleByokModelsTargetingSessionType(this._languageModelsService, SessionType.AgentHostCopilot);
+        const state = getSignedOutModelsNotificationState({
+            allowSignedOutWhenUsable,
+            accountResolved: this._accountResolved,
+            entitlementResolved,
+            signedIn,
+            hasCopilotHarness,
+            hasModels,
+            localModelsLoaded,
+            gracePeriodElapsed: this._gracePeriodElapsed,
+            setupDialogVisible: this._contextKeyService.getContextKeyValue(ChatSetupDialogVisibleContext.key) === true
+        });
+        this._updateGracePeriod(state);
+        this._setNotification(state === SignedOutModelsNotificationState.Visible);
+    }
+    _updateGracePeriod(state) {
+        if (state === SignedOutModelsNotificationState.Hidden) {
+            this._gracePeriod.clear();
+            this._gracePeriodElapsed = false;
+            return;
+        }
+        if (state === SignedOutModelsNotificationState.Visible) {
+            this._gracePeriod.clear();
+            return;
+        }
+        if (!this._gracePeriod.value) {
+            this._gracePeriod.value = disposableTimeout(() => {
+                this._gracePeriodElapsed = true;
+                this._update();
+            }, NOTIFICATION_GRACE_PERIOD_MS);
+        }
+    }
+    _setNotification(show) {
+        if (show === this._notificationShown) {
+            return;
+        }
+        this._notificationShown = show;
+        if (!show) {
+            this._chatInputNotificationService.deleteNotification(SIGNED_OUT_MODELS_NOTIFICATION_ID);
+            return;
+        }
+        this._chatInputNotificationService.setNotification(this._createNotification());
+    }
+    _createNotification() {
+        return {
+            id: SIGNED_OUT_MODELS_NOTIFICATION_ID,
+            severity: ChatInputNotificationSeverity.Info,
+            message: ( localize(6110, "Choose how you want to use Copilot.")),
+            description: ( localize(
+                6111,
+                "Sign in to use GitHub Copilot models, or add a model with your own API key."
+            )),
+            actions: [{
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6112, "Add Models")),
+                commandId: MANAGE_CHAT_COMMAND_ID,
+                keepOpen: true
+            }, {
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6113, "Sign In")),
+                commandId: SIGN_IN_COMMAND_ID,
+                keepOpen: true
+            }],
+            dismissible: false,
+            autoDismissOnMessage: false,
+            sessionTypes: [SessionType.AgentHostCopilot]
+        };
+    }
+};
+AgentHostSignedOutModelsNotificationContribution = ( __decorate([( __param(0, IChatInputNotificationService)), ( __param(1, IDefaultAccountService)), ( __param(2, ILanguageModelsService)), ( __param(3, ILanguageModelsConfigurationService)), ( __param(4, IAgentHostService)), ( __param(5, IConfigurationService)), ( __param(6, IChatEntitlementService)), ( __param(7, IContextKeyService)), ( __param(8, IExtensionService))], AgentHostSignedOutModelsNotificationContribution));
+
+export { AgentHostSignedOutModelsNotificationContribution, SignedOutModelsNotificationState, areLocalModelsLoaded, getSignedOutModelsNotificationState };

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

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+export declare function isUnstartedSubagent(part: IChatProgress): boolean;
+/** Appends subagent entries when their children start without reserving earlier positions in the stream. */
+export declare class AgentHostSubagentProgress extends Disposable {
+    private readonly sink;
+    private readonly pending;
+    constructor(sink: (parts: IChatProgress[]) => void);
+    publish(parts: IChatProgress[]): void;
+}

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

@@ -0,0 +1,50 @@
+
+import { Disposable, DisposableMap, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+function needsInput(part) {
+    const state = part.kind === "toolInvocation" ? part.state.get().type : undefined;
+    return state === IChatToolInvocation.StateKind.WaitingForConfirmation || state === IChatToolInvocation.StateKind.WaitingForAuthentication || state === IChatToolInvocation.StateKind.WaitingForPostApproval;
+}
+function isUnstartedSubagent(part) {
+    if ((part.kind !== "toolInvocation" && part.kind !== "toolInvocationSerialized") || part.subAgentInvocationId || part.toolSpecificData?.kind !== "subagent" || part.toolSpecificData.hasStarted !== false) {
+        return false;
+    }
+    return !needsInput(part);
+}
+class AgentHostSubagentProgress extends Disposable {
+    constructor(sink) {
+        super();
+        this.sink = sink;
+        this.pending = this._register(( new DisposableMap()));
+    }
+    publish(parts) {
+        const ready = parts.filter(part => {
+            if (!isUnstartedSubagent(part)) {
+                return true;
+            }
+            if (part.kind === "toolInvocation" && !( this.pending.has(part))) {
+                const tracker = ( new MutableDisposable());
+                this.pending.set(part, tracker);
+                let published = false;
+                tracker.value = autorun(reader => {
+                    part.state.read(reader);
+                    const hasStarted = part.toolSpecificData?.kind === "subagent" && part.toolSpecificData.hasStarted === true;
+                    if (!published && (hasStarted || needsInput(part))) {
+                        published = true;
+                        this.sink([part]);
+                        queueMicrotask(() => this.pending.deleteAndDispose(part));
+                    }
+                });
+            }
+            return false;
+        });
+        if (ready.length > 0) {
+            this.sink(ready);
+        }
+    }
+}
+
+export { AgentHostSubagentProgress, isUnstartedSubagent };

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

@@ -0,0 +1,42 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ITerminalProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
+import { ITerminalProfileResolverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
+import { IAgentHostTerminalService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+/**
+ * Registers local agent host terminal entries with
+ * {@link IAgentHostTerminalService} so they appear in the terminal dropdown,
+ * and forwards the terminal-related agent-host root-config keys (the resolved
+ * default shell and the custom-terminal-tool toggle) via the shared
+ * {@link AgentHostRootConfigForwarder} (also used by
+ * `AgentHostCopilotCliSettingsContribution`).
+ *
+ * Gated on Agent Host runtime availability.
+ */
+export declare class AgentHostTerminalContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _agentHostService;
+    private readonly _agentHostTerminalService;
+    private readonly _configurationService;
+    private readonly _terminalProfileService;
+    private readonly _terminalProfileResolverService;
+    private readonly _defaultAccountService;
+    private readonly _agentHostEnablementService;
+    static readonly ID = "workbench.contrib.agentHostTerminal";
+    private readonly _localEntry;
+    private readonly _conditionalListeners;
+    private readonly _forwarder;
+    constructor(_agentHostService: IAgentHostService, _agentHostTerminalService: IAgentHostTerminalService, _configurationService: IConfigurationService, _terminalProfileService: ITerminalProfileService, _terminalProfileResolverService: ITerminalProfileResolverService, _defaultAccountService: IDefaultAccountService, _agentHostEnablementService: IAgentHostEnablementService, environmentService: IWorkbenchEnvironmentService);
+    private _updateEnabled;
+    private _registerLocalEntry;
+    /**
+     * Resolve the agent host terminal profile (with `defaultProfile.<os>`
+     * fallback) so its host-managed shells inherit the user's preferred terminal
+     * binary. Returns `undefined` when no usable path can be resolved.
+     */
+    private _resolveDefaultShell;
+}

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

@@ -0,0 +1,132 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { OS } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+import { AgentHostConfigKey } from '../../../../../../platform/agentHost/common/agentHostCustomizationConfig.js';
+import { CopilotCliConfigKey, AgentHostCustomTerminalToolEnabledSettingId } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/copilotCliConfig';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { TerminalSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/terminal';
+import { ITerminalProfileService, ITerminalProfileResolverService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service';
+import { IAgentHostTerminalService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/browser/agentHostTerminalService.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { AgentHostRootConfigForwarder } from './agentHostRootConfigForwarder.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const AGENT_HOST_SHELL_DEPENDENT_SETTINGS = [
+    TerminalSettingId.AgentHostProfileLinux,
+    TerminalSettingId.AgentHostProfileMacOs,
+    TerminalSettingId.AgentHostProfileWindows,
+    TerminalSettingId.DefaultProfileLinux,
+    TerminalSettingId.DefaultProfileMacOs,
+    TerminalSettingId.DefaultProfileWindows,
+    TerminalSettingId.ProfilesLinux,
+    TerminalSettingId.ProfilesMacOs,
+    TerminalSettingId.ProfilesWindows
+];
+let AgentHostTerminalContribution = class AgentHostTerminalContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostTerminal";
+    }
+    constructor(
+        _agentHostService,
+        _agentHostTerminalService,
+        _configurationService,
+        _terminalProfileService,
+        _terminalProfileResolverService,
+        _defaultAccountService,
+        _agentHostEnablementService,
+        environmentService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._agentHostTerminalService = _agentHostTerminalService;
+        this._configurationService = _configurationService;
+        this._terminalProfileService = _terminalProfileService;
+        this._terminalProfileResolverService = _terminalProfileResolverService;
+        this._defaultAccountService = _defaultAccountService;
+        this._agentHostEnablementService = _agentHostEnablementService;
+        this._localEntry = this._register(( new MutableDisposable()));
+        this._conditionalListeners = this._register(( new MutableDisposable()));
+        const defaultShellKey = {
+            key: AgentHostConfigKey.DefaultShell,
+            computeValue: () => this._resolveDefaultShell(),
+            registerTriggers: (store, push) => {
+                store.add(this._configurationService.onDidChangeConfiguration(e => {
+                    if (( AGENT_HOST_SHELL_DEPENDENT_SETTINGS.some(s => e.affectsConfiguration(s)))) {
+                        push();
+                    }
+                }));
+                store.add(this._terminalProfileService.onDidChangeAvailableProfiles(() => push()));
+            }
+        };
+        const keys = [...(environmentService.remoteAuthority ? [] : [defaultShellKey]), {
+            key: CopilotCliConfigKey.EnableCustomTerminalTool,
+            computeValue: () => this._configurationService.getValue(AgentHostCustomTerminalToolEnabledSettingId) === true,
+            registerTriggers: (store, push) => {
+                store.add(this._configurationService.onDidChangeConfiguration(e => {
+                    if (e.affectsConfiguration(AgentHostCustomTerminalToolEnabledSettingId)) {
+                        push();
+                    }
+                }));
+            }
+        }, {
+            key: AgentHostConfigKey.GithubEnterpriseUri,
+            computeValue: () => {
+                const provider = this._defaultAccountService.getDefaultAccountAuthenticationProvider();
+                return provider.enterprise ? this._defaultAccountService.resolveGitHubUrl("").replace(/\/+$/, "") : "";
+            },
+            registerTriggers: (store, push) => {
+                store.add(this._defaultAccountService.onDidChangeDefaultAccount(() => push()));
+            }
+        }];
+        this._forwarder = this._register(( new AgentHostRootConfigForwarder(keys, this._agentHostService)));
+        this._register(autorun(
+            reader => this._updateEnabled(this._agentHostEnablementService.enabled.read(reader))
+        ));
+    }
+    _updateEnabled(enabled) {
+        if (enabled) {
+            if (!this._conditionalListeners.value) {
+                const store = ( new DisposableStore());
+                store.add(this._agentHostService.onAgentHostStart(() => this._registerLocalEntry()));
+                this._conditionalListeners.value = store;
+                this._registerLocalEntry();
+                this._forwarder.start();
+            }
+        } else {
+            this._conditionalListeners.value = undefined;
+            this._localEntry.value = undefined;
+            this._forwarder.stop();
+        }
+    }
+    _registerLocalEntry() {
+        if (!this._localEntry.value) {
+            this._localEntry.value = this._agentHostTerminalService.registerEntry({
+                name: ( localize(6114, "Local")),
+                address: "__local__",
+                getConnection: () => this._agentHostService
+            });
+        }
+    }
+    async _resolveDefaultShell() {
+        let profile;
+        try {
+            profile = await this._terminalProfileResolverService.getDefaultProfile({
+                remoteAuthority: undefined,
+                os: OS,
+                allowAgentHostShell: true
+            });
+        } catch {
+            return undefined;
+        }
+        return profile.path || undefined;
+    }
+};
+AgentHostTerminalContribution = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, IAgentHostTerminalService)), ( __param(2, IConfigurationService)), ( __param(3, ITerminalProfileService)), ( __param(4, ITerminalProfileResolverService)), ( __param(5, IDefaultAccountService)), ( __param(6, IAgentHostEnablementService)), ( __param(7, IWorkbenchEnvironmentService))], AgentHostTerminalContribution));
+
+export { AgentHostTerminalContribution };

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

@@ -7,6 +7,10 @@ import { IAgentHostToolSetEnablementService } from "@codingame/monaco-vscode-api
  * only target for the Chat Customizations → Tools section today.
  */
 export declare const AGENT_HOST_COPILOT_CLI_SESSION_TYPE = "agent-host-copilotcli";
+/**
+ * Whether a session type runs the Copilot CLI harness, locally or on a remote agent host.
+ */
+export declare function isCopilotCliSessionType(sessionType: string): boolean;
 /**
  * Tool / tool-set enablement state. Both maps are keyed by id and store only deviations from the
  * default ("enabled"). A tool's effective state resolves child → parent → default:

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

@@ -2,6 +2,7 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { parseRemoteAgentHostHarness } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSessionType';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
 import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
 import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
@@ -10,6 +11,9 @@ import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/com
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
 
 const AGENT_HOST_COPILOT_CLI_SESSION_TYPE = "agent-host-copilotcli";
+function isCopilotCliSessionType(sessionType) {
+    return sessionType === AGENT_HOST_COPILOT_CLI_SESSION_TYPE || parseRemoteAgentHostHarness(sessionType) === "copilotcli";
+}
 function isToolEnabledInSet(state, toolSetId, toolId) {
     return state.tools.get(toolId) ?? state.toolSets.get(toolSetId) ?? true;
 }
@@ -160,4 +164,4 @@ let AgentHostToolSetEnablementService = class AgentHostToolSetEnablementService
 };
 AgentHostToolSetEnablementService = ( __decorate([( __param(0, IStorageService))], AgentHostToolSetEnablementService));
 
-export { AGENT_HOST_COPILOT_CLI_SESSION_TYPE, AgentHostToolSetEnablementService, countEnabledCustomizationTools, getToolSetTriState, isToolEnabledInSet };
+export { AGENT_HOST_COPILOT_CLI_SESSION_TYPE, AgentHostToolSetEnablementService, countEnabledCustomizationTools, getToolSetTriState, isCopilotCliSessionType, isToolEnabledInSet };

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

@@ -1,14 +1,15 @@
 
 
 function toolDataToDefinition(tool) {
-    return {
+    const definition = {
         name: tool.toolReferenceName ?? tool.id,
         title: tool.displayName,
         description: tool.modelDescription,
-        inputSchema: tool.inputSchema?.type === 'object'
-            ? tool.inputSchema
-            : undefined,
     };
+    if (tool.inputSchema?.type === 'object') {
+        definition.inputSchema = tool.inputSchema;
+    }
+    return definition;
 }
 
 export { toolDataToDefinition };

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

@@ -4,10 +4,14 @@ import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import type { ResolveSessionConfigResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
 import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
 import { IChatService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service";
 import { IAgentHostNewSessionFolderService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService.service";
+import { IAgentHostActiveClientService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostActiveClientService.service";
+import { IAgentHostImportConversationStore } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostImportConversationStore.service";
 import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
 export declare class AgentHostUntitledProvisionalSessionService extends Disposable implements IAgentHostUntitledProvisionalSessionService {
     private readonly _agentHostService;
@@ -15,20 +19,80 @@ export declare class AgentHostUntitledProvisionalSessionService extends Disposab
     private readonly _configurationService;
     private readonly _environmentService;
     private readonly _newSessionFolderService;
+    private readonly _workspaceContextService;
     private readonly _workspaceTrustManagementService;
+    private readonly _importConversationStore;
+    private readonly _activeClientService;
+    private readonly _uriIdentityService;
     readonly _serviceBrand: undefined;
     private readonly _entries;
     private readonly _pending;
     private readonly _resolvedConfigs;
     private readonly _resolvedConfigRequestSeq;
+    private readonly _sessionCreationMetadata;
+    private readonly _pendingBackendDisposals;
     private readonly _rebound;
     private readonly _sequencer;
     private readonly _onDidChange;
     readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<URI>;
-    constructor(_agentHostService: IAgentHostService, _logService: ILogService, chatService: IChatService, _configurationService: IConfigurationService, _environmentService: IWorkbenchEnvironmentService, _newSessionFolderService: IAgentHostNewSessionFolderService, _workspaceTrustManagementService: IWorkspaceTrustManagementService);
+    constructor(_agentHostService: IAgentHostService, _logService: ILogService, chatService: IChatService, _configurationService: IConfigurationService, _environmentService: IWorkbenchEnvironmentService, _newSessionFolderService: IAgentHostNewSessionFolderService, _workspaceContextService: IWorkspaceContextService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _importConversationStore: IAgentHostImportConversationStore, _activeClientService: IAgentHostActiveClientService, _uriIdentityService: IUriIdentityService);
     get(sessionResource: URI): URI | undefined;
+    getProvisionalWorkingDirectories(sessionResource: URI): readonly URI[] | undefined;
+    private _computeWorkingDirectories;
+    private _computeEntryWorkingDirectories;
+    private _updateActiveClientScope;
+    /**
+     * Re-run {@link _reconcileWorkspaceRootSet} for every open not-yet-started
+     * (untitled) draft. Started/rebound sessions are skipped: their working
+     * directories are the agent's fixed process root once the session has
+     * started, so recreating the backend would tear down the live conversation.
+     */
+    private _reconcileUntitledDraftsForRootSet;
+    /**
+     * Escalate a draft to the workspace root set when its desired directory set
+     * has grown beyond its primary, refresh its active-client scope, and recreate
+     * its backend generation when the published one no longer matches the desired
+     * set. Shared by the workspace-folder and root-state (capability) change
+     * reactions. Escalation is one-way (never back to single-root); a later
+     * capability-off or folder shrink is still honored because
+     * {@link _computeEntryWorkingDirectories} recomputes the desired set live.
+     */
+    private _reconcileWorkspaceRootSet;
+    getInitialSessionMetadata(sessionResource?: URI): Record<string, unknown> | undefined;
+    setSessionCreationMetadata(sessionResource: URI, metadata: Record<string, unknown>): void;
+    clearSessionCreationMetadata(sessionResource: URI): void;
+    getInitialSessionConfig(): Record<string, unknown> | undefined;
     waitForPending(sessionResource: URI): Promise<URI | undefined>;
     getOrCreate(sessionResource: URI, provider: string, workingDirectory: URI | undefined): Promise<URI | undefined>;
+    private _ensureEntry;
+    private _createEntry;
+    private _publishActiveClient;
+    /**
+     * Serializes lifecycle work for one logical draft and records its latest tail
+     * so external callers can wait for a stable current generation.
+     */
+    private _queue;
+    private _generationMatchingDesiredState;
+    private _sameUri;
+    /**
+     * Whether a draft's primary working directory was just removed from the
+     * workspace. Only folders present in `e.removed` and no longer among the
+     * current workspace folders qualify, so a standalone folder outside the
+     * workspace (never a member) is preserved, and a folder removed and re-added
+     * in the same event is not treated as gone.
+     */
+    private _primaryWasRemoved;
+    /** Provider-agnostic: only an agent advertising `immutablePrimary` pins index 0. */
+    private _sameWorkingDirectories;
+    private _newProvisionalUri;
+    /**
+     * Ensures the published generation realizes the draft's current folder and config.
+     * It keeps the previous generation hidden until a valid candidate can replace it, discarding stale candidates along the way.
+     */
+    private _reconcileGeneration;
+    private _retireGeneration;
+    private _disposeBackend;
+    private _retryPendingBackendDisposals;
     /**
      * Whether the folder the provisional agent would run in is trusted. When a
      * working directory is known (it may be a standalone folder outside the
@@ -36,14 +100,19 @@ export declare class AgentHostUntitledProvisionalSessionService extends Disposab
      * otherwise fall back to whole-workspace trust.
      */
     private _isTargetFolderTrusted;
-    tryRebind(oldSessionResource: URI, newSessionResource: URI, provider: string, workingDirectory: URI | undefined): Promise<URI | undefined>;
+    tryRebind(oldSessionResource: URI, newSessionResource: URI, provider: string): Promise<URI | undefined>;
+    private _restoreImportedConversation;
     /**
      * Recreate the provisional backend session for `sessionResource` at a new
      * working directory, preserving the user's config choices. A created
      * session's cwd is immutable, so the only way to honor a folder change is to
-     * dispose and recreate. Reuses the same deterministic backend URI so the
-     * chat-resource-to-backend mapping stays stable. Sequencer-queued so it
-     * settles in order with config-chip changes for the same resource.
+     * dispose and recreate. The replacement uses a fresh backend URI so existing
+     * subscribers acquire an authoritative snapshot for the new incarnation.
+     *
+     * `newWorkingDirectory` may be `undefined` when the workspace has no folders
+     * left (e.g. the draft's only/primary folder was removed); the provisional is
+     * then recreated with no working directory, letting the host choose — the same
+     * as a draft first created in an empty workspace.
      */
     private _changeWorkingDirectory;
     disposeSession(sessionResource: URI): Promise<void>;