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

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

@@ -0,0 +1,90 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentConnection } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { IAgentSubscription } from "../../../../../../platform/agentHost/common/state/agentSubscription.js";
+import { SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+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 { IAgentHostSessionWorkingDirectorySynchronizer } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectorySynchronizer.service";
+/** A live session the synchronizer should keep aligned with the workspace. */
+export interface IAgentHostWorkingDirectoryRegistration {
+    readonly session: URI;
+    /** Agent-host provider id, used to read the provider's advertised capabilities. */
+    readonly provider: string;
+    readonly connection: IAgentConnection;
+    /** Authoritative session state, including its current working directories. */
+    readonly subscription: IAgentSubscription<SessionState>;
+}
+export declare class AgentHostSessionWorkingDirectorySynchronizer extends Disposable implements IAgentHostSessionWorkingDirectorySynchronizer {
+    private readonly _workspaceContextService;
+    private readonly _workspaceTrustManagementService;
+    private readonly _environmentService;
+    private readonly _uriIdentityService;
+    private readonly _logService;
+    readonly _serviceBrand: undefined;
+    /** Sessions currently being followed, keyed by session URI. */
+    private readonly _registrations;
+    /** Serializes reconciliation per session so concurrent runs cannot interleave dispatches. */
+    private readonly _reconciler;
+    constructor(_workspaceContextService: IWorkspaceContextService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _environmentService: IWorkbenchEnvironmentService, _uriIdentityService: IUriIdentityService, _logService: ILogService);
+    /**
+     * Starts following a session until the returned disposable is disposed.
+     *
+     * Builds the mutable bookkeeping entry for the session and wires the four
+     * triggers that can invalidate its working directories, each of which
+     * schedules a reconcile:
+     *
+     * - **session state changed** — its directory set moved, so re-diff it.
+     *   Skipped while this synchronizer is dispatching its own actions, and
+     *   while the subscription rolls back a host-rejected action, since either
+     *   would immediately redispatch what just happened.
+     * - **protocol handshake settled** — the working-directory actions only
+     *   exist from AHP 0.7, so a session registered before the negotiated
+     *   version is known must be re-evaluated once it arrives.
+     *
+     * Workspace-folder and trust changes are the other two triggers; they affect
+     * every session and are subscribed once in the constructor.
+     *
+     * The returned disposable removes the entry, so a session registered twice
+     * (re-subscribe after a state error) replaces the previous registration.
+     */
+    register(registration: IAgentHostWorkingDirectoryRegistration): IDisposable;
+    /** Reconciles every followed session, e.g. after a workspace-wide change. */
+    private _scheduleAll;
+    /**
+     * Compares the session's current working directories against the folders it
+     * should have for today's workspace and dispatches the difference. Runs are
+     * serialized per session so two callers cannot interleave their dispatches.
+     *
+     * See {@link IAgentHostSessionWorkingDirectorySynchronizer.reconcile}.
+     */
+    reconcile(session: URI, token: CancellationToken): Promise<void>;
+    /**
+     * Runs an automatic reconcile, coalescing bursts: triggers arriving while a
+     * run is in flight collapse into a single follow-up pass, so a rapid series
+     * of folder changes converges on the final workspace state. Failures are
+     * logged rather than surfaced — these runs have no caller to reject to.
+     */
+    private _scheduleReconcile;
+    private _reconcile;
+    /**
+     * Whether this session may follow the workspace. Requires a host that speaks
+     * the working-directory actions, a provider that supports multiple roots
+     * with a pinned primary, and a plain multi-root session still bound to the
+     * open workspace file. Excludes workspace-less, worktree-isolated, and
+     * multi-chat sessions, whose directories are not the workspace's to manage.
+     *
+     * Deliberately not a reconcile trigger: this reads `connection.rootState`,
+     * but a session registered before provider capabilities hydrate is not
+     * re-reconciled when they land. The pre-send `reconcile` re-evaluates
+     * eligibility before every prompt, so an agent never runs with stale roots —
+     * only the session's own state lags until the next trigger.
+     */
+    private _isEligible;
+    /** Returns an error for the first untrusted folder, or `undefined` if all are trusted. */
+    private _getAdditionTrustError;
+}

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

@@ -0,0 +1,207 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { SequencerByKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
+import { compareProtocolVersions, ACTION_INTRODUCED_IN } from '../../../../../../platform/agentHost/common/state/protocol/version/registry.js';
+import { readSessionWorkspaceless, readSessionMultiRootMetadata } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+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 { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { computeDesiredWorkingDirectories, hasImmutablePrimaryWorkingDirectory } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostNewSessionFolderService';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { SessionLifecycle } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+
+let AgentHostSessionWorkingDirectorySynchronizer = class AgentHostSessionWorkingDirectorySynchronizer extends Disposable {
+    constructor(
+        _workspaceContextService,
+        _workspaceTrustManagementService,
+        _environmentService,
+        _uriIdentityService,
+        _logService
+    ) {
+        super();
+        this._workspaceContextService = _workspaceContextService;
+        this._workspaceTrustManagementService = _workspaceTrustManagementService;
+        this._environmentService = _environmentService;
+        this._uriIdentityService = _uriIdentityService;
+        this._logService = _logService;
+        this._registrations = ( new Map());
+        this._reconciler = ( new SequencerByKey());
+        this._register(
+            this._workspaceContextService.onDidChangeWorkspaceFolders(() => this._scheduleAll("workspace folder change"))
+        );
+        this._register(
+            this._workspaceTrustManagementService.onDidChangeTrust(() => this._scheduleAll("workspace trust change"))
+        );
+        this._register(
+            this._workspaceTrustManagementService.onDidChangeTrustedFolders(() => this._scheduleAll("trusted folders change"))
+        );
+    }
+    register(registration) {
+        if (this._environmentService.isSessionsWindow) {
+            return Disposable.None;
+        }
+        const key = ( registration.session.toString());
+        this._registrations.get(key)?.store.dispose();
+        const store = ( new DisposableStore());
+        const entry = {
+            ...registration,
+            store,
+            applyingRejectedAction: false,
+            automaticReconcileAgain: false,
+            automaticReconcileScheduled: false,
+            dispatching: false
+        };
+        store.add(registration.subscription.onWillApplyAction(envelope => {
+            entry.applyingRejectedAction = !!envelope.rejectionReason;
+        }));
+        store.add(registration.subscription.onDidApplyAction(() => {
+            entry.applyingRejectedAction = false;
+        }));
+        store.add(registration.subscription.onDidChange(() => {
+            if (!entry.applyingRejectedAction && !entry.dispatching) {
+                this._scheduleReconcile(entry, "subscription change");
+            }
+        }));
+        store.add(autorun(reader => {
+            registration.connection.initializeResult.read(reader);
+            this._scheduleReconcile(entry, "protocol initialization");
+        }));
+        store.add(toDisposable(() => {
+            if (this._registrations.get(key) === entry) {
+                this._registrations.delete(key);
+            }
+        }));
+        this._registrations.set(key, entry);
+        return store;
+    }
+    _scheduleAll(reason) {
+        for (const registration of ( this._registrations.values())) {
+            this._scheduleReconcile(registration, reason);
+        }
+    }
+    reconcile(session, token) {
+        return this._reconciler.queue(( session.toString()), () => this._reconcile(session, token));
+    }
+    _scheduleReconcile(registration, reason) {
+        if (registration.automaticReconcileScheduled) {
+            registration.automaticReconcileAgain = true;
+            return;
+        }
+        registration.automaticReconcileScheduled = true;
+        const run = () => {
+            registration.automaticReconcileAgain = false;
+            void this.reconcile(registration.session, CancellationToken.None).then(() => finish(), error => {
+                this._logService.warn(`[AgentHostWorkingDirectories] Failed to reconcile ${reason}`, error);
+                finish();
+            });
+        };
+        const finish = () => {
+            if (this._registrations.get(( registration.session.toString())) !== registration) {
+                return;
+            }
+            if (registration.automaticReconcileAgain) {
+                run();
+            } else {
+                registration.automaticReconcileScheduled = false;
+            }
+        };
+        run();
+    }
+    async _reconcile(session, token) {
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        const registration = this._registrations.get(( session.toString()));
+        const value = registration?.subscription.value;
+        const state = value && !(value instanceof Error) ? value : undefined;
+        if (!registration || !state || !this._isEligible(registration, state)) {
+            return;
+        }
+        const current = state.workingDirectories?.map(directory => ( URI.parse(directory))) ?? [];
+        if (current.length === 0) {
+            return;
+        }
+        const desired = computeDesiredWorkingDirectories(current[0], current, ( this._workspaceContextService.getWorkspace().folders.map(folder => folder.uri)), this._uriIdentityService.extUri);
+        const additions = desired.slice(1).filter(directory => !( current.some(existing => this._uriIdentityService.extUri.isEqual(existing, directory))));
+        const removals = current.slice(1).filter(directory => !( desired.some(expected => this._uriIdentityService.extUri.isEqual(expected, directory))));
+        if (additions.length === 0 && removals.length === 0) {
+            return;
+        }
+        const trustError = await this._getAdditionTrustError(additions, token);
+        if (token.isCancellationRequested) {
+            throw ( new CancellationError());
+        }
+        if (this._registrations.get(( session.toString())) !== registration) {
+            return;
+        }
+        registration.dispatching = true;
+        try {
+            if (!trustError) {
+                for (const directory of additions) {
+                    registration.connection.dispatch(( session.toString()), {
+                        type: ActionType.SessionWorkingDirectorySet,
+                        directory: ( directory.toString())
+                    });
+                }
+            }
+            for (const directory of removals) {
+                registration.connection.dispatch(( session.toString()), {
+                    type: ActionType.SessionWorkingDirectoryRemoved,
+                    directory: ( directory.toString())
+                });
+            }
+        } finally {
+            registration.dispatching = false;
+        }
+        if (trustError) {
+            throw trustError;
+        }
+    }
+    _isEligible(registration, state) {
+        const protocolVersion = registration.connection.initializeResult.get()?.protocolVersion;
+        if (state.lifecycle !== SessionLifecycle.Ready || !protocolVersion || compareProtocolVersions(
+            protocolVersion,
+            ACTION_INTRODUCED_IN[ActionType.SessionWorkingDirectorySet]
+        ) < 0 || readSessionWorkspaceless(state._meta) || state.config?.values[SessionConfigKey.Isolation] === "worktree" || state.chats.length !== 1 || state.defaultChat !== state.chats[0].resource || !state.workingDirectories?.length) {
+            return false;
+        }
+        const workspace = this._workspaceContextService.getWorkspace();
+        const multiRoot = readSessionMultiRootMetadata(state._meta);
+        if (!multiRoot || !URI.isUri(workspace.configuration) || !this._uriIdentityService.extUri.isEqual(( URI.parse(multiRoot.workspaceFile)), workspace.configuration)) {
+            return false;
+        }
+        return hasImmutablePrimaryWorkingDirectory(registration.connection.rootState.value, registration.provider);
+    }
+    async _getAdditionTrustError(additions, token) {
+        for (const directory of additions) {
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            const {
+                trusted
+            } = await this._workspaceTrustManagementService.getUriTrustInfo(directory);
+            if (!trusted) {
+                return (new Error(
+                    localize(6012, "The workspace folder '{0}' is not trusted.", directory.path)
+                ));
+            }
+        }
+        return undefined;
+    }
+};
+AgentHostSessionWorkingDirectorySynchronizer = ( __decorate([( __param(0, IWorkspaceContextService)), ( __param(1, IWorkspaceTrustManagementService)), ( __param(2, IWorkbenchEnvironmentService)), ( __param(3, IUriIdentityService)), ( __param(4, ILogService))], AgentHostSessionWorkingDirectorySynchronizer));
+
+export { AgentHostSessionWorkingDirectorySynchronizer };

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

@@ -0,0 +1,31 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IAgentSubscription } from "../../../../../../platform/agentHost/common/state/agentSubscription.js";
+import { SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IEnvironmentVariableService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/environmentVariable.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IAgentHostShellInitSynchronizer } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostShellInitSynchronizer.service";
+/**
+ * Publishes one combined profile-loading and Python-activation script for each
+ * session. Script text travels in session config; the agent host owns the file.
+ */
+export declare class AgentHostShellInitSynchronizer extends Disposable implements IAgentHostShellInitSynchronizer {
+    private readonly _agentHostService;
+    private readonly _configurationService;
+    private readonly _environmentVariableService;
+    private readonly _workspaceContextService;
+    private readonly _environmentService;
+    readonly _serviceBrand: undefined;
+    private readonly _registrations;
+    constructor(_agentHostService: IAgentHostService, _configurationService: IConfigurationService, _environmentVariableService: IEnvironmentVariableService, _workspaceContextService: IWorkspaceContextService, _environmentService: IWorkbenchEnvironmentService);
+    register(session: URI, subscription: IAgentSubscription<SessionState>): IDisposable;
+    reconcile(session: URI): void;
+    private _scheduleAll;
+    private _supportsShellInit;
+    private _publish;
+    private _readPythonActivation;
+    private _resolveFolder;
+}

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

@@ -0,0 +1,140 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { AgentHostShellToolInitScriptEnabledSettingId } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/copilotCliConfig';
+import { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { createShellInitScript } from '../../../../../../platform/agentHost/common/shellInitScript.js';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IEnvironmentVariableService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/environmentVariable.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const PYTHON_ENV_EXTENSION_ID = "ms-python.vscode-python-envs";
+const PYTHON_ACTIVATION_VARIABLES = isWindows ? ["VSCODE_PYTHON_PWSH_ACTIVATE"] : ["VSCODE_PYTHON_BASH_ACTIVATE"];
+const TOOL_SHELL = isWindows ? "powershell" : "bash";
+let AgentHostShellInitSynchronizer = class AgentHostShellInitSynchronizer extends Disposable {
+    constructor(
+        _agentHostService,
+        _configurationService,
+        _environmentVariableService,
+        _workspaceContextService,
+        _environmentService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._configurationService = _configurationService;
+        this._environmentVariableService = _environmentVariableService;
+        this._workspaceContextService = _workspaceContextService;
+        this._environmentService = _environmentService;
+        this._registrations = ( new Map());
+        this._register(
+            this._environmentVariableService.onDidChangeCollections(() => this._scheduleAll())
+        );
+        this._register(
+            this._workspaceContextService.onDidChangeWorkspaceFolders(() => this._scheduleAll())
+        );
+        this._register(this._configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(AgentHostShellToolInitScriptEnabledSettingId)) {
+                this._scheduleAll();
+            }
+        }));
+    }
+    register(session, subscription) {
+        if (this._environmentService.remoteAuthority) {
+            return Disposable.None;
+        }
+        const key = ( session.toString());
+        this._registrations.get(key)?.store.dispose();
+        const store = ( new DisposableStore());
+        const scheduler = store.add(( new RunOnceScheduler(() => this._publish(key), 0)));
+        const registration = {
+            subscription,
+            store,
+            scheduler,
+            schemaReady: this._supportsShellInit(subscription.value)
+        };
+        this._registrations.set(key, registration);
+        store.add(subscription.onDidChange(state => {
+            if (!registration.schemaReady && this._supportsShellInit(state)) {
+                registration.schemaReady = true;
+                scheduler.schedule();
+            }
+        }));
+        store.add(toDisposable(() => {
+            if (this._registrations.get(key) === registration) {
+                this._registrations.delete(key);
+            }
+        }));
+        scheduler.schedule();
+        return store;
+    }
+    reconcile(session) {
+        const key = ( session.toString());
+        this._registrations.get(key)?.scheduler.cancel();
+        this._publish(key);
+    }
+    _scheduleAll() {
+        for (const registration of ( this._registrations.values())) {
+            registration.scheduler.schedule();
+        }
+    }
+    _supportsShellInit(state) {
+        return !!state && !(state instanceof Error) && !!state.config?.schema.properties[SessionConfigKey.ShellInitScripts];
+    }
+    _publish(key) {
+        const state = this._registrations.get(key)?.subscription.value;
+        if (!state || state instanceof Error || !state.config?.schema.properties[SessionConfigKey.ShellInitScripts]) {
+            return;
+        }
+        const enabled = this._configurationService.getValue(AgentHostShellToolInitScriptEnabledSettingId) === true;
+        const folder = enabled && !this._environmentService.isSessionsWindow ? this._resolveFolder(state) : undefined;
+        if (enabled && !folder) {
+            return;
+        }
+        const desired = enabled && folder ? [createShellInitScript(TOOL_SHELL, this._readPythonActivation(folder))] : [];
+        const current = state.config.values[SessionConfigKey.ShellInitScripts];
+        if (structuralEquals(current, desired) || (!desired.length && current === undefined)) {
+            return;
+        }
+        this._agentHostService.dispatch(key, {
+            type: ActionType.SessionConfigChanged,
+            config: {
+                [SessionConfigKey.ShellInitScripts]: desired
+            }
+        });
+    }
+    _readPythonActivation(folder) {
+        const variables = this._environmentVariableService.mergedCollection.getVariableMap({
+            workspaceFolder: folder
+        });
+        for (const name of PYTHON_ACTIVATION_VARIABLES) {
+            const value = variables.get(name)?.find(mutator => mutator.extensionIdentifier === PYTHON_ENV_EXTENSION_ID)?.value;
+            if (value?.trim()) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    _resolveFolder(state) {
+        for (const value of [state.project?.uri, ...(state.workingDirectories ?? [])]) {
+            if (value) {
+                const folder = this._workspaceContextService.getWorkspaceFolder(( URI.parse(value)));
+                if (folder) {
+                    return folder;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+AgentHostShellInitSynchronizer = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, IConfigurationService)), ( __param(2, IEnvironmentVariableService)), ( __param(3, IWorkspaceContextService)), ( __param(4, IWorkbenchEnvironmentService))], AgentHostShellInitSynchronizer));
+
+export { AgentHostShellInitSynchronizer };

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>;