@codingame/monaco-vscode-katex-common 26.2.2 → 28.0.0

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

@@ -0,0 +1,104 @@
+import { ChatAgentLocation, ChatModeKind } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ILanguageModelChatMetadataAndIdentifier } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
+/**
+ * Describes the context needed for model selection decisions.
+ */
+export interface IModelSelectionContext {
+    readonly location: ChatAgentLocation;
+    readonly currentModeKind: ChatModeKind;
+    readonly isInlineChatV2Enabled: boolean;
+    readonly sessionType: string | undefined;
+}
+/**
+ * Filter models based on session type.
+ * When a session has a specific type (and it's not 'local'), only models targeting that
+ * session type are returned. Otherwise, general-purpose models are returned.
+ */
+export declare function filterModelsForSession(models: ILanguageModelChatMetadataAndIdentifier[], sessionType: string | undefined, currentModeKind: ChatModeKind, location: ChatAgentLocation, isInlineChatV2Enabled: boolean): ILanguageModelChatMetadataAndIdentifier[];
+/**
+ * Check if a model is suitable for the current chat mode (e.g., agent mode requires tool calling).
+ */
+export declare function isModelSupportedForMode(model: ILanguageModelChatMetadataAndIdentifier, currentModeKind: ChatModeKind): boolean;
+/**
+ * Check if a model is suitable for inline chat (editor inline) usage.
+ */
+export declare function isModelSupportedForInlineChat(model: ILanguageModelChatMetadataAndIdentifier, location: ChatAgentLocation, isInlineChatV2Enabled: boolean): boolean;
+/**
+ * Check if any models in the pool target a specific session type.
+ */
+export declare function hasModelsTargetingSession(allModels: ILanguageModelChatMetadataAndIdentifier[], sessionType: string | undefined): boolean;
+/**
+ * Check if a model is valid for the current session's model pool.
+ * If the session has targeted models, the model must target that session type.
+ * If no models target this session, the model must not be session-specific.
+ */
+export declare function isModelValidForSession(model: ILanguageModelChatMetadataAndIdentifier, allModels: ILanguageModelChatMetadataAndIdentifier[], sessionType: string | undefined): boolean;
+/**
+ * Find the default model for a given location from a list of models.
+ * Prefers the model marked as default for the location, falls back to the first model.
+ */
+export declare function findDefaultModel(models: ILanguageModelChatMetadataAndIdentifier[], location: ChatAgentLocation): ILanguageModelChatMetadataAndIdentifier | undefined;
+/**
+ * Determine whether a persisted model selection should be restored.
+ *
+ * A persisted model should be restored if:
+ * 1. The model still exists in the available models list
+ * 2. Either the model wasn't the default at the time it was persisted,
+ *    OR it is currently the default for the location
+ *
+ * This prevents scenarios where a user's explicit model choice gets overridden
+ * when the default model changes, while still tracking default model changes
+ * for users who never explicitly chose a model.
+ */
+export declare function shouldRestorePersistedModel(persistedModelId: string, persistedAsDefault: boolean, availableModels: ILanguageModelChatMetadataAndIdentifier[], location: ChatAgentLocation): {
+    shouldRestore: boolean;
+    model: ILanguageModelChatMetadataAndIdentifier | undefined;
+};
+/**
+ * Determines whether the current model should be reset because it is no longer
+ * compatible with the current mode, session, or availability.
+ *
+ * Returns true if the model should be reset to default.
+ */
+export declare function shouldResetModelToDefault(currentModel: ILanguageModelChatMetadataAndIdentifier | undefined, availableModels: ILanguageModelChatMetadataAndIdentifier[], context: IModelSelectionContext, allModels: ILanguageModelChatMetadataAndIdentifier[]): boolean;
+/**
+ * Determines whether a model from a sync state should be applied to the current view.
+ *
+ * Returns an action:
+ * - `'keep'`    - the view already has the same model; no change needed.
+ * - `'apply'`   - the state model is valid; the caller should switch to it.
+ * - `'default'` - the state model is incompatible (wrong session pool, unsupported
+ *                 mode, or missing inline-chat capability); the caller should fall
+ *                 back to the default model for the current location.
+ *
+ * @param context Optional because some callers (e.g. unit tests, or code paths
+ *   that only care about session-pool validation) don't have a full UI context
+ *   available. When omitted, mode and inline-chat checks are skipped and only
+ *   session-pool membership is validated.
+ */
+export declare function resolveModelFromSyncState(stateModel: ILanguageModelChatMetadataAndIdentifier, currentModel: ILanguageModelChatMetadataAndIdentifier | undefined, allModels: ILanguageModelChatMetadataAndIdentifier[], sessionType: string | undefined, context?: IModelSelectionContext): {
+    action: "keep" | "apply" | "default";
+};
+/**
+ * Merges live models with cached models per-vendor.
+ * For vendors whose models have resolved, uses live data.
+ * For vendors that are contributed but haven't resolved yet (startup race), keeps cached models.
+ * Vendors no longer contributed are evicted from cache.
+ */
+export declare function mergeModelsWithCache(liveModels: ILanguageModelChatMetadataAndIdentifier[], cachedModels: ILanguageModelChatMetadataAndIdentifier[], contributedVendors: Set<string>): ILanguageModelChatMetadataAndIdentifier[];
+/**
+ * Determines whether the currently selected model should be reset to default
+ * when the language model list changes.
+ *
+ * Returns true if the model should be reset to default (i.e., the selected model
+ * is no longer in the available models list).
+ */
+export declare function shouldResetOnModelListChange(currentModelId: string | undefined, availableModels: ILanguageModelChatMetadataAndIdentifier[]): boolean;
+/**
+ * Determines whether a late-arriving persisted model should be restored.
+ * This handles the startup race where the model wasn't available during
+ * `initSelectedModel` but arrives later via `onDidChangeLanguageModels`.
+ *
+ * The model must pass both the persisted-default check and the `isUserSelectable` check.
+ */
+export declare function shouldRestoreLateArrivingModel(persistedModelId: string, persistedAsDefault: boolean, model: ILanguageModelChatMetadataAndIdentifier, location: ChatAgentLocation): boolean;

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

