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

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostAgentPicker.js

@@ -0,0 +1,300 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { BaseActionViewItem } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionViewItems';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionViewItemService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/browser/actionViewItemService.service';
+import { registerAction2, Action2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { agentHostAgentPickerStorageKey, resolveAgentHostAgent } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customAgents';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+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';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { IChatWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service';
+import { ChatContextKeyExprs, ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { ChatMode } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes';
+import { IChatService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService.service';
+import { logChangesToStateModel } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel';
+import { ChatModeKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { Menus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/menus';
+import { LOCAL_AGENT_HOST_PROVIDER_ID, REMOTE_AGENT_HOST_PROVIDER_RE, isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { SessionProviderIdContext, IsPhoneLayoutContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { ScopedModePickerModelCache, ModePicker } from '../../copilotChatSessions/browser/modePicker.js';
+import { ISessionContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionContext.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const IsActiveSessionAgentHost = ( ContextKeyExpr.or(( ContextKeyExpr.equals(SessionProviderIdContext.key, LOCAL_AGENT_HOST_PROVIDER_ID)), ( ContextKeyExpr.regex(SessionProviderIdContext.key, REMOTE_AGENT_HOST_PROVIDER_RE))));
+registerAction2(class extends Action2 {
+    constructor() {
+        super({
+            id: "sessions.agentHost.agentPicker",
+            title: ( localize2(4162, "Agent")),
+            f1: false,
+            menu: [{
+                id: Menus.NewSessionConfig,
+                group: "navigation",
+                order: -1,
+                when: ( ContextKeyExpr.and(IsActiveSessionAgentHost, ( IsPhoneLayoutContext.negate())))
+            }, {
+                id: MenuId.ChatInput,
+                group: "navigation",
+                order: 1,
+                when: ( ContextKeyExpr.and(
+                    ChatContextKeyExprs.isAgentHostSession,
+                    IsSessionsWindowContext,
+                    ( IsPhoneLayoutContext.negate()),
+                    ( ChatContextKeys.hasPendingDelegationTarget.negate())
+                ))
+            }]
+        });
+    }
+    async run() {}
+});
+class AgentHostModePickerActionViewItem extends BaseActionViewItem {
+    constructor(picker, disposable) {
+        super(undefined, {
+            id: "",
+            label: "",
+            enabled: true,
+            class: undefined,
+            tooltip: "",
+            run: () => {}
+        });
+        this.picker = picker;
+        this._register(disposable);
+    }
+    render(container) {
+        container.classList.add("chat-input-picker-item", "chat-agent-picker-item");
+        this.picker.render(container);
+    }
+    dispose() {
+        this.picker.dispose();
+        super.dispose();
+    }
+}
+let AgentHostAgentPickerContribution = class AgentHostAgentPickerContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.agentHostAgentPicker";
+    }
+    constructor(
+        actionViewItemService,
+        sessionsService,
+        sessionsProvidersService,
+        chatService,
+        chatWidgetService,
+        storageService,
+        logService
+    ) {
+        super();
+        this.chatService = chatService;
+        this.chatWidgetService = chatWidgetService;
+        this.storageService = storageService;
+        this.logService = logService;
+        let settingAgentInternally = false;
+        const modePickerModels = this._register(( new ScopedModePickerModelCache(session => {
+            const provider = sessionsProvidersService.getProvider(session.providerId);
+            return !!provider && isAgentHostProvider(provider);
+        })));
+        const initAgentFromActiveSession = () => {
+            const session = sessionsService.activeSession.get();
+            this._initAgent(
+                session,
+                session?.mode.get()?.id,
+                session?.status.get() === SessionStatus.Untitled,
+                sessionsProvidersService,
+                () => settingAgentInternally = true,
+                () => settingAgentInternally = false
+            );
+        };
+        const syncChatInputModeFromActiveSession = () => {
+            const session = sessionsService.activeSession.get();
+            const selectedAgentUri = session?.mode.get()?.id;
+            this._syncChatInputMode(session, selectedAgentUri, sessionsProvidersService);
+        };
+        this._register(autorun(reader => {
+            const session = sessionsService.activeSession.read(reader);
+            const selectedAgentUri = session?.mode.read(reader)?.id;
+            const isUntitled = session?.status.read(reader) === SessionStatus.Untitled;
+            this._syncChatInputMode(session, selectedAgentUri, sessionsProvidersService);
+            this._initAgent(
+                session,
+                selectedAgentUri,
+                isUntitled,
+                sessionsProvidersService,
+                () => settingAgentInternally = true,
+                () => settingAgentInternally = false
+            );
+        }));
+        this._register(this.chatWidgetService.onDidAddWidget(() => {
+            syncChatInputModeFromActiveSession();
+        }));
+        this._register(this.chatWidgetService.onDidChangeFocusedSession(() => {
+            syncChatInputModeFromActiveSession();
+        }));
+        const customAgentsListener = this._register(( new MutableDisposable()));
+        this._register(autorun(reader => {
+            const session = sessionsService.activeSession.read(reader);
+            const provider = this._getProvider(session, sessionsProvidersService);
+            customAgentsListener.value = provider?.onDidChangeCustomAgents(() => {
+                if (!settingAgentInternally) {
+                    initAgentFromActiveSession();
+                }
+            });
+        }));
+        const factory = (_action, _options, scopedInstantiationService) => {
+            const {
+                session
+            } = scopedInstantiationService.invokeFunction(accessor => accessor.get(ISessionContext));
+            const disposableStore = ( new DisposableStore());
+            const modePickerModel = disposableStore.add(modePickerModels.acquire(session, scopedInstantiationService));
+            const picker = scopedInstantiationService.createInstance(ModePicker, modePickerModel.model, session);
+            disposableStore.add(picker.onDidSelect(mode => {
+                this._selectMode(mode, session.get(), sessionsProvidersService);
+            }));
+            return scopedInstantiationService.createInstance(AgentHostModePickerActionViewItem, picker, disposableStore);
+        };
+        this._register(
+            actionViewItemService.register(Menus.NewSessionConfig, "sessions.agentHost.agentPicker", factory)
+        );
+        this._register(
+            actionViewItemService.register(MenuId.ChatInput, "sessions.agentHost.agentPicker", factory)
+        );
+    }
+    _getProvider(session, sessionsProvidersService) {
+        if (!session) {
+            return undefined;
+        }
+        const provider = sessionsProvidersService.getProvider(session.providerId);
+        return provider && isAgentHostProvider(provider) ? provider : undefined;
+    }
+    _syncChatInputMode(session, selectedAgentUri, sessionsProvidersService) {
+        if (!session || !this._getProvider(session, sessionsProvidersService)) {
+            return;
+        }
+        const chatModel = this.chatService.getSession(session.resource);
+        const currentMode = chatModel?.inputModel.state.get()?.mode;
+        const nextMode = selectedAgentUri ? {
+            id: selectedAgentUri,
+            kind: ChatModeKind.Agent
+        } : {
+            id: ChatMode.Agent.id,
+            kind: ChatModeKind.Agent
+        };
+        if (currentMode?.id === nextMode.id && currentMode.kind === nextMode.kind) {
+            this._syncVisibleChatInputMode(session, nextMode.id);
+            return;
+        }
+        chatModel?.inputModel.setState({
+            mode: nextMode
+        });
+        this._syncVisibleChatInputMode(session, nextMode.id);
+    }
+    _syncVisibleChatInputMode(session, modeId) {
+        const widget = this.chatWidgetService.getWidgetBySessionResource(session.resource);
+        if (!widget) {
+            return;
+        }
+        const currentMode = widget.input.currentModeObs.get();
+        if (currentMode.id === modeId) {
+            return;
+        }
+        const apply = async () => {
+            await widget.input.currentChatModesObs.get().waitForPendingUpdates();
+            if (widget.viewModel?.model.sessionResource.toString() !== ( session.resource.toString())) {
+                return;
+            }
+            const mode = widget.input.currentChatModesObs.get().findModeById(modeId);
+            if (!mode) {
+                return;
+            }
+            const chatModel = this.chatService.getSession(session.resource);
+            logChangesToStateModel(
+                chatModel?.inputModel,
+                `[AGPK] _syncVisibleChatInputMode -> widget.input.setChatMode(${modeId}) for ${( session.resource.toString())}`,
+                undefined,
+                chatModel?.inputModel.state.get(),
+                this.logService
+            );
+            widget.input.setChatMode(modeId, false);
+        };
+        apply().catch(
+            err => this.logService.error("[AgentHostAgentPickerProbe] sync visible chat input mode failed", err)
+        );
+    }
+    _initAgent(
+        session,
+        selectedAgentUri,
+        isUntitled,
+        sessionsProvidersService,
+        beginInternalSet,
+        endInternalSet
+    ) {
+        const provider = this._getProvider(session, sessionsProvidersService);
+        if (!session || !provider) {
+            return;
+        }
+        const agents = provider.getCustomAgents(session.sessionId);
+        const storedUri = isUntitled ? this.storageService.get(
+            agentHostAgentPickerStorageKey(session.resource.scheme),
+            StorageScope.PROFILE
+        ) : undefined;
+        const resolved = resolveAgentHostAgent(agents, selectedAgentUri, storedUri);
+        if (!selectedAgentUri && isUntitled && resolved) {
+            beginInternalSet();
+            try {
+                this._setAgent(session, provider, resolved);
+            } finally {
+                endInternalSet();
+            }
+        } else if (selectedAgentUri && !resolved && agents.length > 0 && !isUntitled) {
+            beginInternalSet();
+            try {
+                this._setAgent(session, provider, undefined);
+            } finally {
+                endInternalSet();
+            }
+        }
+    }
+    _selectMode(mode, session, sessionsProvidersService) {
+        if (!session) {
+            return;
+        }
+        const provider = sessionsProvidersService.getProvider(session.providerId);
+        if (!provider || !isAgentHostProvider(provider)) {
+            return;
+        }
+        if (mode.id === ChatMode.Agent.id) {
+            this._setAgent(session, provider, undefined);
+        } else {
+            const rawAgentUri = mode.id;
+            this._setAgent(session, provider, {
+                uri: rawAgentUri,
+                name: mode.name.get()
+            });
+        }
+    }
+    _setAgent(session, provider, agent) {
+        const key = agentHostAgentPickerStorageKey(session.resource.scheme);
+        if (agent) {
+            this.storageService.store(key, agent.uri, StorageScope.PROFILE, StorageTarget.MACHINE);
+        } else {
+            this.storageService.remove(key, StorageScope.PROFILE);
+        }
+        provider.setAgent?.(session.sessionId, agent ? {
+            uri: agent.uri,
+            name: agent.name
+        } : undefined);
+    }
+};
+AgentHostAgentPickerContribution = ( __decorate([( __param(0, IActionViewItemService)), ( __param(1, ISessionsService)), ( __param(2, ISessionsProvidersService)), ( __param(3, IChatService)), ( __param(4, IChatWidgetService)), ( __param(5, IStorageService)), ( __param(6, ILogService))], AgentHostAgentPickerContribution));
+registerWorkbenchContribution2(
+    AgentHostAgentPickerContribution.ID,
+    AgentHostAgentPickerContribution,
+    WorkbenchPhase.AfterRestored
+);

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSettings.contribution.d.ts

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

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSettings.contribution.js

@@ -0,0 +1,74 @@
+
+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 } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+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 { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { SessionProviderIdContext } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/contextkeys';
+import { SessionItemContextMenuId } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessions/browser/views/sessionsList';
+import { AgentHostSettingsSchemaRegistrar, AgentHostSettingsFileSystemProvider, AGENT_HOST_SETTINGS_SCHEME, agentHostSettingsUri } from './agentHostSettingsFileSystemProvider.js';
+import { ANY_AGENT_HOST_PROVIDER_RE } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+
+let AgentHostSettingsContribution = class AgentHostSettingsContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.agentHostSettingsContribution";
+    }
+    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(4167, "Host Settings")),
+                separator: "/"
+            }
+        }));
+    }
+};
+AgentHostSettingsContribution = ( __decorate([( __param(0, IFileService)), ( __param(1, IInstantiationService)), ( __param(2, ILabelService))], AgentHostSettingsContribution));
+registerWorkbenchContribution2(
+    AgentHostSettingsContribution.ID,
+    AgentHostSettingsContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerAction2(class OpenHostSettingsAction extends Action2 {
+    constructor() {
+        super({
+            id: "sessionsViewPane.openHostSettings",
+            title: ( localize2(4168, "Open Host Settings")),
+            menu: [{
+                id: SessionItemContextMenuId,
+                group: "2_settings",
+                order: 2,
+                when: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE))
+            }],
+            precondition: ( ContextKeyExpr.regex(SessionProviderIdContext.key, ANY_AGENT_HOST_PROVIDER_RE)),
+            f1: true
+        });
+    }
+    async run(accessor, context) {
+        const sessionsService = accessor.get(ISessionsService);
+        const session = (Array.isArray(context) ? context[0] : context) ?? sessionsService.activeSession.get();
+        if (!session) {
+            return;
+        }
+        const editorService = accessor.get(IEditorService);
+        const resource = agentHostSettingsUri(session.providerId);
+        await editorService.openEditor({
+            resource,
+            options: {
+                pinned: true
+            }
+        });
+    }
+});

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSettingsFileSystemProvider.d.ts

