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

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

@@ -0,0 +1,345 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { extUriBiasedIgnorePathCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+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 { readSessionMatchesByProjectRoot, readSessionMultiRootMetadata } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { AgentSession } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+
+let AgentHostSessionListStore = class AgentHostSessionListStore extends Disposable {
+    constructor(_connection, _workspaceContextService, _logService) {
+        super();
+        this._connection = _connection;
+        this._workspaceContextService = _workspaceContextService;
+        this._logService = _logService;
+        this._onDidChangeSessions = this._register(( new Emitter()));
+        this.onDidChangeSessions = this._onDidChangeSessions.event;
+        this._entries = ( new Map());
+        this._pendingNewSessions = ( new Set());
+        this._cacheValid = false;
+        this._mutationGeneration = 0;
+        this._reportedNonLocalProjects = ( new Set());
+        this._register(this._connection.onDidNotification(n => this._onNotification(n)));
+        this._register(this._workspaceContextService.onDidChangeWorkspaceFolders(() => {
+            this._cacheValid = false;
+            this._filterEntriesToWorkspace();
+            void this.refresh(CancellationToken.None);
+        }));
+    }
+    getSessions(provider) {
+        return [...( this._entries.values())].filter(entry => entry.provider === provider);
+    }
+    addPendingNewSession(provider, rawId) {
+        this._pendingNewSessions.add(this._key(provider, rawId));
+    }
+    isPendingNewSession(provider, rawId) {
+        return ( this._pendingNewSessions.has(this._key(provider, rawId)));
+    }
+    clearPendingNewSession(provider, rawId) {
+        this._pendingNewSessions.delete(this._key(provider, rawId));
+    }
+    resetCache() {
+        this._cacheValid = false;
+        this._mutationGeneration++;
+    }
+    async disposeSession(provider, rawId) {
+        await this._connection.disposeSession(AgentSession.uri(provider, rawId));
+    }
+    setSessionArchived(provider, rawId, archived) {
+        this._setSessionFlag(provider, rawId, SessionStatus.IsArchived, archived, {
+            type: ActionType.SessionIsArchivedChanged,
+            isArchived: archived
+        });
+    }
+    setSessionRead(provider, rawId, isRead) {
+        this._setSessionFlag(provider, rawId, SessionStatus.IsRead, isRead, {
+            type: ActionType.SessionIsReadChanged,
+            isRead
+        });
+    }
+    _setSessionFlag(provider, rawId, flag, set, action) {
+        const session = AgentSession.uri(provider, rawId);
+        const key = this._key(provider, rawId);
+        const cached = this._entries.get(key);
+        let updated;
+        if (cached) {
+            const status = set ? cached.summary.status | flag : cached.summary.status & ~flag;
+            if (status === cached.summary.status && cached.statusKnown) {
+                return;
+            }
+            updated = {
+                ...cached,
+                statusKnown: true,
+                summary: {
+                    ...cached.summary,
+                    status
+                }
+            };
+        }
+        this._mutationGeneration++;
+        this._connection.dispatch(( session.toString()), action);
+        if (updated) {
+            this._entries.set(key, updated);
+            this._onDidChangeSessions.fire({
+                addedOrUpdated: [updated]
+            });
+        }
+    }
+    removeSession(provider, rawId) {
+        this._mutationGeneration++;
+        this._removeSessionFromList(provider, rawId);
+    }
+    _removeSessionFromList(provider, rawId) {
+        const key = this._key(provider, rawId);
+        this._pendingNewSessions.delete(key);
+        const entry = this._entries.get(key);
+        if (!entry) {
+            return;
+        }
+        this._entries.delete(key);
+        this._onDidChangeSessions.fire({
+            removed: [this._toRemoval(entry)]
+        });
+    }
+    async refresh(token) {
+        if (this._refreshInFlight) {
+            return this._refreshInFlight;
+        }
+        this._refreshInFlight = this._doRefresh(token);
+        try {
+            await this._refreshInFlight;
+        } finally {
+            this._refreshInFlight = undefined;
+        }
+    }
+    async _doRefresh(token) {
+        if (this._cacheValid) {
+            return;
+        }
+        const previousEntries = [...( this._entries.values())];
+        const startGeneration = this._mutationGeneration;
+        let sessions;
+        try {
+            sessions = await this._connection.listSessions();
+        } catch {
+            return;
+        }
+        if (startGeneration !== this._mutationGeneration) {
+            return this._doRefresh(token);
+        }
+        const nextEntries = [];
+        for (const session of sessions) {
+            const entry = this._makeEntryFromMetadata(session);
+            if (entry) {
+                if (this._isSessionInWorkspace(entry)) {
+                    nextEntries.push(entry);
+                }
+            }
+        }
+        this._entries.clear();
+        for (const entry of nextEntries) {
+            const key = this._key(entry.provider, entry.rawId);
+            this._entries.set(key, entry);
+            this._pendingNewSessions.delete(key);
+        }
+        this._cacheValid = true;
+        const nextKeys = ( new Set(( nextEntries.map(entry => this._key(entry.provider, entry.rawId)))));
+        const removed = ( previousEntries.filter(entry => !( nextKeys.has(this._key(entry.provider, entry.rawId)))).map(entry => this._toRemoval(entry)));
+        if (nextEntries.length === 0 && removed.length === 0) {
+            return;
+        }
+        this._onDidChangeSessions.fire({
+            ...(nextEntries.length > 0 ? {
+                addedOrUpdated: nextEntries
+            } : undefined),
+            ...(removed.length > 0 ? {
+                removed
+            } : undefined)
+        });
+    }
+    _onNotification(notification) {
+        if (notification.type === "root/sessionAdded") {
+            const entry = this._makeEntryFromSummary(notification.summary);
+            if (!entry) {
+                return;
+            }
+            const key = this._key(entry.provider, entry.rawId);
+            if (!this._isSessionInWorkspace(entry)) {
+                return;
+            }
+            this._mutationGeneration++;
+            this._entries.set(key, entry);
+            this._pendingNewSessions.delete(key);
+            this._onDidChangeSessions.fire({
+                addedOrUpdated: [entry]
+            });
+        } else if (notification.type === "root/sessionRemoved") {
+            const provider = AgentSession.provider(notification.session);
+            if (!provider) {
+                return;
+            }
+            this.removeSession(provider, AgentSession.id(notification.session));
+        } else if (notification.type === "root/sessionSummaryChanged") {
+            const provider = AgentSession.provider(notification.session);
+            if (!provider) {
+                return;
+            }
+            const rawId = AgentSession.id(notification.session);
+            const key = this._key(provider, rawId);
+            const cached = this._entries.get(key);
+            if (!cached) {
+                return;
+            }
+            const {
+                activity,
+                ...changes
+            } = notification.changes;
+            const updated = {
+                provider,
+                rawId,
+                statusKnown: cached.statusKnown || notification.changes.status !== undefined,
+                summary: {
+                    ...cached.summary,
+                    ...changes,
+                    ...(Object.prototype.hasOwnProperty.call(notification.changes, "activity") ? {
+                        activity: activity ?? undefined
+                    } : {})
+                }
+            };
+            if (!this._isSessionInWorkspace(updated)) {
+                this._mutationGeneration++;
+                this._removeSessionFromList(provider, rawId);
+                return;
+            }
+            this._mutationGeneration++;
+            this._entries.set(key, updated);
+            this._onDidChangeSessions.fire({
+                addedOrUpdated: [updated]
+            });
+        }
+    }
+    _makeEntryFromMetadata(session) {
+        const provider = AgentSession.provider(session.session);
+        if (!provider) {
+            return undefined;
+        }
+        const rawId = AgentSession.id(session.session);
+        return {
+            provider,
+            rawId,
+            statusKnown: session.status !== undefined,
+            summary: {
+                resource: ( session.session.toString()),
+                provider,
+                title: session.summary ?? `Session ${rawId.substring(0, 8)}`,
+                status: session.status ?? SessionStatus.Idle,
+                activity: session.activity,
+                createdAt: ( new Date(session.startTime)).toISOString(),
+                modifiedAt: ( new Date(session.modifiedTime)).toISOString(),
+                changes: session.changes,
+                workingDirectories: session.workingDirectories?.map(d => ( d.toString())),
+                ...(session.project ? {
+                    project: {
+                        uri: ( session.project.uri.toString()),
+                        displayName: session.project.displayName
+                    }
+                } : {}),
+                ...(session._meta !== undefined ? {
+                    _meta: session._meta
+                } : {})
+            }
+        };
+    }
+    _makeEntryFromSummary(summary) {
+        const provider = summary.provider || AgentSession.provider(summary.resource);
+        if (!provider) {
+            return undefined;
+        }
+        return {
+            provider,
+            rawId: AgentSession.id(summary.resource),
+            statusKnown: true,
+            summary
+        };
+    }
+    _isSessionInWorkspace(entry) {
+        const inWorkspace = this._computeSessionInWorkspace(entry);
+        if (!inWorkspace && readSessionMatchesByProjectRoot(entry.summary._meta) && entry.summary.project && ( URI.parse(entry.summary.project.uri)).scheme !== Schemas.file && !( this._reportedNonLocalProjects.has(entry.summary.resource))) {
+            this._reportedNonLocalProjects.add(entry.summary.resource);
+            this._logService.warn(
+                `[AgentHost] legacy session ${entry.summary.resource} has a non-local project '${entry.summary.project.uri}' and cannot be matched to a workspace folder`
+            );
+        }
+        return inWorkspace;
+    }
+    _computeSessionInWorkspace(entry) {
+        const workingDirectories = this._containmentCandidates(entry.summary);
+        const workspace = this._workspaceContextService.getWorkspace();
+        const folders = workspace.folders;
+        const configuration = workspace.configuration;
+        const multiRoot = readSessionMultiRootMetadata(entry.summary._meta);
+        if (multiRoot) {
+            if (URI.isUri(configuration)) {
+                return extUriBiasedIgnorePathCase.isEqual(( URI.parse(multiRoot.workspaceFile)), configuration);
+            }
+            return folders.length === 0 || this._matchesAnyFolder(workingDirectories, folders);
+        }
+        if (folders.length === 0) {
+            return true;
+        }
+        return this._matchesAnyFolder(workingDirectories, folders);
+    }
+    _filterEntriesToWorkspace() {
+        const removed = [];
+        for (const [key, entry] of this._entries) {
+            if (!this._isSessionInWorkspace(entry)) {
+                this._entries.delete(key);
+                this._pendingNewSessions.delete(key);
+                removed.push(this._toRemoval(entry));
+            }
+        }
+        if (removed.length > 0) {
+            this._mutationGeneration++;
+            this._onDidChangeSessions.fire({
+                removed
+            });
+        }
+    }
+    _matchesAnyFolder(workingDirectories, folders) {
+        return ( workingDirectories.some(directory => ( folders.some(
+            folder => extUriBiasedIgnorePathCase.isEqualOrParent(directory, folder.uri)
+        ))));
+    }
+    _containmentCandidates(summary) {
+        const candidates = summary.workingDirectories?.map(directory => ( URI.parse(directory))) ?? [];
+        if (summary.project?.uri && readSessionMatchesByProjectRoot(summary._meta)) {
+            const project = ( URI.parse(summary.project.uri));
+            if (project.scheme === Schemas.file) {
+                candidates.push(project);
+            }
+        }
+        return candidates;
+    }
+    _toRemoval(entry) {
+        return {
+            provider: entry.provider,
+            rawId: entry.rawId,
+            session: AgentSession.uri(entry.provider, entry.rawId)
+        };
+    }
+    _key(provider, rawId) {
+        return `${provider}://${rawId}`;
+    }
+};
+AgentHostSessionListStore = ( __decorate([( __param(1, IWorkspaceContextService)), ( __param(2, ILogService))], AgentHostSessionListStore));
+
+export { AgentHostSessionListStore };

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(6103, "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 };