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

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

@@ -0,0 +1,20 @@
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
+import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
+/**
+ * Resolves the strictly hidden editor harness-picker setting against its experiment treatment.
+ * Hidden settings are excluded from the generic configuration experiment resolver.
+ */
+export declare class AgentHostExistingSessionHarnessPickerEnablement extends Disposable implements IWorkbenchContribution {
+    private readonly configurationService;
+    private readonly assignmentService;
+    private readonly logService;
+    static readonly ID = "workbench.contrib.agentHostExistingSessionHarnessPickerEnablement";
+    private readonly enabledContext;
+    private updateRequest;
+    constructor(configurationService: IConfigurationService, contextKeyService: IContextKeyService, assignmentService: IWorkbenchAssignmentService, logService: ILogService);
+    private update;
+}

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

@@ -0,0 +1,61 @@
+
+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 { AgentHostExistingSessionHarnessPickerEnabledSettingId, AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostEnablementService';
+import { isConfigured } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration';
+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 { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+
+const treatmentId = `config.${AgentHostExistingSessionHarnessPickerEnabledSettingId}`;
+let AgentHostExistingSessionHarnessPickerEnablement = class AgentHostExistingSessionHarnessPickerEnablement extends Disposable {
+    static {
+        this.ID = "workbench.contrib.agentHostExistingSessionHarnessPickerEnablement";
+    }
+    constructor(configurationService, contextKeyService, assignmentService, logService) {
+        super();
+        this.configurationService = configurationService;
+        this.assignmentService = assignmentService;
+        this.logService = logService;
+        this.updateRequest = 0;
+        this.enabledContext = AGENT_HOST_EXISTING_SESSION_HARNESS_PICKER_ENABLED_CONTEXT_KEY.bindTo(contextKeyService);
+        this._register(this.configurationService.onDidChangeConfiguration(event => {
+            if (event.affectsConfiguration(AgentHostExistingSessionHarnessPickerEnabledSettingId)) {
+                void this.update();
+            }
+        }));
+        this._register(this.assignmentService.onDidRefetchAssignments(() => void this.update()));
+        void this.update();
+    }
+    async update() {
+        const request = ++this.updateRequest;
+        const inspection = this.configurationService.inspect(AgentHostExistingSessionHarnessPickerEnabledSettingId);
+        if (isConfigured(inspection)) {
+            this.enabledContext.set(inspection.value === true);
+            return;
+        }
+        let enabled = false;
+        try {
+            enabled = (await this.assignmentService.getTreatment(treatmentId)) === true;
+        } catch (error) {
+            if (this._store.isDisposed || request !== this.updateRequest) {
+                return;
+            }
+            this.logService.warn(
+                `[AgentHostExistingSessionHarnessPickerEnablement] Failed to resolve treatment '${treatmentId}'.`,
+                error
+            );
+        }
+        if (this._store.isDisposed || request !== this.updateRequest) {
+            return;
+        }
+        const currentInspection = this.configurationService.inspect(AgentHostExistingSessionHarnessPickerEnabledSettingId);
+        this.enabledContext.set(
+            isConfigured(currentInspection) ? currentInspection.value === true : enabled
+        );
+    }
+};
+AgentHostExistingSessionHarnessPickerEnablement = ( __decorate([( __param(0, IConfigurationService)), ( __param(1, IContextKeyService)), ( __param(2, IWorkbenchAssignmentService)), ( __param(3, ILogService))], AgentHostExistingSessionHarnessPickerEnablement));
+
+export { AgentHostExistingSessionHarnessPickerEnablement };

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

@@ -0,0 +1,112 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { SessionModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { ILanguageModelChatMetadataAndIdentifier, ILanguageModelChatProvider } 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";
+/**
+ * Returns whether an agent host provider exposes a synthetic "Auto" model to
+ * fall back to.
+ *
+ * Today only the Copilot CLI harness exposes an Auto selection and can run
+ * without an explicit model, so it shows "Auto" rather than a "No models
+ * available" state when no models are listed. Other harnesses (Claude,
+ * Codex, …) require an explicit model.
+ *
+ * `provider` is the underlying agent provider id (e.g. `'copilotcli'`,
+ * `'claude'`, `'codex'`), not the `agent-host-<provider>` session type.
+ *
+ * TODO: hoist this capability onto the agent host protocol (e.g. a
+ * `supportsAutoModel?: boolean` on `IAgentDescriptor` / `AgentInfo`) so each
+ * agent declares its own value instead of this allow-list living in core.
+ */
+export declare function agentHostProviderSupportsAutoModel(provider: string): boolean;
+/**
+ * Read-only view of the workbench model catalogue an agent host's models are enriched from.
+ *
+ * Narrowed to the reads {@link AgentHostLanguageModelProvider} performs (all plain lookups into
+ * already-registered models, so none of them re-enter a provider) plus the change signal, both so
+ * the dependency stays obviously side-effect free and so tests can supply a small fake.
+ */
+export type IAgentHostModelCatalogue = Pick<ILanguageModelsService, "getLanguageModelIds" | "lookupLanguageModel" | "onDidChangeLanguageModels">;
+/**
+ * Exposes models available from the agent host process as selectable
+ * language models in the chat model picker. Models are provided from
+ * root state (via {@link AgentInfo.models}) rather than via RPC.
+ */
+export declare class AgentHostLanguageModelProvider extends Disposable implements ILanguageModelChatProvider {
+    private readonly _sessionType;
+    private readonly _vendor;
+    private readonly _catalogue?;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@codingame/monaco-vscode-api/vscode/vs/base/common/event").Event<void>;
+    private _models;
+    constructor(_sessionType: string, _vendor: string, _catalogue?: IAgentHostModelCatalogue | undefined);
+    /**
+     * Called by {@link AgentHostContribution} when models change in root state.
+     */
+    updateModels(models: readonly SessionModelInfo[]): void;
+    provideLanguageModelChatInfo(_options: unknown, _token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
+    /**
+     * The workbench catalogue entry describing the same model, when one is known.
+     *
+     * A host driving the Copilot SDK advertises no billing and, where the SDK omits them, no token
+     * limits — so the CAPI-backed Copilot catalogue fills the gaps.
+     *
+     * Matching by raw model id does not prove the two describe the same offering — they can differ
+     * by entitlement, policy, rollout or billing route — so this is restricted to models billed
+     * through Copilot and only ever fills fields the host left absent.
+     *
+     * The token-limit half is a shim: those are native protocol fields, and a host that populates
+     * them makes the fallback dead. The billing half is not. Pricing is deliberately kept off the
+     * agent host protocol as operator-sensitive, so a client that wants to show it has to source it
+     * itself. Removing this join therefore means dropping pricing for these models, which is a
+     * product decision rather than a cleanup.
+     */
+    private _catalogueEntryFor;
+    /**
+     * Translate a host's model {@link ConfigSchema} into the picker's schema shape.
+     *
+     * Values and display text belong to the producer; the workbench only picks the group
+     * ({@link _groupForConfigKey}). The one exception is a reasoning-effort enum with no display
+     * text at all, labelled locally rather than rendering raw values like `xhigh`.
+     *
+     * A property is never dropped for want of local enrichment: a host advertises one because it
+     * will honour it, and a new model, a staged rollout and an unresolved catalogue all look
+     * identical from here.
+     */
+    private _toLanguageModelConfigurationSchema;
+    /** Config keys whose enum values are reasoning-effort levels, whatever the producer named them. */
+    private static readonly _reasoningEffortKeys;
+    /**
+     * Localized labels and descriptions for a reasoning-effort enum whose producer supplied none.
+     *
+     * A host that derives its schema from an upstream SDK advertises the accepted effort values
+     * without display text, because it has none the SDK did not give it — the Copilot agent host
+     * inside a cloud sandbox does exactly that. Deriving the text here keeps the picker from
+     * rendering raw values like `xhigh`, and matches what the agents that build their schema
+     * locally already emit.
+     *
+     * Only synthesized when every enum value is a string, since labels align with `enum` by index
+     * and a partial list would mislabel the rest.
+     *
+     * No `default` is synthesized: schema defaults are merged into the configuration that is sent
+     * (see `resolveModelConfiguration`), so inventing one would send an explicit effort where the
+     * host expects the value omitted and the backend to choose.
+     */
+    private static _reasoningEffortDisplay;
+    private static _groupForConfigKey;
+    /**
+     * Derives the picker group id for a model — the vendor its models are bucketed
+     * under. A producer may pin the group id explicitly in `_meta` (e.g. Claude
+     * stamps its transport vendor — `copilot`/`anthropic` — there while keeping
+     * `provider` as the `claude` routing owner); that wins. Otherwise BYOK models
+     * are surfaced by the agent host under the `vendor/[group/]id` selection id (see
+     * `resolveByokSessionConfig`), so their upstream vendor is the id prefix; native
+     * harness models have no prefix and group under their `provider` (the harness,
+     * e.g. `copilotcli`). The picker resolves the display name from the vendor
+     * registry — no name mapping lives here.
+     */
+    private _modelGroupFor;
+    sendChatRequest(): Promise<never>;
+    provideTokenCount(): Promise<number>;
+}

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

@@ -0,0 +1,192 @@
+
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { readAgentModelNoticesMeta } from '../../../../../../platform/agentHost/common/agentModelNotices.js';
+import { readAgentModelPricingMeta } from '../../../../../../platform/agentHost/common/agentModelPricing.js';
+import { readAgentModelByokIdentifier } from '../../../../../../platform/agentHost/common/agentModelByokMeta.js';
+import { readAgentModelGroupId, readAgentModelSourceId } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/agentModelSource';
+import { getReasoningEffortDescription, getReasoningEffortLabel } from '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/reasoningEffort';
+import { nullExtensionDescription } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions';
+import { COPILOT_VENDOR_ID, AUTO_RAW_MODEL_ID, ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+
+function agentHostProviderSupportsAutoModel(provider) {
+    return provider === "copilotcli";
+}
+class AgentHostLanguageModelProvider extends Disposable {
+    constructor(_sessionType, _vendor, _catalogue) {
+        super();
+        this._sessionType = _sessionType;
+        this._vendor = _vendor;
+        this._catalogue = _catalogue;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._models = [];
+        if (this._catalogue) {
+            this._register(this._catalogue.onDidChangeLanguageModels(vendor => {
+                if (vendor === COPILOT_VENDOR_ID) {
+                    this._onDidChange.fire();
+                }
+            }));
+        }
+    }
+    updateModels(models) {
+        this._models = models;
+        this._onDidChange.fire();
+    }
+    async provideLanguageModelChatInfo(_options, _token) {
+        return (this._models.filter(m => m.policyState !== "disabled").map(m => {
+            const pricing = readAgentModelPricingMeta(m);
+            const multiplierNumeric = pricing.multiplierNumeric;
+            const isAuto = m.id === AUTO_RAW_MODEL_ID;
+            const notices = isAuto ? undefined : readAgentModelNoticesMeta(m);
+            const discountPercent = pricing.discountPercent;
+            const hasDiscount = typeof discountPercent === "number" && discountPercent > 0 && discountPercent <= 100;
+            const detail = isAuto && hasDiscount ? ( localize(6019, "{0}% discount", discountPercent)) : undefined;
+            const tooltip = notices?.rowWarning ?? (isAuto ? ILanguageModelChatMetadata.getAutoModelDescription(hasDiscount ? discountPercent : undefined) : undefined);
+            const modelGroup = this._modelGroupFor(m);
+            const byokModelIdentifier = readAgentModelByokIdentifier(m);
+            const known = this._catalogueEntryFor(m, modelGroup);
+            return {
+                identifier: `${this._vendor}:${m.id}`,
+                metadata: {
+                    extension: nullExtensionDescription.identifier,
+                    name: m.name,
+                    id: m.id,
+                    vendor: this._vendor,
+                    version: "1.0",
+                    family: m.id,
+                    ...(tooltip !== undefined && {
+                        tooltip
+                    }),
+                    ...(detail !== undefined && {
+                        detail
+                    }),
+                    maxInputTokens: m.maxPromptTokens ?? known?.maxInputTokens ?? 0,
+                    maxOutputTokens: m.maxOutputTokens ?? known?.maxOutputTokens ?? 0,
+                    isDefaultForLocation: {},
+                    isUserSelectable: true,
+                    statusIcon: notices?.rowWarning ? Codicon.warning : undefined,
+                    warningText: notices?.warningText,
+                    infoText: notices?.infoText,
+                    pricing: multiplierNumeric !== undefined ? `${multiplierNumeric}x` : known?.pricing,
+                    multiplierNumeric: multiplierNumeric ?? known?.multiplierNumeric,
+                    inputCost: pricing.inputCost ?? known?.inputCost,
+                    cacheCost: pricing.cacheCost ?? known?.cacheCost,
+                    cacheWriteCost: pricing.cacheWriteCost ?? known?.cacheWriteCost,
+                    outputCost: pricing.outputCost ?? known?.outputCost,
+                    longContextInputCost: pricing.longContextInputCost ?? known?.longContextInputCost,
+                    longContextCacheCost: pricing.longContextCacheCost ?? known?.longContextCacheCost,
+                    longContextCacheWriteCost: pricing.longContextCacheWriteCost ?? known?.longContextCacheWriteCost,
+                    longContextOutputCost: pricing.longContextOutputCost ?? known?.longContextOutputCost,
+                    priceCategory: pricing.priceCategory ?? known?.priceCategory,
+                    category: pricing.category ?? known?.category,
+                    promo: pricing.promo ?? known?.promo,
+                    targetChatSessionType: this._sessionType,
+                    ...(modelGroup ? {
+                        modelGroup
+                    } : {}),
+                    ...(byokModelIdentifier !== undefined && {
+                        byokModelIdentifier
+                    }),
+                    capabilities: {
+                        vision: m.supportsVision ?? known?.capabilities?.vision ?? false,
+                        toolCalling: true,
+                        agentMode: true
+                    },
+                    configurationSchema: this._toLanguageModelConfigurationSchema(m.configSchema)
+                }
+            };
+        }));
+    }
+    _catalogueEntryFor(model, group) {
+        if (!this._catalogue || group?.id !== COPILOT_VENDOR_ID) {
+            return undefined;
+        }
+        for (const identifier of this._catalogue.getLanguageModelIds()) {
+            const metadata = this._catalogue.lookupLanguageModel(identifier);
+            if (metadata?.vendor === COPILOT_VENDOR_ID && metadata.id === model.id) {
+                return metadata;
+            }
+        }
+        return undefined;
+    }
+    _toLanguageModelConfigurationSchema(schema) {
+        if (!schema) {
+            return undefined;
+        }
+        const properties = {};
+        for (const [key, property] of Object.entries(schema.properties)) {
+            const effortDisplay = property.enumLabels === undefined && property.enumDescriptions === undefined ? AgentHostLanguageModelProvider._reasoningEffortDisplay(key, property.enum) : undefined;
+            properties[key] = {
+                type: property.type,
+                title: property.title,
+                description: property.description,
+                default: property.default,
+                enum: property.enum,
+                enumItemLabels: property.enumLabels ?? effortDisplay?.labels,
+                enumDescriptions: property.enumDescriptions ?? effortDisplay?.descriptions,
+                readOnly: property.readOnly,
+                group: AgentHostLanguageModelProvider._groupForConfigKey(key)
+            };
+        }
+        return {
+            type: schema.type,
+            required: schema.required,
+            properties
+        };
+    }
+    static {
+        this._reasoningEffortKeys = ( new Set(["reasoningEffort", "thinkingLevel"]));
+    }
+    static _reasoningEffortDisplay(key, values) {
+        if (!( AgentHostLanguageModelProvider._reasoningEffortKeys.has(key)) || !values?.length) {
+            return undefined;
+        }
+        const levels = values.filter(value => typeof value === "string");
+        if (levels.length !== values.length) {
+            return undefined;
+        }
+        return {
+            labels: ( levels.map(getReasoningEffortLabel)),
+            descriptions: ( levels.map(level => getReasoningEffortDescription(level) ?? ""))
+        };
+    }
+    static _groupForConfigKey(key) {
+        switch (key) {
+        case "tier":
+        case "thinkingLevel":
+        case "reasoningEffort":
+            return "navigation";
+        case "contextSize":
+        case "contextTier":
+            return "tokens";
+        default:
+            return undefined;
+        }
+    }
+    _modelGroupFor(model) {
+        const explicitGroupId = readAgentModelGroupId(model);
+        const slash = model.id.indexOf("/");
+        const groupVendorId = explicitGroupId ?? (slash > 0 ? model.id.slice(0, slash) : model.provider);
+        if (!groupVendorId) {
+            return undefined;
+        }
+        const sourceId = readAgentModelSourceId(model);
+        return {
+            id: groupVendorId,
+            ...(sourceId !== undefined && {
+                sourceId
+            })
+        };
+    }
+    async sendChatRequest() {
+        throw ( new Error("Agent-host models do not support direct chat requests"));
+    }
+    async provideTokenCount() {
+        return 0;
+    }
+}
+
+export { AgentHostLanguageModelProvider, agentHostProviderSupportsAutoModel };

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

@@ -64,8 +64,8 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
         const path = request.uri.scheme === Schemas.file ? request.uri.fsPath : ( request.uri.toString());
         const fence = "`".repeat((path.match(/`+/g)?.reduce((m, s) => Math.max(m, s.length), 0) ?? 0) + 1);
         const codePath = `${fence}${path}${fence}`;
-        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(5971, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(5972, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
-        const description = totalPending > 1 ? totalPending === 2 ? ( localize(5973, "+1 more request waiting")) : ( localize(5974, "+{0} more requests waiting", totalPending - 1)) : undefined;
+        const message = ( new MarkdownString(request.mode === AgentHostPermissionMode.Write ? ( localize(6034, "Remote agent host \"{0}\" wants to write {1}", hostName, codePath)) : ( localize(6035, "Remote agent host \"{0}\" wants to read {1}", hostName, codePath))));
+        const description = totalPending > 1 ? totalPending === 2 ? ( localize(6036, "+1 more request waiting")) : ( localize(6037, "+{0} more requests waiting", totalPending - 1)) : undefined;
         return {
             id: AgentHostPermissionUiContribution_1.NOTIFICATION_ID,
             severity: ChatInputNotificationSeverity.Warning,
@@ -73,17 +73,17 @@ let AgentHostPermissionUiContribution = class AgentHostPermissionUiContribution
             description,
             actions: [{
                 kind: ChatInputNotificationActionKind.Command,
-                label: ( localize(5975, "Deny")),
+                label: ( localize(6038, "Deny")),
                 commandId: DENY_COMMAND,
                 commandArgs: [request.id]
             }, {
                 kind: ChatInputNotificationActionKind.Command,
-                label: ( localize(5976, "Allow")),
+                label: ( localize(6039, "Allow")),
                 commandId: ALLOW_COMMAND,
                 commandArgs: [request.id]
             }, {
                 kind: ChatInputNotificationActionKind.Command,
-                label: ( localize(5977, "Always Allow")),
+                label: ( localize(6040, "Always Allow")),
                 commandId: ALLOW_ALWAYS_COMMAND,
                 commandArgs: [request.id]
             }],

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

@@ -0,0 +1,21 @@
+import { Disposable, type IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type IAgentSubscription } from "../../../../../../platform/agentHost/common/state/agentSubscription.js";
+import { type SessionState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
+import { IChatInputNotificationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/widget/input/chatInputNotificationService.service";
+export declare class AgentHostPromptCacheNotification extends Disposable {
+    private readonly _notificationService;
+    private readonly _storageService;
+    private readonly _logService;
+    private readonly _trackedSessions;
+    private readonly _cacheExpirations;
+    private readonly _dismissedExpirations;
+    private _experimentEnabled;
+    constructor(_notificationService: IChatInputNotificationService, assignmentService: IWorkbenchAssignmentService, _storageService: IStorageService, _logService: ILogService);
+    trackSession(sessionResource: URI, subscription: IAgentSubscription<SessionState>): IDisposable;
+    private _updateNotification;
+    private _notificationId;
+}

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

@@ -0,0 +1,137 @@
+
+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 { Disposable, DisposableMap, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { MarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { readSessionPromptCacheState } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+import { CommandsRegistry } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands';
+import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IWorkbenchAssignmentService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service';
+import { ChatInputNotificationActionKind, ChatInputNotificationSeverity } from '@codingame/monaco-vscode-api/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';
+
+const PROMPT_CACHE_EXPIRATION_NOTIFICATION_EXPERIMENT = "copilotchat.promptCacheExpirationNotification";
+const PROMPT_CACHE_EXPIRATION_DISABLED_STORAGE_KEY = "chat.promptCacheExpirationNotification.disabled";
+const DISABLE_PROMPT_CACHE_EXPIRATION_NOTIFICATION_COMMAND = "workbench.action.chat.disablePromptCacheExpirationNotification";
+const PROMPT_CACHE_EXPIRATION_LEARN_MORE_URL = "https://code.visualstudio.com/docs/agents/agent-troubleshooting/cache-explorer#_why-prompt-caching-matters";
+let AgentHostPromptCacheNotification = class AgentHostPromptCacheNotification extends Disposable {
+    constructor(_notificationService, assignmentService, _storageService, _logService) {
+        super();
+        this._notificationService = _notificationService;
+        this._storageService = _storageService;
+        this._logService = _logService;
+        this._trackedSessions = this._register(( new DisposableMap()));
+        this._cacheExpirations = ( new ResourceMap());
+        this._dismissedExpirations = ( new ResourceMap());
+        this._experimentEnabled = false;
+        this._register(
+            CommandsRegistry.registerCommand(DISABLE_PROMPT_CACHE_EXPIRATION_NOTIFICATION_COMMAND, () => {
+                this._storageService.store(
+                    PROMPT_CACHE_EXPIRATION_DISABLED_STORAGE_KEY,
+                    true,
+                    StorageScope.PROFILE,
+                    StorageTarget.USER
+                );
+                for (const sessionResource of ( this._cacheExpirations.keys())) {
+                    this._notificationService.deleteNotification(this._notificationId(sessionResource));
+                }
+            })
+        );
+        this._register(this._notificationService.onDidDismiss(id => {
+            for (const [sessionResource, cacheExpiresAt] of this._cacheExpirations) {
+                if (id === this._notificationId(sessionResource)) {
+                    this._dismissedExpirations.set(sessionResource, cacheExpiresAt);
+                    break;
+                }
+            }
+        }));
+        void assignmentService.getTreatment(PROMPT_CACHE_EXPIRATION_NOTIFICATION_EXPERIMENT).then(enabled => {
+            this._experimentEnabled = enabled === true;
+            for (const sessionResource of ( this._cacheExpirations.keys())) {
+                this._updateNotification(sessionResource);
+            }
+        }).catch(error => this._logService.warn(
+            `[AgentHostPromptCacheNotification] Failed to resolve experiment: ${error}`
+        ));
+    }
+    trackSession(sessionResource, subscription) {
+        const key = ( sessionResource.toString());
+        const store = ( new DisposableStore());
+        this._trackedSessions.set(key, store);
+        const expirationScheduler = store.add(( new RunOnceScheduler(() => this._updateNotification(sessionResource), 0)));
+        const update = state => {
+            expirationScheduler.cancel();
+            const promptCache = state && !(state instanceof Error) ? readSessionPromptCacheState(state._meta) : undefined;
+            if (promptCache) {
+                if (this._cacheExpirations.get(sessionResource) !== promptCache.cacheExpiresAt) {
+                    this._dismissedExpirations.delete(sessionResource);
+                }
+                this._cacheExpirations.set(sessionResource, promptCache.cacheExpiresAt);
+                const expirationTime = Date.parse(promptCache.cacheExpiresAt);
+                if (Number.isFinite(expirationTime)) {
+                    const remainingTime = expirationTime - Date.now();
+                    if (remainingTime > 0) {
+                        expirationScheduler.schedule(remainingTime);
+                    }
+                }
+            } else {
+                this._cacheExpirations.delete(sessionResource);
+                this._dismissedExpirations.delete(sessionResource);
+            }
+            this._updateNotification(sessionResource);
+        };
+        store.add(subscription.onDidChange(update));
+        update(subscription.value);
+        store.add(toDisposable(() => {
+            this._cacheExpirations.delete(sessionResource);
+            this._dismissedExpirations.delete(sessionResource);
+            this._notificationService.deleteNotification(this._notificationId(sessionResource));
+        }));
+        return toDisposable(() => this._trackedSessions.deleteAndDispose(key));
+    }
+    _updateNotification(sessionResource) {
+        const cacheExpiresAt = this._cacheExpirations.get(sessionResource);
+        const expirationTime = cacheExpiresAt ? Date.parse(cacheExpiresAt) : Number.NaN;
+        const disabled = this._storageService.getBoolean(PROMPT_CACHE_EXPIRATION_DISABLED_STORAGE_KEY, StorageScope.PROFILE, false);
+        if (!this._experimentEnabled || disabled || !Number.isFinite(expirationTime) || Date.now() < expirationTime) {
+            this._notificationService.deleteNotification(this._notificationId(sessionResource));
+            return;
+        }
+        if (this._dismissedExpirations.get(sessionResource) === cacheExpiresAt) {
+            return;
+        }
+        this._notificationService.setNotification({
+            id: this._notificationId(sessionResource),
+            telemetryId: "copilot.promptCacheExpired",
+            severity: ChatInputNotificationSeverity.Info,
+            message: ( localize(6041, "This chat's prompt cache is stale")),
+            description: ( new MarkdownString(( localize(
+                6042,
+                "The next prompt will incur increased cost. Consider starting a new chat. [Learn more]({0})",
+                PROMPT_CACHE_EXPIRATION_LEARN_MORE_URL
+            )))),
+            actions: [{
+                kind: ChatInputNotificationActionKind.Command,
+                label: ( localize(6043, "Start New Chat")),
+                commandId: "workbench.action.chat.newChat"
+            }],
+            dismissible: true,
+            autoDismissOnMessage: true,
+            mute: {
+                commandId: DISABLE_PROMPT_CACHE_EXPIRATION_NOTIFICATION_COMMAND,
+                tooltip: ( localize(6044, "Don't Show Again"))
+            },
+            sessionResources: [sessionResource]
+        });
+    }
+    _notificationId(sessionResource) {
+        return `copilot.promptCacheExpired.${( sessionResource.toString())}`;
+    }
+};
+AgentHostPromptCacheNotification = ( __decorate([( __param(0, IChatInputNotificationService)), ( __param(1, IWorkbenchAssignmentService)), ( __param(2, IStorageService)), ( __param(3, ILogService))], AgentHostPromptCacheNotification));
+
+export { AgentHostPromptCacheNotification };