@codingame/monaco-vscode-api 33.0.8 → 34.0.0

package/vscode/src/vs/workbench/contrib/chat/common/attachments/chatVariableEntries.js

@@ -83,9 +83,9 @@ var IDiagnosticVariableEntryFilterData;
             }
             return data.problemMessage.substring(0, lastSpace) + "…";
         }
-        let labelStr = ( localize(7767, "All Problems"));
+        let labelStr = ( localize(7916, "All Problems"));
         if (data.filterUri) {
-            labelStr = ( localize(7768, "Problems in {0}", basename(data.filterUri)));
+            labelStr = ( localize(7917, "Problems in {0}", basename(data.filterUri)));
         }
         return labelStr;
     }
@@ -157,6 +157,19 @@ function isWorkspaceVariableEntry(obj) {
 function isImageVariableEntry(obj) {
     return obj.kind === "image";
 }
+function isExplicitFileOrImageVariableEntry(obj) {
+    return obj.kind === "file" || obj.kind === "directory" || obj.kind === "image";
+}
+function getExplicitFileOrImageAttachmentSummary(entries) {
+    const fileOrImageEntries = entries.filter(isExplicitFileOrImageVariableEntry);
+    if (!fileOrImageEntries.length) {
+        return undefined;
+    }
+    if (fileOrImageEntries.every(isImageVariableEntry)) {
+        return fileOrImageEntries.length === 1 ? ( localize(7918, "Attached 1 image")) : ( localize(7919, "Attached {0} images", fileOrImageEntries.length));
+    }
+    return fileOrImageEntries.length === 1 ? ( localize(7920, "Attached 1 file")) : ( localize(7921, "Attached {0} files", fileOrImageEntries.length));
+}
 function isNotebookOutputVariableEntry(obj) {
     return obj.kind === "notebookOutput";
 }
@@ -273,4 +286,4 @@ class ChatRequestVariableSet {
     }
 }
 
-export { ChatRequestVariableSet, IChatRequestVariableEntry, IDiagnosticVariableEntryFilterData, OmittedState, PromptFileVariableKind, getImageAttachmentLimit, isBrowserViewVariableEntry, isElementVariableEntry, isImageVariableEntry, isImplicitVariableEntry, isNotebookOutputVariableEntry, isPasteVariableEntry, isPromptFileVariableEntry, isPromptTextVariableEntry, isSCMHistoryItemChangeRangeVariableEntry, isSCMHistoryItemChangeVariableEntry, isSCMHistoryItemVariableEntry, isStringImplicitContextValue, isStringVariableEntry, isTerminalVariableEntry, isWorkspaceVariableEntry, toPromptFileVariableEntry, toPromptTextVariableEntry, toToolSetVariableEntry, toToolVariableEntry };
+export { ChatRequestVariableSet, IChatRequestVariableEntry, IDiagnosticVariableEntryFilterData, OmittedState, PromptFileVariableKind, getExplicitFileOrImageAttachmentSummary, getImageAttachmentLimit, isBrowserViewVariableEntry, isElementVariableEntry, isExplicitFileOrImageVariableEntry, isImageVariableEntry, isImplicitVariableEntry, isNotebookOutputVariableEntry, isPasteVariableEntry, isPromptFileVariableEntry, isPromptTextVariableEntry, isSCMHistoryItemChangeRangeVariableEntry, isSCMHistoryItemChangeVariableEntry, isSCMHistoryItemVariableEntry, isStringImplicitContextValue, isStringVariableEntry, isTerminalVariableEntry, isWorkspaceVariableEntry, toPromptFileVariableEntry, toPromptTextVariableEntry, toToolSetVariableEntry, toToolVariableEntry };

package/vscode/src/vs/workbench/contrib/chat/common/chatModes.d.ts

