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

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

@@ -0,0 +1,460 @@
+
+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 { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { dirname, basename, extUriBiasedIgnorePathCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { getCustomizationDisabledReason, isCustomizationEnabled } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/customizationEnablement';
+import { isAgentBuiltinCustomizationUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostCustomizationUri';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import '../../../../../services/agentHost/common/agentHostFileSystemService.js';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { toAgentHostUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostUri';
+import { readAgentCustomizationMeta } from '../../../../../../platform/agentHost/common/meta/agentCustomizationMeta.js';
+import { AICustomizationSources } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/aiCustomizationWorkspaceService';
+import { Target, PromptsType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes';
+import { AgentCustomizationContentExpander } from './agentCustomizationContentExpander.js';
+import { IAgentHostCustomizationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostCustomizationService.service';
+import { PromptsStorage } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService';
+import { IPromptsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service';
+import { getChatSessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { getAgentHostPluginEnablementActions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentPluginActions';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { SYNCED_CUSTOMIZATION_SCHEME } from '../../../../../../platform/agentHost/common/agentHostFileSystemService.js';
+import { CustomizationType, CustomizationLoadStatus } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+
+const REMOTE_HOST_GROUP = "remote-host";
+const REMOTE_CLIENT_GROUP = "remote-client";
+let AgentCustomizationItemProvider = class AgentCustomizationItemProvider extends Disposable {
+    constructor(
+        _connectionAuthority,
+        _getItemActions,
+        _resolveSyncedOrigin,
+        _fileService,
+        _logService,
+        _customAgentsService,
+        _promptsService
+    ) {
+        super();
+        this._connectionAuthority = _connectionAuthority;
+        this._getItemActions = _getItemActions;
+        this._resolveSyncedOrigin = _resolveSyncedOrigin;
+        this._fileService = _fileService;
+        this._logService = _logService;
+        this._customAgentsService = _customAgentsService;
+        this._promptsService = _promptsService;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._expansionCache = ( new ResourceMap());
+        this._contentExpander = ( new AgentCustomizationContentExpander(this._fileService, this._logService));
+        this._register(this._customAgentsService.onDidChangeCustomizations(() => {
+            this._onDidChange.fire();
+        }));
+        this._register(this._promptsService.onDidChangeSkills(() => {
+            this._onDidChange.fire();
+        }));
+    }
+    setDraftCustomAgents(customAgents) {
+        this._draftCustomAgents = customAgents;
+        this._register(autorun(reader => {
+            customAgents.read(reader);
+            this._onDidChange.fire();
+        }));
+    }
+    setDraftCustomizations(customizations) {
+        this._draftCustomizations = customizations;
+        this._register(autorun(reader => {
+            customizations.read(reader);
+            this._onDidChange.fire();
+        }));
+    }
+    toRemoteUri(customizationUri) {
+        const original = ( URI.parse(customizationUri));
+        if (original.scheme === SYNCED_CUSTOMIZATION_SCHEME) {
+            return original;
+        }
+        return toAgentHostUri(original, this._connectionAuthority);
+    }
+    toBadge(customization, fromClient) {
+        if (fromClient) {
+            return {
+                groupKey: REMOTE_CLIENT_GROUP
+            };
+        }
+        return {
+            groupKey: REMOTE_HOST_GROUP
+        };
+    }
+    toItem(sessionResource, customization, source) {
+        const clientId = customization.clientId;
+        const badge = this.toBadge(customization, clientId !== undefined);
+        const uri = this.toRemoteUri(customization.uri);
+        return {
+            itemKey: customizationItemKey(customization, clientId),
+            uri: uri,
+            type: "plugin",
+            name: customization.name,
+            description: undefined,
+            source,
+            status: toStatusString(customization.load),
+            statusMessage: toStatusMessage(customization.load),
+            enabled: isCustomizationEnabled(customization),
+            disabledReason: getCustomizationDisabledReason(customization),
+            badge: badge.badge,
+            badgeTooltip: badge.badgeTooltip,
+            groupKey: badge.groupKey,
+            extensionId: undefined,
+            pluginUri: uri,
+            userInvocable: undefined,
+            actions: [...(clientId === undefined ? getAgentHostPluginEnablementActions(
+                this._customAgentsService,
+                undefined,
+                sessionResource,
+                customization,
+                this._customAgentsService.getWorkingDirectories(sessionResource).length > 0
+            ) : []), ...(this._getItemActions?.(customization, clientId) ?? [])]
+        };
+    }
+    toDirectoryItems(customization, source, isRemote, workingDirectories) {
+        const items = [];
+        for (const child of customization.children ?? []) {
+            const item = this.toDirectoryChildItem(
+                child,
+                getDirectoryChildSource(workingDirectories, child.uri, source),
+                isRemote
+            );
+            if (item) {
+                items.push(item);
+            }
+        }
+        return items;
+    }
+    toDirectoryChildItem(child, source, isRemote) {
+        const type = toPromptsType(child.type);
+        if (!type) {
+            return undefined;
+        }
+        let userInvocable = undefined;
+        if (child.type === CustomizationType.Agent) {
+            userInvocable = readAgentCustomizationMeta(child).userInvocable !== false;
+        }
+        let groupKey = isRemote ? REMOTE_CLIENT_GROUP : undefined;
+        let badge = undefined;
+        let badgeTooltip = undefined;
+        if (!groupKey && child.type === CustomizationType.Rule) {
+            const pattern = child.globs?.[0];
+            if (child.globs && child.globs.length > 0) {
+                groupKey = "context-instructions";
+                badge = pattern === "**" ? ( localize(5983, "always added")) : pattern;
+                badgeTooltip = pattern === "**" ? ( localize(5984, "This instruction is automatically included in every interaction.")) : ( localize(
+                    5985,
+                    "This instruction is automatically included when files matching '{0}' are in context.",
+                    pattern
+                ));
+            } else if (child.alwaysApply) {
+                groupKey = "agent-instructions";
+            } else {
+                groupKey = "on-demand-instructions";
+            }
+        }
+        return {
+            itemKey: child.id,
+            uri: this.toRemoteUri(child.uri),
+            type,
+            name: child.name,
+            description: getChildDescription(child),
+            source,
+            groupKey,
+            badge,
+            badgeTooltip,
+            extensionId: undefined,
+            pluginUri: undefined,
+            userInvocable
+        };
+    }
+    async provideSourceFolders(sessionResource, type, token) {
+        await this._customAgentsService.whenCustomizationsReady(sessionResource, token);
+        const workingDirectories = this._customAgentsService.getWorkingDirectories(sessionResource);
+        const folders = [];
+        for (const customization of this._customAgentsService.getCustomizations(sessionResource)) {
+            if (!isDirectoryCustomization(customization) || !customization.writable) {
+                continue;
+            }
+            if (toPromptsType(customization.contents) !== type) {
+                continue;
+            }
+            const source = isUnderAnyRoot(workingDirectories, customization.uri) ? AICustomizationSources.local : AICustomizationSources.user;
+            folders.push({
+                uri: this.toRemoteUri(customization.uri),
+                label: customization.name,
+                source,
+                destinationGroupId: ( dirname(this.toRemoteUri(customization.uri)).toString())
+            });
+        }
+        return folders;
+    }
+    async provideCustomAgents(sessionResource) {
+        const agents = this.getCustomAgents(sessionResource);
+        const sessionTypes = [getChatSessionType(sessionResource)];
+        return ( agents.map(agent => ({
+            id: agent.uri,
+            uri: this.toRemoteUri(agent.uri),
+            name: agent.name,
+            description: agent.description,
+            sessionTypes: sessionTypes,
+            enabled: true,
+            source: {
+                storage: PromptsStorage.local
+            },
+            tools: undefined,
+            agents: undefined,
+            argumentHint: undefined,
+            handOffs: undefined,
+            hooks: undefined,
+            model: undefined,
+            agentInstructions: {
+                content: "",
+                toolReferences: []
+            },
+            visibility: {
+                agentInvocable: true,
+                userInvocable: readAgentCustomizationMeta(agent).userInvocable !== false
+            },
+            target: Target.Undefined
+        })));
+    }
+    async provideChatSessionCustomizations(sessionResource, token) {
+        const items = ( new Map());
+        const workingDirectories = this._customAgentsService.getWorkingDirectories(sessionResource);
+        const plugins = [];
+        const expandPromises = [];
+        const customizations = this.getCustomizations(sessionResource);
+        const directoryCustomizations = [];
+        for (const sessionCustomization of customizations) {
+            if (isDirectoryCustomization(sessionCustomization)) {
+                directoryCustomizations.push(sessionCustomization);
+            } else if (sessionCustomization.type === CustomizationType.McpServer) {
+                continue;
+            } else {
+                const isBundleItem = isSyntheticBundle(sessionCustomization);
+                const isClientSynced = sessionCustomization.clientId !== undefined;
+                const childGroupKey = isClientSynced ? REMOTE_CLIENT_GROUP : REMOTE_HOST_GROUP;
+                let item;
+                if (!isBundleItem) {
+                    item = this.toItem(sessionResource, sessionCustomization, AICustomizationSources.plugin);
+                    items.set(
+                        customizationItemKey(sessionCustomization, sessionCustomization.clientId),
+                        item
+                    );
+                } else {
+                    item = {
+                        uri: this.toRemoteUri(sessionCustomization.uri),
+                        type: "plugin",
+                        source: AICustomizationSources.plugin,
+                        name: "",
+                        groupKey: childGroupKey,
+                        extensionId: undefined,
+                        pluginUri: undefined
+                    };
+                }
+                const pluginMeta = {
+                    item,
+                    nonce: sessionCustomization.nonce,
+                    status: toStatusString(sessionCustomization.load),
+                    statusMessage: toStatusMessage(sessionCustomization.load),
+                    enabled: isCustomizationEnabled(sessionCustomization),
+                    disabledReason: getCustomizationDisabledReason(sessionCustomization),
+                    childGroupKey,
+                    isBundleItem,
+                    pluginLabel: isBundleItem ? undefined : item.name
+                };
+                plugins.push(pluginMeta);
+                expandPromises.push(this._expandPluginContents(pluginMeta, token));
+            }
+        }
+        const expansions = await Promise.all(expandPromises);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        for (let i = 0; i < plugins.length; i++) {
+            const p = plugins[i];
+            for (const child of expansions[i]) {
+                const enriched = p.isBundleItem ? this._applySyncedOrigin(child) : child;
+                items.set(( enriched.uri.toString()), {
+                    ...enriched,
+                    status: p.status,
+                    statusMessage: p.statusMessage,
+                    enabled: p.enabled,
+                    disabledReason: p.disabledReason
+                });
+            }
+        }
+        for (const sessionCustomization of directoryCustomizations) {
+            const source = isAgentBuiltinCustomizationUri(( URI.parse(sessionCustomization.uri))) ? AICustomizationSources.builtin : isUnderAnyRoot(workingDirectories, sessionCustomization.uri) ? AICustomizationSources.local : AICustomizationSources.user;
+            const isRemote = sessionCustomization.clientId !== undefined;
+            for (const child of this.toDirectoryItems(sessionCustomization, source, isRemote, workingDirectories)) {
+                items.set(child.itemKey ?? ( child.uri.toString()), {
+                    ...child,
+                    status: toStatusString(sessionCustomization.load),
+                    statusMessage: toStatusMessage(sessionCustomization.load),
+                    enabled: sessionCustomization.enabled
+                });
+            }
+        }
+        const disabledBuiltinSkills = this._promptsService.getDisabledPromptFiles(PromptsType.skill);
+        const builtinSkills = await this._promptsService.listPromptFilesForStorage(PromptsType.skill, PromptsStorage.builtIn, token);
+        if (token.isCancellationRequested) {
+            return [];
+        }
+        for (const skill of builtinSkills) {
+            if (!( disabledBuiltinSkills.has(skill.uri))) {
+                continue;
+            }
+            const key = ( skill.uri.toString());
+            const existing = items.get(key);
+            items.set(key, {
+                ...existing,
+                uri: skill.uri,
+                type: PromptsType.skill,
+                name: skill.name ?? existing?.name ?? basename(dirname(skill.uri)),
+                description: skill.description ?? existing?.description,
+                source: AICustomizationSources.builtin,
+                extensionId: undefined,
+                pluginUri: undefined,
+                enabled: false,
+                userInvocable: true
+            });
+        }
+        return [...( items.values())];
+    }
+    getCustomAgents(sessionResource) {
+        const sessionAgents = this._customAgentsService.getCustomAgents(sessionResource);
+        return sessionAgents.length > 0 ? sessionAgents : this._draftCustomAgents?.get() ?? [];
+    }
+    getCustomizations(sessionResource) {
+        const sessionCustomizations = this._customAgentsService.getCustomizations(sessionResource);
+        const draftCustomizations = this._draftCustomizations?.get() ?? [];
+        if (draftCustomizations.length === 0) {
+            return sessionCustomizations;
+        }
+        const sessionKeys = ( new Set(( sessionCustomizations.map(customization => `${customization.type}:${customization.uri}`))));
+        return [
+            ...sessionCustomizations,
+            ...draftCustomizations.filter(customization => !( sessionKeys.has(`${customization.type}:${customization.uri}`)))
+        ];
+    }
+    _applySyncedOrigin(child) {
+        const origin = this._resolveSyncedOrigin?.(child.uri);
+        if (!origin) {
+            return child;
+        }
+        return {
+            ...child,
+            uri: origin.uri,
+            source: origin.source,
+            extensionId: origin.extensionId,
+            pluginUri: origin.pluginUri,
+            groupKey: origin.source === AICustomizationSources.user ? child.groupKey : undefined
+        };
+    }
+    async _expandPluginContents(plugin, token) {
+        const cached = this._expansionCache.get(plugin.item.uri);
+        if (cached && cached.nonce === plugin.nonce && cached.pluginLabel === plugin.pluginLabel) {
+            return cached.children;
+        }
+        const children = await this._contentExpander.expandPluginContents(
+            plugin.item.uri,
+            plugin.childGroupKey,
+            plugin.isBundleItem,
+            plugin.item.source,
+            plugin.pluginLabel,
+            token
+        );
+        this._expansionCache.set(plugin.item.uri, {
+            nonce: plugin.nonce,
+            pluginLabel: plugin.pluginLabel,
+            children
+        });
+        return children;
+    }
+};
+AgentCustomizationItemProvider = ( __decorate([( __param(3, IFileService)), ( __param(4, ILogService)), ( __param(5, IAgentHostCustomizationService)), ( __param(6, IPromptsService))], AgentCustomizationItemProvider));
+function isParentOrEqual(folderURI, childURI) {
+    try {
+        return extUriBiasedIgnorePathCase.isEqualOrParent(( URI.parse(childURI)), ( URI.parse(folderURI)));
+    } catch {
+        return childURI === folderURI || childURI.startsWith(folderURI + "/");
+    }
+}
+function isUnderAnyRoot(roots, childURI) {
+    return ( roots.some(root => isParentOrEqual(root, childURI)));
+}
+function getDirectoryChildSource(roots, childURI, fallback) {
+    try {
+        if (( URI.parse(childURI)).scheme !== Schemas.file) {
+            return fallback;
+        }
+    } catch {
+        return fallback;
+    }
+    return isUnderAnyRoot(roots, childURI) ? AICustomizationSources.local : AICustomizationSources.user;
+}
+function toStatusString(load) {
+    return load?.kind;
+}
+function toStatusMessage(load) {
+    if (load?.kind === CustomizationLoadStatus.Degraded || load?.kind === CustomizationLoadStatus.Error) {
+        return load.message;
+    }
+    return undefined;
+}
+function customizationKey(customization) {
+    return customization.id;
+}
+function customizationItemKey(customization, clientId) {
+    return clientId !== undefined ? `${customizationKey(customization)}::${clientId}` : customizationKey(customization);
+}
+function isDirectoryCustomization(customization) {
+    return customization.type === CustomizationType.Directory;
+}
+function toPromptsType(type) {
+    switch (type) {
+    case CustomizationType.Agent:
+        return PromptsType.agent;
+    case CustomizationType.Skill:
+        return PromptsType.skill;
+    case CustomizationType.Rule:
+        return PromptsType.instructions;
+    case CustomizationType.Prompt:
+        return PromptsType.prompt;
+    case CustomizationType.Hook:
+        return PromptsType.hook;
+    default:
+        return undefined;
+    }
+}
+function getChildDescription(child) {
+    switch (child.type) {
+    case CustomizationType.Agent:
+    case CustomizationType.Skill:
+    case CustomizationType.Prompt:
+    case CustomizationType.Rule:
+        return child.description;
+    default:
+        return undefined;
+    }
+}
+function isSyntheticBundle(customization) {
+    try {
+        return ( URI.parse(customization.uri)).scheme === SYNCED_CUSTOMIZATION_SCHEME;
+    } catch {
+        return false;
+    }
+}
+
+export { AgentCustomizationItemProvider };

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,92 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { registerWorkbenchContribution2, WorkbenchPhase } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions';
+import { AgentHostAllowSignedOutWhenUsableContribution } from './agentHostAllowSignedOutWhenUsableContribution.js';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/lazy';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { AgentHostContribution } from './agentHostChatContribution.js';
+import { AgentHostCopilotCliSettingsContribution } from './agentHostCopilotCliSettingsContribution.js';
+import { AgentHostExistingSessionHarnessPickerEnablement } from './agentHostExistingSessionHarnessPickerEnablement.js';
+import { AgentHostOpenSessionLinkOpenerContribution } from './openSessionLinkOpener.contribution.js';
+import { AgentHostSessionListContribution } from './agentHostSessionListContribution.js';
+import { AgentHostSdkSetupNotificationContribution } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostSdkSetupNotification';
+import { AgentHostSignedOutModelsNotificationContribution } from './agentHostSignedOutModelsNotification.js';
+import { AgentHostTerminalContribution } from './agentHostTerminalContribution.js';
+import { CopilotConfigSlashSubmitHandlerContribution } from './copilotConfigSlashSubmitHandler.js';
+import { primeLegacyMigrationStartupSnapshot } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostLegacyMigration';
+import './agentHostSettings.contribution.js';
+import './agentSessionSettings.contribution.js';
+
+let AgentHostLegacyMigrationGateContribution = class AgentHostLegacyMigrationGateContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.chat.agentHostLegacyMigrationGate";
+    }
+    constructor(configurationService) {
+        super();
+        primeLegacyMigrationStartupSnapshot(configurationService);
+    }
+};
+AgentHostLegacyMigrationGateContribution = ( __decorate([( __param(0, IConfigurationService))], AgentHostLegacyMigrationGateContribution));
+registerWorkbenchContribution2(
+    AgentHostContribution.ID,
+    AgentHostContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentHostExistingSessionHarnessPickerEnablement.ID,
+    AgentHostExistingSessionHarnessPickerEnablement,
+    WorkbenchPhase.BlockRestore
+);
+registerWorkbenchContribution2(
+    AgentHostLegacyMigrationGateContribution.ID,
+    AgentHostLegacyMigrationGateContribution,
+    WorkbenchPhase.BlockStartup
+);
+registerWorkbenchContribution2(
+    CopilotConfigSlashSubmitHandlerContribution.ID,
+    CopilotConfigSlashSubmitHandlerContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentHostSessionListContribution.ID,
+    AgentHostSessionListContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentHostOpenSessionLinkOpenerContribution.ID,
+    AgentHostOpenSessionLinkOpenerContribution,
+    WorkbenchPhase.BlockStartup
+);
+registerWorkbenchContribution2(
+    AgentHostTerminalContribution.ID,
+    AgentHostTerminalContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentHostCopilotCliSettingsContribution.ID,
+    AgentHostCopilotCliSettingsContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentHostAllowSignedOutWhenUsableContribution.ID,
+    AgentHostAllowSignedOutWhenUsableContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentHostSignedOutModelsNotificationContribution.ID,
+    AgentHostSignedOutModelsNotificationContribution,
+    WorkbenchPhase.AfterRestored
+);
+registerWorkbenchContribution2(
+    AgentHostSdkSetupNotificationContribution.ID,
+    AgentHostSdkSetupNotificationContribution,
+    WorkbenchPhase.AfterRestored
+);

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

@@ -0,0 +1,23 @@
+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 { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+/**
+ * Forwards the `chat.agentHost.allowSignedOutWhenUsable` experimentation opt-in
+ * into the **local** agent host's root config under the short key
+ * {@link AgentHostConfigKey.AllowSignedOutWhenUsable}. This closes the two-reader
+ * contract: the workbench reads the VS Code setting directly, while the node-side
+ * Layer 1 gate reads the root-config bag (keyed only by short keys), so the flag
+ * must be mirrored here or the node side would never see it. Gated on
+ * Agent Host runtime availability. The schema-gate / hydration-retry / loop-guard
+ * machinery lives in the shared {@link AgentHostRootConfigForwarder}; this
+ * contribution only declares the key.
+ */
+export declare class AgentHostAllowSignedOutWhenUsableContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _configurationService;
+    private readonly _agentHostEnablementService;
+    static readonly ID = "workbench.contrib.agentHostAllowSignedOutWhenUsable";
+    private readonly _forwarder;
+    constructor(agentHostService: IAgentHostService, _configurationService: IConfigurationService, _agentHostEnablementService: IAgentHostEnablementService);
+}

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

@@ -0,0 +1,46 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { AgentHostAllowSignedOutWhenUsableSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { AgentHostConfigKey } from '../../../../../../platform/agentHost/common/agentHostCustomizationConfig.js';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { AgentHostRootConfigForwarder } from './agentHostRootConfigForwarder.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let AgentHostAllowSignedOutWhenUsableContribution = class AgentHostAllowSignedOutWhenUsableContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostAllowSignedOutWhenUsable";
+    }
+    constructor(agentHostService, _configurationService, _agentHostEnablementService) {
+        super();
+        this._configurationService = _configurationService;
+        this._agentHostEnablementService = _agentHostEnablementService;
+        const keys = [{
+            key: AgentHostConfigKey.AllowSignedOutWhenUsable,
+            computeValue: () => this._configurationService.getValue(AgentHostAllowSignedOutWhenUsableSettingId) === true,
+            registerTriggers: (store, push) => {
+                const optInChanged = Event.filter(
+                    this._configurationService.onDidChangeConfiguration,
+                    e => e.affectsConfiguration(AgentHostAllowSignedOutWhenUsableSettingId),
+                    store
+                );
+                store.add(optInChanged(() => push()));
+            }
+        }];
+        this._forwarder = this._register(( new AgentHostRootConfigForwarder(keys, agentHostService)));
+        this._register(autorun(reader => {
+            if (this._agentHostEnablementService.enabled.read(reader)) {
+                this._forwarder.start();
+            } else {
+                this._forwarder.stop();
+            }
+        }));
+    }
+};
+AgentHostAllowSignedOutWhenUsableContribution = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, IConfigurationService)), ( __param(2, IAgentHostEnablementService))], AgentHostAllowSignedOutWhenUsableContribution));
+
+export { AgentHostAllowSignedOutWhenUsableContribution };