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

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

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

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

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

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

@@ -0,0 +1,85 @@
+
+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 { isMarshalledAgentSessionContext, isAgentSession } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessionsModel';
+import { AgentSessionSettingsSchemaRegistrar, AgentSessionSettingsFileSystemProvider, AGENT_SESSION_SETTINGS_SCHEME, agentSessionSettingsUri } from './agentSessionSettingsFileSystemProvider.js';
+import { toAgentHostBackendSessionUri } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionUri';
+
+let AgentSessionSettingsContribution = class AgentSessionSettingsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chat.agentSessionSettingsEditor";
+    }
+    constructor(fileService, instantiationService, labelService) {
+        super();
+        const schemaRegistrar = this._register(instantiationService.createInstance(AgentSessionSettingsSchemaRegistrar));
+        const provider = this._register(
+            instantiationService.createInstance(AgentSessionSettingsFileSystemProvider, schemaRegistrar)
+        );
+        this._register(fileService.registerProvider(AGENT_SESSION_SETTINGS_SCHEME, provider));
+        this._register(labelService.registerFormatter({
+            scheme: AGENT_SESSION_SETTINGS_SCHEME,
+            formatting: {
+                label: ( localize(6115, "Session Settings")),
+                separator: "/"
+            }
+        }));
+    }
+};
+AgentSessionSettingsContribution = ( __decorate([( __param(0, IFileService)), ( __param(1, IInstantiationService)), ( __param(2, ILabelService))], AgentSessionSettingsContribution));
+registerWorkbenchContribution2(
+    AgentSessionSettingsContribution.ID,
+    AgentSessionSettingsContribution,
+    WorkbenchPhase.AfterRestored
+);
+const LOCAL_AGENT_HOST_SESSION_TYPE_RE = /^agent-host-/;
+const agentSessionSettingsPrecondition = ( ContextKeyExpr.and(ChatContextKeys.enabled, AGENT_HOST_ENABLED_CONTEXT_KEY));
+function resolveSelectedSession(context) {
+    if (isMarshalledAgentSessionContext(context)) {
+        return context.session;
+    }
+    if (isAgentSession(context)) {
+        return context;
+    }
+    return undefined;
+}
+registerAction2(class OpenAgentSessionSettingsAction extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.chat.openAgentSessionSettings",
+            title: ( localize2(6116, "Open Session Settings")),
+            menu: [{
+                id: MenuId.AgentSessionsContext,
+                group: "3_settings",
+                order: 2,
+                when: ( ContextKeyExpr.and(agentSessionSettingsPrecondition, ( ContextKeyExpr.regex(ChatContextKeys.agentSessionType.key, LOCAL_AGENT_HOST_SESSION_TYPE_RE))))
+            }]
+        });
+    }
+    async run(accessor, context) {
+        const session = resolveSelectedSession(context);
+        if (!session) {
+            return;
+        }
+        const backendSession = toAgentHostBackendSessionUri(session.resource);
+        if (!backendSession) {
+            return;
+        }
+        const editorService = accessor.get(IEditorService);
+        await editorService.openEditor({
+            resource: agentSessionSettingsUri(backendSession),
+            options: {
+                pinned: true
+            }
+        });
+    }
+});

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

