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

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

@@ -0,0 +1,169 @@
+import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { IJSONSchema } from "@codingame/monaco-vscode-api/vscode/vs/base/common/jsonSchema";
+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 { FileType, IFileChange, IFileDeleteOptions, IFileOverwriteOptions, IFileSystemProviderWithFileReadWriteCapability, IFileWriteOptions, IStat, IWatchOptions } 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 { ConfigPropertySchema, ConfigSchema } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Minimal config shape shared by session and root configuration.
+ */
+export interface IAgentHostConfigLike {
+    readonly schema: ConfigSchema;
+    readonly values: Record<string, unknown>;
+}
+/**
+ * Filter applied to schema properties to decide which ones surface in the
+ * editable document (and in the derived JSON schema).
+ */
+export type AgentHostConfigPropertyFilter = (key: string, schema: ConfigPropertySchema) => boolean;
+/**
+ * Localized strings used to decorate the serialized JSONC document.
+ */
+export interface IAgentHostSettingsLocale {
+    /** Header comment line describing the document. */
+    readonly header: string;
+    /** Secondary hint comment describing save semantics. */
+    readonly saveHint: string;
+    /** Error message thrown when the document fails to parse as JSONC. */
+    readonly parseError: string;
+    /** Error message thrown when the parsed document is not a JSON object. */
+    readonly notObject: string;
+}
+/**
+ * Convert a config property schema (protocol shape) into an
+ * {@link IJSONSchema} suitable for registration with the JSON language
+ * service.
+ */
+export declare function convertPropertySchema(schema: ConfigPropertySchema): IJSONSchema;
+/**
+ * Build a JSON schema describing the filtered properties of an agent-host
+ * config. Properties that pass {@link filter} are included; others are
+ * dropped. `required` entries are carried through when the referenced
+ * property survives the filter.
+ */
+export declare function buildAgentHostConfigJsonSchema(config: IAgentHostConfigLike, filter: AgentHostConfigPropertyFilter): IJSONSchema;
+/**
+ * Serialize the filtered config values into a commented, pretty-printed
+ * JSONC document.
+ */
+export declare function serializeAgentHostConfigDocument(config: IAgentHostConfigLike | undefined, filter: AgentHostConfigPropertyFilter, locale: IAgentHostSettingsLocale): string;
+/**
+ * Abstract filesystem provider backing the synthetic agent-host settings
+ * JSONC editors. Subclasses supply scheme-specific URI parsing, target
+ * resolution (e.g. a sessions provider, or the ambient agent host),
+ * config-fetching, change-watching, and replace-dispatch hooks; the base
+ * handles the boilerplate (`stat`/`readFile`/`writeFile`/error shapes).
+ */
+export declare abstract class AbstractAgentHostConfigFileSystemProvider<TContext, TTarget> extends Disposable implements IFileSystemProviderWithFileReadWriteCapability {
+    protected readonly _logService: ILogService;
+    readonly capabilities: number;
+    private readonly _onDidChangeCapabilities;
+    readonly onDidChangeCapabilities: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    protected readonly _onDidChangeFile: Emitter<readonly IFileChange[]>;
+    readonly onDidChangeFile: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<readonly IFileChange[]>;
+    constructor(_logService: ILogService);
+    /** URI scheme label used in error messages (e.g. `'agent-host-settings'`). */
+    protected abstract readonly _schemeLabel: string;
+    /** Log trace-tag (e.g. `'AgentHostSettings'`). */
+    protected abstract readonly _traceTag: string;
+    /** Localized strings for the JSONC document and write-path errors. */
+    protected abstract readonly _locale: IAgentHostSettingsLocale;
+    /** Parse a URI of the subclass's scheme into a typed context. */
+    protected abstract _parseUri(resource: URI): TContext | undefined;
+    /**
+     * Resolve the backing target (e.g. a sessions provider, the ambient
+     * agent host, a refcounted session subscription) for a parsed context.
+     * Called once per {@link stat}/{@link readFile}/{@link writeFile} call
+     * and once per {@link watch} call; every resolution that returns a
+     * target is paired with exactly one {@link _releaseTarget} call (see
+     * there for the ownership contract). Returning `undefined` signals the
+     * target genuinely could not be resolved (e.g. an unknown provider id) -
+     * a target whose backing value is merely pending or errored should still
+     * be resolved and returned so callers can render that state.
+     */
+    protected abstract _resolveTarget(ctx: TContext): TTarget | undefined;
+    /**
+     * Release a target obtained from {@link _resolveTarget}. Called exactly
+     * once for every resolution that returned a defined target: after
+     * {@link stat}/{@link readFile}/{@link writeFile} complete (including on
+     * error), and when a {@link watch} caller disposes its returned
+     * disposable. Default is a no-op for targets with no per-resolution
+     * ownership (e.g. a shared provider or the ambient agent host);
+     * subclasses whose {@link _resolveTarget} acquires a scoped resource
+     * (e.g. a refcounted subscription reference) must override this to
+     * release it symmetrically.
+     */
+    protected _releaseTarget(_target: TTarget, _ctx: TContext): void;
+    /** Error to throw when {@link _resolveTarget} returns `undefined` for a parsed context. */
+    protected _missingTargetError(_ctx: TContext): Error;
+    /** Render the current config for a context as a JSONC document. */
+    protected abstract _serialize(target: TTarget, ctx: TContext): string;
+    /**
+     * Subscribe for changes relevant to the given context. When a change is
+     * detected the subclass should invoke {@link fire}.
+     */
+    protected abstract _watchChanges(target: TTarget, ctx: TContext, fire: () => void): IDisposable;
+    /** Register / refresh the JSON schema for the given context. */
+    protected abstract _ensureSchemaRegistered(target: TTarget, ctx: TContext): void;
+    /** Whether the backing config is currently available. */
+    protected abstract _hasConfig(target: TTarget, ctx: TContext): boolean;
+    /** Dispatch a replace write of the parsed JSONC document. */
+    protected abstract _replaceConfig(target: TTarget, ctx: TContext, values: Record<string, unknown>): Promise<void>;
+    /**
+     * Build a short human-readable description of `ctx` for log messages
+     * when a write is ignored due to missing config (e.g. a session id).
+     */
+    protected abstract _describeForTrace(ctx: TContext): string;
+    watch(resource: URI, _opts: IWatchOptions): IDisposable;
+    stat(resource: URI): Promise<IStat>;
+    readdir(): Promise<[
+        string,
+        FileType
+    ][]>;
+    readFile(resource: URI): Promise<Uint8Array>;
+    writeFile(resource: URI, content: Uint8Array, _opts: IFileWriteOptions): Promise<void>;
+    mkdir(): Promise<void>;
+    delete(_resource: URI, _opts: IFileDeleteOptions): Promise<void>;
+    rename(_from: URI, _to: URI, _opts: IFileOverwriteOptions): Promise<void>;
+    private _resolveOrThrow;
+}
+/**
+ * Abstract base for the schema registrars that keep JSON schemas registered
+ * on the {@link IJSONContributionRegistry} for the synthetic settings
+ * editors. Subclasses plumb the target type that identifies what a schema
+ * belongs to (an `ISession`/`IAgentHostSessionsProvider` for the sessions
+ * window, the ambient `IAgentHostService` for the editor window) and any
+ * lifecycle needed to discover/observe/dispose targets.
+ *
+ * Registration is lazy - {@link ensureRegistered} is called by the
+ * filesystem provider when a settings file is first read.
+ */
+export declare abstract class AbstractAgentHostConfigSchemaRegistrar<TTarget> extends Disposable {
+    private readonly _schemaRegistry;
+    /** Per-target registered-schema disposables, keyed by the settings URI string. */
+    private readonly _targetSchemas;
+    /**
+     * Tracks the {@link ConfigSchema} identity last used to register a schema
+     * for a given settings URI so we can skip re-registration when only
+     * values have changed.
+     */
+    private readonly _lastSchemaIdentity;
+    /** Stringified URI identifying the settings document for a target. */
+    protected abstract _settingsUri(target: TTarget): string;
+    /** `vscode://schemas/...` schema id used for JSON language service registration. */
+    protected abstract _schemaId(target: TTarget): string;
+    /** Fetch the backing config for a target. Returns `undefined` when none yet. */
+    protected abstract _getConfig(target: TTarget): IAgentHostConfigLike | undefined;
+    /** Filter applied to schema properties when building the JSON schema. */
+    protected abstract _propertyFilter(): AgentHostConfigPropertyFilter;
+    /**
+     * Ensures a JSON schema is registered for the given target. Safe to
+     * call repeatedly; a no-op when the cached schema identity matches.
+     */
+    ensureRegistered(target: TTarget): void;
+    /** Whether a schema is currently registered for `target`. */
+    protected _isRegistered(target: TTarget): boolean;
+    protected _refreshSchema(target: TTarget): void;
+    protected _disposeSchemaForTarget(target: TTarget): void;
+}

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

