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

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

@@ -0,0 +1,125 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type IAgentSessionMetadata } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService";
+import { type INotification, type SessionAction } from "../../../../../../platform/agentHost/common/state/sessionActions.js";
+import { type SessionSummary } 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";
+/**
+ * Minimal agent-host connection surface needed by the session list store.
+ */
+export interface IAgentHostSessionListConnection {
+    readonly onDidNotification: Event<INotification>;
+    listSessions(): Promise<IAgentSessionMetadata[]>;
+    disposeSession(session: URI): Promise<void>;
+    dispatch(channel: string, action: SessionAction): void;
+}
+/**
+ * Provider-tagged backend session entry owned by the shared session-list store.
+ */
+export interface IAgentHostSessionListEntry {
+    readonly provider: string;
+    readonly rawId: string;
+    readonly summary: SessionSummary;
+    /**
+     * Whether {@link summary}'s status came from the host. `listSessions()`
+     * metadata carries no status for a cold session that has never been marked
+     * read or archived, and `SessionSummary.status` is required — so the status
+     * is synthesized and the session-scoped flags on it mean nothing.
+     */
+    readonly statusKnown: boolean;
+}
+/**
+ * Provider-tagged backend session removal emitted by the shared session-list store.
+ */
+export interface IAgentHostSessionListRemoval {
+    readonly provider: string;
+    readonly rawId: string;
+    readonly session: URI;
+}
+/**
+ * Backend session delta emitted by the shared session-list store. Every delta
+ * carries the affected entries, so consumers can apply them incrementally:
+ * narrow notifications carry the single changed/removed entry, while a refresh
+ * carries the full current entry set (plus any sessions that dropped out).
+ */
+export interface IAgentHostSessionListDelta {
+    readonly addedOrUpdated?: readonly IAgentHostSessionListEntry[];
+    readonly removed?: readonly IAgentHostSessionListRemoval[];
+}
+/**
+ * Shared provider-agnostic cache of agent-host sessions. It owns the
+ * provider-wide listSessions refresh, workspace filtering, and root session
+ * notifications. Per-provider list controllers project this state into chat
+ * session items.
+ */
+export declare class AgentHostSessionListStore extends Disposable {
+    private readonly _connection;
+    private readonly _workspaceContextService;
+    private readonly _logService;
+    private readonly _onDidChangeSessions;
+    readonly onDidChangeSessions: Event<IAgentHostSessionListDelta>;
+    private readonly _entries;
+    /**
+     * Backend session keys for sessions a controller created locally (via
+     * `newChatSessionItem`) that the backend has not yet announced. Tracked here
+     * so per-provider controllers stay stateless; cleared once the backend
+     * surfaces or removes the session.
+     */
+    private readonly _pendingNewSessions;
+    private _cacheValid;
+    private _refreshInFlight;
+    /**
+     * Incremented whenever the in-memory list is mutated outside of
+     * {@link refresh}. Used to detect races where a `root/sessionAdded`,
+     * `root/sessionRemoved`, or `root/sessionSummaryChanged` notification
+     * arrives while a `listSessions()` round-trip is in flight.
+     */
+    private _mutationGeneration;
+    /** Sessions already reported as having an unusable (non-local) project root. */
+    private readonly _reportedNonLocalProjects;
+    constructor(_connection: IAgentHostSessionListConnection, _workspaceContextService: IWorkspaceContextService, _logService: ILogService);
+    getSessions(provider: string): readonly IAgentHostSessionListEntry[];
+    /** Record a session created locally before the backend has announced it. */
+    addPendingNewSession(provider: string, rawId: string): void;
+    /** Whether a session was created locally and the backend has not surfaced it yet. */
+    isPendingNewSession(provider: string, rawId: string): boolean;
+    /** Stop treating a locally-created session as pending without adding it to the visible list. */
+    clearPendingNewSession(provider: string, rawId: string): void;
+    resetCache(): void;
+    disposeSession(provider: string, rawId: string): Promise<void>;
+    setSessionArchived(provider: string, rawId: string, archived: boolean): void;
+    setSessionRead(provider: string, rawId: string, isRead: boolean): void;
+    /**
+     * Optimistically flips a session-scoped status flag and dispatches the owning
+     * action, so the host can fan the change out to other connected clients. An
+     * uncached session still dispatches; the summary notification seeds the entry.
+     */
+    private _setSessionFlag;
+    removeSession(provider: string, rawId: string): void;
+    private _removeSessionFromList;
+    refresh(token: CancellationToken): Promise<void>;
+    private _doRefresh;
+    private _onNotification;
+    private _makeEntryFromMetadata;
+    private _makeEntryFromSummary;
+    /** Uses workspace-file provenance for multi-root workspaces and path containment otherwise. */
+    private _isSessionInWorkspace;
+    private _computeSessionInWorkspace;
+    private _filterEntriesToWorkspace;
+    private _matchesAnyFolder;
+    /**
+     * The directories a session may be matched against a workspace folder by: its
+     * working directories plus - for legacy Copilot CLI sessions only - its
+     * server-owned project (repository) root. Those legacy sessions run out of a
+     * `copilot-worktrees/` directory outside the repository, so working
+     * directories alone would hide them from a window opened on that repository.
+     * The marker has to outlive adoption: a migrated session is still a legacy
+     * session and must not drop out of the list the moment it migrates.
+     */
+    private _containmentCandidates;
+    private _toRemoval;
+    private _key;
+}

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