@@ -0,0 +1,79 @@
+import { IDisposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { IAgentSubscription } from "../../../../../../platform/agentHost/common/state/agentSubscription.js";
+import { AbstractAgentHostConfigFileSystemProvider, AbstractAgentHostConfigSchemaRegistrar, AgentHostConfigPropertyFilter, IAgentHostConfigLike, IAgentHostSettingsLocale } from "./agentHostConfigEditor.js";
+/** Scheme for the synthetic editor-window agent-host session settings file. */
+export declare const AGENT_SESSION_SETTINGS_SCHEME = "agent-session-settings";
+/**
+ * Build the URI used to open the settings file for a backend agent-host
+ * session in the editor window.
+ *
+ * URI shape: `agent-session-settings://{provider}/{rawId}.jsonc`, where
+ * `provider`/`rawId` are the scheme/path of the backend AHP session URI
+ * (see {@link toAgentHostBackendSessionUri}), so the URI round-trips back to
+ * the backend session without any additional lookup.
+ */
+export declare function agentSessionSettingsUri(backendSession: URI): URI;
+interface ISessionSettingsContext {
+    readonly backendSession: URI;
+}
+interface ISessionSettingsTarget {
+    readonly backendSession: URI;
+    readonly ref: IReference<IAgentSubscription<SessionState>>;
+}
+/**
+ * Filesystem provider serving synthetic JSONC documents representing the
+ * session-mutable config values of a selected agent-host session in the
+ * editor window. Unlike the sessions-window's provider-keyed equivalent,
+ * there is no `ISessionsProvidersService` to resolve a target from - the
+ * backend AHP session URI is encoded directly in the settings URI (see
+ * {@link agentSessionSettingsUri}).
+ *
+ * Every {@link _resolveTarget} call acquires a fresh, scoped reference via
+ * {@link IAgentHostService.getSubscription} and {@link _releaseTarget}
+ * releases exactly that reference - there is no provider-local cache or
+ * refcount map. `stat`/`readFile`/`writeFile` hold their reference only for
+ * the duration of the call; a `watch` holds its reference until the caller
+ * disposes it. Multiple concurrent references to the same backend session
+ * are deduped and refcounted by {@link IAgentHostService} itself.
+ */
+export declare class AgentSessionSettingsFileSystemProvider extends AbstractAgentHostConfigFileSystemProvider<ISessionSettingsContext, ISessionSettingsTarget> {
+    private readonly _schemaRegistrar;
+    private readonly _agentHostService;
+    private readonly _configurationService;
+    protected readonly _schemeLabel = "agent-session-settings";
+    protected readonly _traceTag = "AgentSessionSettings";
+    protected readonly _locale: IAgentHostSettingsLocale;
+    constructor(_schemaRegistrar: AgentSessionSettingsSchemaRegistrar, _agentHostService: IAgentHostService, _configurationService: IConfigurationService, logService: ILogService);
+    protected _parseUri(resource: URI): ISessionSettingsContext | undefined;
+    protected _resolveTarget(ctx: ISessionSettingsContext): ISessionSettingsTarget;
+    protected _releaseTarget(target: ISessionSettingsTarget): void;
+    protected _serialize(target: ISessionSettingsTarget): string;
+    protected _watchChanges(target: ISessionSettingsTarget, _ctx: ISessionSettingsContext, fire: () => void): IDisposable;
+    protected _ensureSchemaRegistered(target: ISessionSettingsTarget): void;
+    protected _hasConfig(target: ISessionSettingsTarget): boolean;
+    protected _replaceConfig(target: ISessionSettingsTarget, ctx: ISessionSettingsContext, values: Record<string, unknown>): Promise<void>;
+    protected _describeForTrace(ctx: ISessionSettingsContext): string;
+}
+/**
+ * Keeps the JSON schema registered for an open `agent-session-settings://...`
+ * document. Reads the current config via
+ * {@link IAgentHostService.getSubscriptionUnmanaged}, which returns the live
+ * value of the {@link AgentSessionSettingsFileSystemProvider}'s own managed
+ * subscription for the same backend session (already acquired by the time
+ * `readFile` calls {@link ensureRegistered}) - the registrar itself never
+ * acquires a subscription.
+ */
+export declare class AgentSessionSettingsSchemaRegistrar extends AbstractAgentHostConfigSchemaRegistrar<URI> {
+    private readonly _agentHostService;
+    constructor(_agentHostService: IAgentHostService);
+    protected _propertyFilter(): AgentHostConfigPropertyFilter;
+    protected _settingsUri(backendSession: URI): string;
+    protected _schemaId(backendSession: URI): string;
+    protected _getConfig(backendSession: URI): IAgentHostConfigLike | undefined;
+}
+export {};

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

@@ -0,0 +1,161 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { isAutoApprovePolicyRestricted, normalizeSessionConfigValue } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/agentHostConfigPolicy';
+import { AbstractAgentHostConfigFileSystemProvider, serializeAgentHostConfigDocument, AbstractAgentHostConfigSchemaRegistrar } from './agentHostConfigEditor.js';
+
+const AGENT_SESSION_SETTINGS_SCHEME = "agent-session-settings";
+const SUBSCRIPTION_OWNER = "AgentSessionSettingsEditor";
+function agentSessionSettingsUri(backendSession) {
+    const rawId = backendSession.path.startsWith("/") ? backendSession.path.substring(1) : backendSession.path;
+    return ( URI.from({
+        scheme: AGENT_SESSION_SETTINGS_SCHEME,
+        authority: backendSession.scheme,
+        path: `/${rawId}.jsonc`
+    }));
+}
+function parseSessionSettingsUri(uri) {
+    if (uri.scheme !== AGENT_SESSION_SETTINGS_SCHEME || !uri.authority) {
+        return undefined;
+    }
+    let rawId = uri.path.startsWith("/") ? uri.path.substring(1) : uri.path;
+    const lastDot = rawId.lastIndexOf(".");
+    if (lastDot > 0) {
+        rawId = rawId.substring(0, lastDot);
+    }
+    if (!rawId) {
+        return undefined;
+    }
+    return {
+        backendSession: ( URI.from({
+            scheme: uri.authority,
+            path: `/${rawId}`
+        }))
+    };
+}
+const sessionSettingsPropertyFilter = (_key, schema) => {
+    const s = schema;
+    return s.sessionMutable === true && s.readOnly !== true;
+};
+const sessionSettingsLocale = {
+    get header() {
+        return localize(6117, "Session settings for this agent host session.");
+    },
+    get saveHint() {
+        return localize(
+            6118,
+            "Edit values below and save to apply. Unknown or non-mutable properties are ignored."
+        );
+    },
+    get parseError() {
+        return localize(6119, "Failed to parse agent session settings as JSON.");
+    },
+    get notObject() {
+        return localize(6120, "Agent session settings must be a JSON object.");
+    }
+};
+function readSessionConfig(state) {
+    if (!state || state instanceof Error || !state.config) {
+        return undefined;
+    }
+    return state.config;
+}
+let AgentSessionSettingsFileSystemProvider = class AgentSessionSettingsFileSystemProvider extends AbstractAgentHostConfigFileSystemProvider {
+    constructor(_schemaRegistrar, _agentHostService, _configurationService, logService) {
+        super(logService);
+        this._schemaRegistrar = _schemaRegistrar;
+        this._agentHostService = _agentHostService;
+        this._configurationService = _configurationService;
+        this._schemeLabel = AGENT_SESSION_SETTINGS_SCHEME;
+        this._traceTag = "AgentSessionSettings";
+        this._locale = sessionSettingsLocale;
+    }
+    _parseUri(resource) {
+        return parseSessionSettingsUri(resource);
+    }
+    _resolveTarget(ctx) {
+        const ref = this._agentHostService.getSubscription(StateComponents.Session, ctx.backendSession, SUBSCRIPTION_OWNER);
+        return {
+            backendSession: ctx.backendSession,
+            ref
+        };
+    }
+    _releaseTarget(target) {
+        target.ref.dispose();
+    }
+    _serialize(target) {
+        return serializeAgentHostConfigDocument(
+            readSessionConfig(target.ref.object.value),
+            sessionSettingsPropertyFilter,
+            sessionSettingsLocale
+        );
+    }
+    _watchChanges(target, _ctx, fire) {
+        return target.ref.object.onDidChange(() => fire());
+    }
+    _ensureSchemaRegistered(target) {
+        this._schemaRegistrar.ensureRegistered(target.backendSession);
+    }
+    _hasConfig(target) {
+        return readSessionConfig(target.ref.object.value) !== undefined;
+    }
+    async _replaceConfig(target, ctx, values) {
+        const current = readSessionConfig(target.ref.object.value);
+        if (!current) {
+            return;
+        }
+        const policyRestricted = isAutoApprovePolicyRestricted(this._configurationService);
+        const nextValues = {};
+        for (const [key, schema] of Object.entries(current.schema.properties)) {
+            if (sessionSettingsPropertyFilter(key, schema)) {
+                if (Object.hasOwn(values, key)) {
+                    nextValues[key] = normalizeSessionConfigValue(key, values[key], policyRestricted);
+                }
+            } else if (Object.hasOwn(current.values, key)) {
+                nextValues[key] = current.values[key];
+            }
+        }
+        if (equals(nextValues, current.values)) {
+            return;
+        }
+        this._agentHostService.dispatch(( ctx.backendSession.toString()), {
+            type: ActionType.SessionConfigChanged,
+            config: nextValues,
+            replace: true
+        });
+    }
+    _describeForTrace(ctx) {
+        return `session ${( ctx.backendSession.toString())}`;
+    }
+};
+AgentSessionSettingsFileSystemProvider = ( __decorate([( __param(1, IAgentHostService)), ( __param(2, IConfigurationService)), ( __param(3, ILogService))], AgentSessionSettingsFileSystemProvider));
+let AgentSessionSettingsSchemaRegistrar = class AgentSessionSettingsSchemaRegistrar extends AbstractAgentHostConfigSchemaRegistrar {
+    constructor(_agentHostService) {
+        super();
+        this._agentHostService = _agentHostService;
+    }
+    _propertyFilter() {
+        return sessionSettingsPropertyFilter;
+    }
+    _settingsUri(backendSession) {
+        return ( agentSessionSettingsUri(backendSession).toString());
+    }
+    _schemaId(backendSession) {
+        const rawId = backendSession.path.startsWith("/") ? backendSession.path.substring(1) : backendSession.path;
+        return `vscode://schemas/agent-session-settings/${backendSession.scheme}/${rawId}.jsonc`;
+    }
+    _getConfig(backendSession) {
+        const sub = this._agentHostService.getSubscriptionUnmanaged(StateComponents.Session, backendSession);
+        return readSessionConfig(sub?.value);
+    }
+};
+AgentSessionSettingsSchemaRegistrar = ( __decorate([( __param(0, IAgentHostService))], AgentSessionSettingsSchemaRegistrar));
+
+export { AGENT_SESSION_SETTINGS_SCHEME, AgentSessionSettingsFileSystemProvider, AgentSessionSettingsSchemaRegistrar, agentSessionSettingsUri };

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

@@ -0,0 +1,18 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IAgentHostSessionWorkingDirectoryResolver } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+export interface IApplyAgentHostSubmitConfigServices {
+    readonly agentHostService: IAgentHostService;
+    readonly provisionalService: IAgentHostUntitledProvisionalSessionService;
+    readonly workingDirectoryResolver: IAgentHostSessionWorkingDirectoryResolver;
+    readonly workspaceContextService: IWorkspaceContextService;
+    readonly configurationService: IConfigurationService;
+    readonly dialogService: IDialogService;
+    readonly storageService: IStorageService;
+}
+export declare function applyAgentHostSubmitConfig(sessionResource: URI, config: Readonly<Record<string, string>>, services: IApplyAgentHostSubmitConfigServices): Promise<boolean>;

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

