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

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

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

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

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

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/agentHostShellInitSynchronizer.d.ts

@@ -0,0 +1,31 @@
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+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 { IAgentSubscription } from "../../../../../../platform/agentHost/common/state/agentSubscription.js";
+import { SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
+import { IEnvironmentVariableService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/environmentVariable.service";
+import { IWorkbenchEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IAgentHostShellInitSynchronizer } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentHost/agentHostShellInitSynchronizer.service";
+/**
+ * Publishes one combined profile-loading and Python-activation script for each
+ * session. Script text travels in session config; the agent host owns the file.
+ */
+export declare class AgentHostShellInitSynchronizer extends Disposable implements IAgentHostShellInitSynchronizer {
+    private readonly _agentHostService;
+    private readonly _configurationService;
+    private readonly _environmentVariableService;
+    private readonly _workspaceContextService;
+    private readonly _environmentService;
+    readonly _serviceBrand: undefined;
+    private readonly _registrations;
+    constructor(_agentHostService: IAgentHostService, _configurationService: IConfigurationService, _environmentVariableService: IEnvironmentVariableService, _workspaceContextService: IWorkspaceContextService, _environmentService: IWorkbenchEnvironmentService);
+    register(session: URI, subscription: IAgentSubscription<SessionState>): IDisposable;
+    reconcile(session: URI): void;
+    private _scheduleAll;
+    private _supportsShellInit;
+    private _publish;
+    private _readPythonActivation;
+    private _resolveFolder;
+}

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

@@ -0,0 +1,140 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { structuralEquals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isWindows } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+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 { AgentHostShellToolInitScriptEnabledSettingId } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/copilotCliConfig';
+import { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+import { createShellInitScript } from '../../../../../../platform/agentHost/common/shellInitScript.js';
+import { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/actions';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/extensions';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { IEnvironmentVariableService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/terminal/common/environmentVariable.service';
+import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/environment/common/environmentService.service';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const PYTHON_ENV_EXTENSION_ID = "ms-python.vscode-python-envs";
+const PYTHON_ACTIVATION_VARIABLES = isWindows ? ["VSCODE_PYTHON_PWSH_ACTIVATE"] : ["VSCODE_PYTHON_BASH_ACTIVATE"];
+const TOOL_SHELL = isWindows ? "powershell" : "bash";
+let AgentHostShellInitSynchronizer = class AgentHostShellInitSynchronizer extends Disposable {
+    constructor(
+        _agentHostService,
+        _configurationService,
+        _environmentVariableService,
+        _workspaceContextService,
+        _environmentService
+    ) {
+        super();
+        this._agentHostService = _agentHostService;
+        this._configurationService = _configurationService;
+        this._environmentVariableService = _environmentVariableService;
+        this._workspaceContextService = _workspaceContextService;
+        this._environmentService = _environmentService;
+        this._registrations = ( new Map());
+        this._register(
+            this._environmentVariableService.onDidChangeCollections(() => this._scheduleAll())
+        );
+        this._register(
+            this._workspaceContextService.onDidChangeWorkspaceFolders(() => this._scheduleAll())
+        );
+        this._register(this._configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(AgentHostShellToolInitScriptEnabledSettingId)) {
+                this._scheduleAll();
+            }
+        }));
+    }
+    register(session, subscription) {
+        if (this._environmentService.remoteAuthority) {
+            return Disposable.None;
+        }
+        const key = ( session.toString());
+        this._registrations.get(key)?.store.dispose();
+        const store = ( new DisposableStore());
+        const scheduler = store.add(( new RunOnceScheduler(() => this._publish(key), 0)));
+        const registration = {
+            subscription,
+            store,
+            scheduler,
+            schemaReady: this._supportsShellInit(subscription.value)
+        };
+        this._registrations.set(key, registration);
+        store.add(subscription.onDidChange(state => {
+            if (!registration.schemaReady && this._supportsShellInit(state)) {
+                registration.schemaReady = true;
+                scheduler.schedule();
+            }
+        }));
+        store.add(toDisposable(() => {
+            if (this._registrations.get(key) === registration) {
+                this._registrations.delete(key);
+            }
+        }));
+        scheduler.schedule();
+        return store;
+    }
+    reconcile(session) {
+        const key = ( session.toString());
+        this._registrations.get(key)?.scheduler.cancel();
+        this._publish(key);
+    }
+    _scheduleAll() {
+        for (const registration of ( this._registrations.values())) {
+            registration.scheduler.schedule();
+        }
+    }
+    _supportsShellInit(state) {
+        return !!state && !(state instanceof Error) && !!state.config?.schema.properties[SessionConfigKey.ShellInitScripts];
+    }
+    _publish(key) {
+        const state = this._registrations.get(key)?.subscription.value;
+        if (!state || state instanceof Error || !state.config?.schema.properties[SessionConfigKey.ShellInitScripts]) {
+            return;
+        }
+        const enabled = this._configurationService.getValue(AgentHostShellToolInitScriptEnabledSettingId) === true;
+        const folder = enabled && !this._environmentService.isSessionsWindow ? this._resolveFolder(state) : undefined;
+        if (enabled && !folder) {
+            return;
+        }
+        const desired = enabled && folder ? [createShellInitScript(TOOL_SHELL, this._readPythonActivation(folder))] : [];
+        const current = state.config.values[SessionConfigKey.ShellInitScripts];
+        if (structuralEquals(current, desired) || (!desired.length && current === undefined)) {
+            return;
+        }
+        this._agentHostService.dispatch(key, {
+            type: ActionType.SessionConfigChanged,
+            config: {
+                [SessionConfigKey.ShellInitScripts]: desired
+            }
+        });
+    }
+    _readPythonActivation(folder) {
+        const variables = this._environmentVariableService.mergedCollection.getVariableMap({
+            workspaceFolder: folder
+        });
+        for (const name of PYTHON_ACTIVATION_VARIABLES) {
+            const value = variables.get(name)?.find(mutator => mutator.extensionIdentifier === PYTHON_ENV_EXTENSION_ID)?.value;
+            if (value?.trim()) {
+                return value;
+            }
+        }
+        return undefined;
+    }
+    _resolveFolder(state) {
+        for (const value of [state.project?.uri, ...(state.workingDirectories ?? [])]) {
+            if (value) {
+                const folder = this._workspaceContextService.getWorkspaceFolder(( URI.parse(value)));
+                if (folder) {
+                    return folder;
+                }
+            }
+        }
+        return undefined;
+    }
+};
+AgentHostShellInitSynchronizer = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, IConfigurationService)), ( __param(2, IEnvironmentVariableService)), ( __param(3, IWorkspaceContextService)), ( __param(4, IWorkbenchEnvironmentService))], AgentHostShellInitSynchronizer));
+
+export { AgentHostShellInitSynchronizer };

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;
+}