@@ -23,11 +23,11 @@ export interface IChatModes {
     findModeById(id: string): IChatMode | undefined;
     findModeByName(name: string): IChatMode | undefined;
     /**
-     * Awaits the most recently scheduled refresh of custom prompt modes.
+     * Awaits the most recently scheduled update of custom prompt modes.
      * After this resolves, {@link custom} reflects the latest data from the
      * prompts service.
      */
-    waitForRefresh(): Promise<void>;
+    waitForPendingUpdates(): Promise<void>;
 }
 export declare class ChatModeService extends Disposable implements IChatModeService {
     private readonly instantiationService;
@@ -89,6 +89,9 @@ export interface IChatModeInstructions {
     readonly toolReferences: readonly IVariableReference[];
     readonly metadata?: Record<string, boolean | string | number>;
 }
+export declare namespace IChatModeInstructions {
+    function isEquals(a: IChatModeInstructions | undefined, b: IChatModeInstructions | undefined): boolean;
+}
 export declare class CustomChatMode implements IChatMode {
     private readonly _nameObservable;
     private readonly _descriptionObservable;
@@ -125,7 +128,7 @@ export declare class CustomChatMode implements IChatMode {
     /**
      * Updates the underlying data and triggers observable changes
      */
-    updateData(newData: ICustomAgent): void;
+    updateData(newData: ICustomAgent): boolean;
     toJSON(): IChatModeData;
 }
 type IChatModeSourceData = {

package/vscode/src/vs/workbench/contrib/chat/common/chatModes.js

@@ -1,6 +1,6 @@
 
 import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { CancellationToken } from '../../../../base/common/cancellation.js';
+import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
 import { Emitter } from '../../../../base/common/event.js';
 import { Disposable } from '../../../../base/common/lifecycle.js';
 import '../../../../base/common/observableInternal/index.js';
@@ -17,14 +17,17 @@ import { IChatAgentService } from './participants/chatAgents.service.js';
 import { ChatContextKeys } from './actions/chatContextKeys.js';
 import { getChatSessionType, LocalChatSessionUri } from './model/chatUri.js';
 import { ChatConfiguration, ChatModeKind } from './constants.js';
-import { PromptsStorage, matchesSessionType, isCustomAgentVisibility } from './promptSyntax/service/promptsService.js';
-import { IPromptsService } from './promptSyntax/service/promptsService.service.js';
+import { PromptsStorage, isCustomAgentVisibility, IAgentSource } from './promptSyntax/service/promptsService.js';
 import { ICustomizationHarnessService } from './customizationHarnessService.service.js';
 import { Target } from './promptSyntax/promptTypes.js';
 import { Codicon } from '../../../../base/common/codicons.js';
 import { hash } from '../../../../base/common/hash.js';
 import { isString } from '../../../../base/common/types.js';
 import { isTarget } from './promptSyntax/languageProviders/promptFileAttributes.js';
+import { equals as equals$1 } from '../../../../base/common/arrays.js';
+import { isEqual } from '../../../../base/common/resources.js';
+import { equals } from '../../../../base/common/objects.js';
+import { Delayer } from '../../../../base/common/async.js';
 import { constObservable } from '../../../../base/common/observableInternal/observables/constObservable.js';
 import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
 import { transaction } from '../../../../base/common/observableInternal/transaction.js';
@@ -39,7 +42,6 @@ let ChatModes = class ChatModes extends Disposable {
     }
     constructor(
         sessionResource,
-        promptsService,
         chatAgentService,
         contextKeyService,
         logService,
@@ -49,7 +51,6 @@ let ChatModes = class ChatModes extends Disposable {
     ) {
         super();
         this.sessionResource = sessionResource;
-        this.promptsService = promptsService;
         this.chatAgentService = chatAgentService;
         this.logService = logService;
         this.storageService = storageService;
@@ -59,17 +60,15 @@ let ChatModes = class ChatModes extends Disposable {
         this._onDidChange = this._register(( new Emitter()));
         this.onDidChange = this._onDidChange.event;
         this._pendingRefresh = Promise.resolve();
+        this._refreshThrottler = this._register(( new Delayer(100)));
         const sessionType = getChatSessionType(sessionResource);
         this._storageKey = ChatModes_1.CUSTOM_MODES_STORAGE_KEY_PREFIX + sessionType;
         this.hasCustomModes = ChatContextKeys.Modes.hasCustomChatModes.bindTo(contextKeyService);
         this.loadCachedModes();
-        this._pendingRefresh = this.refreshCustomPromptModes(true);
-        this._register(this.promptsService.onDidChangeCustomAgents(() => {
-            this._pendingRefresh = this.refreshCustomPromptModes(true);
-        }));
+        this._pendingRefresh = this.triggerRefresh();
         this._register(this.customizationHarnessService.onDidChangeCustomAgents(e => {
-            if (e.sessionType === sessionType && this.useChatSessionCustomizationsForCustomAgents()) {
-                this._pendingRefresh = this.refreshCustomPromptModes(true);
+            if (e.sessionType === sessionType) {
+                this._pendingRefresh = this.triggerRefresh();
             }
         }));
         this._register(this.storageService.onWillSaveState(() => this.saveCachedModes()));
@@ -77,9 +76,6 @@ let ChatModes = class ChatModes extends Disposable {
             if (e.affectsConfiguration(ChatConfiguration.AgentEnabled)) {
                 this._onDidChange.fire();
             }
-            if (e.affectsConfiguration(ChatConfiguration.UseChatSessionCustomizationsForCustomAgents)) {
-                this._pendingRefresh = this.refreshCustomPromptModes(true);
-            }
         }));
         let didHaveToolsAgent = this.chatAgentService.hasToolsAgent;
         this._register(this.chatAgentService.onDidChangeAgents(() => {
@@ -99,9 +95,9 @@ let ChatModes = class ChatModes extends Disposable {
         return this.getBuiltinModes().find(mode => mode.id === id) ?? this._customModeInstances.get(id);
     }
     findModeByName(name) {
-        return this.getBuiltinModes().find(mode => mode.name.get() === name) ?? this.getCustomModes().find(mode => mode.name.get() === name);
+        return this.getBuiltinModes().find(mode => mode.name.get() === name) ?? this.getCustomModes().find(mode => mode.name.get() === name || mode.id === name);
     }
-    waitForRefresh() {
+    waitForPendingUpdates() {
         return this._pendingRefresh;
     }
     loadCachedModes() {
@@ -131,6 +127,7 @@ let ChatModes = class ChatModes extends Disposable {
                     }
                     const uri = URI.revive(cachedMode.uri);
                     const customChatMode = {
+                        id: cachedMode.id,
                         uri,
                         name: cachedMode.name,
                         description: cachedMode.description,
@@ -173,20 +170,37 @@ let ChatModes = class ChatModes extends Disposable {
             this.logService.warn("Failed to save cached custom agents", error);
         }
     }
-    useChatSessionCustomizationsForCustomAgents() {
-        return this.configurationService.getValue(ChatConfiguration.UseChatSessionCustomizationsForCustomAgents) === true;
+    triggerRefresh() {
+        this._refreshCancellationSource?.cancel();
+        this._refreshCancellationSource?.dispose();
+        const refreshCancellationSource = this._refreshCancellationSource = ( new CancellationTokenSource());
+        return this._refreshThrottler.trigger(async () => {
+            try {
+                await this.refreshCustomPromptModes(refreshCancellationSource.token);
+            } finally {
+                if (this._refreshCancellationSource === refreshCancellationSource) {
+                    this._refreshCancellationSource = undefined;
+                }
+                refreshCancellationSource.dispose();
+            }
+        });
     }
-    async computeCustomAgents() {
-        const useHarness = this.useChatSessionCustomizationsForCustomAgents();
-        if (useHarness) {
-            return await this.customizationHarnessService.getCustomAgents(getChatSessionType(this.sessionResource), CancellationToken.None);
-        }
-        const sessionType = getChatSessionType(this.sessionResource);
-        return (await this.promptsService.getCustomAgents(CancellationToken.None)).filter(mode => matchesSessionType(mode.sessionTypes, sessionType));
+    dispose() {
+        this._refreshCancellationSource?.cancel();
+        this._refreshCancellationSource?.dispose();
+        this._refreshCancellationSource = undefined;
+        super.dispose();
     }
-    async refreshCustomPromptModes(fireChangeEvent) {
+    async refreshCustomPromptModes(token) {
+        let hasChanges = false;
         try {
-            const customModes = await this.computeCustomAgents();
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const customModes = await this.customizationHarnessService.getCustomAgents(this.sessionResource, token);
+            if (token.isCancellationRequested) {
+                return;
+            }
             const seenUris = ( new Set());
             for (const customMode of customModes) {
                 if (!customMode.visibility.userInvocable || !customMode.enabled) {
@@ -196,15 +210,19 @@ let ChatModes = class ChatModes extends Disposable {
                 seenUris.add(uriString);
                 let modeInstance = this._customModeInstances.get(uriString);
                 if (modeInstance) {
-                    modeInstance.updateData(customMode);
+                    if (modeInstance.updateData(customMode)) {
+                        hasChanges = true;
+                    }
                 } else {
                     modeInstance = ( new CustomChatMode(customMode));
                     this._customModeInstances.set(uriString, modeInstance);
+                    hasChanges = true;
                 }
             }
             for (const [uriString] of this._customModeInstances.entries()) {
                 if (!( seenUris.has(uriString))) {
                     this._customModeInstances.delete(uriString);
+                    hasChanges = true;
                 }
             }
             this.hasCustomModes.set(this._customModeInstances.size > 0);
@@ -212,8 +230,9 @@ let ChatModes = class ChatModes extends Disposable {
             this.logService.error(error, "Failed to load custom agents");
             this._customModeInstances.clear();
             this.hasCustomModes.set(false);
+            hasChanges = true;
         }
-        if (fireChangeEvent) {
+        if (hasChanges) {
             this._onDidChange.fire();
         }
     }
@@ -232,7 +251,7 @@ let ChatModes = class ChatModes extends Disposable {
         return this.configurationService.inspect(ChatConfiguration.AgentEnabled).policyValue === false;
     }
 };
-ChatModes = ChatModes_1 = ( __decorate([( __param(1, IPromptsService)), ( __param(2, IChatAgentService)), ( __param(3, IContextKeyService)), ( __param(4, ILogService)), ( __param(5, IStorageService)), ( __param(6, IConfigurationService)), ( __param(7, ICustomizationHarnessService))], ChatModes));
+ChatModes = ChatModes_1 = ( __decorate([( __param(1, IChatAgentService)), ( __param(2, IContextKeyService)), ( __param(3, ILogService)), ( __param(4, IStorageService)), ( __param(5, IConfigurationService)), ( __param(6, ICustomizationHarnessService))], ChatModes));
 let ChatModeService = class ChatModeService extends Disposable {
     constructor(instantiationService, contextKeyService, configurationService) {
         super();
@@ -253,7 +272,7 @@ let ChatModeService = class ChatModeService extends Disposable {
         if (!this.localMode) {
             this.localMode = (async () => {
                 const modes = this._register(this.createModes(LocalChatSessionUri.getNewSessionUri()));
-                await modes.waitForRefresh();
+                await modes.waitForPendingUpdates();
                 return modes;
             })();
         }
@@ -267,6 +286,19 @@ let ChatModeService = class ChatModeService extends Disposable {
     }
 };
 ChatModeService = ( __decorate([( __param(0, IInstantiationService)), ( __param(1, IContextKeyService)), ( __param(2, IConfigurationService))], ChatModeService));
+var IChatModeInstructions;
+(function(IChatModeInstructions) {
+    function isEquals(a, b) {
+        if (a === b) {
+            return true;
+        }
+        if (!a || !b) {
+            return false;
+        }
+        return a.content === b.content && equals(a.toolReferences, b.toolReferences) && equals(a.metadata, b.metadata);
+    }
+    IChatModeInstructions.isEquals = isEquals;
+})(IChatModeInstructions || (IChatModeInstructions = {}));
 function isCachedChatModeData(data) {
     if (typeof data !== "object" || data === null) {
         return false;
@@ -341,21 +373,39 @@ class CustomChatMode {
         this._sessionTypes = customChatMode.sessionTypes;
     }
     updateData(newData) {
+        let hasChanges = false;
         transaction(tx => {
-            this._nameObservable.set(newData.name, tx);
-            this._descriptionObservable.set(newData.description, tx);
-            this._customToolsObservable.set(newData.tools, tx);
-            this._modelObservable.set(newData.model, tx);
-            this._argumentHintObservable.set(newData.argumentHint, tx);
-            this._handoffsObservable.set(newData.handOffs, tx);
-            this._targetObservable.set(newData.target, tx);
-            this._visibilityObservable.set(newData.visibility, tx);
-            this._agentsObservable.set(newData.agents, tx);
-            this._modeInstructions.set(newData.agentInstructions, tx);
-            this._uriObservable.set(newData.uri, tx);
-            this._source = newData.source;
-            this._sessionTypes = newData.sessionTypes;
+            const update = (observable, newValue, equals = (a, b) => a === b) => {
+                if (!equals(observable.get(), newValue)) {
+                    observable.set(newValue, tx);
+                    hasChanges = true;
+                }
+            };
+            update(this._nameObservable, newData.name);
+            update(this._descriptionObservable, newData.description);
+            update(this._customToolsObservable, newData.tools, equals$1);
+            update(this._modelObservable, newData.model, equals$1);
+            update(this._argumentHintObservable, newData.argumentHint);
+            update(
+                this._modeInstructions,
+                newData.agentInstructions,
+                IChatModeInstructions.isEquals
+            );
+            update(this._uriObservable, newData.uri, isEqual);
+            update(this._handoffsObservable, newData.handOffs, equals);
+            update(this._targetObservable, newData.target);
+            update(this._visibilityObservable, newData.visibility, equals);
+            update(this._agentsObservable, newData.agents, equals$1);
+            if (!IAgentSource.isEquals(this._source, newData.source)) {
+                this._source = newData.source;
+                hasChanges = true;
+            }
+            if (!equals$1(this._sessionTypes, newData.sessionTypes)) {
+                this._sessionTypes = newData.sessionTypes;
+                hasChanges = true;
+            }
         });
+        return hasChanges;
     }
     toJSON() {
         return {
@@ -456,9 +506,9 @@ class BuiltinChatMode {
 }
 var ChatMode;
 (function(ChatMode) {
-    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(7774, "Explore and understand your code")), Codicon.question));
-    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(7775, "Edit or refactor selected code")), Codicon.edit));
-    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(7776, "Describe what to build")), Codicon.agent));
+    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(7927, "Explore and understand your code")), Codicon.question));
+    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(7928, "Edit or refactor selected code")), Codicon.edit));
+    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(7929, "Describe what to build")), Codicon.agent));
 })(ChatMode || (ChatMode = {}));
 function isBuiltinChatMode(mode) {
     return mode.id === ChatMode.Ask.id || mode.id === ChatMode.Edit.id || mode.id === ChatMode.Agent.id;
@@ -505,4 +555,4 @@ function buildCustomAgentHandoffsInfo(modes) {
     }));
 }
 
-export { BuiltinChatMode, ChatMode, ChatModeService, CustomChatMode, buildCustomAgentHandoffsInfo, getHandoffId, getModeNameForTelemetry, isBuiltinChatMode };
+export { BuiltinChatMode, ChatMode, ChatModeService, CustomChatMode, IChatModeInstructions, buildCustomAgentHandoffsInfo, getHandoffId, getModeNameForTelemetry, isBuiltinChatMode };

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatService.d.ts

@@ -283,6 +283,37 @@ export interface IChatWorkspaceEdit {
     kind: "workspaceEdit";
     edits: IChatWorkspaceFileEdit[];
 }
+/**
+ * The kind of file operation an {@link IChatExternalEdit} represents.
+ */
+export type ChatExternalEditKind = "create" | "delete" | "rename" | "edit";
+/**
+ * A summary of a file edit that has been performed externally (i.e. by an
+ * agent or tool outside of chat's own editing pipeline). Carries everything
+ * needed to render a static "edit pill" without round-tripping through
+ * {@link IChatEditingSession} for diff computation: the producer already
+ * knows the URIs and diff stats up-front.
+ */
+export interface IChatExternalEdit {
+    kind: "externalEdit";
+    /** The resulting file URI (after-URI for create/edit/rename, before-URI for delete). */
+    uri: URI;
+    /** The kind of file operation. */
+    editKind: ChatExternalEditKind;
+    /** For renames, the file URI before the operation. */
+    originalUri?: URI;
+    /** URI from which the "before" content can be read (for diff viewing). Absent for creates. */
+    beforeContentUri?: URI;
+    /** URI from which the "after" content can be read (for diff viewing). Absent for deletes. */
+    afterContentUri?: URI;
+    /** Pre-computed diff display metadata. */
+    diff?: {
+        added: number;
+        removed: number;
+    };
+    /** Optional undo-stop id (typically the tool call id) for grouping. */
+    undoStopId?: string;
+}
 export interface IChatConfirmation {
     title: string;
     message: string | IMarkdownString;
@@ -470,6 +501,10 @@ export interface IChatTerminalToolInvocationData {
     requestUnsandboxedExecution?: boolean;
     /** The model-provided reason for requesting sandbox bypass */
     requestUnsandboxedExecutionReason?: string;
+    /** Whether the terminal command was approved to run sandboxed with unrestricted network access */
+    requestAllowNetwork?: boolean;
+    /** The model-provided reason for requesting unrestricted network access within the sandbox */
+    requestAllowNetworkReason?: string;
     /** Serialized URI for the command that was executed in the terminal */
     terminalCommandUri?: UriComponents;
     /** Serialized output of the executed command */
@@ -840,7 +875,7 @@ export declare class ChatMcpServersStarting implements IChatMcpServersStarting {
     wait(): Promise<IAutostartResult>;
     toJSON(): IChatMcpServersStartingSerialized;
 }
-export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatUsage | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatInfoMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatPlanReview | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart;
+export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatUsage | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatInfoMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatExternalEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatPlanReview | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart;
 export interface IChatFollowup {
     kind: "reply";
     message: string;

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionsService.d.ts

@@ -22,6 +22,29 @@ export interface IChatSessionCommandContribution {
     readonly description: string;
     readonly when?: string;
 }
+export interface IChatSessionProviderOptionModelMetadata {
+    readonly name: string;
+    readonly id: string;
+    readonly vendor?: string;
+    readonly version?: string;
+    readonly family?: string;
+    readonly tooltip?: string;
+    readonly pricing?: string;
+    readonly multiplierNumeric?: number;
+    readonly inputCost?: number;
+    readonly outputCost?: number;
+    readonly cacheCost?: number;
+    readonly longContextInputCost?: number;
+    readonly longContextOutputCost?: number;
+    readonly longContextCacheCost?: number;
+    readonly priceCategory?: string;
+    readonly maxInputTokens?: number;
+    readonly maxOutputTokens?: number;
+    readonly capabilities?: {
+        readonly vision?: boolean;
+        readonly toolCalling?: boolean;
+    };
+}
 export interface IChatSessionProviderOptionItem {
     readonly id: string;
     readonly name: string;
@@ -31,6 +54,8 @@ export interface IChatSessionProviderOptionItem {
     readonly icon?: ThemeIcon;
     readonly default?: boolean;
     readonly slashCommand?: string;
+    readonly tooltip?: string;
+    readonly modelMetadata?: IChatSessionProviderOptionModelMetadata;
 }
 export interface IChatSessionProviderOptionGroupCommand {
     readonly command: string;
@@ -123,6 +148,13 @@ export interface IChatSessionItem {
     } | readonly IChatSessionFileChange[] | readonly IChatSessionFileChange2[];
     readonly archived?: boolean;
     readonly metadata?: IChatSessionItemMetadata;
+    /**
+     * Resource identifier the item was previously known by. When set, host-stored
+     * per-resource state (archive, pin, read) recorded under that URI is adopted
+     * forward onto {@link resource} on first state read, and the legacy entry is
+     * removed. Scheme must match {@link resource}'s scheme; otherwise ignored.
+     */
+    readonly legacyResource?: URI;
 }
 export interface IChatSessionItemMetadata {
     readonly repositoryPath?: string;
@@ -166,6 +198,8 @@ export type IChatSessionHistoryItem = {
     variableData?: IChatRequestVariableData;
     modelId?: string;
     modeInstructions?: IChatRequestModeInstructions;
+    isSystemInitiated?: boolean;
+    systemInitiatedLabel?: string;
 } | {
     type: "response";
     parts: IChatProgress[];
@@ -175,6 +209,12 @@ export type IChatSessionHistoryItem = {
 export type IChatSessionRequestHistoryItem = Extract<IChatSessionHistoryItem, {
     type: "request";
 }>;
+export interface IChatSessionServerRequest {
+    readonly prompt: string;
+    readonly variableData?: IChatRequestVariableData;
+    readonly isSystemInitiated?: boolean;
+    readonly systemInitiatedLabel?: string;
+}
 /**
  * A set of well-known session types
  */
@@ -185,17 +225,25 @@ export declare namespace SessionType {
     const ClaudeCode = "claude-code";
     const Codex = "openai-codex";
     const Growth = "copilot-growth";
-    const AgentHostCopilot = "agent-host-copilot";
+    const AgentHostCopilot = "agent-host-copilotcli";
 }
 /**
- * Returns whether the given session type is an agent host target.
- * Matches the local agent host (`agent-host-*`) and remote agent hosts (`remote-*`).
+ * Returns whether the given session type is a local agent host target.
+ */
+export declare function isLocalAgentHostTarget(target: string): boolean;
+/**
+ * Returns whether the given session type is a remote agent host target.
  *
  * Note: The `remote-` prefix convention is established by
  * `RemoteAgentHostContribution` which generates session types as
  * `remote-{sanitizedAddress}-{provider}`. If future remote providers that
  * are NOT agent hosts need a different prefix, this function must be updated.
  */
+export declare function isRemoteAgentHostTarget(target: string): boolean;
+/**
+ * Returns whether the given session type is an agent host target.
+ * Matches the local agent host (`agent-host-*`) and remote agent hosts (`remote-*`).
+ */
 export declare function isAgentHostTarget(target: string): boolean;
 /**
  * The session type used for local agent chat sessions.
@@ -215,10 +263,7 @@ export interface IChatSession extends IDisposable {
      * queued message). The consumer should create a new request+response pair in
      * the model and prepare to receive progress via {@link progressObs}.
      */
-    readonly onDidStartServerRequest?: Event<{
-        prompt: string;
-        variableData?: IChatRequestVariableData;
-    }>;
+    readonly onDidStartServerRequest?: Event<IChatSessionServerRequest>;
     /**
      * Editing session transferred from a previously-untitled chat session in `onDidCommitChatSessionItem`.
      */
@@ -235,6 +280,13 @@ export interface IChatSession extends IDisposable {
      * @returns The forked session item. The promise is rejected if forking fails.
      */
     forkSession?: (request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken) => Promise<IChatSessionItem>;
+    /**
+     * Renames the session.
+     * @param title The new title for the session.
+     * @param token Cancellation token.
+     * @returns A promise that resolves once the rename has been dispatched. The promise is rejected if renaming fails.
+     */
+    renameSession?: (title: string, token: CancellationToken) => Promise<void>;
 }
 export interface IChatSessionContentProvider {
     provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionsService.js

@@ -16,10 +16,16 @@ var SessionType;
     SessionType.ClaudeCode = "claude-code";
     SessionType.Codex = "openai-codex";
     SessionType.Growth = "copilot-growth";
-    SessionType.AgentHostCopilot = "agent-host-copilot";
+    SessionType.AgentHostCopilot = "agent-host-copilotcli";
 })(SessionType || (SessionType = {}));
+function isLocalAgentHostTarget(target) {
+    return target === SessionType.AgentHostCopilot || target.startsWith("agent-host-");
+}
+function isRemoteAgentHostTarget(target) {
+    return target.startsWith("remote-");
+}
 function isAgentHostTarget(target) {
-    return target === SessionType.AgentHostCopilot || target.startsWith("agent-host-") || target.startsWith("remote-");
+    return isLocalAgentHostTarget(target) || isRemoteAgentHostTarget(target);
 }
 const localChatSessionType = SessionType.Local;
 var ChatSessionOptionsMap;
@@ -63,4 +69,4 @@ function isIChatSessionFileChange2(obj) {
     return candidate && candidate.uri instanceof URI && typeof candidate.insertions === "number" && typeof candidate.deletions === "number";
 }
 
-export { ChatSessionOptionsMap, ChatSessionStatus, SessionType, isAgentHostTarget, isIChatSessionFileChange2, isSessionInProgressStatus, localChatSessionType };
+export { ChatSessionOptionsMap, ChatSessionStatus, SessionType, isAgentHostTarget, isIChatSessionFileChange2, isLocalAgentHostTarget, isRemoteAgentHostTarget, isSessionInProgressStatus, localChatSessionType };

package/vscode/src/vs/workbench/contrib/chat/common/chatSessionsService.service.d.ts

@@ -117,6 +117,17 @@ export interface IChatSessionsService {
     * @returns The forked session item, or undefined if forking failed.
     */
     forkChatSession(sessionResource: URI, request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken): Promise<IChatSessionItem>;
+    /**
+    * Returns whether the loaded session supports renaming.
+    */
+    sessionSupportsRename(sessionResource: URI): boolean;
+    /**
+    * Renames a contributed chat session.
+    * @param sessionResource The session resource to rename.
+    * @param title The new title for the session.
+    * @param token Cancellation token.
+    */
+    renameChatSession(sessionResource: URI, title: string, token: CancellationToken): Promise<void>;
     readonly onDidChangeOptionGroups: Event<string>;
     getOptionGroupsForSessionType(chatSessionType: string): IChatSessionProviderOptionGroup[] | undefined;
     setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: readonly IChatSessionProviderOptionGroup[]): void;

package/vscode/src/vs/workbench/contrib/chat/common/constants.d.ts

@@ -1,11 +1,15 @@
+import { IChatSessionsService } from "./chatSessionsService.service.js";
+import { IConfigurationService } from "../../../../platform/configuration/common/configuration.service.js";
 import { ServicesAccessor } from "../../../../platform/instantiation/common/instantiation.js";
 import { RawContextKey } from "../../../../platform/contextkey/common/contextkey.js";
 export declare enum ChatConfiguration {
     AIDisabled = "chat.disableAIFeatures",
-    OfflineByok = "chat.offlineByok",
     PluginsEnabled = "chat.plugins.enabled",
     PluginLocations = "chat.pluginLocations",
     PluginMarketplaces = "chat.plugins.marketplaces",
+    ExtraMarketplaces = "chat.plugins.extraMarketplaces",
+    StrictMarketplaces = "chat.plugins.strictMarketplaces",
+    EnabledPlugins = "chat.plugins.enabledPlugins",
     AgentEnabled = "chat.agent.enabled",
     PlanAgentDefaultModel = "chat.planAgent.defaultModel",
     ExploreAgentDefaultModel = "chat.exploreAgent.defaultModel",
@@ -57,10 +61,10 @@ export declare enum ChatConfiguration {
     RevealNextChangeOnResolve = "chat.editing.revealNextChangeOnResolve",
     GrowthNotificationEnabled = "chat.growthNotification.enabled",
     TitleBarSignInEnabled = "chat.titleBar.signIn.enabled",
+    TitleBarOpenInAgentsWindowEnabled = "chat.titleBar.openInAgentsWindow.enabled",
     ChatCustomizationHarnessSelectorEnabled = "chat.customizations.harnessSelector.enabled",
     ChatCustomizationsStructuredPreviewEnabled = "chat.customizations.structuredPreview.enabled",
-    UseChatSessionCustomizationsForCustomAgents = "chat.customizations.useChatSessionCustomizationsForCustomAgents",
-    AutopilotEnabled = "chat.autopilot.enabled",
+    AutopilotAdvancedEnabled = "chat.autopilot.advanced.enabled",
     PlanReviewInlineEditorEnabled = "chat.planReview.inlineEditor.enabled",
     DefaultPermissionLevel = "chat.permissions.default",
     ImageCarouselEnabled = "imageCarousel.chat.enabled",
@@ -73,6 +77,8 @@ export declare enum ChatConfiguration {
     ToolRiskAssessmentModel = "chat.tools.riskAssessment.model",
     DefaultNewSessionMode = "chat.newSession.defaultMode",
     AgentHostClientTools = "chat.agentHost.clientTools",
+    AgentHostDefaultChatProvider = "chat.agentHost.defaultChatProvider",
+    AgentsHandoffTipMode = "chat.agentsHandoffTip.mode",
     IncrementalRendering = "chat.experimental.incrementalRendering.enabled",
     IncrementalRenderingStyle = "chat.experimental.incrementalRendering.animationStyle",
     IncrementalRenderingBuffering = "chat.experimental.incrementalRendering.buffering"
@@ -135,6 +141,14 @@ export declare namespace ChatAgentLocation {
     function fromRaw(value: RawChatParticipantLocation | string): ChatAgentLocation;
 }
 export declare function isSupportedChatFileScheme(accessor: ServicesAccessor, scheme: string): boolean;
+/**
+ * Returns the effective default session type for a new chat in the VS Code
+ * window, honoring the experimental
+ * {@link ChatConfiguration.AgentHostDefaultChatProvider} setting. Falls back to
+ * {@link localChatSessionType} when the setting is disabled or the agent host
+ * contribution is not registered.
+ */
+export declare function getDefaultNewChatSessionType(configurationService: IConfigurationService, chatSessionsService: Pick<IChatSessionsService, "getChatSessionContribution">): string;
 export declare const MANAGE_CHAT_COMMAND_ID = "workbench.action.chat.manage";
 export declare const OPEN_WORKSPACE_IN_AGENTS_WINDOW_COMMAND_ID = "workbench.action.openWorkspaceInAgentsWindow";
 export declare const OPEN_AGENTS_WINDOW_COMMAND_ID = "workbench.action.openAgentsWindow";