@@ -0,0 +1,13 @@
+
+import { applyAgentHostCompletionAction } from '../../agentHostCompletionAction.js';
+import { applyAgentHostSessionConfigChange } from './applyAgentHostSessionConfig.js';
+
+async function applyAgentHostSubmitConfig(sessionResource, config, services) {
+    let applied = false;
+    const confirmed = await applyAgentHostCompletionAction({ applyConfig: config }, services.dialogService, services.storageService, async (config) => {
+        applied = await applyAgentHostSessionConfigChange(sessionResource, config, services);
+    });
+    return confirmed && applied;
+}
+
+export { applyAgentHostSubmitConfig };

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

@@ -0,0 +1,28 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentHostService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IDialogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatSubmitRequestHandlerService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatSubmitRequestHandlerService.service";
+import { IAgentHostSessionWorkingDirectoryResolver } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service";
+import { IAgentHostUntitledProvisionalSessionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service";
+export interface ICopilotConfigSlashSubmitResolution {
+    readonly applyConfig: Readonly<Record<string, string>>;
+    readonly strippedPrompt: string;
+}
+/** Resolves a typed Copilot config slash command into a config change. */
+export declare function resolveCopilotConfigSlashSubmit(input: string): ICopilotConfigSlashSubmitResolution | undefined;
+export declare class CopilotConfigSlashSubmitHandlerContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _agentHostService;
+    private readonly _provisionalService;
+    private readonly _workingDirectoryResolver;
+    private readonly _workspaceContextService;
+    private readonly _configurationService;
+    private readonly _dialogService;
+    private readonly _storageService;
+    static readonly ID = "workbench.contrib.chat.copilotConfigSlashSubmitHandler";
+    constructor(submitRequestHandlerService: IChatSubmitRequestHandlerService, _agentHostService: IAgentHostService, _provisionalService: IAgentHostUntitledProvisionalSessionService, _workingDirectoryResolver: IAgentHostSessionWorkingDirectoryResolver, _workspaceContextService: IWorkspaceContextService, _configurationService: IConfigurationService, _dialogService: IDialogService, _storageService: IStorageService);
+    private _tryHandle;
+}

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

