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

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

@@ -0,0 +1,163 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+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 { 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 { 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 { ROOT_STATE_URI } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { AbstractAgentHostConfigFileSystemProvider, serializeAgentHostConfigDocument, AbstractAgentHostConfigSchemaRegistrar } from './agentHostConfigEditor.js';
+
+const AGENT_HOST_SETTINGS_SCHEME = "agent-host-settings";
+const AGENT_HOST_SETTINGS_LOCAL_AUTHORITY = "local";
+function agentHostSettingsUri() {
+    return ( URI.from({
+        scheme: AGENT_HOST_SETTINGS_SCHEME,
+        authority: AGENT_HOST_SETTINGS_LOCAL_AUTHORITY,
+        path: `/settings.jsonc`
+    }));
+}
+function parseAmbientHostSettingsUri(uri) {
+    if (uri.scheme !== AGENT_HOST_SETTINGS_SCHEME || uri.authority !== AGENT_HOST_SETTINGS_LOCAL_AUTHORITY || uri.path !== "/settings.jsonc") {
+        return undefined;
+    }
+    return {
+        kind: "local"
+    };
+}
+const hostSettingsPropertyFilter = () => true;
+const hostSettingsLocale = {
+    get header() {
+        return localize(6106, "Agent host settings.");
+    },
+    get saveHint() {
+        return localize(
+            6107,
+            "Edit values below and save to apply. Unknown properties are ignored."
+        );
+    },
+    get parseError() {
+        return localize(6108, "Failed to parse agent host settings as JSON.");
+    },
+    get notObject() {
+        return localize(6109, "Agent host settings must be a JSON object.");
+    }
+};
+function readRootConfig(state) {
+    if (!state || state instanceof Error) {
+        return undefined;
+    }
+    return state.config;
+}
+let AgentHostSettingsFileSystemProvider = class AgentHostSettingsFileSystemProvider extends AbstractAgentHostConfigFileSystemProvider {
+    constructor(_schemaRegistrar, _agentHostService, logService) {
+        super(logService);
+        this._schemaRegistrar = _schemaRegistrar;
+        this._agentHostService = _agentHostService;
+        this._schemeLabel = AGENT_HOST_SETTINGS_SCHEME;
+        this._traceTag = "AgentHostSettings";
+        this._locale = hostSettingsLocale;
+        this._onDidChangeRootConfig = this._register(( new Emitter()));
+        this._syncRootConfig(this._agentHostService.rootState.value);
+        this._register(
+            this._agentHostService.rootState.onDidChange(state => this._syncRootConfig(state))
+        );
+    }
+    _syncRootConfig(state) {
+        const next = readRootConfig(state);
+        const prev = this._rootConfig;
+        if (prev === next) {
+            return;
+        }
+        if (!next) {
+            this._rootConfig = undefined;
+            this._onDidChangeRootConfig.fire();
+            return;
+        }
+        if (prev?.schema === next.schema && equals(prev.values, next.values)) {
+            return;
+        }
+        this._rootConfig = next;
+        this._onDidChangeRootConfig.fire();
+    }
+    _parseUri(resource) {
+        return parseAmbientHostSettingsUri(resource);
+    }
+    _resolveTarget() {
+        return this._agentHostService;
+    }
+    _missingTargetError() {
+        return createFileSystemProviderError("Agent host is not available", FileSystemProviderErrorCode.FileNotFound);
+    }
+    _serialize() {
+        return serializeAgentHostConfigDocument(this._rootConfig, hostSettingsPropertyFilter, hostSettingsLocale);
+    }
+    _watchChanges(_target, _ctx, fire) {
+        return this._onDidChangeRootConfig.event(() => fire());
+    }
+    _ensureSchemaRegistered(target) {
+        this._schemaRegistrar.ensureRegistered(target);
+    }
+    _hasConfig() {
+        return this._rootConfig !== undefined;
+    }
+    async _replaceConfig(_target, _ctx, values) {
+        const current = this._rootConfig;
+        if (!current) {
+            return;
+        }
+        const nextValues = {};
+        for (const [key, value] of Object.entries(values)) {
+            if (current.schema.properties[key]) {
+                nextValues[key] = value;
+            }
+        }
+        if (equals(nextValues, current.values)) {
+            return;
+        }
+        this._rootConfig = {
+            ...current,
+            values: nextValues
+        };
+        this._onDidChangeRootConfig.fire();
+        this._agentHostService.dispatch(ROOT_STATE_URI, {
+            type: ActionType.RootConfigChanged,
+            config: nextValues,
+            replace: true
+        });
+    }
+    _describeForTrace() {
+        return "local agent host";
+    }
+};
+AgentHostSettingsFileSystemProvider = ( __decorate([( __param(1, IAgentHostService)), ( __param(2, ILogService))], AgentHostSettingsFileSystemProvider));
+let AgentHostSettingsSchemaRegistrar = class AgentHostSettingsSchemaRegistrar extends AbstractAgentHostConfigSchemaRegistrar {
+    constructor(_agentHostService) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._register(this._agentHostService.rootState.onDidChange(() => {
+            if (!this._isRegistered(this._agentHostService)) {
+                return;
+            }
+            this._refreshSchema(this._agentHostService);
+        }));
+    }
+    _propertyFilter() {
+        return hostSettingsPropertyFilter;
+    }
+    _settingsUri() {
+        return ( agentHostSettingsUri().toString());
+    }
+    _schemaId() {
+        return `vscode://schemas/agent-host-settings/${AGENT_HOST_SETTINGS_LOCAL_AUTHORITY}.jsonc`;
+    }
+    _getConfig(target) {
+        return readRootConfig(target.rootState.value);
+    }
+};
+AgentHostSettingsSchemaRegistrar = ( __decorate([( __param(0, IAgentHostService))], AgentHostSettingsSchemaRegistrar));
+
+export { AGENT_HOST_SETTINGS_LOCAL_AUTHORITY, AGENT_HOST_SETTINGS_SCHEME, AgentHostSettingsFileSystemProvider, AgentHostSettingsSchemaRegistrar, agentHostSettingsUri };

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

@@ -0,0 +1,54 @@
+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 { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { ILanguageModelsConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration.service";
+export declare enum SignedOutModelsNotificationState {
+    Hidden = 0,
+    Waiting = 1,
+    Visible = 2
+}
+export declare function getSignedOutModelsNotificationState(options: {
+    readonly allowSignedOutWhenUsable: boolean;
+    readonly accountResolved: boolean;
+    readonly entitlementResolved: boolean;
+    readonly signedIn: boolean;
+    readonly hasCopilotHarness: boolean;
+    readonly hasModels: boolean;
+    readonly localModelsLoaded: boolean;
+    readonly gracePeriodElapsed: boolean;
+    readonly setupDialogVisible: boolean;
+}): SignedOutModelsNotificationState;
+export declare function areLocalModelsLoaded(extensionsRegistered: boolean, configurationLoaded: boolean, configuredByokVendors: readonly string[], hasResolvedVendor: (vendor: string) => boolean): boolean;
+/**
+ * Shows harness-scoped guidance when signed-out operation is enabled but the selected harness has no usable models.
+ */
+export declare class AgentHostSignedOutModelsNotificationContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _chatInputNotificationService;
+    private readonly _defaultAccountService;
+    private readonly _languageModelsService;
+    private readonly _languageModelsConfigurationService;
+    private readonly _agentHostService;
+    private readonly _configurationService;
+    private readonly _chatEntitlementService;
+    private readonly _contextKeyService;
+    static readonly ID = "workbench.contrib.agentHostSignedOutModelsNotification";
+    private _notificationShown;
+    /** Startup readiness prevents transient empty catalogs from producing false notifications. */
+    private _accountResolved;
+    private _extensionsRegistered;
+    private _configurationLoaded;
+    private _gracePeriodElapsed;
+    private readonly _gracePeriod;
+    constructor(_chatInputNotificationService: IChatInputNotificationService, _defaultAccountService: IDefaultAccountService, _languageModelsService: ILanguageModelsService, _languageModelsConfigurationService: ILanguageModelsConfigurationService, _agentHostService: IAgentHostService, _configurationService: IConfigurationService, _chatEntitlementService: IChatEntitlementService, _contextKeyService: IContextKeyService, extensionService: IExtensionService);
+    private _update;
+    private _updateGracePeriod;
+    private _setNotification;
+    private _createNotification;
+}

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

@@ -0,0 +1,219 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, MutableDisposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { ChatEntitlementContextKeys, ChatEntitlement } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IExtensionService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service';
+import { hasVisibleByokModelsTargetingSessionType } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/agentSessions/sessionTypeAvailability';
+import { ChatSetupDialogVisibleContext } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/chatSetup/chatSetup';
+import { ChatInputNotificationActionKind, ChatInputNotificationSeverity } from '@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService';
+import { IChatInputNotificationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service';
+import { SessionType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { MANAGE_CHAT_COMMAND_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { COPILOT_VENDOR_ID } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { ILanguageModelsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service';
+import { ILanguageModelsConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModelsConfiguration.service';
+
+const SIGNED_OUT_MODELS_NOTIFICATION_ID = "agentHost.signedOutModels.copilot";
+const SIGN_IN_COMMAND_ID = "workbench.action.chat.triggerSetup";
+const COPILOT_AGENT_HOST_PROVIDER_ID = "copilotcli";
+const NOTIFICATION_CONTEXT_KEYS = ( new Set([
+    ChatEntitlementContextKeys.clientByokEnabled.key,
+    ChatSetupDialogVisibleContext.key
+]));
+const NOTIFICATION_GRACE_PERIOD_MS = 5_000;
+var SignedOutModelsNotificationState;
+(function(SignedOutModelsNotificationState) {
+    SignedOutModelsNotificationState[SignedOutModelsNotificationState["Hidden"] = 0] = "Hidden";
+    SignedOutModelsNotificationState[SignedOutModelsNotificationState["Waiting"] = 1] = "Waiting";
+    SignedOutModelsNotificationState[SignedOutModelsNotificationState["Visible"] = 2] = "Visible";
+})(
+    SignedOutModelsNotificationState || (SignedOutModelsNotificationState = {})
+);
+function getSignedOutModelsNotificationState(options) {
+    if (options.setupDialogVisible || !options.allowSignedOutWhenUsable || !options.accountResolved || !options.entitlementResolved || options.signedIn || !options.hasCopilotHarness || options.hasModels) {
+        return SignedOutModelsNotificationState.Hidden;
+    }
+    return options.localModelsLoaded || options.gracePeriodElapsed ? SignedOutModelsNotificationState.Visible : SignedOutModelsNotificationState.Waiting;
+}
+function areLocalModelsLoaded(
+    extensionsRegistered,
+    configurationLoaded,
+    configuredByokVendors,
+    hasResolvedVendor
+) {
+    return extensionsRegistered && configurationLoaded && configuredByokVendors.every(hasResolvedVendor);
+}
+let AgentHostSignedOutModelsNotificationContribution = class AgentHostSignedOutModelsNotificationContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostSignedOutModelsNotification";
+    }
+    constructor(
+        _chatInputNotificationService,
+        _defaultAccountService,
+        _languageModelsService,
+        _languageModelsConfigurationService,
+        _agentHostService,
+        _configurationService,
+        _chatEntitlementService,
+        _contextKeyService,
+        extensionService
+    ) {
+        super();
+        this._chatInputNotificationService = _chatInputNotificationService;
+        this._defaultAccountService = _defaultAccountService;
+        this._languageModelsService = _languageModelsService;
+        this._languageModelsConfigurationService = _languageModelsConfigurationService;
+        this._agentHostService = _agentHostService;
+        this._configurationService = _configurationService;
+        this._chatEntitlementService = _chatEntitlementService;
+        this._contextKeyService = _contextKeyService;
+        this._notificationShown = false;
+        this._accountResolved = false;
+        this._extensionsRegistered = false;
+        this._configurationLoaded = false;
+        this._gracePeriodElapsed = false;
+        this._gracePeriod = this._register(( new MutableDisposable()));
+        this._register(this._defaultAccountService.onDidChangeDefaultAccount(() => {
+            this._accountResolved = true;
+            this._update();
+        }));
+        this._defaultAccountService.getDefaultAccount().then(() => {
+            if (!this._store.isDisposed) {
+                this._accountResolved = true;
+                this._update();
+            }
+        });
+        this._register(Event.any(
+            this._chatEntitlementService.onDidChangeEntitlement,
+            this._languageModelsService.onDidChangeLanguageModels,
+            this._languageModelsService.onDidChangeModelVisibility,
+            this._languageModelsConfigurationService.onDidChangeLanguageModelGroups,
+            Event.filter(
+                this._contextKeyService.onDidChangeContext,
+                event => event.affectsSome(NOTIFICATION_CONTEXT_KEYS)
+            )
+        )(() => this._update()));
+        this._register(this._configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(AgentHostAllowSignedOutWhenUsableSettingId)) {
+                this._update();
+            }
+        }));
+        extensionService.whenInstalledExtensionsRegistered().then(() => {
+            if (!this._store.isDisposed) {
+                this._extensionsRegistered = true;
+                this._update();
+            }
+        });
+        this._languageModelsConfigurationService.whenReady.then(() => {
+            if (!this._store.isDisposed) {
+                this._configurationLoaded = true;
+                this._update();
+            }
+        });
+        const rootStateListeners = this._register(( new DisposableStore()));
+        const bindRootState = () => {
+            rootStateListeners.clear();
+            rootStateListeners.add(this._agentHostService.rootState.onDidChange(() => this._update()));
+            if (this._agentHostService.rootState.onDidError) {
+                rootStateListeners.add(this._agentHostService.rootState.onDidError(() => this._update()));
+            }
+            this._update();
+        };
+        bindRootState();
+        this._register(this._agentHostService.onAgentHostStart(bindRootState));
+    }
+    _update() {
+        const allowSignedOutWhenUsable = this._configurationService.getValue(AgentHostAllowSignedOutWhenUsableSettingId) === true;
+        const entitlement = this._chatEntitlementService.entitlement;
+        const entitlementResolved = entitlement !== ChatEntitlement.Unresolved;
+        const signedIn = this._defaultAccountService.currentDefaultAccount !== null || (entitlementResolved && entitlement !== ChatEntitlement.Unknown);
+        const configuredByokVendors = ( new Set(( this._languageModelsConfigurationService.getLanguageModelsProviderGroups().map(group => group.vendor)).filter(vendor => vendor !== COPILOT_VENDOR_ID)));
+        const localModelsLoaded = areLocalModelsLoaded(
+            this._extensionsRegistered,
+            this._configurationLoaded,
+            [...configuredByokVendors],
+            vendor => this._languageModelsService.hasResolvedVendor(vendor)
+        );
+        const rootState = this._agentHostService.rootState.value;
+        const hasCopilotHarness = !!rootState && !(rootState instanceof Error) && ( rootState.agents.some(agent => agent.provider === COPILOT_AGENT_HOST_PROVIDER_ID));
+        const hasModels = this._chatEntitlementService.clientByokEnabled && hasVisibleByokModelsTargetingSessionType(this._languageModelsService, SessionType.AgentHostCopilot);
+        const state = getSignedOutModelsNotificationState({
+            allowSignedOutWhenUsable,
+            accountResolved: this._accountResolved,
+            entitlementResolved,
+            signedIn,
+            hasCopilotHarness,
+            hasModels,
+            localModelsLoaded,
+            gracePeriodElapsed: this._gracePeriodElapsed,
+            setupDialogVisible: this._contextKeyService.getContextKeyValue(ChatSetupDialogVisibleContext.key) === true
+        });
+        this._updateGracePeriod(state);
+        this._setNotification(state === SignedOutModelsNotificationState.Visible);
+    }
+    _updateGracePeriod(state) {
+        if (state === SignedOutModelsNotificationState.Hidden) {
+            this._gracePeriod.clear();
+            this._gracePeriodElapsed = false;
+            return;
+        }
+        if (state === SignedOutModelsNotificationState.Visible) {
+            this._gracePeriod.clear();
+            return;
+        }
+        if (!this._gracePeriod.value) {
+            this._gracePeriod.value = disposableTimeout(() => {
+                this._gracePeriodElapsed = true;
+                this._update();
+            }, NOTIFICATION_GRACE_PERIOD_MS);
+        }
+    }
+    _setNotification(show) {
+        if (show === this._notificationShown) {
+            return;
+        }
+        this._notificationShown = show;
+        if (!show) {
+            this._chatInputNotificationService.deleteNotification(SIGNED_OUT_MODELS_NOTIFICATION_ID);
+            return;
+        }
+        this._chatInputNotificationService.setNotification(this._createNotification());
+    }
+    _createNotification() {
+        return {
+            id: SIGNED_OUT_MODELS_NOTIFICATION_ID,
+            severity: ChatInputNotificationSeverity.Info,
+            message: ( localize(6110, "Choose how you want to use Copilot.")),
+            description: ( localize(
+                6111,
+                "Sign in to use GitHub Copilot models, or add a model with your own API key."
+            )),
+            actions: [{
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6112, "Add Models")),
+                commandId: MANAGE_CHAT_COMMAND_ID,
+                keepOpen: true
+            }, {
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6113, "Sign In")),
+                commandId: SIGN_IN_COMMAND_ID,
+                keepOpen: true
+            }],
+            dismissible: false,
+            autoDismissOnMessage: false,
+            sessionTypes: [SessionType.AgentHostCopilot]
+        };
+    }
+};
+AgentHostSignedOutModelsNotificationContribution = ( __decorate([( __param(0, IChatInputNotificationService)), ( __param(1, IDefaultAccountService)), ( __param(2, ILanguageModelsService)), ( __param(3, ILanguageModelsConfigurationService)), ( __param(4, IAgentHostService)), ( __param(5, IConfigurationService)), ( __param(6, IChatEntitlementService)), ( __param(7, IContextKeyService)), ( __param(8, IExtensionService))], AgentHostSignedOutModelsNotificationContribution));
+
+export { AgentHostSignedOutModelsNotificationContribution, SignedOutModelsNotificationState, areLocalModelsLoaded, getSignedOutModelsNotificationState };

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

