@codingame/monaco-vscode-katex-common 34.1.2 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputStatePersistence.d.ts

@@ -0,0 +1,6 @@
+import { IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
+import { IChatModelInputState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
+export declare function serializeUntitledInputState(value: IChatModelInputState | undefined): string;
+export declare function deserializeUntitledInputState(value: string): IChatModelInputState;
+export declare function serializeUntitledInputAttachments(attachments: readonly IChatRequestVariableEntry[]): string;
+export declare function deserializeUntitledInputAttachments(value: string): IChatRequestVariableEntry[];

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatInputStatePersistence.js

@@ -0,0 +1,21 @@
+
+import { stringify, parse } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshalling';
+import { IChatRequestVariableEntry } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries';
+
+function serializeUntitledInputState(value) {
+    return stringify(value && {
+        ...value,
+        attachments: []
+    });
+}
+function deserializeUntitledInputState(value) {
+    return parse(value);
+}
+function serializeUntitledInputAttachments(attachments) {
+    return stringify(( attachments.map(IChatRequestVariableEntry.toExport)));
+}
+function deserializeUntitledInputAttachments(value) {
+    return ( parse(value).map(IChatRequestVariableEntry.fromExport));
+}
+
+export { deserializeUntitledInputAttachments, deserializeUntitledInputState, serializeUntitledInputAttachments, serializeUntitledInputState };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatModelConfigurationLogic.d.ts

@@ -0,0 +1,50 @@
+import { IStringDictionary } from "@codingame/monaco-vscode-api/vscode/vs/base/common/collections";
+import { ILanguageModelConfigurationSchema } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+/**
+ * Extracts the schema-default values from a model configuration schema, keyed by
+ * property name. Properties without a `default` are omitted.
+ */
+export declare function extractSchemaDefaults(schema: ILanguageModelConfigurationSchema | undefined): IStringDictionary<unknown>;
+/**
+ * Filters a (e.g. restored) configuration down to what the *current* schema
+ * accepts, so a value captured against an older schema cannot be re-pinned as a
+ * stale override. Two rules are applied:
+ *   1. Keys absent from the current schema are dropped (removed properties).
+ *   2. Values that violate the property's `enum` constraint are dropped, so the
+ *      property falls back to its live default instead of an invalid value.
+ * Properties without an `enum` keep their value (no constraint to validate
+ * against). When the schema is missing entirely, nothing can be validated and an
+ * empty configuration is returned.
+ */
+export declare function filterConfigurationToSchema(values: IStringDictionary<unknown>, schema: ILanguageModelConfigurationSchema | undefined): IStringDictionary<unknown>;
+/**
+ * Resolves the effective configuration for a model within a single
+ * `(location, sessionType)` scope.
+ *
+ * A *present* stored entry — even an empty one, which marks an explicit
+ * reset-to-default — wins and is merged over the schema defaults. Only a
+ * *missing* entry (`undefined`) falls back to the profile-global value, which is
+ * the one-time migration for setups that pre-date per-editor scoping.
+ *
+ * Schema defaults are merged in every branch so a value the user never
+ * explicitly set (e.g. a model's default `contextSize`) is always present in the
+ * resolved configuration. Otherwise the model picker — which paints the schema
+ * default when a key is absent — would show one value while the request and the
+ * context-usage widget, which read the resolved configuration, fall back to the
+ * model's full native window. See issue #320393.
+ *
+ * Distinguishing "present but empty" from "absent" is what prevents a newly
+ * opened editor from reverting an explicit default selection back to a stale
+ * profile-global value. See issue #320393.
+ */
+export declare function resolveModelConfiguration(storedEntry: IStringDictionary<unknown> | undefined, schemaDefaults: IStringDictionary<unknown>, globalConfig: IStringDictionary<unknown> | undefined): IStringDictionary<unknown>;
+/**
+ * Computes the entry to persist for a model after applying `values` on top of the
+ * `current` effective configuration. Values equal to their schema default are
+ * stripped so storage holds only genuine user overrides.
+ *
+ * The result may be an empty object: callers are expected to still persist it so
+ * that an explicit reset-to-default is remembered and does not fall back to the
+ * profile-global value on the next read. See issue #320393.
+ */
+export declare function computeStoredConfiguration(current: IStringDictionary<unknown>, values: IStringDictionary<unknown>, schemaDefaults: IStringDictionary<unknown>): IStringDictionary<unknown>;

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatModelConfigurationLogic.js

@@ -0,0 +1,49 @@
+
+
+function extractSchemaDefaults(schema) {
+    const defaults = {};
+    if (schema?.properties) {
+        for (const [key, propSchema] of Object.entries(schema.properties)) {
+            if (propSchema.default !== undefined) {
+                defaults[key] = propSchema.default;
+            }
+        }
+    }
+    return defaults;
+}
+function filterConfigurationToSchema(values, schema) {
+    const properties = schema?.properties;
+    if (!properties) {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(values)) {
+        const propSchema = properties[key];
+        if (!propSchema) {
+            continue;
+        }
+        if (Array.isArray(propSchema.enum) && !propSchema.enum.includes(value)) {
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
+function resolveModelConfiguration(storedEntry, schemaDefaults, globalConfig) {
+    if (storedEntry) {
+        return { ...schemaDefaults, ...storedEntry };
+    }
+    return globalConfig ? { ...schemaDefaults, ...globalConfig } : { ...schemaDefaults };
+}
+function computeStoredConfiguration(current, values, schemaDefaults) {
+    const merged = { ...current, ...values };
+    const stripped = {};
+    for (const [key, value] of Object.entries(merged)) {
+        if (schemaDefaults[key] !== value) {
+            stripped[key] = value;
+        }
+    }
+    return stripped;
+}
+
+export { computeStoredConfiguration, extractSchemaDefaults, filterConfigurationToSchema, resolveModelConfiguration };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatModelConfigurationStore.d.ts

@@ -0,0 +1,79 @@
+import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IStringDictionary } from "@codingame/monaco-vscode-api/vscode/vs/base/common/collections";
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
+import { IModelConfigurationAccess } from "./modelPickerActionItem.js";
+/**
+ * Per-editor store for model configuration (e.g. context size, thinking effort).
+ *
+ * It keeps an in-memory snapshot per model so an editor's value stays stable
+ * even when another editor writes to the same persisted bucket, and persists
+ * changes to a `(location, sessionType)`-scoped storage bucket — the key is
+ * supplied by the owner via `getStorageKey` — so newly opened editors in the
+ * same scope inherit the latest value.
+ *
+ * Implements {@link IModelConfigurationAccess} so the model picker can route
+ * reads/writes through this editor-scoped layer instead of the global
+ * {@link ILanguageModelsService}. See issue #320393.
+ */
+export declare class ChatModelConfigurationStore extends Disposable implements IModelConfigurationAccess {
+    private readonly getStorageKey;
+    private readonly languageModelsService;
+    private readonly storageService;
+    private readonly _overrides;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<string>;
+    constructor(getStorageKey: () => string, languageModelsService: ILanguageModelsService, storageService: IStorageService);
+    /**
+     * Returns this editor's snapshot of the given model's configuration. The
+     * resolution order is:
+     *   1. In-memory snapshot (this editor's live value).
+     *   2. Scoped storage bucket. A present entry wins even when empty, since an
+     *      empty entry records an explicit reset-to-default.
+     *   3. The profile-global value (migration fallback, only when no scoped
+     *      entry exists).
+     * The merged result is cached so subsequent reads are O(1).
+     */
+    getModelConfiguration(modelId: string): IStringDictionary<unknown> | undefined;
+    setModelConfiguration(modelId: string, values: IStringDictionary<unknown>): Promise<void>;
+    /**
+     * Applies the change to this editor's scoped state only (in-memory snapshot
+     * and persisted bucket). Returns `true` when something actually changed, so
+     * callers can skip propagating no-op updates to the profile-global value.
+     */
+    private _applyLocalModelConfiguration;
+    getModelConfigurationActions(modelId: string): IAction[];
+    /**
+     * Restores a previously captured configuration for a model (e.g. when
+     * reopening a chat session). Seeds this editor's in-memory snapshot and
+     * persists it as the scoped default so the restored value participates in
+     * the same resolution hierarchy as a user-made change — mirroring how the
+     * restored model selection is persisted to its scoped storage key.
+     *
+     * When the model is registered, the captured values are filtered against its
+     * *current* configuration schema so that a config saved against an older
+     * schema does not re-pin removed properties or invalid values: unknown keys
+     * and values that violate the schema's `enum` constraint are dropped and fall
+     * back to the live default.
+     *
+     * When the model is NOT yet registered (asynchronous provider registration),
+     * its schema is unavailable. Filtering would then discard the *entire*
+     * captured config, causing the restore to merge an empty value over whatever
+     * the shared per-scope snapshot currently holds — re-pinning another
+     * conversation's value (e.g. its context size). To preserve the reopened
+     * session's own configuration in that race, the captured values are restored
+     * as-is; a later sync re-validates them once the schema loads. See #320393.
+     */
+    restoreModelConfiguration(modelId: string, values: IStringDictionary<unknown>): void;
+    /**
+     * Drops all in-memory snapshots so the next read re-seeds from the (now
+     * different) scoped storage bucket. Call when the owning editor's scope
+     * (e.g. session type) changes.
+     */
+    clear(): void;
+    private _schemaDefaults;
+    private _readBucket;
+    private _writeBucket;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatModelConfigurationStore.js

@@ -0,0 +1,127 @@
+
+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 { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
+import { createModelConfigurationActions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+import { resolveModelConfiguration, computeStoredConfiguration, filterConfigurationToSchema, extractSchemaDefaults } from './chatModelConfigurationLogic.js';
+
+class ChatModelConfigurationStore extends Disposable {
+    constructor(getStorageKey, languageModelsService, storageService) {
+        super();
+        this.getStorageKey = getStorageKey;
+        this.languageModelsService = languageModelsService;
+        this.storageService = storageService;
+        this._overrides = ( new Map());
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._register(this.languageModelsService.onDidChangeLanguageModels(() => {
+            if (this._overrides.size === 0) {
+                return;
+            }
+            const bucket = this._readBucket();
+            for (const [modelId, override] of [...this._overrides]) {
+                const schemaDefaults = this._schemaDefaults(modelId);
+                const nextOverride = ( Object.keys(override)).length === 0 ? resolveModelConfiguration(
+                    bucket[modelId],
+                    schemaDefaults,
+                    this.languageModelsService.getModelConfiguration(modelId)
+                ) : {
+                    ...schemaDefaults,
+                    ...override
+                };
+                if (!equals(override, nextOverride)) {
+                    this._overrides.set(modelId, nextOverride);
+                    this._onDidChange.fire(modelId);
+                }
+            }
+        }));
+    }
+    getModelConfiguration(modelId) {
+        let override = this._overrides.get(modelId);
+        if (!override) {
+            const bucketEntry = this._readBucket()[modelId];
+            const schemaDefaults = this._schemaDefaults(modelId);
+            const globalConfig = this.languageModelsService.getModelConfiguration(modelId);
+            override = resolveModelConfiguration(bucketEntry, schemaDefaults, globalConfig);
+            this._overrides.set(modelId, override);
+        }
+        return ( Object.keys(override)).length > 0 ? override : undefined;
+    }
+    async setModelConfiguration(modelId, values) {
+        const changed = this._applyLocalModelConfiguration(modelId, values);
+        if (!changed) {
+            return;
+        }
+        await this.languageModelsService.setModelConfiguration(modelId, values);
+    }
+    _applyLocalModelConfiguration(modelId, values) {
+        const schemaDefaults = this._schemaDefaults(modelId);
+        const stored = computeStoredConfiguration(this.getModelConfiguration(modelId) ?? {}, values, schemaDefaults);
+        const nextOverride = {
+            ...schemaDefaults,
+            ...stored
+        };
+        const bucket = this._readBucket();
+        if (equals(this._overrides.get(modelId), nextOverride) && equals(bucket[modelId], stored)) {
+            return false;
+        }
+        this._overrides.set(modelId, nextOverride);
+        bucket[modelId] = stored;
+        this._writeBucket(bucket);
+        this._onDidChange.fire(modelId);
+        return true;
+    }
+    getModelConfigurationActions(modelId) {
+        return createModelConfigurationActions(
+            this.languageModelsService.lookupLanguageModel(modelId)?.configurationSchema,
+            this.getModelConfiguration(modelId) ?? {},
+            (key, value) => this.setModelConfiguration(modelId, {
+                [key]: value
+            })
+        );
+    }
+    restoreModelConfiguration(modelId, values) {
+        const metadata = this.languageModelsService.lookupLanguageModel(modelId);
+        const filtered = metadata ? filterConfigurationToSchema(values, metadata.configurationSchema) : {
+            ...values
+        };
+        this._applyLocalModelConfiguration(modelId, filtered);
+    }
+    clear() {
+        this._overrides.clear();
+    }
+    _schemaDefaults(modelId) {
+        return extractSchemaDefaults(
+            this.languageModelsService.lookupLanguageModel(modelId)?.configurationSchema
+        );
+    }
+    _readBucket() {
+        const result = Object.create(null);
+        const raw = this.storageService.get(this.getStorageKey(), StorageScope.APPLICATION);
+        if (!raw) {
+            return result;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (parsed && typeof parsed === "object") {
+                for (const [modelId, entry] of Object.entries(parsed)) {
+                    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+                        result[modelId] = entry;
+                    }
+                }
+            }
+        } catch {}
+        return result;
+    }
+    _writeBucket(bucket) {
+        const key = this.getStorageKey();
+        if (( Object.keys(bucket)).length === 0) {
+            this.storageService.remove(key, StorageScope.APPLICATION);
+        } else {
+            this.storageService.store(key, JSON.stringify(bucket), StorageScope.APPLICATION, StorageTarget.USER);
+        }
+    }
+}
+
+export { ChatModelConfigurationStore };

package/vscode/src/vs/workbench/contrib/chat/browser/widget/input/chatModelPicker.d.ts

@@ -9,6 +9,7 @@ import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform
 import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
 import { IProductService } from "@codingame/monaco-vscode-api/vscode/vs/platform/product/common/productService.service";
 import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
 import { IModelControlEntry, ILanguageModelChatMetadataAndIdentifier, IModelsControlManifest } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
 import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
 import { ChatEntitlement } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService";
@@ -18,6 +19,8 @@ import { IUriIdentityService } from "@codingame/monaco-vscode-api/vscode/vs/plat
 import { IDefaultAccountService } from "@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service";
 import { StateType } from "@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update";
 import { IUpdateService } from "@codingame/monaco-vscode-api/vscode/vs/platform/update/common/update.service";
+import { IWorkspaceTrustRequestService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
+import { IWorkspaceTrustManagementService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspaceTrust.service";
 export declare function getControlModelsForEntitlement(manifest: IModelsControlManifest, entitlement: ChatEntitlement): IStringDictionary<IModelControlEntry>;
 /**
  * Builds the grouped items for the model picker dropdown.
@@ -37,8 +40,16 @@ export declare function getControlModelsForEntitlement(manifest: IModelsControlM
  *      Compatible" group and an "AWS Bedrock" group both registered to
  *      the `customoai` vendor) renders as distinct sections.
  * 4. Optional "Manage Models..." action shown in Other Models after a separator
+ *
+ * When `restrictedMode` is set (untrusted workspace), an explanatory "Models
+ * unavailable while in Restricted mode" header and a "Trust Workspace to enable
+ * models..." action (invoking `onRequestTrust`) replace all of the above.
+ * Likewise, when
+ * `setupRequired` is set (trusted, but Chat still needs sign-in / setup), a
+ * "Sign in to use Copilot" header and a Sign In action (invoking
+ * `onRequestSetup`) replace all of the above. `restrictedMode` takes precedence.
  */
-export declare function buildModelPickerItems(models: ILanguageModelChatMetadataAndIdentifier[], selectedModelId: string | undefined, recentModelIds: string[], pinnedModelIds: string[], controlModels: IStringDictionary<IModelControlEntry>, currentVSCodeVersion: string, updateStateType: StateType, onSelect: (model: ILanguageModelChatMetadataAndIdentifier) => void, onTogglePin: ((modelIdentifier: string, pinned: boolean) => void) | undefined, manageSettingsUrl: string | undefined, useGroupedModelPicker: boolean, manageModelsAction: IActionWidgetDropdownAction | undefined, chatEntitlementService: IChatEntitlementService, showUnavailableFeatured: boolean, showFeatured: boolean, languageModelsService?: ILanguageModelsService, openerService?: IOpenerService, isUBB?: boolean): IActionListItem<IActionWidgetDropdownAction>[];
+export declare function buildModelPickerItems(models: ILanguageModelChatMetadataAndIdentifier[], selectedModelId: string | undefined, recentModelIds: string[], pinnedModelIds: string[], controlModels: IStringDictionary<IModelControlEntry>, currentVSCodeVersion: string, updateStateType: StateType, onSelect: (model: ILanguageModelChatMetadataAndIdentifier) => void, onTogglePin: ((modelIdentifier: string, pinned: boolean) => void) | undefined, manageSettingsUrl: string | undefined, useGroupedModelPicker: boolean, manageModelsAction: IActionWidgetDropdownAction | undefined, chatEntitlementService: IChatEntitlementService, showUnavailableFeatured: boolean, showFeatured: boolean, languageModelsService?: ILanguageModelsService, openerService?: IOpenerService, showAutoModel?: boolean, onConfigure?: (model: ILanguageModelChatMetadataAndIdentifier, group: string) => void, restrictedMode?: boolean, onRequestTrust?: () => void, setupRequired?: boolean, onRequestSetup?: () => void, isUBB?: boolean): IActionListItem<IActionWidgetDropdownAction>[];
 export declare function getModelPickerAccessibilityProvider(): {
     readonly getAriaLabel: (element: IActionListItem<IActionWidgetDropdownAction>) => string | null;
     readonly isChecked: (element: IActionListItem<IActionWidgetDropdownAction>) => boolean | undefined;
@@ -68,39 +79,104 @@ export declare class ModelPickerWidget extends Disposable {
     private readonly _updateService;
     private readonly _uriIdentityService;
     private readonly _defaultAccountService;
+    private readonly _workspaceTrustManagementService;
+    private readonly _workspaceTrustRequestService;
+    private readonly _storageService;
     private readonly _onDidChangeSelection;
     readonly onDidChangeSelection: Event<ILanguageModelChatMetadataAndIdentifier>;
     private _selectedModel;
     private _badge;
     private _compact;
+    private _workspaceTrustInitialized;
+    private _activatingAfterTrust;
+    private readonly _activatingTimer;
     private _domNode;
     private _badgeIcon;
     private _nameButton;
-    private _effortButton;
-    private _tokensButton;
+    private _configButton;
     get selectedModel(): ILanguageModelChatMetadataAndIdentifier | undefined;
     get domNode(): HTMLElement | undefined;
     get nameButton(): HTMLElement | undefined;
-    constructor(_delegate: IModelPickerDelegate, _actionWidgetService: IActionWidgetService, _commandService: ICommandService, _openerService: IOpenerService, _telemetryService: ITelemetryService, _languageModelsService: ILanguageModelsService, _productService: IProductService, _entitlementService: IChatEntitlementService, _updateService: IUpdateService, _uriIdentityService: IUriIdentityService, _defaultAccountService: IDefaultAccountService);
+    constructor(_delegate: IModelPickerDelegate, _actionWidgetService: IActionWidgetService, _commandService: ICommandService, _openerService: IOpenerService, _telemetryService: ITelemetryService, _languageModelsService: ILanguageModelsService, _productService: IProductService, _entitlementService: IChatEntitlementService, _updateService: IUpdateService, _uriIdentityService: IUriIdentityService, _defaultAccountService: IDefaultAccountService, _workspaceTrustManagementService: IWorkspaceTrustManagementService, _workspaceTrustRequestService: IWorkspaceTrustRequestService, _storageService: IStorageService);
     setCompact(compact: IObservable<boolean>): void;
     setSelectedModel(model: ILanguageModelChatMetadataAndIdentifier | undefined): void;
     setEnabled(enabled: boolean): void;
     setBadge(badge: ModelPickerBadge | undefined): void;
+    /**
+     * Why the picker currently has no model to offer (untrusted vs. needs
+     * sign-in/setup), or `undefined` when a model is available. See
+     * {@link getModelPickerUnavailableReason}.
+     */
+    private _unavailableReason;
+    private _requiresSetup;
+    /**
+     * Whether the picker has no usable model specifically because the workspace
+     * is untrusted (Restricted Mode disables the chat model providers).
+     */
+    isRestrictedMode(): boolean;
+    /**
+     * Whether the picker has no usable model because Chat still needs sign-in /
+     * setup (and the workspace is trusted, so it is not Restricted Mode). BYOK
+     * and anonymous access never report this state.
+     */
+    isSetupRequired(): boolean;
+    private _clearActivating;
+    /**
+     * Prompts the user to trust the workspace. On grant, providers register their
+     * models and `onDidChangeLanguageModels` refreshes the picker.
+     */
+    private _requestWorkspaceTrust;
+    /**
+     * Starts the Chat setup / sign-in flow (same command as the title-bar Sign In
+     * affordance). On completion the entitlement and model registry change, which
+     * refreshes the picker.
+     */
+    private _requestSetup;
     render(container: HTMLElement): void;
     /**
      * Registers mouse-down and Enter/Space key handlers on a button element.
      */
     private _registerButtonAction;
+    /** The "Learn more" header link for cache-break hints; `undefined` when the product has no URL. */
+    private getCacheBreakLearnMoreLink;
+    private isCacheBreakHintDismissed;
+    private dismissCacheBreakHint;
+    /**
+     * Whether a picker should show the cache-break hint: the hint has not been
+     * dismissed and the session's cache is warm. When `excludeAutoModel` is
+     * set (the model picker), the hint is suppressed for the Auto model, since
+     * Auto routes each request dynamically so "switching models" does not apply.
+     * The options picker passes `false`: changing reasoning effort / context size
+     * resets the cache even under Auto, which only routes the model.
+     */
+    private shouldShowCacheBreakHint;
     show(anchor?: HTMLElement): void;
     private _updateBadge;
     private _renderLabel;
+    /**
+     * Per-editor model configuration access when the delegate provides it,
+     * otherwise the global service. Routing through this keeps configuration
+     * (e.g. context size) scoped to this editor so changes do not sync to other
+     * already-open editors. See issue #320393.
+     */
+    private get _modelConfiguration();
     private _getConfigProperty;
-    private _showEffortPicker;
-    private _showTokensPicker;
+    /**
+     * Builds the combined configuration items containing the model's Thinking
+     * Effort and Context Size options (when available).
+     */
+    private _buildConfigItems;
+    /**
+     * Opens the combined configuration dropdown containing the model's Thinking
+     * Effort and Context Size options (when available), in a single popup anchored
+     * to the config button. When `focusGroup` is provided, focus is moved to the
+     * first option of that section (e.g. 'navigation' for Thinking Effort or
+     * 'tokens' for Context Size).
+     */
+    private _showConfigPicker;
 }
-export declare function getModelHoverContent(model: ILanguageModelChatMetadataAndIdentifier, openerService: IOpenerService, isUBB?: boolean): {
+export declare function getModelHoverContent(model: ILanguageModelChatMetadataAndIdentifier, isUBB: boolean | undefined, onConfigure: ((group: string) => void) | undefined, openerService: IOpenerService): {
     element: HTMLElement;
     disposable: DisposableStore;
 } | undefined;
-export declare function formatTokenCount(count: number): string;
 export {};