@@ -195,7 +195,7 @@ let AgentHostSessionWorkingDirectorySynchronizer = class AgentHostSessionWorking
             } = await this._workspaceTrustManagementService.getUriTrustInfo(directory);
             if (!trusted) {
                 return (new Error(
-                    localize(6012, "The workspace folder '{0}' is not trusted.", directory.path)
+                    localize(6103, "The workspace folder '{0}' is not trusted.", directory.path)
                 ));
             }
         }

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,68 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { AGENT_HOST_ENABLED_CONTEXT_KEY } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/agentHostEnablementService';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ILabelService } from '@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { AgentHostSettingsSchemaRegistrar, AgentHostSettingsFileSystemProvider, AGENT_HOST_SETTINGS_SCHEME, agentHostSettingsUri } from './agentHostSettingsFileSystemProvider.js';
+
+let AgentHostSettingsContribution = class AgentHostSettingsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chat.agentHostSettingsEditor";
+    }
+    constructor(fileService, instantiationService, labelService) {
+        super();
+        const schemaRegistrar = this._register(instantiationService.createInstance(AgentHostSettingsSchemaRegistrar));
+        const provider = this._register(
+            instantiationService.createInstance(AgentHostSettingsFileSystemProvider, schemaRegistrar)
+        );
+        this._register(fileService.registerProvider(AGENT_HOST_SETTINGS_SCHEME, provider));
+        this._register(labelService.registerFormatter({
+            scheme: AGENT_HOST_SETTINGS_SCHEME,
+            formatting: {
+                label: ( localize(6104, "Host Settings")),
+                separator: "/"
+            }
+        }));
+    }
+};
+AgentHostSettingsContribution = ( __decorate([( __param(0, IFileService)), ( __param(1, IInstantiationService)), ( __param(2, ILabelService))], AgentHostSettingsContribution));
+registerWorkbenchContribution2(
+    AgentHostSettingsContribution.ID,
+    AgentHostSettingsContribution,
+    WorkbenchPhase.AfterRestored
+);
+const LOCAL_AGENT_HOST_SESSION_TYPE_RE = /^agent-host-/;
+const agentHostSettingsPrecondition = ( ContextKeyExpr.and(ChatContextKeys.enabled, AGENT_HOST_ENABLED_CONTEXT_KEY));
+registerAction2(class OpenAgentHostSettingsAction extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.chat.openAgentHostSettings",
+            title: ( localize2(6105, "Open Host Settings")),
+            f1: true,
+            precondition: agentHostSettingsPrecondition,
+            menu: [{
+                id: MenuId.AgentSessionsContext,
+                group: "3_settings",
+                order: 1,
+                when: ( ContextKeyExpr.and(agentHostSettingsPrecondition, ( ContextKeyExpr.regex(ChatContextKeys.agentSessionType.key, LOCAL_AGENT_HOST_SESSION_TYPE_RE))))
+            }]
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        await editorService.openEditor({
+            resource: agentHostSettingsUri(),
+            options: {
+                pinned: true
+            }
+        });
+    }
+});

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

