@codingame/monaco-vscode-api 26.2.2 → 27.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IChatDebugService = ( createDecorator("chatDebugService"));
+
+export { IChatDebugService };

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

@@ -131,6 +131,9 @@ type IChatModeSourceData = {
     type?: ExtensionAgentSourceType;
 } | {
     readonly storage: PromptsStorage.local | PromptsStorage.user;
+} | {
+    readonly storage: PromptsStorage.plugin;
+    readonly pluginUri: URI;
 };
 export declare class BuiltinChatMode implements IChatMode {
     readonly kind: ChatModeKind;
@@ -153,4 +156,9 @@ export declare namespace ChatMode {
     const Agent: BuiltinChatMode;
 }
 export declare function isBuiltinChatMode(mode: IChatMode): boolean;
+/**
+ * Returns a telemetry-safe mode name. User/local mode names are hashed
+ * to avoid leaking PII; builtin and extension mode names are returned as-is.
+ */
+export declare function getModeNameForTelemetry(mode: IChatMode): string;
 export {};

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

@@ -4,7 +4,7 @@ import { CancellationToken } 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';
-import { URI } from '../../../../base/common/uri.js';
+import { URI, isUriComponents } from '../../../../base/common/uri.js';
 import { localize } from '../../../../nls.js';
 import { IConfigurationService } from '../../../../platform/configuration/common/configuration.service.js';
 import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.service.js';
@@ -19,6 +19,7 @@ import { isTarget } from './promptSyntax/promptFileParser.js';
 import { PromptsStorage, Target, isCustomAgentVisibility, ExtensionAgentSourceType } from './promptSyntax/service/promptsService.js';
 import { IPromptsService } from './promptSyntax/service/promptsService.service.js';
 import { Codicon } from '../../../../base/common/codicons.js';
+import { hash } from '../../../../base/common/hash.js';
 import { isString } from '../../../../base/common/types.js';
 import { constObservable } from '../../../../base/common/observableInternal/observables/constObservable.js';
 import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
@@ -47,7 +48,7 @@ let ChatModeService = class ChatModeService extends Disposable {
         this.storageService = storageService;
         this.configurationService = configurationService;
         this._customModeInstances = ( new Map());
-        this._onDidChangeChatModes = ( new Emitter());
+        this._onDidChangeChatModes = this._register(( new Emitter()));
         this.onDidChangeChatModes = this._onDidChangeChatModes.event;
         this.hasCustomModes = ChatContextKeys.Modes.hasCustomChatModes.bindTo(contextKeyService);
         this.agentModeDisabledByPolicy = ChatContextKeys.Modes.agentModeDisabledByPolicy.bindTo(contextKeyService);
@@ -90,6 +91,13 @@ let ChatModeService = class ChatModeService extends Disposable {
         for (const cachedMode of cachedCustomModes) {
             if (isCachedChatModeData(cachedMode) && cachedMode.uri) {
                 try {
+                    const visibility = cachedMode.visibility ?? {
+                        userInvocable: true,
+                        agentInvocable: cachedMode.infer !== false
+                    };
+                    if (!visibility.userInvocable) {
+                        continue;
+                    }
                     const uri = URI.revive(cachedMode.uri);
                     const customChatMode = {
                         uri,
@@ -104,10 +112,7 @@ let ChatModeService = class ChatModeService extends Disposable {
                         },
                         handOffs: cachedMode.handOffs,
                         target: cachedMode.target ?? Target.Undefined,
-                        visibility: cachedMode.visibility ?? {
-                            userInvokable: true,
-                            agentInvokable: cachedMode.infer !== false
-                        },
+                        visibility,
                         agents: cachedMode.agents,
                         source: reviveChatModeSource(cachedMode.source) ?? {
                             storage: PromptsStorage.local
@@ -140,7 +145,7 @@ let ChatModeService = class ChatModeService extends Disposable {
             const customModes = await this.promptsService.getCustomAgents(CancellationToken.None);
             const seenUris = ( new Set());
             for (const customMode of customModes) {
-                if (!customMode.visibility.userInvokable) {
+                if (!customMode.visibility.userInvocable) {
                     continue;
                 }
                 const uriString = ( customMode.uri.toString());
@@ -311,6 +316,9 @@ function isChatModeSourceData(value) {
     if (data.storage === PromptsStorage.extension) {
         return typeof data.extensionId === "string";
     }
+    if (data.storage === PromptsStorage.plugin) {
+        return isUriComponents(data.pluginUri);
+    }
     return data.storage === PromptsStorage.local || data.storage === PromptsStorage.user;
 }
 function serializeChatModeSource(source) {
@@ -324,6 +332,12 @@ function serializeChatModeSource(source) {
             type: source.type
         };
     }
+    if (source.storage === PromptsStorage.plugin) {
+        return {
+            storage: PromptsStorage.plugin,
+            pluginUri: source.pluginUri
+        };
+    }
     return {
         storage: source.storage
     };
@@ -339,6 +353,12 @@ function reviveChatModeSource(data) {
             type: data.type ?? ExtensionAgentSourceType.contribution
         };
     }
+    if (data.storage === PromptsStorage.plugin) {
+        return {
+            storage: PromptsStorage.plugin,
+            pluginUri: URI.revive(data.pluginUri)
+        };
+    }
     return {
         storage: data.storage
     };
@@ -369,12 +389,19 @@ class BuiltinChatMode {
 }
 var ChatMode;
 (function(ChatMode) {
-    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(6314, "Explore and understand your code")), Codicon.question));
-    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(6315, "Edit or refactor selected code")), Codicon.edit));
-    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(6316, "Describe what to build next")), Codicon.agent));
+    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(6865, "Explore and understand your code")), Codicon.question));
+    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(6866, "Edit or refactor selected code")), Codicon.edit));
+    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(6867, "Describe what to build next")), Codicon.agent));
 })(ChatMode || (ChatMode = {}));
 function isBuiltinChatMode(mode) {
     return mode.id === ChatMode.Ask.id || mode.id === ChatMode.Edit.id || mode.id === ChatMode.Agent.id;
 }