@@ -0,0 +1,261 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/json';
+import { Disposable, toDisposable, DisposableMap, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { FileSystemProviderCapabilities, createFileSystemProviderError, FileSystemProviderErrorCode, FileChangeType, FileType } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/jsonschemas/common/jsonContributionRegistry';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+
+function convertPropertySchema(schema) {
+    const out = {
+        type: schema.type,
+        title: schema.title,
+        description: schema.description,
+        default: schema.default
+    };
+    if (schema.enum && schema.enum.length > 0) {
+        out.enum = [...schema.enum];
+        if (schema.enumDescriptions && schema.enumDescriptions.length > 0) {
+            out.enumDescriptions = [...schema.enumDescriptions];
+        }
+    }
+    if (schema.type === "array" && schema.items) {
+        out.items = convertPropertySchema(schema.items);
+    }
+    if (schema.type === "object" && schema.properties) {
+        const properties = {};
+        for (const [key, value] of Object.entries(schema.properties)) {
+            properties[key] = convertPropertySchema(value);
+        }
+        out.properties = properties;
+        if (schema.required && schema.required.length > 0) {
+            out.required = [...schema.required];
+        }
+    }
+    return out;
+}
+function buildAgentHostConfigJsonSchema(config, filter) {
+    const properties = {};
+    const required = [];
+    for (const [key, schema] of Object.entries(config.schema.properties)) {
+        if (!filter(key, schema)) {
+            continue;
+        }
+        properties[key] = convertPropertySchema(schema);
+        if (config.schema.required?.includes(key)) {
+            required.push(key);
+        }
+    }
+    const result = {
+        type: "object",
+        properties,
+        additionalProperties: true
+    };
+    if (required.length > 0) {
+        result.required = required;
+    }
+    return result;
+}
+function buildHeaderComment(locale, props) {
+    const lines = [];
+    lines.push(`// ${locale.header}`);
+    lines.push(`// ${locale.saveHint}`);
+    if (props && props.length > 0) {
+        lines.push("//");
+        for (const [key, schema] of props) {
+            const suffix = schema.enum && schema.enum.length > 0 ? ` (${schema.enum.join(" | ")})` : "";
+            const title = schema.title || key;
+            lines.push(`// ${key}: ${title}${suffix}`);
+            if (schema.description) {
+                lines.push(`//   ${schema.description}`);
+            }
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+function serializeAgentHostConfigDocument(config, filter, locale) {
+    if (!config) {
+        return `${buildHeaderComment(locale, undefined)}{}\n`;
+    }
+    const editableProps = Object.entries(config.schema.properties).filter(([key, schema]) => filter(key, schema));
+    const values = {};
+    for (const [key] of editableProps) {
+        if (config.values[key] !== undefined) {
+            values[key] = config.values[key];
+        }
+    }
+    return `${buildHeaderComment(locale, editableProps)}${JSON.stringify(values, null, 2)}\n`;
+}
+let AbstractAgentHostConfigFileSystemProvider = class AbstractAgentHostConfigFileSystemProvider extends Disposable {
+    constructor(_logService) {
+        super();
+        this._logService = _logService;
+        this.capabilities = FileSystemProviderCapabilities.FileReadWrite | FileSystemProviderCapabilities.PathCaseSensitive;
+        this._onDidChangeCapabilities = this._register(( new Emitter()));
+        this.onDidChangeCapabilities = this._onDidChangeCapabilities.event;
+        this._onDidChangeFile = this._register(( new Emitter()));
+        this.onDidChangeFile = this._onDidChangeFile.event;
+    }
+    _releaseTarget(_target, _ctx) {}
+    _missingTargetError(_ctx) {
+        return createFileSystemProviderError(
+            `${this._schemeLabel} target is not available`,
+            FileSystemProviderErrorCode.FileNotFound
+        );
+    }
+    watch(resource, _opts) {
+        const parsed = this._parseUri(resource);
+        if (!parsed) {
+            return Disposable.None;
+        }
+        const target = this._resolveTarget(parsed);
+        if (!target) {
+            return Disposable.None;
+        }
+        const watcher = this._watchChanges(target, parsed, () => {
+            this._onDidChangeFile.fire([{
+                type: FileChangeType.UPDATED,
+                resource
+            }]);
+        });
+        return toDisposable(() => {
+            watcher.dispose();
+            this._releaseTarget(target, parsed);
+        });
+    }
+    async stat(resource) {
+        const {
+            target,
+            ctx
+        } = this._resolveOrThrow(resource);
+        try {
+            const content = this._serialize(target, ctx);
+            return {
+                type: FileType.File,
+                ctime: 0,
+                mtime: 0,
+                size: VSBuffer.fromString(content).byteLength,
+                permissions: 0
+            };
+        } finally {
+            this._releaseTarget(target, ctx);
+        }
+    }
+    async readdir() {
+        throw createFileSystemProviderError("readdir not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async readFile(resource) {
+        const {
+            target,
+            ctx
+        } = this._resolveOrThrow(resource);
+        try {
+            const content = this._serialize(target, ctx);
+            this._ensureSchemaRegistered(target, ctx);
+            return VSBuffer.fromString(content).buffer;
+        } finally {
+            this._releaseTarget(target, ctx);
+        }
+    }
+    async writeFile(resource, content, _opts) {
+        const {
+            target,
+            ctx
+        } = this._resolveOrThrow(resource);
+        try {
+            const text = ( VSBuffer.wrap(content).toString());
+            const errors = [];
+            const parsedJson = parse(text, errors);
+            if (errors.length > 0) {
+                throw createFileSystemProviderError(this._locale.parseError, FileSystemProviderErrorCode.Unavailable);
+            }
+            if (parsedJson === null || typeof parsedJson !== "object" || Array.isArray(parsedJson)) {
+                throw createFileSystemProviderError(this._locale.notObject, FileSystemProviderErrorCode.Unavailable);
+            }
+            if (!this._hasConfig(target, ctx)) {
+                this._logService.trace(
+                    `[${this._traceTag}] No config state for ${this._describeForTrace(ctx)}; ignoring write.`
+                );
+                this._onDidChangeFile.fire([{
+                    type: FileChangeType.UPDATED,
+                    resource
+                }]);
+                return;
+            }
+            await this._replaceConfig(target, ctx, parsedJson);
+            this._onDidChangeFile.fire([{
+                type: FileChangeType.UPDATED,
+                resource
+            }]);
+        } finally {
+            this._releaseTarget(target, ctx);
+        }
+    }
+    async mkdir() {
+        throw createFileSystemProviderError("mkdir not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async delete(_resource, _opts) {
+        throw createFileSystemProviderError("delete not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    async rename(_from, _to, _opts) {
+        throw createFileSystemProviderError("rename not supported", FileSystemProviderErrorCode.NoPermissions);
+    }
+    _resolveOrThrow(resource) {
+        const ctx = this._parseUri(resource);
+        if (!ctx) {
+            throw createFileSystemProviderError(`Invalid ${this._schemeLabel} URI: ${( resource.toString())}`, FileSystemProviderErrorCode.FileNotFound);
+        }
+        const target = this._resolveTarget(ctx);
+        if (!target) {
+            throw this._missingTargetError(ctx);
+        }
+        return {
+            target,
+            ctx
+        };
+    }
+};
+AbstractAgentHostConfigFileSystemProvider = ( __decorate([( __param(0, ILogService))], AbstractAgentHostConfigFileSystemProvider));
+class AbstractAgentHostConfigSchemaRegistrar extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._schemaRegistry = ( Registry.as(Extensions.JSONContribution));
+        this._targetSchemas = this._register(( new DisposableMap()));
+        this._lastSchemaIdentity = ( new Map());
+    }
+    ensureRegistered(target) {
+        this._refreshSchema(target);
+    }
+    _isRegistered(target) {
+        return ( this._lastSchemaIdentity.has(this._settingsUri(target)));
+    }
+    _refreshSchema(target) {
+        const config = this._getConfig(target);
+        if (!config) {
+            return;
+        }
+        const settingsUri = this._settingsUri(target);
+        const identity = config.schema;
+        if (this._lastSchemaIdentity.get(settingsUri) === identity) {
+            return;
+        }
+        const schema = buildAgentHostConfigJsonSchema(config, this._propertyFilter());
+        const schemaId = this._schemaId(target);
+        this._targetSchemas.deleteAndDispose(settingsUri);
+        const store = ( new DisposableStore());
+        this._schemaRegistry.registerSchema(schemaId, schema, store);
+        store.add(this._schemaRegistry.registerSchemaAssociation(schemaId, settingsUri));
+        store.add(toDisposable(() => this._lastSchemaIdentity.delete(settingsUri)));
+        this._targetSchemas.set(settingsUri, store);
+        this._lastSchemaIdentity.set(settingsUri, identity);
+    }
+    _disposeSchemaForTarget(target) {
+        this._targetSchemas.deleteAndDispose(this._settingsUri(target));
+    }
+}
+
+export { AbstractAgentHostConfigFileSystemProvider, AbstractAgentHostConfigSchemaRegistrar, buildAgentHostConfigJsonSchema, convertPropertySchema, serializeAgentHostConfigDocument };

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

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IAgentHostEnablementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service";
+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 { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+/**
+ * Forwards Copilot-CLI settings into the **local** agent host's root config so
+ * `CopilotAgent` and `CopilotSessionLauncher` can read them. 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 keys.
+ */
+export declare class AgentHostCopilotCliSettingsContribution extends Disposable implements IWorkbenchContribution {
+    private readonly _configurationService;
+    private readonly _agentHostEnablementService;
+    static readonly ID = "workbench.contrib.agentHostCopilotCliSettings";
+    private readonly _forwarder;
+    constructor(agentHostService: IAgentHostService, _configurationService: IConfigurationService, _agentHostEnablementService: IAgentHostEnablementService);
+    private _pushOnSettingChange;
+}

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

@@ -0,0 +1,90 @@
+
+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 '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isObject } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { IAgentHostEnablementService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService.service';
+import { IAgentHostService } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentService.service';
+import { CopilotCliConfigKey, AgentHostCopilotSdkLogLevelSettingId, AgentHostOpus48PromptEnabledSettingId, CopilotClaudeAdvisorEnabledSettingId, AgentHostToolSearchEnabledSettingId, AgentHostToolSearchDeferThresholdSettingId, normalizeToolSearchDeferThreshold, AgentHostReasoningSummaryEnabledSettingId, CopilotAutoModeTiersEnabledSettingId, CopilotAutoModeTierOverrideSettingId, CopilotSubagentModelGuidanceEnabledSettingId, AgentHostCopilotModelCapabilityOverridesSettingId, AgentHostShellToolInitScriptEnabledSettingId } 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 { AgentHostRootConfigForwarder } from './agentHostRootConfigForwarder.js';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+let AgentHostCopilotCliSettingsContribution = class AgentHostCopilotCliSettingsContribution extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostCopilotCliSettings";
+    }
+    constructor(agentHostService, _configurationService, _agentHostEnablementService) {
+        super();
+        this._configurationService = _configurationService;
+        this._agentHostEnablementService = _agentHostEnablementService;
+        const keys = [{
+            key: CopilotCliConfigKey.CopilotSdkLogLevel,
+            computeValue: () => this._configurationService.getValue(AgentHostCopilotSdkLogLevelSettingId) ?? "info",
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, AgentHostCopilotSdkLogLevelSettingId)
+        }, {
+            key: CopilotCliConfigKey.Opus48Prompt,
+            computeValue: () => this._configurationService.getValue(AgentHostOpus48PromptEnabledSettingId) === true,
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, AgentHostOpus48PromptEnabledSettingId)
+        }, {
+            key: CopilotCliConfigKey.ClaudeAdvisor,
+            computeValue: () => this._configurationService.getValue(CopilotClaudeAdvisorEnabledSettingId) === true,
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, CopilotClaudeAdvisorEnabledSettingId)
+        }, {
+            key: CopilotCliConfigKey.ToolSearchEnabled,
+            computeValue: () => this._configurationService.getValue(AgentHostToolSearchEnabledSettingId) === true,
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, AgentHostToolSearchEnabledSettingId)
+        }, {
+            key: CopilotCliConfigKey.ToolSearchDeferThreshold,
+            computeValue: () => normalizeToolSearchDeferThreshold(
+                this._configurationService.getValue(AgentHostToolSearchDeferThresholdSettingId)
+            ),
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, AgentHostToolSearchDeferThresholdSettingId)
+        }, {
+            key: CopilotCliConfigKey.ReasoningSummary,
+            computeValue: () => this._configurationService.getValue(AgentHostReasoningSummaryEnabledSettingId),
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, AgentHostReasoningSummaryEnabledSettingId)
+        }, {
+            key: CopilotCliConfigKey.AutoModeTiers,
+            computeValue: () => this._configurationService.getValue(CopilotAutoModeTiersEnabledSettingId) === true,
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, CopilotAutoModeTiersEnabledSettingId)
+        }, {
+            key: CopilotCliConfigKey.AutoModeTierOverride,
+            computeValue: () => this._configurationService.getValue(CopilotAutoModeTierOverrideSettingId) ?? "",
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, CopilotAutoModeTierOverrideSettingId)
+        }, {
+            key: CopilotCliConfigKey.SubagentModelGuidance,
+            computeValue: () => this._configurationService.getValue(CopilotSubagentModelGuidanceEnabledSettingId) === true,
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, CopilotSubagentModelGuidanceEnabledSettingId)
+        }, {
+            key: CopilotCliConfigKey.ModelCapabilityOverrides,
+            computeValue: () => {
+                const value = this._configurationService.getValue(AgentHostCopilotModelCapabilityOverridesSettingId);
+                return isObject(value) ? value : {};
+            },
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, AgentHostCopilotModelCapabilityOverridesSettingId)
+        }, {
+            key: CopilotCliConfigKey.EnableShellInitScript,
+            computeValue: () => this._configurationService.getValue(AgentHostShellToolInitScriptEnabledSettingId) === true,
+            registerTriggers: (store, push) => this._pushOnSettingChange(store, push, AgentHostShellToolInitScriptEnabledSettingId)
+        }];
+        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();
+            }
+        }));
+    }
+    _pushOnSettingChange(store, push, settingId) {
+        store.add(this._configurationService.onDidChangeConfiguration(e => {
+            if (e.affectsConfiguration(settingId)) {
+                push();
+            }
+        }));
+    }
+};
+AgentHostCopilotCliSettingsContribution = ( __decorate([( __param(0, IAgentHostService)), ( __param(1, IConfigurationService)), ( __param(2, IAgentHostEnablementService))], AgentHostCopilotCliSettingsContribution));
+
+export { AgentHostCopilotCliSettingsContribution };

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