@@ -0,0 +1,127 @@
+
+import { ChatModeKind, ChatAgentLocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants';
+import { ILanguageModelChatMetadata } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels';
+
+function filterModelsForSession(models, sessionType, currentModeKind, location, isInlineChatV2Enabled) {
+    if (sessionType && sessionType !== "local" && hasModelsTargetingSession(models, sessionType)) {
+        return models.filter(
+            entry => entry.metadata?.targetChatSessionType === sessionType && entry.metadata?.isUserSelectable
+        );
+    }
+    return models.filter(
+        entry => !entry.metadata?.targetChatSessionType && entry.metadata?.isUserSelectable && isModelSupportedForMode(entry, currentModeKind) && isModelSupportedForInlineChat(entry, location, isInlineChatV2Enabled)
+    );
+}
+function isModelSupportedForMode(model, currentModeKind) {
+    if (currentModeKind === ChatModeKind.Agent) {
+        return ILanguageModelChatMetadata.suitableForAgentMode(model.metadata);
+    }
+    return true;
+}
+function isModelSupportedForInlineChat(model, location, isInlineChatV2Enabled) {
+    if (location !== ChatAgentLocation.EditorInline || !isInlineChatV2Enabled) {
+        return true;
+    }
+    return !!model.metadata.capabilities?.toolCalling;
+}
+function hasModelsTargetingSession(allModels, sessionType) {
+    if (!sessionType) {
+        return false;
+    }
+    return ( allModels.some(m => m.metadata.targetChatSessionType === sessionType));
+}
+function isModelValidForSession(model, allModels, sessionType) {
+    if (hasModelsTargetingSession(allModels, sessionType)) {
+        return model.metadata.targetChatSessionType === sessionType;
+    }
+    return !model.metadata.targetChatSessionType;
+}
+function findDefaultModel(models, location) {
+    return models.find(m => m.metadata.isDefaultForLocation[location]) || models[0];
+}
+function shouldRestorePersistedModel(persistedModelId, persistedAsDefault, availableModels, location) {
+    const model = availableModels.find(m => m.identifier === persistedModelId);
+    if (!model) {
+        return {
+            shouldRestore: false,
+            model: undefined
+        };
+    }
+    if (!persistedAsDefault || model.metadata.isDefaultForLocation[location]) {
+        return {
+            shouldRestore: true,
+            model
+        };
+    }
+    return {
+        shouldRestore: false,
+        model
+    };
+}
+function shouldResetModelToDefault(currentModel, availableModels, context, allModels) {
+    if (!currentModel) {
+        return true;
+    }
+    if (!( availableModels.some(m => m.identifier === currentModel.identifier))) {
+        return true;
+    }
+    if (!isModelSupportedForMode(currentModel, context.currentModeKind)) {
+        return true;
+    }
+    if (!isModelSupportedForInlineChat(currentModel, context.location, context.isInlineChatV2Enabled)) {
+        return true;
+    }
+    if (!isModelValidForSession(currentModel, allModels, context.sessionType)) {
+        return true;
+    }
+    return false;
+}
+function resolveModelFromSyncState(stateModel, currentModel, allModels, sessionType, context) {
+    if (currentModel && currentModel.identifier === stateModel.identifier) {
+        return {
+            action: "keep"
+        };
+    }
+    if (!isModelValidForSession(stateModel, allModels, sessionType)) {
+        return {
+            action: "default"
+        };
+    }
+    if (context) {
+        if (!isModelSupportedForMode(stateModel, context.currentModeKind)) {
+            return {
+                action: "default"
+            };
+        }
+        if (!isModelSupportedForInlineChat(stateModel, context.location, context.isInlineChatV2Enabled)) {
+            return {
+                action: "default"
+            };
+        }
+    }
+    return {
+        action: "apply"
+    };
+}
+function mergeModelsWithCache(liveModels, cachedModels, contributedVendors) {
+    if (liveModels.length > 0) {
+        const liveVendors = ( new Set(( liveModels.map(m => m.metadata.vendor))));
+        return [...liveModels, ...cachedModels.filter(m => !( liveVendors.has(m.metadata.vendor)) && ( contributedVendors.has(m.metadata.vendor)))];
+    }
+    return cachedModels;
+}
+function shouldResetOnModelListChange(currentModelId, availableModels) {
+    if (!currentModelId) {
+        return true;
+    }
+    return !( availableModels.some(m => m.identifier === currentModelId));
+}
+function shouldRestoreLateArrivingModel(persistedModelId, persistedAsDefault, model, location) {
+    if (!model.metadata.isUserSelectable) {
+        return false;
+    }
+    const result = shouldRestorePersistedModel(persistedModelId, persistedAsDefault, [model], location);
+    return result.shouldRestore;
+}
+
+export { filterModelsForSession, findDefaultModel, hasModelsTargetingSession, isModelSupportedForInlineChat, isModelSupportedForMode, isModelValidForSession, mergeModelsWithCache, resolveModelFromSyncState, shouldResetModelToDefault, shouldResetOnModelListChange, shouldRestoreLateArrivingModel, shouldRestorePersistedModel };

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

@@ -1,12 +1,24 @@
 import { IAction } from "@codingame/monaco-vscode-api/vscode/vs/base/common/actions";
+import { IActionWidgetService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service";
 import { IActionWidgetDropdownAction } from "../../../../../../platform/actionWidget/browser/actionWidgetDropdown.js";
+import { MenuItemAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions";
+import { ICommandService } from "@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service";
+import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
+import { IKeybindingService } from "@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service";
+import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
 import { AgentSessionProviders } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions";
+import { ISessionTypePickerDelegate } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
 import { ISessionTypeItem, SessionTypePickerActionItem } from "./sessionTargetPickerActionItem.js";
 /**
  * Action view item for delegating to a remote session (Background or Cloud).
  * This picker allows switching to remote execution providers when the session is not empty.
  */
 export declare class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
+    private readonly _isSessionsWindow;
+    constructor(action: MenuItemAction, chatSessionPosition: "sidebar" | "editor", delegate: ISessionTypePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, keybindingService: IKeybindingService, contextKeyService: IContextKeyService, chatSessionsService: IChatSessionsService, commandService: ICommandService, openerService: IOpenerService, telemetryService: ITelemetryService);
     protected _run(sessionTypeItem: ISessionTypeItem): void;
     protected _getSelectedSessionType(): AgentSessionProviders | undefined;
     protected _isSessionTypeEnabled(type: AgentSessionProviders): boolean;
@@ -16,7 +28,6 @@ export declare class DelegationSessionPickerActionItem extends SessionTypePicker
         order: number;
         showHeader: boolean;
     };
-    protected _getSessionDescription(sessionTypeItem: ISessionTypeItem): string | undefined;
     protected _getLearnMore(): IAction;
     protected _getAdditionalActions(): IActionWidgetDropdownAction[];
 }

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

@@ -1,12 +1,49 @@
 
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IActionWidgetService } from '@codingame/monaco-vscode-api/vscode/vs/platform/actionWidget/browser/actionWidget.service';
+import { ICommandService } from '@codingame/monaco-vscode-api/vscode/vs/platform/commands/common/commands.service';
+import { IContextKeyService } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service';
+import { IKeybindingService } from '@codingame/monaco-vscode-api/vscode/vs/platform/keybinding/common/keybinding.service';
+import { IOpenerService } from '@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IsSessionsWindowContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { IChatSessionsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service';
 import { ACTION_ID_NEW_CHAT } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/actions/chatActions';
 import { getAgentSessionProvider, AgentSessionProviders, getAgentCanContinueIn, isFirstPartyAgentSessionProvider } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/agentSessions';
 import { SessionTypePickerActionItem } from './sessionTargetPickerActionItem.js';
 