@@ -0,0 +1,55 @@
+import { IJSONSchema } from "@codingame/monaco-vscode-api/vscode/vs/base/common/jsonSchema";
+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 { RootConfigState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { IAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { AbstractMultiProviderAgentHostConfigSchemaRegistrar, AbstractSessionsAgentHostConfigFileSystemProvider, AgentHostConfigPropertyFilter, IAgentHostConfigLike, IAgentHostSettingsContext, IAgentHostSettingsLocale } from "./agentHostSettingsShared.js";
+/** Scheme for the synthetic agent-host settings files. */
+export declare const AGENT_HOST_SETTINGS_SCHEME = "agent-host-settings";
+/**
+ * Build the URI used to open the settings file for an agent host provider.
+ *
+ * URI shape: `agent-host-settings://{providerId}/settings.jsonc`
+ */
+export declare function agentHostSettingsUri(providerId: string): URI;
+/**
+ * Serialize the root config values for an agent host provider into a
+ * commented, pretty-printed JSON document.
+ */
+export declare function serializeHostSettings(provider: IAgentHostSessionsProvider): string;
+/**
+ * Build a JSON schema describing the root config of an agent host provider.
+ */
+export declare function buildHostSettingsJsonSchema(config: RootConfigState): IJSONSchema;
+/**
+ * Filesystem provider serving synthetic JSONC documents representing the
+ * root (agent host) configuration values of agent-host providers.
+ */
+export declare class AgentHostSettingsFileSystemProvider extends AbstractSessionsAgentHostConfigFileSystemProvider<IAgentHostSettingsContext> {
+    private readonly _schemaRegistrar;
+    protected readonly _schemeLabel = "agent-host-settings";
+    protected readonly _traceTag = "AgentHostSettings";
+    protected readonly _locale: IAgentHostSettingsLocale;
+    constructor(_schemaRegistrar: AgentHostSettingsSchemaRegistrar, sessionsProvidersService: ISessionsProvidersService, logService: ILogService);
+    protected _parseUri(resource: URI): IAgentHostSettingsContext | undefined;
+    protected _serialize(provider: IAgentHostSessionsProvider): string;
+    protected _watchChanges(provider: IAgentHostSessionsProvider, _ctx: IAgentHostSettingsContext, fire: () => void): IDisposable;
+    protected _ensureSchemaRegistered(provider: IAgentHostSessionsProvider): void;
+    protected _hasConfig(provider: IAgentHostSessionsProvider): boolean;
+    protected _replaceConfig(provider: IAgentHostSessionsProvider, _ctx: IAgentHostSettingsContext, values: Record<string, unknown>): Promise<void>;
+    protected _describeForTrace(ctx: IAgentHostSettingsContext): string;
+}
+/**
+ * Keeps per-provider JSON schemas registered so editors of the synthetic
+ * `agent-host-settings://…` files get completions, hover, and validation.
+ */
+export declare class AgentHostSettingsSchemaRegistrar extends AbstractMultiProviderAgentHostConfigSchemaRegistrar<IAgentHostSessionsProvider> {
+    protected _propertyFilter(): AgentHostConfigPropertyFilter;
+    protected _settingsUri(provider: IAgentHostSessionsProvider): string;
+    protected _schemaId(provider: IAgentHostSessionsProvider): string;
+    protected _getConfig(target: IAgentHostSessionsProvider): IAgentHostConfigLike | undefined;
+    protected _targetsForProvider(provider: IAgentHostSessionsProvider): readonly IAgentHostSessionsProvider[];
+    protected _observeProvider(provider: IAgentHostSessionsProvider, onChanged: (target: IAgentHostSessionsProvider) => void, _onRemoved: (target: IAgentHostSessionsProvider) => void): IDisposable;
+}

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSettingsFileSystemProvider.js

@@ -0,0 +1,103 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { AbstractSessionsAgentHostConfigFileSystemProvider, AbstractMultiProviderAgentHostConfigSchemaRegistrar } from './agentHostSettingsShared.js';
+import { serializeAgentHostConfigDocument } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostConfigEditor.js';
+
+const AGENT_HOST_SETTINGS_SCHEME = "agent-host-settings";
+function agentHostSettingsUri(providerId) {
+    return ( URI.from({
+        scheme: AGENT_HOST_SETTINGS_SCHEME,
+        authority: providerId,
+        path: `/settings.jsonc`
+    }));
+}
+function parseHostSettingsUri(uri) {
+    if (uri.scheme !== AGENT_HOST_SETTINGS_SCHEME) {
+        return undefined;
+    }
+    const providerId = uri.authority;
+    if (!providerId) {
+        return undefined;
+    }
+    return {
+        providerId
+    };
+}
+const hostSettingsPropertyFilter = () => true;
+const hostSettingsLocale = {
+    get header() {
+        return localize(4169, "Agent host settings.");
+    },
+    get saveHint() {
+        return localize(
+            4170,
+            "Edit values below and save to apply. Unknown properties are ignored."
+        );
+    },
+    get parseError() {
+        return localize(4171, "Failed to parse agent host settings as JSON.");
+    },
+    get notObject() {
+        return localize(4172, "Agent host settings must be a JSON object.");
+    }
+};
+function serializeHostSettings(provider) {
+    return serializeAgentHostConfigDocument(provider.getRootConfig(), hostSettingsPropertyFilter, hostSettingsLocale);
+}
+let AgentHostSettingsFileSystemProvider = class AgentHostSettingsFileSystemProvider extends AbstractSessionsAgentHostConfigFileSystemProvider {
+    constructor(_schemaRegistrar, sessionsProvidersService, logService) {
+        super(sessionsProvidersService, logService);
+        this._schemaRegistrar = _schemaRegistrar;
+        this._schemeLabel = AGENT_HOST_SETTINGS_SCHEME;
+        this._traceTag = "AgentHostSettings";
+        this._locale = hostSettingsLocale;
+    }
+    _parseUri(resource) {
+        return parseHostSettingsUri(resource);
+    }
+    _serialize(provider) {
+        return serializeHostSettings(provider);
+    }
+    _watchChanges(provider, _ctx, fire) {
+        return provider.onDidChangeRootConfig(() => fire());
+    }
+    _ensureSchemaRegistered(provider) {
+        this._schemaRegistrar.ensureRegistered(provider);
+    }
+    _hasConfig(provider) {
+        return provider.getRootConfig() !== undefined;
+    }
+    _replaceConfig(provider, _ctx, values) {
+        return provider.replaceRootConfig(values);
+    }
+    _describeForTrace(ctx) {
+        return `provider ${ctx.providerId}`;
+    }
+};
+AgentHostSettingsFileSystemProvider = ( __decorate([( __param(1, ISessionsProvidersService)), ( __param(2, ILogService))], AgentHostSettingsFileSystemProvider));
+class AgentHostSettingsSchemaRegistrar extends AbstractMultiProviderAgentHostConfigSchemaRegistrar {
+    _propertyFilter() {
+        return hostSettingsPropertyFilter;
+    }
+    _settingsUri(provider) {
+        return ( agentHostSettingsUri(provider.id).toString());
+    }
+    _schemaId(provider) {
+        return `vscode://schemas/agent-host-settings/${provider.id}.jsonc`;
+    }
+    _getConfig(target) {
+        return target.getRootConfig();
+    }
+    _targetsForProvider(provider) {
+        return [provider];
+    }
+    _observeProvider(provider, onChanged, _onRemoved) {
+        return provider.onDidChangeRootConfig(() => onChanged(provider));
+    }
+}
+
+export { AGENT_HOST_SETTINGS_SCHEME, AgentHostSettingsFileSystemProvider, AgentHostSettingsSchemaRegistrar, agentHostSettingsUri, serializeHostSettings };

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSettingsShared.d.ts

@@ -0,0 +1,50 @@
+import { IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IAgentHostSessionsProvider } from "@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
+import { AbstractAgentHostConfigFileSystemProvider, AbstractAgentHostConfigSchemaRegistrar } from "../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostConfigEditor.js";
+export { buildAgentHostConfigJsonSchema, convertPropertySchema, serializeAgentHostConfigDocument, } from "../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostConfigEditor.js";
+export type { AgentHostConfigPropertyFilter, IAgentHostConfigLike, IAgentHostSettingsLocale, } from "../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostConfigEditor.js";
+/**
+ * Base context shared by all sessions-window settings filesystem providers.
+ * Subclasses extend with any additional state they need (e.g. a sessionId).
+ */
+export interface IAgentHostSettingsContext {
+    readonly providerId: string;
+}
+/**
+ * Abstract filesystem provider backing the sessions-window's synthetic
+ * agent-host settings JSONC editors. Resolves the {@link IAgentHostSessionsProvider}
+ * target from `ctx.providerId` via {@link ISessionsProvidersService}; subclasses
+ * still supply scheme-specific URI parsing, config-fetching, and change/replace
+ * hooks (see {@link AbstractAgentHostConfigFileSystemProvider}).
+ */
+export declare abstract class AbstractSessionsAgentHostConfigFileSystemProvider<TContext extends IAgentHostSettingsContext> extends AbstractAgentHostConfigFileSystemProvider<TContext, IAgentHostSessionsProvider> {
+    protected readonly _sessionsProvidersService: ISessionsProvidersService;
+    constructor(_sessionsProvidersService: ISessionsProvidersService, logService: ILogService);
+    protected _resolveTarget(ctx: TContext): IAgentHostSessionsProvider | undefined;
+    protected _missingTargetError(ctx: TContext): Error;
+    protected _lookupProvider(providerId: string): IAgentHostSessionsProvider | undefined;
+}
+/**
+ * Abstract base for the sessions-window schema registrars. Adds discovery
+ * and lifecycle tracking of every registered {@link IAgentHostSessionsProvider}
+ * (local + remote) on top of the shared, target-neutral
+ * {@link AbstractAgentHostConfigSchemaRegistrar}, which only knows how to
+ * register/refresh/dispose a schema for a single target once told to.
+ */
+export declare abstract class AbstractMultiProviderAgentHostConfigSchemaRegistrar<TTarget> extends AbstractAgentHostConfigSchemaRegistrar<TTarget> {
+    protected readonly _sessionsProvidersService: ISessionsProvidersService;
+    /** Per-provider subscriptions. */
+    private readonly _providerSubscriptions;
+    constructor(_sessionsProvidersService: ISessionsProvidersService);
+    /** Enumerate the targets currently tracked on a provider (used for cleanup). */
+    protected abstract _targetsForProvider(provider: IAgentHostSessionsProvider): readonly TTarget[];
+    /**
+     * Subscribe to change signals from {@link provider}. The subclass should
+     * invoke {@link onChanged} when a tracked target's config changes and
+     * {@link onRemoved} when a tracked target disappears.
+     */
+    protected abstract _observeProvider(provider: IAgentHostSessionsProvider, onChanged: (target: TTarget) => void, onRemoved: (target: TTarget) => void): IDisposable;
+    private _onProviderAdded;
+}

package/vscode/src/vs/sessions/contrib/providers/agentHost/browser/agentHostSettingsShared.js

@@ -0,0 +1,72 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { createFileSystemProviderError, FileSystemProviderErrorCode } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { isAgentHostProvider } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/agentHostSessionsProvider';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
+import { AbstractAgentHostConfigFileSystemProvider, AbstractAgentHostConfigSchemaRegistrar } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostConfigEditor.js';
+export { buildAgentHostConfigJsonSchema, convertPropertySchema, serializeAgentHostConfigDocument } from '../../../../../workbench/contrib/chat/browser/agentSessions/agentHost/agentHostConfigEditor.js';
+
+let AbstractSessionsAgentHostConfigFileSystemProvider = class AbstractSessionsAgentHostConfigFileSystemProvider extends AbstractAgentHostConfigFileSystemProvider {
+    constructor(_sessionsProvidersService, logService) {
+        super(logService);
+        this._sessionsProvidersService = _sessionsProvidersService;
+    }
+    _resolveTarget(ctx) {
+        return this._lookupProvider(ctx.providerId);
+    }
+    _missingTargetError(ctx) {
+        return createFileSystemProviderError(
+            `Unknown agent host provider: ${ctx.providerId}`,
+            FileSystemProviderErrorCode.FileNotFound
+        );
+    }
+    _lookupProvider(providerId) {
+        const provider = this._sessionsProvidersService.getProvider(providerId);
+        if (!provider || !isAgentHostProvider(provider)) {
+            return undefined;
+        }
+        return provider;
+    }
+};
+AbstractSessionsAgentHostConfigFileSystemProvider = ( __decorate([( __param(0, ISessionsProvidersService)), ( __param(1, ILogService))], AbstractSessionsAgentHostConfigFileSystemProvider));
+let AbstractMultiProviderAgentHostConfigSchemaRegistrar = class AbstractMultiProviderAgentHostConfigSchemaRegistrar extends AbstractAgentHostConfigSchemaRegistrar {
+    constructor(_sessionsProvidersService) {
+        super();
+        this._sessionsProvidersService = _sessionsProvidersService;
+        this._providerSubscriptions = this._register(( new DisposableMap()));
+        for (const provider of this._sessionsProvidersService.getProviders()) {
+            this._onProviderAdded(provider);
+        }
+        this._register(this._sessionsProvidersService.onDidChangeProviders(e => {
+            for (const provider of e.added) {
+                this._onProviderAdded(provider);
+            }
+            for (const provider of e.removed) {
+                this._providerSubscriptions.deleteAndDispose(provider.id);
+            }
+        }));
+    }
+    _onProviderAdded(provider) {
+        if (!isAgentHostProvider(provider)) {
+            return;
+        }
+        const store = ( new DisposableStore());
+        store.add(this._observeProvider(provider, target => {
+            if (!this._isRegistered(target)) {
+                return;
+            }
+            this._refreshSchema(target);
+        }, target => this._disposeSchemaForTarget(target)));
+        store.add(toDisposable(() => {
+            for (const target of this._targetsForProvider(provider)) {
+                this._disposeSchemaForTarget(target);
+            }
+        }));
+        this._providerSubscriptions.set(provider.id, store);
+    }
+};
+AbstractMultiProviderAgentHostConfigSchemaRegistrar = ( __decorate([( __param(0, ISessionsProvidersService))], AbstractMultiProviderAgentHostConfigSchemaRegistrar));
+
+export { AbstractMultiProviderAgentHostConfigSchemaRegistrar, AbstractSessionsAgentHostConfigFileSystemProvider };