@@ -0,0 +1,62 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { AbstractAgentHostConfigFileSystemProvider, AbstractAgentHostConfigSchemaRegistrar, AgentHostConfigPropertyFilter, IAgentHostConfigLike, IAgentHostSettingsLocale } from "./agentHostConfigEditor.js";
+/** Scheme for the synthetic ambient agent-host settings file. */
+export declare const AGENT_HOST_SETTINGS_SCHEME = "agent-host-settings";
+/** Fixed authority identifying the single ambient local agent host. */
+export declare const AGENT_HOST_SETTINGS_LOCAL_AUTHORITY = "local";
+/**
+ * Build the URI used to open the ambient local agent host's settings file.
+ *
+ * URI shape: `agent-host-settings://local/settings.jsonc`
+ */
+export declare function agentHostSettingsUri(): URI;
+/** Marker context: there is exactly one ambient target, so no fields are needed to identify it. */
+interface IAmbientAgentHostSettingsContext {
+    readonly kind: "local";
+}
+/**
+ * Filesystem provider serving a synthetic JSONC document representing the
+ * root configuration of the ambient local {@link IAgentHostService}. Unlike
+ * the sessions-window's provider-keyed equivalent, there is exactly one
+ * target, the ambient agent host, so the provider maintains its own
+ * optimistically-updated cache of the root config rather than resolving a
+ * per-request target from a registry.
+ */
+export declare class AgentHostSettingsFileSystemProvider extends AbstractAgentHostConfigFileSystemProvider<IAmbientAgentHostSettingsContext, IAgentHostService> {
+    private readonly _schemaRegistrar;
+    private readonly _agentHostService;
+    protected readonly _schemeLabel = "agent-host-settings";
+    protected readonly _traceTag = "AgentHostSettings";
+    protected readonly _locale: IAgentHostSettingsLocale;
+    private readonly _onDidChangeRootConfig;
+    /** Last-known root config state (schema + values), kept in sync with {@link IAgentHostService.rootState}. */
+    private _rootConfig;
+    constructor(_schemaRegistrar: AgentHostSettingsSchemaRegistrar, _agentHostService: IAgentHostService, logService: ILogService);
+    private _syncRootConfig;
+    protected _parseUri(resource: URI): IAmbientAgentHostSettingsContext | undefined;
+    protected _resolveTarget(): IAgentHostService;
+    protected _missingTargetError(): Error;
+    protected _serialize(): string;
+    protected _watchChanges(_target: IAgentHostService, _ctx: IAmbientAgentHostSettingsContext, fire: () => void): IDisposable;
+    protected _ensureSchemaRegistered(target: IAgentHostService): void;
+    protected _hasConfig(): boolean;
+    protected _replaceConfig(_target: IAgentHostService, _ctx: IAmbientAgentHostSettingsContext, values: Record<string, unknown>): Promise<void>;
+    protected _describeForTrace(): string;
+}
+/**
+ * Keeps the ambient local agent host's JSON schema registered so editors of
+ * the synthetic `agent-host-settings://local/settings.jsonc` document get
+ * completions, hover, and validation.
+ */
+export declare class AgentHostSettingsSchemaRegistrar extends AbstractAgentHostConfigSchemaRegistrar<IAgentHostService> {
+    private readonly _agentHostService;
+    constructor(_agentHostService: IAgentHostService);
+    protected _propertyFilter(): AgentHostConfigPropertyFilter;
+    protected _settingsUri(): string;
+    protected _schemaId(): string;
+    protected _getConfig(target: IAgentHostService): IAgentHostConfigLike | undefined;
+}
+export {};