@@ -0,0 +1,71 @@
+
+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 { parseLeadingSlashCommand } from '../../../../../../platform/agentHost/common/agentHostSlashCommand.js';
+import { resolveCopilotConfigSlashCommandOnSend } from '../../../../../../platform/agentHost/common/copilotConfigSlashCommands.js';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDialogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/dialogs/common/dialogs.service';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IChatSubmitRequestHandlerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chatSubmitRequestHandlerService.service';
+import { SessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { IAgentHostSessionWorkingDirectoryResolver } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSessionWorkingDirectoryResolver.service';
+import { IAgentHostUntitledProvisionalSessionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostUntitledProvisionalSessionService.service';
+import { applyAgentHostSubmitConfig } from './applyAgentHostSubmitConfig.js';
+
+function resolveCopilotConfigSlashSubmit(input) {
+    const slashCommand = parseLeadingSlashCommand(input);
+    return slashCommand ? resolveCopilotConfigSlashCommandOnSend(slashCommand.command, slashCommand.rawRest) : undefined;
+}
+let CopilotConfigSlashSubmitHandlerContribution = class CopilotConfigSlashSubmitHandlerContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chat.copilotConfigSlashSubmitHandler";
+    }
+    constructor(
+        submitRequestHandlerService,
+        _agentHostService,
+        _provisionalService,
+        _workingDirectoryResolver,
+        _workspaceContextService,
+        _configurationService,
+        _dialogService,
+        _storageService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._provisionalService = _provisionalService;
+        this._workingDirectoryResolver = _workingDirectoryResolver;
+        this._workspaceContextService = _workspaceContextService;
+        this._configurationService = _configurationService;
+        this._dialogService = _dialogService;
+        this._storageService = _storageService;
+        this._register(submitRequestHandlerService.register({
+            id: "copilot.configSlash",
+            tryHandle: request => this._tryHandle(request)
+        }));
+    }
+    async _tryHandle(request) {
+        if (getChatSessionType(request.sessionResource) !== SessionType.AgentHostCopilot) {
+            return false;
+        }
+        const configAction = resolveCopilotConfigSlashSubmit(request.input);
+        if (!configAction) {
+            return false;
+        }
+        await applyAgentHostSubmitConfig(request.sessionResource, configAction.applyConfig, {
+            agentHostService: this._agentHostService,
+            provisionalService: this._provisionalService,
+            workingDirectoryResolver: this._workingDirectoryResolver,
+            workspaceContextService: this._workspaceContextService,
+            configurationService: this._configurationService,
+            dialogService: this._dialogService,
+            storageService: this._storageService
+        });
+        return !configAction.strippedPrompt;
+    }
+};
+CopilotConfigSlashSubmitHandlerContribution = ( __decorate([( __param(0, IChatSubmitRequestHandlerService)), ( __param(1, IAgentHostService)), ( __param(2, IAgentHostUntitledProvisionalSessionService)), ( __param(3, IAgentHostSessionWorkingDirectoryResolver)), ( __param(4, IWorkspaceContextService)), ( __param(5, IConfigurationService)), ( __param(6, IDialogService)), ( __param(7, IStorageService))], CopilotConfigSlashSubmitHandlerContribution));
+
+export { CopilotConfigSlashSubmitHandlerContribution, resolveCopilotConfigSlashSubmit };

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