@@ -0,0 +1,35 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { type ProgressParams } from "../../../../../../platform/agentHost/common/state/sessionActions.js";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IProgressService } from "@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service";
+/**
+ * Renders agent-host `progress` notifications as notification progress bars.
+ *
+ * Shared by the Agents window (via `BaseAgentHostSessionsProvider`) and the
+ * editor window (via `AgentHostContribution`) so both surfaces render the
+ * agent host's lazy, first-use SDK download identically.
+ *
+ * Progress is correlated by {@link ProgressParams.progressToken}; today's only
+ * producer is the SDK download, which the host surfaces as a single stream per
+ * provider keyed by the download's own stable identity — so one indicator per
+ * download regardless of how many sessions await it. Determinate when the host
+ * knows the `total` (`Content-Length`), or a byte-count spinner otherwise. The
+ * operation is complete — and the notification dismissed — once
+ * `progress >= total`. The human-readable brand noun rides on
+ * {@link ProgressParams.message}.
+ */
+export declare class AgentHostDownloadProgress extends Disposable {
+    private readonly _progressService;
+    private readonly _configurationService;
+    /**
+     * Active progress indicators keyed by `progressToken`. The host emits a
+     * single stream per download keyed by the download's own stable identity
+     * (so distinct sessions of a provider share one indicator). Each entry owns
+     * one long-running notification progress (opened on the first frame), driven
+     * via {@link IActiveDownload.report} and dismissed via
+     * {@link IActiveDownload.complete} once `progress >= total`.
+     */
+    private readonly _activeDownloads;
+    constructor(_progressService: IProgressService, _configurationService: IConfigurationService);
+    handleProgress(progress: ProgressParams): void;
+}

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

