@codingame/monaco-vscode-api 28.4.1 → 29.1.0

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

@@ -22,6 +22,7 @@ import { IChatRequestVariableEntry } from "../attachments/chatVariableEntries.js
 import { IChatRequestVariableValue } from "../attachments/chatVariables.js";
 import { ChatAgentLocation } from "../constants.js";
 import { IPreparedToolInvocation, IToolConfirmationMessages, IToolResult, IToolResultInputOutputDetails, ToolDataSource } from "../tools/languageModelToolsService.js";
+import { ReadonlyChatSessionOptionsMap } from "../chatSessionsService.js";
 export interface IChatRequest {
     message: string;
     variables: Record<string, IChatRequestVariableValue[]>;
@@ -113,6 +114,7 @@ export interface IChatUsagePromptTokenDetail {
 export interface IChatUsage {
     promptTokens: number;
     completionTokens: number;
+    outputBuffer?: number;
     promptTokenDetails?: readonly IChatUsagePromptTokenDetail[];
     kind: "usage";
 }
@@ -269,6 +271,17 @@ export interface IChatConfirmation {
     isUsed?: boolean;
     kind: "confirmation";
 }
+/**
+ * Validation rules for a question in a question carousel.
+ */
+export interface IChatQuestionValidation {
+    minLength?: number;
+    maxLength?: number;
+    format?: "email" | "uri" | "date" | "date-time";
+    minimum?: number;
+    maximum?: number;
+    isInteger?: boolean;
+}
 /**
  * Represents an individual question in a question carousel.
  */
@@ -277,14 +290,31 @@ export interface IChatQuestion {
     type: "text" | "singleSelect" | "multiSelect";
     title: string;
     message?: string | IMarkdownString;
+    description?: string;
     options?: {
         id: string;
         label: string;
-        value: unknown;
+        value: string;
     }[];
     defaultValue?: string | string[];
     allowFreeformInput?: boolean;
-}
+    required?: boolean;
+    validation?: IChatQuestionValidation;
+}
+/** Answer shape for a single-select question. */
+export interface IChatSingleSelectAnswer {
+    selectedValue?: string;
+    freeformValue?: string;
+}
+/** Answer shape for a multi-select question. */
+export interface IChatMultiSelectAnswer {
+    selectedValues: string[];
+    freeformValue?: string;
+}
+/** Union of all possible answer values in a question carousel. */
+export type IChatQuestionAnswerValue = string | IChatSingleSelectAnswer | IChatMultiSelectAnswer;
+/** Record mapping question IDs to their typed answer values. */
+export type IChatQuestionAnswers = Record<string, IChatQuestionAnswerValue>;
 /**
  * A carousel for presenting multiple questions inline in the chat response.
  * Users can navigate between questions and submit their answers.
@@ -295,9 +325,13 @@ export interface IChatQuestionCarousel {
     /** Unique identifier for resolving the carousel answers back to the extension */
     resolveId?: string;
     /** Storage for collected answers when user submits */
-    data?: Record<string, unknown>;
+    data?: IChatQuestionAnswers;
     /** Whether the carousel has been submitted/skipped */
     isUsed?: boolean;
+    /** Top-level message shown above the questions (e.g. from MCP elicitation message) */
+    message?: string | IMarkdownString;
+    /** Source attribution (e.g. MCP server) */
+    source?: ToolDataSource;
     kind: "questionCarousel";
 }
 export declare enum ElicitationState {
@@ -369,6 +403,7 @@ export interface IChatTerminalToolInvocationData {
         userEdited?: string;
         toolEdited?: string;
         forDisplay?: string;
+        isSandboxWrapped?: boolean;
     };
     /** The working directory URI for the terminal */
     cwd?: UriComponents;
@@ -404,6 +439,10 @@ export interface IChatTerminalToolInvocationData {
     terminalCommandId?: string;
     /** Whether the terminal command was started as a background execution */
     isBackground?: boolean;
+    /** Whether the command was explicitly approved to run outside the sandbox */
+    requestUnsandboxedExecution?: boolean;
+    /** The model-provided reason for requesting sandbox bypass */
+    requestUnsandboxedExecutionReason?: string;
     /** Serialized URI for the command that was executed in the terminal */
     terminalCommandUri?: UriComponents;
     /** Serialized output of the executed command */
@@ -477,7 +516,7 @@ export type ConfirmedReason = {
 };
 export interface IChatToolInvocation {
     readonly presentation: IPreparedToolInvocation["presentation"];
-    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData;
+    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
     readonly originMessage: string | IMarkdownString | undefined;
     readonly invocationMessage: string | IMarkdownString;
     readonly pastTenseMessage: string | IMarkdownString | undefined;
@@ -485,8 +524,10 @@ export interface IChatToolInvocation {
     readonly toolId: string;
     readonly toolCallId: string;
     readonly subAgentInvocationId?: string;
+    readonly icon?: ThemeIcon;
     readonly state: IObservable<IChatToolInvocation.State>;
     generatedTitle?: string;
+    isAttachedToThinking: boolean;
     kind: "toolInvocation";
     toJSON(): IChatToolInvocationSerialized;
 }
@@ -578,7 +619,7 @@ export interface IToolResultOutputDetailsSerialized {
  */
 export interface IChatToolInvocationSerialized {
     presentation: IPreparedToolInvocation["presentation"];
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData;
     invocationMessage: string | IMarkdownString;
     originMessage: string | IMarkdownString | undefined;
     pastTenseMessage: string | IMarkdownString | undefined;
@@ -588,9 +629,11 @@ export interface IChatToolInvocationSerialized {
     isComplete: boolean;
     toolCallId: string;
     toolId: string;
+    readonly icon?: undefined;
     source: ToolDataSource | undefined;
     readonly subAgentInvocationId?: string;
     generatedTitle?: string;
+    isAttachedToThinking?: boolean;
     kind: "toolInvocationSerialized";
 }
 export interface IChatExtensionsContent {
@@ -630,8 +673,9 @@ export interface IChatExternalToolInvocationUpdate {
     errorMessage?: string;
     invocationMessage?: string | IMarkdownString;
     pastTenseMessage?: string | IMarkdownString;
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatModifiedFilesConfirmationData;
     subagentInvocationId?: string;
+    resultDetails?: IToolResultInputOutputDetails;
 }
 export interface IChatTodoListContent {
     kind: "todoList";
@@ -650,6 +694,18 @@ export interface IChatToolResourcesInvocationData {
     readonly kind: "resources";
     readonly values: Array<URI | Location>;
 }
+export interface IChatModifiedFilesConfirmationData {
+    readonly kind: "modifiedFilesConfirmation";
+    readonly options: readonly string[];
+    readonly modifiedFiles: readonly {
+        readonly uri: UriComponents;
+        readonly originalUri?: UriComponents;
+        readonly insertions?: number;
+        readonly deletions?: number;
+        readonly title?: string;
+        readonly description?: string;
+    }[];
+}
 export interface IChatMcpServersStarting {
     readonly kind: "mcpServersStarting";
     readonly state?: IObservable<IAutostartResult>;
@@ -804,31 +860,31 @@ export interface IChatCompleteResponse {
     followups?: IChatFollowup[];
 }
 export interface IChatSessionStats {
-    fileCount: number;
-    added: number;
-    removed: number;
+    readonly fileCount: number;
+    readonly added: number;
+    readonly removed: number;
 }
 export type IChatSessionTiming = {
     /**
      * Timestamp when the session was created in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
      */
-    created: number;
+    readonly created: number;
     /**
      * Timestamp when the most recent request started in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
      *
      * Should be undefined if no requests have been made yet.
      */
-    lastRequestStarted: number | undefined;
+    readonly lastRequestStarted: number | undefined;
     /**
      * Timestamp when the most recent request completed in milliseconds elapsed since January 1, 1970 00:00:00 UTC.
      *
      * Should be undefined if the most recent request is still in progress or if no requests have been made yet.
      */
-    lastRequestEnded: number | undefined;
+    readonly lastRequestEnded: number | undefined;
 };
 interface ILegacyChatSessionTiming {
-    startTime: number;
-    endTime?: number;
+    readonly startTime: number;
+    readonly endTime?: number;
 }
 export declare function convertLegacyChatSessionTiming(timing: IChatSessionTiming | ILegacyChatSessionTiming): IChatSessionTiming;
 export declare enum ResponseModelState {
@@ -869,6 +925,8 @@ export interface ChatSendResultRejected {
 export interface ChatSendResultSent {
     readonly kind: "sent";
     readonly data: IChatSendRequestData;
+    /** Set when the session was replaced by a new one (e.g. untitled -> real contributed session). */
+    readonly newSessionResource?: URI;
 }
 export interface ChatSendResultQueued {
     readonly kind: "queued";
@@ -944,16 +1002,8 @@ export interface IChatSendRequestOptions {
 }
 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;
-        };
-    }>;
+    readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;
 }
 export declare const KEYWORD_ACTIVIATION_SETTING_ID = "accessibility.voice.keywordActivation";
 export interface IChatSessionStartOptions {
@@ -968,6 +1018,7 @@ export type ChatStopCancellationNoopEvent = {
     pendingRequests: number;
     sessionScheme?: string;
     lastRequestId?: string;
+    chatSessionId?: string;
 };
 export type ChatStopCancellationNoopClassification = {
     source: {
@@ -1001,6 +1052,11 @@ export type ChatStopCancellationNoopClassification = {
         purpose: "FeatureInsight";
         comment: "The ID of the last request in the session, for correlating with tool invocations.";
     };
+    chatSessionId?: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The chat session ID.";
+    };
     owner: "roblourens";
     comment: "Tracks possible no-op stop cancellation paths.";
 };
@@ -1008,6 +1064,8 @@ export declare const ChatPendingRequestChangeEventName = "chat.pendingRequestCha
 export type ChatPendingRequestChangeEvent = {
     action: "add" | "remove" | "notCancelable";
     source: string;
+    requestId?: string;
+    chatSessionId?: string;
 };
 export type ChatPendingRequestChangeClassification = {
     action: {
@@ -1020,6 +1078,16 @@ export type ChatPendingRequestChangeClassification = {
         purpose: "FeatureInsight";
         comment: "The method that triggered the pending request change.";
     };
+    requestId?: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The request ID associated with the pending request change.";
+    };
+    chatSessionId?: {
+        classification: "SystemMetaData";
+        purpose: "FeatureInsight";
+        comment: "The chat session ID.";
+    };
     owner: "roblourens";
     comment: "Tracks pending request lifecycle changes in the chat service.";
 };

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

@@ -1,12 +1,13 @@
 import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { Event } from "../../../../../base/common/event.js";
+import { IDisposable } from "../../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../../base/common/observable.js";
 import { URI } from "../../../../../base/common/uri.js";
 import { ChatAgentLocation } from "../constants.js";
 import { IChatEditingSession } from "../editing/chatEditingService.js";
 import { IChatModel, IExportableChatData, ISerializableChatData, IChatRequestModel, IChatRequestVariableData } from "../model/chatModel.js";
 import { IParsedChatRequest } from "../requestParser/chatParserTypes.js";
-import { IChatSessionStartOptions, IChatModelReference, IChatSessionContext, IChatSendRequestOptions, ChatSendResult, IChatProgress, ChatRequestQueueKind, IChatCompleteResponse, IChatDetail, IChatUserActionEvent } from "./chatService.js";
+import { IChatSessionStartOptions, IChatModelReference, IChatSessionContext, IChatSendRequestOptions, ChatSendResult, IChatProgress, ChatRequestQueueKind, IChatCompleteResponse, IChatDetail, IChatUserActionEvent, IChatQuestionAnswers } from "./chatService.js";
 export declare const IChatService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatService>;
 export interface IChatService {
     _serviceBrand: undefined;
@@ -64,7 +65,13 @@ export interface IChatService {
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     adoptRequest(sessionResource: URI, request: IChatRequestModel): Promise<void>;
     removeRequest(sessionResource: URI, requestId: string): Promise<void>;
-    cancelCurrentRequestForSession(sessionResource: URI, source?: string): void;
+    cancelCurrentRequestForSession(sessionResource: URI, source?: string): Promise<void>;
+    /**
+    * Migrates all in-flight and queued pending requests from one session to another.
+    * Cancels the in-flight request on the original session, removes queued requests,
+    * and re-sends them all on the target session preserving their original send options.
+    */
+    migrateRequests(originalResource: URI, targetResource: URI): void;
     /**
     * Sets yieldRequested on the active request for the given session.
     */
@@ -103,17 +110,21 @@ export interface IChatService {
     readonly onDidReceiveQuestionCarouselAnswer: Event<{
         requestId: string;
         resolveId: string;
-        answers: Record<string, unknown> | undefined;
+        answers: IChatQuestionAnswers | undefined;
     }>;
-    notifyQuestionCarouselAnswer(requestId: string, resolveId: string, answers: Record<string, unknown> | undefined): void;
+    notifyQuestionCarouselAnswer(requestId: string, resolveId: string, answers: IChatQuestionAnswers | undefined): void;
     readonly onDidDisposeSession: Event<{
-        readonly sessionResource: URI[];
+        readonly sessionResource: readonly URI[];
         readonly reason: "cleared";
     }>;
     transferChatSession(transferredSessionResource: URI, toWorkspace: URI): Promise<void>;
     activateDefaultAgent(location: ChatAgentLocation): Promise<void>;
     readonly requestInProgressObs: IObservable<boolean>;
     /**
+    * @deprecated
+    */
+    registerChatModelChangeListeners(chatSessionType: string, onChange: (chatSessionResource: URI) => void): IDisposable;
+    /**
     * For tests only!
     */
     setSaveModelsEnabled(enabled: boolean): void;

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

@@ -1,5 +1,5 @@
 import { CancellationToken } from "../../../../base/common/cancellation.js";
-import { Event, IWaitUntil } from "../../../../base/common/event.js";
+import { Event } from "../../../../base/common/event.js";
 import { IMarkdownString } from "../../../../base/common/htmlContent.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { IObservable } from "../../../../base/common/observable.js";
@@ -17,44 +17,44 @@ export declare enum ChatSessionStatus {
     NeedsInput = 3
 }
 export interface IChatSessionCommandContribution {
-    name: string;
-    description: string;
-    when?: string;
+    readonly name: string;
+    readonly description: string;
+    readonly when?: string;
 }
 export interface IChatSessionProviderOptionItem {
-    id: string;
-    name: string;
-    description?: string;
-    locked?: boolean;
-    icon?: ThemeIcon;
-    default?: boolean;
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly locked?: boolean;
+    readonly icon?: ThemeIcon;
+    readonly default?: boolean;
 }
 export interface IChatSessionProviderOptionGroupCommand {
-    command: string;
-    title: string;
-    tooltip?: string;
-    arguments?: unknown[];
+    readonly command: string;
+    readonly title: string;
+    readonly tooltip?: string;
+    readonly arguments?: readonly unknown[];
 }
 export interface IChatSessionProviderOptionGroup {
-    id: string;
-    name: string;
-    description?: string;
-    items: IChatSessionProviderOptionItem[];
-    searchable?: boolean;
-    onSearch?: (query: string, token: CancellationToken) => Thenable<IChatSessionProviderOptionItem[]>;
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string;
+    readonly items: readonly IChatSessionProviderOptionItem[];
+    readonly searchable?: boolean;
+    readonly onSearch?: (query: string, token: CancellationToken) => Thenable<IChatSessionProviderOptionItem[]>;
     /**
      * A context key expression that controls visibility of this option group picker.
      * When specified, the picker is only visible when the expression evaluates to true.
      * The expression can reference other option group values via `chatSessionOption.<groupId>`.
      * Example: `"chatSessionOption.models == 'gpt-4'"`
      */
-    when?: string;
-    icon?: ThemeIcon;
+    readonly when?: string;
+    readonly icon?: ThemeIcon;
     /**
      * Custom commands to show in the option group's picker UI.
      * These will be shown in a separate section at the end of the picker.
      */
-    commands?: IChatSessionProviderOptionGroupCommand[];
+    readonly commands?: readonly IChatSessionProviderOptionGroupCommand[];
 }
 export interface IChatSessionsExtensionPoint {
     readonly type: string;
@@ -84,31 +84,41 @@ export interface IChatSessionsExtensionPoint {
      */
     readonly customAgentTarget?: Target;
     readonly requiresCustomModels?: boolean;
+    /**
+     * When false, the delegation picker is hidden for this session type.
+     * Defaults to true.
+     */
+    readonly supportsDelegation?: boolean;
+    /**
+     * Decides whether to automatically attach instruction files to chat requests
+     * for this session type. Defaults to false when not specified.
+     */
+    readonly autoAttachReferences?: boolean;
 }
 export interface IChatSessionItem {
-    resource: URI;
-    label: string;
-    iconPath?: ThemeIcon;
-    badge?: string | IMarkdownString;
-    description?: string | IMarkdownString;
-    status?: ChatSessionStatus;
-    tooltip?: string | IMarkdownString;
-    timing: IChatSessionTiming;
-    changes?: {
-        files: number;
-        insertions: number;
-        deletions: number;
+    readonly resource: URI;
+    readonly label: string;
+    readonly iconPath?: ThemeIcon;
+    readonly badge?: string | IMarkdownString;
+    readonly description?: string | IMarkdownString;
+    readonly status?: ChatSessionStatus;
+    readonly tooltip?: string | IMarkdownString;
+    readonly timing: IChatSessionTiming;
+    readonly changes?: {
+        readonly files: number;
+        readonly insertions: number;
+        readonly deletions: number;
     } | readonly IChatSessionFileChange[] | readonly IChatSessionFileChange2[];
-    archived?: boolean;
-    metadata?: {
+    readonly archived?: boolean;
+    readonly metadata?: {
         readonly [key: string]: unknown;
     };
 }
 export interface IChatSessionFileChange {
-    modifiedUri: URI;
-    originalUri?: URI;
-    insertions: number;
-    deletions: number;
+    readonly modifiedUri: URI;
+    readonly originalUri?: URI;
+    readonly insertions: number;
+    readonly deletions: number;
 }
 export interface IChatSessionFileChange2 {
     readonly uri: URI;
@@ -130,6 +140,9 @@ export type IChatSessionHistoryItem = {
     parts: IChatProgress[];
     participant: string;
 };
+export type IChatSessionRequestHistoryItem = Extract<IChatSessionHistoryItem, {
+    type: "request";
+}>;
 /**
  * The session type used for local agent chat sessions.
  */
@@ -143,11 +156,7 @@ export interface IChatSession extends IDisposable {
     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')
-     * and values are either the selected option item IDs (string) or full option items (for locked state).
-     */
-    readonly options?: Record<string, string | IChatSessionProviderOptionItem>;
+    readonly options?: ReadonlyChatSessionOptionsMap;
     readonly progressObs?: IObservable<IChatProgress[]>;
     readonly isCompleteObs?: IObservable<boolean>;
     readonly interruptActiveResponseCallback?: () => Promise<boolean>;
@@ -155,31 +164,63 @@ export interface IChatSession extends IDisposable {
      * Editing session transferred from a previously-untitled chat session in `onDidCommitChatSessionItem`.
      */
     transferredState?: {
-        editingSession: IChatEditingSession | undefined;
-        inputState: ISerializableChatModelInputState | undefined;
+        readonly editingSession: IChatEditingSession | undefined;
+        readonly inputState: ISerializableChatModelInputState | undefined;
     };
     requestHandler?: (request: IChatAgentRequest, progress: (progress: IChatProgress[]) => void, history: any[], // TODO: Nail down types
     token: CancellationToken) => Promise<void>;
+    /**
+     * Forks the session from the given request point.
+     * @param request The request history item to fork from, or undefined to fork from the end.
+     * @param token Cancellation token.
+     * @returns The forked session item. The promise is rejected if forking fails.
+     */
+    forkSession?: (request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken) => Promise<IChatSessionItem>;
 }
 export interface IChatSessionContentProvider {
     provideChatSessionContent(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
 }
+export interface IChatNewSessionRequest {
+    readonly prompt: string;
+    readonly command?: string;
+    readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;
+}
+export interface IChatSessionItemsDelta {
+    readonly addedOrUpdated?: readonly IChatSessionItem[];
+    readonly removed?: readonly URI[];
+}
 export interface IChatSessionItemController {
-    readonly onDidChangeChatSessionItems: Event<void>;
+    readonly onDidChangeChatSessionItems: Event<IChatSessionItemsDelta>;
     get items(): readonly IChatSessionItem[];
     refresh(token: CancellationToken): Promise<void>;
-    newChatSessionItem?(request: IChatAgentRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
+    newChatSessionItem?(request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
 }
+export interface IChatSessionOptionsChangeEvent {
+    readonly sessionResource: URI;
+    readonly updates: ReadonlyMap<string, string | IChatSessionProviderOptionItem | undefined>;
+}
+export type ResolvedChatSessionsExtensionPoint = Omit<IChatSessionsExtensionPoint, "icon"> & {
+    readonly icon: ThemeIcon | URI | 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.
+ * Session options as key-value pairs.
+ *
+ * Keys correspond to option group IDs (e.g., 'models', 'subagents') and values are either the selected option item IDs (string) or full option items (for locked state).
  */
-export interface IChatSessionOptionsWillNotifyExtensionEvent extends IWaitUntil {
-    readonly sessionResource: URI;
-    readonly updates: ReadonlyArray<{
+export type ChatSessionOptionsMap = Map<string, string | IChatSessionProviderOptionItem>;
+export declare namespace ChatSessionOptionsMap {
+    function fromRecord(obj: {
+        [key: string]: string | IChatSessionProviderOptionItem;
+    }): ChatSessionOptionsMap;
+    function toRecord(map: ReadonlyChatSessionOptionsMap): Record<string, string | IChatSessionProviderOptionItem>;
+    function toStrValueArray(map: ReadonlyChatSessionOptionsMap | undefined): Array<{
         optionId: string;
-        value: string | IChatSessionProviderOptionItem;
-    }>;
+        value: string;
+    }> | undefined;
 }
+/**
+ * Readonly version of {@link ChatSessionOptionsMap}
+ */
+export type ReadonlyChatSessionOptionsMap = ReadonlyMap<string, string | IChatSessionProviderOptionItem>;
 export declare function isSessionInProgressStatus(state: ChatSessionStatus): boolean;
 export declare function isIChatSessionFileChange2(obj: unknown): obj is IChatSessionFileChange2;

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

@@ -2,20 +2,45 @@
 import { URI } from '../../../../base/common/uri.js';
 
 var ChatSessionStatus;
-(function (ChatSessionStatus) {
+(function(ChatSessionStatus) {
     ChatSessionStatus[ChatSessionStatus["Failed"] = 0] = "Failed";
     ChatSessionStatus[ChatSessionStatus["Completed"] = 1] = "Completed";
     ChatSessionStatus[ChatSessionStatus["InProgress"] = 2] = "InProgress";
     ChatSessionStatus[ChatSessionStatus["NeedsInput"] = 3] = "NeedsInput";
 })(ChatSessionStatus || (ChatSessionStatus = {}));
-const localChatSessionType = 'local';
-const agentOptionId = 'agent';
+const localChatSessionType = "local";
+const agentOptionId = "agent";
+var ChatSessionOptionsMap;
+(function(ChatSessionOptionsMap) {
+    function fromRecord(obj) {
+        return ( new Map(Object.entries(obj)));
+    }
+    ChatSessionOptionsMap.fromRecord = fromRecord;
+    function toRecord(map) {
+        const record = Object.create(null);
+        for (const [key, value] of map) {
+            record[key] = value;
+        }
+        return record;
+    }
+    ChatSessionOptionsMap.toRecord = toRecord;
+    function toStrValueArray(map) {
+        if (!map) {
+            return undefined;
+        }
+        return Array.from(map, ([optionId, value]) => ({
+            optionId,
+            value: typeof value === "string" ? value : value.id
+        }));
+    }
+    ChatSessionOptionsMap.toStrValueArray = toStrValueArray;
+})(ChatSessionOptionsMap || (ChatSessionOptionsMap = {}));
 function isSessionInProgressStatus(state) {
     return state === ChatSessionStatus.InProgress || state === ChatSessionStatus.NeedsInput;
 }
 function isIChatSessionFileChange2(obj) {
     const candidate = obj;
-    return candidate && candidate.uri instanceof URI && typeof candidate.insertions === 'number' && typeof candidate.deletions === 'number';
+    return candidate && candidate.uri instanceof URI && typeof candidate.insertions === "number" && typeof candidate.deletions === "number";
 }
 
-export { ChatSessionStatus, agentOptionId, isIChatSessionFileChange2, isSessionInProgressStatus, localChatSessionType };
+export { ChatSessionOptionsMap, ChatSessionStatus, agentOptionId, isIChatSessionFileChange2, isSessionInProgressStatus, localChatSessionType };