-class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
+let DelegationSessionPickerActionItem = class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
+    constructor(
+        action,
+        chatSessionPosition,
+        delegate,
+        pickerOptions,
+        actionWidgetService,
+        keybindingService,
+        contextKeyService,
+        chatSessionsService,
+        commandService,
+        openerService,
+        telemetryService
+    ) {
+        super(
+            action,
+            chatSessionPosition,
+            delegate,
+            pickerOptions,
+            actionWidgetService,
+            keybindingService,
+            contextKeyService,
+            chatSessionsService,
+            commandService,
+            openerService,
+            telemetryService
+        );
+        this._isSessionsWindow = IsSessionsWindowContext.getValue(contextKeyService) === true;
+    }
     _run(sessionTypeItem) {
         if (this.delegate.setPendingDelegationTarget) {
             this.delegate.setPendingDelegationTarget(sessionTypeItem.type);
@@ -25,15 +62,22 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
     _isSessionTypeEnabled(type) {
         const allContributions = this.chatSessionsService.getAllChatSessionContributions();
         const contribution = allContributions.find(contribution => getAgentSessionProvider(contribution.type) === type);
-        if (this.delegate.getActiveSessionProvider() !== AgentSessionProviders.Local) {
+        const activeProvider = this.delegate.getActiveSessionProvider();
+        if (!this._isSessionsWindow && activeProvider !== AgentSessionProviders.Local) {
             return false;
         }
-        if (contribution && !contribution.canDelegate && this.delegate.getActiveSessionProvider() !== type ) {
+        if (this._isSessionsWindow && activeProvider !== AgentSessionProviders.Background) {
+            return false;
+        }
+        if (contribution && !contribution.canDelegate && activeProvider !== type ) {
             return false;
         }
         return this._getSelectedSessionType() !== type;
     }
     _isVisible(type) {
+        if (this._isSessionsWindow && type === AgentSessionProviders.Local) {
+            return false;
+        }
         if (this.delegate.getActiveSessionProvider() === type) {
             return true;
         }
@@ -42,29 +86,22 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
     _getSessionCategory(sessionTypeItem) {
         if (isFirstPartyAgentSessionProvider(sessionTypeItem.type)) {
             return {
-                label: ( localize(6181, "Continue In")),
+                label: ( localize(6818, "Continue In")),
                 order: 1,
                 showHeader: true
             };
         }
         return {
-            label: ( localize(6182, "Continue In (Third Party)")),
+            label: ( localize(6819, "Continue In (Third Party)")),
             order: 2,
             showHeader: false
         };
     }
-    _getSessionDescription(sessionTypeItem) {
-        const allContributions = this.chatSessionsService.getAllChatSessionContributions();
-        const contribution = allContributions.find(
-            contribution => getAgentSessionProvider(contribution.type) === sessionTypeItem.type
-        );
-        return contribution?.name ? `@${contribution.name}` : undefined;
-    }
     _getLearnMore() {
         const learnMoreUrl = "https://aka.ms/vscode-continue-chat-in";
         return {
             id: "workbench.action.chat.agentOverview.learnMoreHandOff",
-            label: ( localize(6183, "Learn about agent handoff...")),
+            label: ( localize(6820, "Learn about agent handoff...")),
             tooltip: learnMoreUrl,
             class: undefined,
             enabled: true,
@@ -74,10 +111,13 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
         };
     }
     _getAdditionalActions() {
+        if (this._isSessionsWindow) {
+            return [];
+        }
         return [{
             id: "newChatSession",
             class: undefined,
-            label: ( localize(6184, "New Chat Session")),
+            label: ( localize(6821, "New Chat Session")),
             tooltip: "",
             hover: {
                 content: "",
@@ -87,7 +127,7 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
             icon: Codicon.plus,
             enabled: true,
             category: {
-                label: ( localize(6185, "New Chat Session")),
+                label: ( localize(6822, "New Chat Session")),
                 order: 0,
                 showHeader: false
             },
@@ -97,6 +137,7 @@ class DelegationSessionPickerActionItem extends SessionTypePickerActionItem {
             }
         }];
     }
-}
+};
+DelegationSessionPickerActionItem = ( __decorate([( __param(4, IActionWidgetService)), ( __param(5, IKeybindingService)), ( __param(6, IContextKeyService)), ( __param(7, IChatSessionsService)), ( __param(8, ICommandService)), ( __param(9, IOpenerService)), ( __param(10, ITelemetryService))], DelegationSessionPickerActionItem));
 
 export { DelegationSessionPickerActionItem };

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

@@ -13,9 +13,10 @@ import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
 import { IChatMode } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes";
 import { IChatModeService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatModes.service";
-import { Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService";
+import { Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { ChatInputPickerActionViewItem, IChatInputPickerOptions } from "./chatInputPickerActionItem.js";
 import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/opener/common/opener.service";
+import { IWorkbenchAssignmentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/assignment/common/assignmentService.service";
 export interface IModePickerDelegate {
     readonly currentMode: IObservable<IChatMode>;
     readonly sessionResource: () => URI | undefined;
@@ -30,12 +31,8 @@ export declare class ModePickerActionItem extends ChatInputPickerActionViewItem
     private readonly contextKeyService;
     private readonly menuService;
     private readonly _productService;
-    constructor(action: MenuItemAction, delegate: IModePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, chatAgentService: IChatAgentService, keybindingService: IKeybindingService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatModeService: IChatModeService, menuService: IMenuService, commandService: ICommandService, _productService: IProductService, telemetryService: ITelemetryService, openerService: IOpenerService);
+    constructor(action: MenuItemAction, delegate: IModePickerDelegate, pickerOptions: IChatInputPickerOptions, actionWidgetService: IActionWidgetService, chatAgentService: IChatAgentService, keybindingService: IKeybindingService, configurationService: IConfigurationService, contextKeyService: IContextKeyService, chatModeService: IChatModeService, menuService: IMenuService, commandService: ICommandService, _productService: IProductService, telemetryService: ITelemetryService, openerService: IOpenerService, assignmentService: IWorkbenchAssignmentService);
     private getModePickerActionBarActions;
+    render(container: HTMLElement): void;
     protected renderLabel(element: HTMLElement): IDisposable | null;
 }
-/**
- * Returns true if the mode is the built-in 'implement' mode from the chat extension.
- * This mode is hidden from the mode picker but available for handoffs.
- */
-export declare function isBuiltinImplementMode(mode: IChatMode, productService: IProductService): boolean;