@@ -0,0 +1,10 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IChatProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+export declare function isUnstartedSubagent(part: IChatProgress): boolean;
+/** Appends subagent entries when their children start without reserving earlier positions in the stream. */
+export declare class AgentHostSubagentProgress extends Disposable {
+    private readonly sink;
+    private readonly pending;
+    constructor(sink: (parts: IChatProgress[]) => void);
+    publish(parts: IChatProgress[]): void;
+}

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

@@ -0,0 +1,50 @@
+
+import { Disposable, DisposableMap, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+function needsInput(part) {
+    const state = part.kind === "toolInvocation" ? part.state.get().type : undefined;
+    return state === IChatToolInvocation.StateKind.WaitingForConfirmation || state === IChatToolInvocation.StateKind.WaitingForAuthentication || state === IChatToolInvocation.StateKind.WaitingForPostApproval;
+}
+function isUnstartedSubagent(part) {
+    if ((part.kind !== "toolInvocation" && part.kind !== "toolInvocationSerialized") || part.subAgentInvocationId || part.toolSpecificData?.kind !== "subagent" || part.toolSpecificData.hasStarted !== false) {
+        return false;
+    }
+    return !needsInput(part);
+}
+class AgentHostSubagentProgress extends Disposable {
+    constructor(sink) {
+        super();
+        this.sink = sink;
+        this.pending = this._register(( new DisposableMap()));
+    }
+    publish(parts) {
+        const ready = parts.filter(part => {
+            if (!isUnstartedSubagent(part)) {
+                return true;
+            }
+            if (part.kind === "toolInvocation" && !( this.pending.has(part))) {
+                const tracker = ( new MutableDisposable());
+                this.pending.set(part, tracker);
+                let published = false;
+                tracker.value = autorun(reader => {
+                    part.state.read(reader);
+                    const hasStarted = part.toolSpecificData?.kind === "subagent" && part.toolSpecificData.hasStarted === true;
+                    if (!published && (hasStarted || needsInput(part))) {
+                        published = true;
+                        this.sink([part]);
+                        queueMicrotask(() => this.pending.deleteAndDispose(part));
+                    }
+                });
+            }
+            return false;
+        });
+        if (ready.length > 0) {
+            this.sink(ready);
+        }
+    }
+}
+
+export { AgentHostSubagentProgress, isUnstartedSubagent };

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

@@ -0,0 +1,42 @@
+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 { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { ITerminalProfileService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/terminal.service";
+import { 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";
+/**
+ * Registers local agent host terminal entries with
+ * {@link IAgentHostTerminalService} so they appear in the terminal dropdown,
+ * and forwards the terminal-related agent-host root-config keys (the resolved
+ * default shell and the custom-terminal-tool toggle) via the shared
+ * {@link AgentHostRootConfigForwarder} (also used by
+ * `AgentHostCopilotCliSettingsContribution`).
+ *
+ * Gated on Agent Host runtime availability.
+ */
+export declare class AgentHostTerminalContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _agentHostService;
+    private readonly _agentHostTerminalService;
+    private readonly _configurationService;
+    private readonly _terminalProfileService;
+    private readonly _terminalProfileResolverService;
+    private readonly _defaultAccountService;
+    private readonly _agentHostEnablementService;
+    static readonly ID = "workbench.contrib.agentHostTerminal";
+    private readonly _localEntry;
+    private readonly _conditionalListeners;
+    private readonly _forwarder;
+    constructor(_agentHostService: IAgentHostService, _agentHostTerminalService: IAgentHostTerminalService, _configurationService: IConfigurationService, _terminalProfileService: ITerminalProfileService, _terminalProfileResolverService: ITerminalProfileResolverService, _defaultAccountService: IDefaultAccountService, _agentHostEnablementService: IAgentHostEnablementService, environmentService: IWorkbenchEnvironmentService);
+    private _updateEnabled;
+    private _registerLocalEntry;
+    /**
+     * Resolve the agent host terminal profile (with `defaultProfile.<os>`
+     * fallback) so its host-managed shells inherit the user's preferred terminal
+     * binary. Returns `undefined` when no usable path can be resolved.
+     */
+    private _resolveDefaultShell;
+}