@@ -0,0 +1,35 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { ILinkPresentationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/dataChannel/common/dataChannel.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IPathService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service";
+import { IChatRequestOriginService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatRequestOrigin.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { IChatWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat.service";
+import { ISessionSummaryHoverService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/sessionSummaryHoverService.service";
+/**
+ * Editor-window counterpart to the Agents window's
+ * `OpenSessionLinkOpenerContribution`: handles `agent-host-session://` links
+ * surfaced by the `create_session` / `create_chat` server tools, so the linked
+ * session title also works in the regular editor-window chat.
+ *
+ * The link carries the backend session URI (`<provider>:/<rawId>`); sessions
+ * created from an editor-window chat run on the window's ambient/local host,
+ * whose client scheme is `agent-host-<provider>`. We rebuild that client
+ * resource and open it through {@link IChatWidgetService.openSession}.
+ *
+ * Also registers an {@link IChatRequestOriginService} opener that reuses {@link _open} for delegated request-origin links (e.g. "Sent from another chat").
+ *
+ * Registered only from the workbench's electron-browser chat contribution (never
+ * loaded by the Agents window), so it never competes with the Agents-window
+ * opener.
+ */
+export declare class AgentHostOpenSessionLinkOpenerContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _chatWidgetService;
+    private readonly _chatSessionsService;
+    static readonly ID = "workbench.chat.agentHostOpenSessionLinkOpener";
+    constructor(openerService: IOpenerService, _chatWidgetService: IChatWidgetService, _chatSessionsService: IChatSessionsService, requestOriginService: IChatRequestOriginService, linkPresentationService: ILinkPresentationService, logService: ILogService, sessionSummaryHoverService: ISessionSummaryHoverService, pathService: IPathService);
+    private _findChatSessionItem;
+    private _open;
+}