@@ -0,0 +1,73 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+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 { ProgressLocation } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress';
+import { IProgressService } from '@codingame/monaco-vscode-api/vscode/vs/platform/progress/common/progress.service';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ChatAIDisabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/chatSettings';
+
+let AgentHostDownloadProgress = class AgentHostDownloadProgress extends Disposable {
+    constructor(_progressService, _configurationService) {
+        super();
+        this._progressService = _progressService;
+        this._configurationService = _configurationService;
+        this._activeDownloads = ( new Map());
+        this._register(toDisposable(() => {
+            for (const download of ( this._activeDownloads.values())) {
+                download.complete();
+            }
+            this._activeDownloads.clear();
+        }));
+    }
+    handleProgress(progress) {
+        if (this._configurationService.getValue(ChatAIDisabledSettingId)) {
+            return;
+        }
+        const isComplete = progress.total !== undefined && progress.progress >= progress.total;
+        if (isComplete) {
+            this._activeDownloads.get(progress.progressToken)?.complete();
+            this._activeDownloads.delete(progress.progressToken);
+            return;
+        }
+        let entry = this._activeDownloads.get(progress.progressToken);
+        if (!entry) {
+            const deferred = ( new DeferredPromise());
+            let report;
+            const title = progress.message ?? ( localize(6013, "Downloading"));
+            this._progressService.withProgress({
+                location: ProgressLocation.Notification,
+                title
+            }, p => {
+                report = step => p.report(step);
+                return deferred.p;
+            });
+            entry = {
+                lastPercent: 0,
+                report: step => report?.(step),
+                complete: () => deferred.complete()
+            };
+            this._activeDownloads.set(progress.progressToken, entry);
+        }
+        if (progress.total && progress.total > 0) {
+            const percent = Math.max(0, Math.min(100, Math.round((progress.progress / progress.total) * 100)));
+            const increment = percent - entry.lastPercent;
+            entry.lastPercent = percent;
+            entry.report({
+                message: ( localize(6014, "{0}%", percent)),
+                increment: increment > 0 ? increment : 0,
+                total: 100
+            });
+        } else {
+            const megabytes = (progress.progress / (1024 * 1024)).toFixed(1);
+            entry.report({
+                message: ( localize(6015, "{0} MB", megabytes))
+            });
+        }
+    }
+};
+AgentHostDownloadProgress = ( __decorate([( __param(0, IProgressService)), ( __param(1, IConfigurationService))], AgentHostDownloadProgress));
+
+export { AgentHostDownloadProgress };