+function getModeNameForTelemetry(mode) {
+    const modeStorage = mode.source?.storage;
+    if (modeStorage === PromptsStorage.local || modeStorage === PromptsStorage.user) {
+        return String(hash(mode.name.get()));
+    }
+    return mode.name.get();
+}
 
-export { BuiltinChatMode, ChatMode, ChatModeService, CustomChatMode, isBuiltinChatMode };
+export { BuiltinChatMode, ChatMode, ChatModeService, CustomChatMode, getModeNameForTelemetry, isBuiltinChatMode };

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

@@ -105,6 +105,17 @@ export interface IChatCodeCitation {
     snippet: string;
     kind: "codeCitation";
 }
+export interface IChatUsagePromptTokenDetail {
+    category: string;
+    label: string;
+    percentageOfPrompt: number;
+}
+export interface IChatUsage {
+    promptTokens: number;
+    completionTokens: number;
+    promptTokenDetails?: readonly IChatUsagePromptTokenDetail[];
+    kind: "usage";
+}
 export interface IChatContentInlineReference {
     resolveId?: string;
     inlineReference: URI | Location | IWorkspaceSymbol;
@@ -159,6 +170,7 @@ export declare class ChatMultiDiffData implements IChatMultiDiffData {
 export interface IChatProgressMessage {
     content: IMarkdownString;
     kind: "progressMessage";
+    shimmer?: boolean;
 }
 export interface IChatTask extends IChatTaskDto {
     deferred: DeferredPromise<string | void>;
@@ -459,12 +471,13 @@ export type ConfirmedReason = {
     scope: "session" | "workspace" | "profile";
 } | {
     type: ToolConfirmKind.UserAction;
+    selectedButton?: string;
 } | {
     type: ToolConfirmKind.Skipped;
 };
 export interface IChatToolInvocation {
     readonly presentation: IPreparedToolInvocation["presentation"];
-    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData;
+    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData;
     readonly originMessage: string | IMarkdownString | undefined;
     readonly invocationMessage: string | IMarkdownString;
     readonly pastTenseMessage: string | IMarkdownString | undefined;
@@ -565,7 +578,7 @@ export interface IToolResultOutputDetailsSerialized {
  */
 export interface IChatToolInvocationSerialized {
     presentation: IPreparedToolInvocation["presentation"];
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData;
     invocationMessage: string | IMarkdownString;
     originMessage: string | IMarkdownString | undefined;
     pastTenseMessage: string | IMarkdownString | undefined;
@@ -585,7 +598,11 @@ export interface IChatExtensionsContent {
     kind: "extensions";
 }
 export interface IChatPullRequestContent {
-    uri: URI;
+    /**
+     * @deprecated use `command` instead
+     */
+    uri?: URI;
+    command: Command;
     title: string;
     description: string;
     author: string;
@@ -600,6 +617,22 @@ export interface IChatSubagentToolInvocationData {
     result?: string;
     modelName?: string;
 }
+/**
+ * Progress type for external tool invocation updates from extensions.
+ * When isComplete is false, creates or updates a tool invocation.
+ * When isComplete is true, completes an existing tool invocation.
+ */
+export interface IChatExternalToolInvocationUpdate {
+    kind: "externalToolInvocationUpdate";
+    toolCallId: string;
+    toolName: string;
+    isComplete: boolean;
+    errorMessage?: string;
+    invocationMessage?: string | IMarkdownString;
+    pastTenseMessage?: string | IMarkdownString;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData;
+    subagentInvocationId?: string;
+}
 export interface IChatTodoListContent {
     kind: "todoList";
     todoList: Array<{
@@ -608,6 +641,15 @@ export interface IChatTodoListContent {
         status: "not-started" | "in-progress" | "completed";
     }>;
 }
+export interface IChatSimpleToolInvocationData {
+    kind: "simpleToolInvocation";
+    input: string;
+    output: string;
+}
+export interface IChatToolResourcesInvocationData {
+    readonly kind: "resources";
+    readonly values: Array<URI | Location>;
+}
 export interface IChatMcpServersStarting {
     readonly kind: "mcpServersStarting";
     readonly state?: IObservable<IAutostartResult>;
@@ -631,7 +673,7 @@ export declare class ChatMcpServersStarting implements IChatMcpServersStarting {
     wait(): Promise<IAutostartResult>;
     toJSON(): IChatMcpServersStartingSerialized;
 }
-export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatHookPart | IChatDisabledClaudeHooksPart;
+export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart;
 export interface IChatFollowup {
     kind: "reply";
     message: string;
@@ -879,6 +921,7 @@ export interface IChatSendRequestOptions {
     acceptedConfirmationData?: any[];
     rejectedConfirmationData?: any[];
     attachedContext?: IChatRequestVariableEntry[];
+    resolvedVariables?: IChatRequestVariableEntry[];
     /** The target agent ID can be specified with this property instead of using @ in 'message' */
     agentId?: string;
     /** agentId, but will not add a @ name to the request */
@@ -893,16 +936,91 @@ export interface IChatSendRequestOptions {
      * If Steering, also sets yieldRequested on any active request to signal it should wrap up.
      */
     queue?: ChatRequestQueueKind;
+    /**
+     * When true, the queued request will not be processed immediately even if no request is active.
+     * The request stays in the queue until `processPendingRequests` is called explicitly.
+     */
+    pauseQueue?: boolean;
 }
 export type IChatModelReference = IReference<IChatModel>;
 export interface IChatSessionContext {
     readonly chatSessionType: string;
     readonly chatSessionResource: URI;
     readonly isUntitled: boolean;
+    readonly initialSessionOptions?: ReadonlyArray<{
+        optionId: string;
+        value: string | {
+            id: string;
+            name: string;
+        };
+    }>;
 }
 export declare const KEYWORD_ACTIVIATION_SETTING_ID = "accessibility.voice.keywordActivation";
 export interface IChatSessionStartOptions {
     canUseTools?: boolean;
     disableBackgroundKeepAlive?: boolean;
 }
+export declare const ChatStopCancellationNoopEventName = "chat.stopCancellationNoop";
+export type ChatStopCancellationNoopEvent = {
+    source: string;
+    reason: "noWidget" | "noViewModel" | "noPendingRequest" | "requestAlreadyCanceled" | "requestIdUnavailable";
+    requestInProgress: "true" | "false" | "unknown";
+    pendingRequests: number;
+    sessionScheme?: string;
+    lastRequestId?: string;
+};
+export type ChatStopCancellationNoopClassification = {
+    source: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The layer where stop cancellation no-op occurred.";
+    };
+    reason: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The no-op reason when stop cancellation did not dispatch fully.";
+    };
+    requestInProgress: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether request-in-progress was true, false, or unknown at no-op time.";
+    };
+    pendingRequests: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The number of queued pending requests at no-op time when known.";
+        isMeasurement: true;
+    };
+    sessionScheme?: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The URI scheme of the session resource (e.g. vscodeLocalChatSession vs remote).";
+    };
+    lastRequestId?: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The ID of the last request in the session, for correlating with tool invocations.";
+    };
+    owner: "roblourens";
+    comment: "Tracks possible no-op stop cancellation paths.";
+};
+export declare const ChatPendingRequestChangeEventName = "chat.pendingRequestChange";
+export type ChatPendingRequestChangeEvent = {
+    action: "add" | "remove" | "notCancelable";
+    source: string;
+};
+export type ChatPendingRequestChangeClassification = {
+    action: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "Whether a pending request was added or removed.";
+    };
+    source: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The method that triggered the pending request change.";
+    };
+    owner: "roblourens";
+    comment: "Tracks pending request lifecycle changes in the chat service.";
+};
 export {};

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

@@ -44,7 +44,7 @@ var ElicitationState;
     ElicitationState["Rejected"] = "rejected";
 })(ElicitationState || (ElicitationState = {}));
 function isLegacyChatTerminalToolInvocationData(data) {
-    return !!data && typeof data === "object" && "command" in data;
+    return !!data && typeof data === "object" && "command" in data && "language" in data;
 }
 var ToolConfirmKind;
 (function(ToolConfirmKind) {
@@ -313,5 +313,7 @@ var ChatRequestQueueKind;
     ChatRequestQueueKind["Queued"] = "queued";
     ChatRequestQueueKind["Steering"] = "steering";
 })(ChatRequestQueueKind || (ChatRequestQueueKind = {}));
+const ChatStopCancellationNoopEventName = "chat.stopCancellationNoop";
+const ChatPendingRequestChangeEventName = "chat.pendingRequestChange";
 
-export { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, isChatContentVariableReference, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };
+export { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatPendingRequestChangeEventName, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ChatStopCancellationNoopEventName, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, isChatContentVariableReference, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };

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

@@ -13,43 +13,58 @@ export interface IChatService {
     transferredSessionResource: URI | undefined;
     readonly onDidSubmitRequest: Event<{
         readonly chatSessionResource: URI;
+        readonly message?: IParsedChatRequest;
     }>;
     readonly onDidCreateModel: Event<IChatModel>;
     /**
     * An observable containing all live chat models.
     */
     readonly chatModels: IObservable<Iterable<IChatModel>>;
+    readonly editingSessions: readonly IChatEditingSession[];
     isEnabled(location: ChatAgentLocation): boolean;
     hasSessions(): boolean;
-    startSession(location: ChatAgentLocation, options?: IChatSessionStartOptions): IChatModelReference;
+    /**
+    * Starts a new chat session at the given location.
+    *
+    * @returns A reference to the session's model.
+    */
+    startNewLocalSession(location: ChatAgentLocation, options?: IChatSessionStartOptions): IChatModelReference;
     /**
     * Get an active session without holding a reference to it.
+    *
+    * @returns The session's model, or undefined if no active session exists.
     */
     getSession(sessionResource: URI): IChatModel | undefined;
     /**
     * Acquire a reference to an active session.
+    *
+    * @returns A reference to the session's model or undefined if there is no active session for the given resource.
     */
-    getActiveSessionReference(sessionResource: URI): IChatModelReference | undefined;
-    getOrRestoreSession(sessionResource: URI): Promise<IChatModelReference | undefined>;
-    getSessionTitle(sessionResource: URI): string | undefined;
-    loadSessionFromContent(data: IExportableChatData | ISerializableChatData | URI): IChatModelReference | undefined;
-    loadSessionForResource(resource: URI, location: ChatAgentLocation, token: CancellationToken): Promise<IChatModelReference | undefined>;
-    readonly editingSessions: IChatEditingSession[];
+    acquireExistingSession(sessionResource: URI): IChatModelReference | undefined;
+    /**
+    * Tries to acquire an existing a chat session for the resource. If no session exists, tries to load one for the given
+    * session resource and location. This may load the session from an external provider.
+    *
+    * @returns A reference to the session's model, or undefined if the session could not be loaded
+    */
+    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken): Promise<IChatModelReference | undefined>;
+    /**
+    * Loads a session from exported chat data
+    */
+    loadSessionFromData(data: IExportableChatData | ISerializableChatData): IChatModelReference;
     getChatSessionFromInternalUri(sessionResource: URI): IChatSessionContext | undefined;
     /**
     * Sends a chat request for the given session.
     * @returns A result indicating whether the request was sent, queued, or rejected.
     */
     sendRequest(sessionResource: URI, message: string, options?: IChatSendRequestOptions): Promise<ChatSendResult>;
-    /**
-    * Sets a custom title for a chat model.
-    */
-    setTitle(sessionResource: URI, title: string): void;
+    getSessionTitle(sessionResource: URI): string | undefined;
+    setSessionTitle(sessionResource: URI, title: string): void;
     appendProgress(request: IChatRequestModel, progress: IChatProgress): void;
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     adoptRequest(sessionResource: URI, request: IChatRequestModel): Promise<void>;
     removeRequest(sessionResource: URI, requestId: string): Promise<void>;
-    cancelCurrentRequestForSession(sessionResource: URI): void;
+    cancelCurrentRequestForSession(sessionResource: URI, source?: string): void;
     /**
     * Sets yieldRequested on the active request for the given session.
     */

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

@@ -75,6 +75,7 @@ export interface IChatSessionsExtensionPoint {
     readonly capabilities?: IChatAgentAttachmentCapabilities;
     readonly commands?: IChatSessionCommandContribution[];
     readonly canDelegate?: boolean;
+    readonly isReadOnly?: boolean;
     /**
      * When set, the chat session will show a filtered mode picker with custom agents
      * that have a matching `target` property. This enables contributed chat sessions
@@ -82,6 +83,7 @@ export interface IChatSessionsExtensionPoint {
      * Custom agents without a `target` property are also shown in all filtered lists
      */
     readonly customAgentTarget?: Target;
+    readonly requiresCustomModels?: boolean;
 }
 export interface IChatSessionItem {
     resource: URI;
@@ -122,6 +124,7 @@ export type IChatSessionHistoryItem = {
     participant: string;
     command?: string;
     variableData?: IChatRequestVariableData;
+    modelId?: string;
 } | {
     type: "response";
     parts: IChatProgress[];
@@ -138,6 +141,7 @@ export declare const agentOptionId = "agent";
 export interface IChatSession extends IDisposable {
     readonly onWillDispose: Event<void>;
     readonly sessionResource: URI;
+    readonly title?: string;
     readonly history: readonly IChatSessionHistoryItem[];
     /**
      * Session options as key-value pairs. Keys correspond to option group IDs (e.g., 'models', 'subagents')
@@ -157,14 +161,15 @@ export interface IChatSession extends IDisposable {
     requestHandler?: (request: IChatAgentRequest, progress: (progress: IChatProgress[]) => void, history: any[], // TODO: Nail down types
     token: CancellationToken) => Promise<void>;
 }
-export interface IChatSessionItemProvider {
-    readonly chatSessionType: string;
-    readonly onDidChangeChatSessionItems: Event<void>;
-    provideChatSessionItems(token: CancellationToken): Promise<IChatSessionItem[]>;
-}
 export interface IChatSessionContentProvider {
     provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
 }
+export interface IChatSessionItemController {
+    readonly onDidChangeChatSessionItems: Event<void>;
+    get items(): readonly IChatSessionItem[];
+    refresh(token: CancellationToken): Promise<void>;
+    newChatSessionItem?(request: IChatAgentRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+}
 /**
  * Event fired when session options need to be sent to the extension.
  * Extends IWaitUntil to allow listeners to register async work that will be awaited.

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

@@ -4,39 +4,46 @@ import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { ThemeIcon } from "../../../../base/common/themables.js";
 import { URI } from "../../../../base/common/uri.js";
 import { IChatService } from "./chatService/chatService.service.js";
-import { IChatSessionItemProvider, IChatSessionsExtensionPoint, IChatSessionItem, IChatSessionContentProvider, IChatSession, IChatSessionProviderOptionItem, IChatSessionProviderOptionGroup, IChatSessionOptionsWillNotifyExtensionEvent } from "./chatSessionsService.js";
+import { IChatSessionsExtensionPoint, IChatSessionItemController, IChatSessionItem, IChatSessionContentProvider, IChatSession, IChatSessionProviderOptionItem, IChatSessionProviderOptionGroup, IChatSessionOptionsWillNotifyExtensionEvent } from "./chatSessionsService.js";
 import { IChatModel } from "./model/chatModel.js";
-import { IChatAgentAttachmentCapabilities } from "./participants/chatAgents.js";
+import { IChatAgentAttachmentCapabilities, IChatAgentRequest } from "./participants/chatAgents.js";
 import { Target } from "./promptSyntax/service/promptsService.js";
 export declare const IChatSessionsService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatSessionsService>;
 export interface IChatSessionsService {
     readonly _serviceBrand: undefined;
-    readonly onDidChangeItemsProviders: Event<IChatSessionItemProvider>;
-    readonly onDidChangeSessionItems: Event<string>;
+    readonly onDidChangeItemsProviders: Event<{
+        readonly chatSessionType: string;
+    }>;
+    readonly onDidChangeSessionItems: Event<{
+        readonly chatSessionType: string;
+    }>;
     readonly onDidChangeAvailability: Event<void>;
     readonly onDidChangeInProgress: Event<void>;
     getChatSessionContribution(chatSessionType: string): IChatSessionsExtensionPoint | undefined;
-    registerChatSessionItemProvider(provider: IChatSessionItemProvider): IDisposable;
-    activateChatSessionItemProvider(chatSessionType: string): Promise<IChatSessionItemProvider | undefined>;
+    registerChatSessionItemController(chatSessionType: string, controller: IChatSessionItemController): IDisposable;
+    activateChatSessionItemProvider(chatSessionType: string): Promise<void>;
     getAllChatSessionContributions(): IChatSessionsExtensionPoint[];
     getIconForSessionType(chatSessionType: string): ThemeIcon | URI | undefined;
     getWelcomeTitleForSessionType(chatSessionType: string): string | undefined;
     getWelcomeMessageForSessionType(chatSessionType: string): string | undefined;
     getInputPlaceholderForSessionType(chatSessionType: string): string | undefined;
     /**
-    * Get the list of chat session items grouped by session type.
+    * Get the list of current chat session items grouped by session type.
     * @param providerTypeFilter If specified, only returns items from the given providers. If undefined, returns items from all providers.
     */
     getChatSessionItems(providerTypeFilter: readonly string[] | undefined, token: CancellationToken): Promise<Array<{
         readonly chatSessionType: string;
-        readonly items: IChatSessionItem[];
+        readonly items: readonly IChatSessionItem[];
     }>>;
+    /**
+    * Forces the controllers to refresh their session items, optionally filtered by provider type.
+    */
+    refreshChatSessionItems(providerTypeFilter: readonly string[] | undefined, token: CancellationToken): Promise<void>;
     reportInProgress(chatSessionType: string, count: number): void;
     getInProgress(): {
         displayName: string;
         count: number;
     }[];
-    notifySessionItemsChanged(chatSessionType: string): void;
     readonly onDidChangeContentProviderSchemes: Event<{
         readonly added: string[];
         readonly removed: string[];
@@ -51,7 +58,7 @@ export interface IChatSessionsService {
     /**
     * Fired when options for a chat session change.
     */
-    onDidChangeSessionOptions: Event<URI>;
+    readonly onDidChangeSessionOptions: Event<URI>;
     /**
     * Get the capabilities for a specific session type
     */
@@ -61,9 +68,15 @@ export interface IChatSessionsService {
     * When the Target is not `Target.Undefined`, the mode picker should show filtered custom agents matching this target.
     */
     getCustomAgentTargetForSessionType(chatSessionType: string): Target;
-    onDidChangeOptionGroups: Event<string>;
+    /**
+    * Returns whether the session type requires custom models. When true, the model picker should show filtered custom models.
+    */
+    requiresCustomModelsForSessionType(chatSessionType: string): boolean;
+    readonly onDidChangeOptionGroups: Event<string>;
     getOptionGroupsForSessionType(chatSessionType: string): IChatSessionProviderOptionGroup[] | undefined;
     setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: IChatSessionProviderOptionGroup[]): void;
+    getNewSessionOptionsForSessionType(chatSessionType: string): Record<string, string | IChatSessionProviderOptionItem> | undefined;
+    setNewSessionOptionsForSessionType(chatSessionType: string, options: Record<string, string | IChatSessionProviderOptionItem>): void;
     /**
     * Event fired when session options change and need to be sent to the extension.
     * MainThreadChatSessions subscribes to this to forward changes to the extension host.
@@ -76,4 +89,14 @@ export interface IChatSessionsService {
     }>): Promise<void>;
     registerChatModelChangeListeners(chatService: IChatService, chatSessionType: string, onChange: () => void): IDisposable;
     getInProgressSessionDescription(chatModel: IChatModel): string | undefined;
+    /**
+    * Creates a new chat session item using the controller's newChatSessionItemHandler.
+    * Returns undefined if the controller doesn't have a handler or if no controller is registered.
+    */
+    createNewChatSessionItem(chatSessionType: string, request: IChatAgentRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    /**
+    * Registers an alias so that session-option lookups by the real resource
+    * are redirected to the canonical (untitled) resource in the internal session map.
+    */
+    registerSessionResourceAlias(untitledResource: URI, realResource: URI): void;
 }