@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -11,12 +11,14 @@ import { EditSuggestionId } from "../../../../../editor/common/textModelEditSour
 import { ILogService } from "../../../../../platform/log/common/log.service.js";
 import { ICellEditOperation } from "../../../notebook/common/notebookCommon.js";
 import { ChatRequestToolReferenceEntry, IChatRequestVariableEntry } from "../attachments/chatVariableEntries.js";
-import { ChatAgentVoteDirection, ChatRequestQueueKind, IChatAgentMarkdownContentWithVulnerability, IChatAutoModeResolutionPart, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatDisabledClaudeHooksPart, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExternalEdit, IChatExternalToolInvocationUpdate, IChatExtensionsContent, IChatFollowup, IChatHookPart, IChatInfoMessage, IChatLocationData, IChatMarkdownContent, IChatMcpAuthenticationRequired, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMcpServersStartingSlow, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatPlanReview, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSendRequestOptions, IChatSessionTiming, IChatSystemNotificationPart, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsage, IChatUsagePromptTokenDetail, IChatUsedContext, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
+import { IChatRequestOrigin, ISerializableChatRequestOrigin } from "../chatRequestOrigin.js";
+import { ChatAgentVoteDirection, ChatRequestQueueKind, IChatAgentMarkdownContentWithVulnerability, IChatAutoModeResolutionPart, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatDisabledClaudeHooksPart, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExternalEdit, IChatExternalToolInvocationUpdate, IChatExtensionsContent, IChatFollowup, IChatHookPart, IChatInfoMessage, IChatLocationData, IChatMarkdownContent, IChatMcpAuthenticationRequired, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMcpServersStartingSlow, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatPlanReview, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSendRequestOptions, IChatSessionTiming, IChatSystemNotificationPart, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsage, IChatUsageModelTotal, IChatUsagePromptTokenDetail, IChatUsedContext, IChatVoiceProgressPart, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
 import { IChatService } from "../chatService/chatService.service.js";
-import { ChatAgentLocation, ChatModeKind, ChatPermissionLevel } from "../constants.js";
+import { ChatAgentLocation, SessionTypeSelectionReason, ChatModeKind, ChatPermissionLevel } from "../constants.js";
 import { IChatEditingSession } from "../editing/chatEditingService.js";
 import { IChatEditingService } from "../editing/chatEditingService.service.js";
 import { ILanguageModelChatMetadata, ILanguageModelChatMetadataAndIdentifier } from "../languageModels.js";
+import { IIntendedModelSelection, ModelSelectionReason } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/common/modelSelection";
 import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools } from "../participants/chatAgents.js";
 import { IChatAgentService } from "../participants/chatAgents.service.js";
 import { IParsedChatRequest } from "../requestParser/chatParserTypes.js";
@@ -43,15 +45,18 @@ export interface ISerializableSendOptions {
     userSelectedModelConfiguration?: IStringDictionary<unknown>;
     /** Static snapshot of user-selected tools (not an observable) */
     userSelectedTools?: UserSelectedTools;
+    instructionContext?: IChatSendRequestOptions["instructionContext"];
     location?: ChatAgentLocation;
     locationData?: IChatLocationData;
     attempt?: number;
     noCommandDetection?: boolean;
+    isVoiceModeInput?: boolean;
     agentId?: string;
     agentIdSilent?: string;
     slashCommand?: string;
     confirmation?: string;
     isSystemInitiated?: boolean;
+    hideFromTranscript?: boolean;
     systemInitiatedLabel?: string;
     terminalExecutionId?: string;
 }
@@ -72,9 +77,14 @@ export interface IChatRequestVariableData {
 export declare namespace IChatRequestVariableData {
     function toExport(data: IChatRequestVariableData): IChatRequestVariableData;
 }
+/** A feature that submits a chat request on the user's behalf. */
+export type ChatRequestSource = "agentMerge";
+/** Backfills the source of legacy Agent Merge requests when restoring history. */
+export declare function getRestoredChatRequestSource(request: Pick<IChatRequestModel, "requestSource" | "isSystemInitiated" | "systemInitiatedLabel">, messageText: string): ChatRequestSource | undefined;
 export interface IChatRequestModel {
     readonly id: string;
     readonly timestamp: number;
+    readonly requestTimestamp: number | undefined;
     readonly version: number;
     readonly modeInfo?: IChatRequestModeInfo;
     readonly session: IChatModel;
@@ -85,6 +95,7 @@ export interface IChatRequestModel {
     readonly locationData?: IChatLocationData;
     readonly attachedContext?: IChatRequestVariableEntry[];
     readonly isCompleteAddedRequest: boolean;
+    readonly isTerminalCommand: boolean;
     readonly response?: IChatResponseModel;
     readonly editedFileEvents?: IChatAgentEditedFileEvent[];
     shouldBeRemovedOnSend: IChatRequestDisablement | undefined;
@@ -93,8 +104,14 @@ export interface IChatRequestModel {
     readonly modelId?: string;
     readonly userSelectedTools?: UserSelectedTools;
     readonly isSystemInitiated?: boolean;
+    /** The request source, independent of the request text or responding participant. */
+    readonly requestSource?: ChatRequestSource;
+    readonly isHiddenFromTranscript: boolean;
+    /** Whether only the request row is hidden. Full-turn hiding also implies this. */
+    readonly isRequestHiddenFromTranscript: boolean;
     readonly systemInitiatedLabel?: string;
     readonly terminalExecutionId?: string;
+    readonly origin?: IChatRequestOrigin;
 }
 export interface ICodeBlockInfo {
     readonly suggestionId: EditSuggestionId;
@@ -133,10 +150,10 @@ export type IChatProgressHistoryResponseContent = IChatMarkdownContent | IChatAg
 /**
  * "Normal" progress kinds that are rendered as parts of the stream of content.
  */
-export type IChatProgressResponseContent = IChatProgressHistoryResponseContent | IChatToolInvocation | IChatToolInvocationSerialized | IChatMultiDiffData | IChatUndoStop | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatClearToPreviousToolInvocation | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatMcpAuthenticationRequired | IChatMcpServersStartingSlow | IChatDisabledClaudeHooksPart;
-export type IChatProgressResponseContentSerialized = Exclude<IChatProgressResponseContent, IChatToolInvocation | IChatElicitationRequest | IChatTask | IChatMultiDiffData | IChatMcpServersStarting | IChatMcpAuthenticationRequired | IChatMcpServersStartingSlow | IChatDisabledClaudeHooksPart>;
+export type IChatProgressResponseContent = IChatProgressHistoryResponseContent | IChatToolInvocation | IChatToolInvocationSerialized | IChatMultiDiffData | IChatUndoStop | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatClearToPreviousToolInvocation | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatMcpAuthenticationRequired | IChatMcpServersStartingSlow | IChatDisabledClaudeHooksPart | IChatVoiceProgressPart;
+export type IChatProgressResponseContentSerialized = Exclude<IChatProgressResponseContent, IChatToolInvocation | IChatElicitationRequest | IChatTask | IChatMultiDiffData | IChatMcpServersStarting | IChatMcpAuthenticationRequired | IChatMcpServersStartingSlow | IChatDisabledClaudeHooksPart | IChatVoiceProgressPart>;
 export declare function toChatHistoryContent(content: ReadonlyArray<IChatProgressResponseContent>): IChatProgressHistoryResponseContent[];
-export type IChatProgressRenderableResponseContent = Exclude<IChatProgressResponseContent, IChatContentInlineReference | IChatAgentMarkdownContentWithVulnerability | IChatResponseCodeblockUriPart>;
+export type IChatProgressRenderableResponseContent = Exclude<IChatProgressResponseContent, IChatContentInlineReference | IChatAgentMarkdownContentWithVulnerability | IChatResponseCodeblockUriPart | IChatVoiceProgressPart>;
 export interface IResponse {
     readonly value: ReadonlyArray<IChatProgressResponseContent>;
     getMarkdown(): string;
@@ -165,6 +182,8 @@ export interface IChatResponseModel {
     readonly timestamp: number;
     /** Milliseconds timestamp when this chat response was completed or cancelled. */
     readonly completedAt?: number;
+    /** Known completion timestamp for display. Undefined for legacy responses whose completion time was synthesized during restore. */
+    readonly completionTimestamp?: number;
     /** The state of this response */
     readonly state: ResponseModelState;
     /** @internal */
@@ -190,6 +209,7 @@ export interface IChatResponseModel {
      */
     readonly isIncomplete: IObservable<boolean>;
     readonly shouldBeRemovedOnSend: IChatRequestDisablement | undefined;
+    readonly isHiddenFromTranscript: boolean;
     readonly shouldBeBlocked: IObservable<boolean>;
     readonly isCompleteAddedRequest: boolean;
     /** A stale response is one that has been persisted and rehydrated, so e.g. Commands that have their arguments stored in the EH are gone. */
@@ -208,6 +228,8 @@ export interface IChatResponseModel {
     addUndoStop(undoStop: IChatUndoStop): void;
     setVote(vote: ChatAgentVoteDirection): void;
     setUsage(usage: IChatUsage): void;
+    setElapsedMs(elapsedMs: number): void;
+    setResult(result: IChatAgentResult): void;
     setEditApplied(edit: IChatTextEditGroup, editCount: number): boolean;
     resolveInlineReference(resolveId: string, resolvedReference: IChatContentInlineReference): boolean;
     updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
@@ -250,7 +272,8 @@ export interface IChatRequestModelParameters {
     session: ChatModel;
     message: IParsedChatRequest;
     variableData: IChatRequestVariableData;
-    timestamp: number;
+    timestamp?: number;
+    fallbackTimestamp?: number;
     attempt?: number;
     modeInfo?: IChatRequestModeInfo;
     confirmation?: string;
@@ -262,22 +285,34 @@ export interface IChatRequestModelParameters {
     editedFileEvents?: IChatAgentEditedFileEvent[];
     userSelectedTools?: UserSelectedTools;
     isSystemInitiated?: boolean;
+    requestSource?: ChatRequestSource;
+    isHiddenFromTranscript?: boolean;
+    isRequestHiddenFromTranscript?: boolean;
     systemInitiatedLabel?: string;
     terminalExecutionId?: string;
+    origin?: IChatRequestOrigin;
+    /** Whether this request runs as a terminal command (agent host `!` prefix). */
+    isTerminalCommand?: boolean;
 }
 export declare class ChatRequestModel implements IChatRequestModel {
     readonly id: string;
     response: ChatResponseModel | undefined;
     shouldBeRemovedOnSend: IChatRequestDisablement | undefined;
     readonly timestamp: number;
+    readonly requestTimestamp: number | undefined;
     readonly message: IParsedChatRequest;
     readonly isCompleteAddedRequest: boolean;
     readonly modelId?: string;
     readonly modeInfo?: IChatRequestModeInfo;
     readonly userSelectedTools?: UserSelectedTools;
     readonly isSystemInitiated?: boolean;
+    readonly requestSource?: ChatRequestSource;
+    readonly isHiddenFromTranscript: boolean;
+    readonly isRequestHiddenFromTranscript: boolean;
     readonly systemInitiatedLabel?: string;
     readonly terminalExecutionId?: string;
+    readonly isTerminalCommand: boolean;
+    readonly origin?: IChatRequestOrigin;
     private readonly _shouldBeBlocked;
     get shouldBeBlocked(): IObservable<boolean>;
     setShouldBeBlocked(value: boolean): void;
@@ -334,11 +369,16 @@ declare class AbstractResponse implements IResponse {
     private partsToRepr;
     private inlineRefToRepr;
     private getToolInvocationText;
+    /**
+     * Renders a reference the way the response showed it — the file name plus any line suffix —
+     * as code, so a name containing `*` or `_` survives being pasted into another document.
+     */
     private uriToRepr;
 }
 export declare class Response extends AbstractResponse implements IDisposable {
     private readonly _store;
     private _onDidChangeValue;
+    private _activeReasoning;
     get onDidChangeValue(): Event<void>;
     private _citations;
     constructor(value: IMarkdownString | ReadonlyArray<SerializedChatResponsePart>);
@@ -346,6 +386,10 @@ export declare class Response extends AbstractResponse implements IDisposable {
     clear(): void;
     clearToPreviousToolInvocation(message?: string): void;
     updateContent(progress: IChatProgressResponseContent | IChatTextEdit | IChatNotebookEdit | IChatTask | IChatExternalToolInvocationUpdate, quiet?: boolean): void;
+    /**
+     * Persists the duration of the active reasoning interval.
+     */
+    finalizeReasoningDuration(): void;
     addCitation(citation: IChatCodeCitation): void;
     resolveInlineReference(resolveId: string, resolvedReference: IChatContentInlineReference): boolean;
     private _mergeOrPushTextEditGroup;
@@ -369,6 +413,7 @@ export interface IChatResponseModelParameters {
     shouldBeBlocked?: boolean;
     restoredId?: string;
     modelState?: ResponseModelStateT;
+    completionTimestamp?: number | null;
     timeSpentWaiting?: number;
     elapsedMs?: number;
     /**
@@ -396,23 +441,29 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     private _vote?;
     private _result?;
     private readonly _usageObs;
+    private _parentUsage;
+    private readonly _subagentCopilotCredits;
     private readonly _completionTokenCountObs;
     private _shouldBeRemovedOnSend;
     readonly isCompleteAddedRequest: boolean;
     private readonly _shouldBeBlocked;
     private readonly _timestamp;
+    private _completionTimestamp;
     private _timeSpentWaitingAccumulator;
     private _elapsedMs;
+    private readonly _timingChanged;
     confirmationAdjustedTimestamp: IObservable<number>;
     get shouldBeBlocked(): IObservable<boolean>;
     get request(): IChatRequestModel | undefined;
     get session(): ChatModel;
     get shouldBeRemovedOnSend(): IChatRequestDisablement | undefined;
+    get isHiddenFromTranscript(): boolean;
     get isComplete(): boolean;
     get timestamp(): number;
     set shouldBeRemovedOnSend(disablement: IChatRequestDisablement | undefined);
     get isCanceled(): boolean;
     get completedAt(): number | undefined;
+    get completionTimestamp(): number | undefined;
     get state(): ResponseModelState;
     get stateT(): ResponseModelStateT;
     get vote(): ChatAgentVoteDirection | undefined;
@@ -478,8 +529,15 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     setAgent(agent: IChatAgentData, slashCommand?: IChatAgentCommand): void;
     setResult(result: IChatAgentResult): void;
     setUsage(usage: IChatUsage): void;
+    setSubagentCopilotCredits(subagentCallId: string, copilotCredits: number): void;
+    private _withSubagentCopilotCredits;
+    private _setUsage;
+    setElapsedMs(elapsedMs: number): void;
     private isSameUsage;
-    complete(): void;
+    complete(completedAt?: number): void;
+    completeWithoutTimestamp(): void;
+    reopen(): void;
+    private _complete;
     cancel(): void;
     setFollowups(followups: IChatFollowup[] | undefined): void;
     setVote(vote: ChatAgentVoteDirection): void;
@@ -487,7 +545,7 @@ export declare class ChatResponseModel extends Disposable implements IChatRespon
     adoptTo(session: ChatModel): void;
     finalizeUndoState(): void;
     dispose(): void;
-    toJSON(): ISerializableChatResponseData;
+    toJSON(): Omit<ISerializableChatResponseData, "timestamp">;
 }
 export interface IChatRequestDisablement {
     requestId: string;
@@ -513,6 +571,7 @@ export interface IChatModel extends IDisposable {
     readonly lastMessageDate: number;
     readonly timing: IChatSessionTiming;
     readonly initialLocation: ChatAgentLocation;
+    readonly sessionTypeSelectionReason: SessionTypeSelectionReason | undefined;
     readonly title: string;
     readonly hasCustomTitle: boolean;
     readonly responderUsername: string;
@@ -522,6 +581,7 @@ export interface IChatModel extends IDisposable {
     readonly hasActiveRequest: IObservable<boolean>;
     /** Provides session information when a request needs user interaction to continue */
     readonly requestNeedsInput: IObservable<IChatRequestNeedsInputInfo | undefined>;
+    readonly isReadOnly: IObservable<boolean>;
     readonly inputPlaceholder?: string;
     readonly editingSession?: IChatEditingSession | undefined;
     readonly checkpoint: IChatRequestModel | undefined;
@@ -562,6 +622,7 @@ interface ISerializableChatResponseData {
     modelState?: ResponseModelStateT;
     vote?: ChatAgentVoteDirection;
     timestamp?: number;
+    responseTimestamp?: number;
     slashCommand?: IChatAgentCommand;
     /** For backward compat: should be optional */
     usedContext?: IChatUsedContext;
@@ -573,6 +634,8 @@ interface ISerializableChatResponseData {
     outputBuffer?: number;
     promptTokenDetails?: readonly IChatUsagePromptTokenDetail[];
     copilotCredits?: number;
+    modelTotals?: readonly IChatUsageModelTotal[];
+    sessionCopilotCredits?: number;
     elapsedMs?: number;
 }
 export type SerializedChatResponsePart = IMarkdownString | IChatResponseProgressFileTreeData | IChatContentInlineReference | IChatAgentMarkdownContentWithVulnerability | IChatThinkingPart | IChatProgressResponseContentSerialized | IChatQuestionCarousel | IChatPlanReview | IChatDisabledClaudeHooksPart;
@@ -584,6 +647,8 @@ export interface ISerializableChatRequestData extends ISerializableChatResponseD
     response: ReadonlyArray<SerializedChatResponsePart> | undefined;
     /**Old, persisted name for shouldBeRemovedOnSend */
     isHidden?: boolean;
+    hiddenFromTranscript?: boolean;
+    requestHiddenFromTranscript?: boolean;
     shouldBeRemovedOnSend?: IChatRequestDisablement;
     agent?: ISerializableChatAgentData;
     /** @deprecated modelState is used instead now */
@@ -594,8 +659,10 @@ export interface ISerializableChatRequestData extends ISerializableChatResponseD
     modelId?: string;
     modeInfo?: IChatRequestModeInfo;
     isSystemInitiated?: boolean;
+    requestSource?: ChatRequestSource;
     systemInitiatedLabel?: string;
     terminalExecutionId?: string;
+    origin?: ISerializableChatRequestOrigin;
 }
 export interface ISerializableMarkdownInfo {
     readonly suggestionId: EditSuggestionId;
@@ -726,7 +793,29 @@ export interface ISerializableChatData3 extends Omit<ISerializableChatData2, "ve
  * - The UI stays in sync with the persisted state
  * - New chats use UI defaults (persisted preferences) instead of hardcoded values
  */
-export interface IInputModel {
+/**
+ * Holds the model a conversation is meant to run on. Implemented by the conversation's
+ * {@link IInputModel}, and by an input part that has no conversation bound to speak for.
+ */
+export interface IIntendedModelHolder {
+    /**
+     * The model this conversation is meant to run on, whatever the catalog can offer right now.
+     *
+     * Distinct from {@link IChatModelInputState.selectedModel}, which is shared draft content: it is
+     * synced to peers and the agent host and shows what the composer currently displays. This is
+     * local reconciliation state — never serialized, never synced — recording what should be
+     * displayed once the catalog can offer it, and it deliberately outlives {@link IInputModel.clearState}.
+     */
+    readonly intendedModel: IIntendedModelSelection | undefined;
+    /** Sets {@link intendedModel}. */
+    setIntendedModel(selection: IIntendedModelSelection | undefined): void;
+}
+/** An {@link IIntendedModelHolder} for an input that has no conversation to speak for it. */
+export declare class IntendedModelSlot implements IIntendedModelHolder {
+    intendedModel: IIntendedModelSelection | undefined;
+    setIntendedModel(selection: IIntendedModelSelection | undefined): void;
+}
+export interface IInputModel extends IIntendedModelHolder {
     /** Observable for current input state (undefined for new/uninitialized chats) */
     readonly state: IObservable<IChatModelInputState | undefined>;
     /** Update the input state (partial update) */
@@ -736,6 +825,10 @@ export interface IInputModel {
     /** Serializes the state */
     toJSON(): ISerializableChatModelInputState | undefined;
 }
+export declare enum ChatInputStateOrigin {
+    /** Pushed in by a draft sync from another client. Not a local user edit. */
+    Remote = "remote"
+}
 /**
  * Represents the current state of the chat input that hasn't been sent yet.
  * This is the "draft" state that should be preserved across sessions.
@@ -750,7 +843,11 @@ export interface IChatModelInputState {
         /** Mode kind for builtin modes */
         kind: ChatModeKind | undefined;
     };
-    /** Currently selected language model, if any */
+    /**
+     * Currently selected language model, if any. Shared draft content: synced to peers and the
+     * agent host. See {@link IIntendedModelHolder.intendedModel} for the model this conversation is
+     * meant to run on, which may differ while the catalog cannot offer it.
+     */
     selectedModel: ILanguageModelChatMetadataAndIdentifier | undefined;
     /**
      * Configuration (e.g. context size, thinking effort) for the selected
@@ -758,12 +855,20 @@ export interface IChatModelInputState {
      * session is reopened.
      */
     modelConfiguration?: IStringDictionary<unknown>;
+    /** Whether {@link selectedModel} was picked by the user or just fallen back to. Not saved. */
+    selectedModelReason?: ModelSelectionReason;
     /** Current input text */
     inputText: string;
     /** Current selection ranges */
     selections: ISelection[];
     /** Current permission level for tool auto-approval */
     permissionLevel?: ChatPermissionLevel;
+    /**
+     * Where this state came from, when it was not authored by the local user.
+     * Absent means a local user edit. Lets consumers that sync input state
+     * elsewhere recognize their own writes instead of treating them as edits.
+     */
+    origin?: ChatInputStateOrigin;
     /** Contributed stored state */
     contrib: Record<string, unknown>;
 }
@@ -791,6 +896,10 @@ export interface ISerializableChatModelInputState {
     permissionLevel?: ChatPermissionLevel;
     contrib: Record<string, unknown>;
 }
+/**
+ * Revives persisted or transferred input state into its live shape, including the legacy model configuration fallback.
+ */
+export declare function reviveSerializableInputState(state: ISerializableChatModelInputState): IChatModelInputState;
 /**
 * Chat data that has been parsed and normalized to the current format.
 */
@@ -810,6 +919,7 @@ export type ISerializableChatDataIn = ISerializableChatData1 | ISerializableChat
  */
 export declare function normalizeSerializableChatData(raw: ISerializableChatDataIn): ISerializableChatData;
 export declare function isExportableSessionData(obj: unknown): obj is IExportableChatData;
+export declare function extractExportableSessionData(data: IExportableChatData): IExportableChatData;
 export declare function isSerializableSessionData(obj: unknown): obj is ISerializableChatData;
 export type IChatChangeEvent = IChatInitEvent | IChatAddRequestEvent | IChatChangedRequestEvent | IChatRemoveRequestEvent | IChatAddResponseEvent | IChatSetAgentEvent | IChatMoveEvent | IChatSetHiddenEvent | IChatCompletedRequestEvent | IChatSetCustomTitleEvent;
 export interface IChatAddRequestEvent {
@@ -876,7 +986,14 @@ declare class InputModel implements IInputModel {
     private readonly sessionId;
     private readonly _state;
     readonly state: IObservable<IChatModelInputState | undefined>;
+    /**
+     * Survives {@link clearState}: sending a message or clearing the draft says nothing about which
+     * model the conversation is meant to run on.
+     */
+    private _intendedModel;
     constructor(initialState: IChatModelInputState | undefined, logger: ILogService, sessionId: string);
+    get intendedModel(): IIntendedModelSelection | undefined;
+    setIntendedModel(selection: IIntendedModelSelection | undefined): void;
     setState(state: Partial<IChatModelInputState>): void;
     clearState(): void;
     toJSON(): ISerializableChatModelInputState | undefined;
@@ -906,6 +1023,10 @@ export declare class ChatModel extends Disposable implements IChatModel {
         requestId: string;
         kind: ChatRequestQueueKind;
     }[]): void;
+    /**
+     * @internal Used by ChatService to atomically replace the pending request queue.
+     */
+    replacePendingRequests(requests: readonly IChatPendingRequest[]): void;
     /**
      * @internal Used by ChatService to add a request to the queue.
      * Steering messages are placed before queued messages.
@@ -937,6 +1058,7 @@ export declare class ChatModel extends Disposable implements IChatModel {
     readonly requestInProgress: IObservable<boolean>;
     readonly hasActiveRequest: IObservable<boolean>;
     readonly requestNeedsInput: IObservable<IChatRequestNeedsInputInfo | undefined>;
+    readonly isReadOnly: IObservable<boolean>;
     /** Input model for managing input state */
     readonly inputModel: InputModel;
     get hasRequests(): boolean;
@@ -961,6 +1083,7 @@ export declare class ChatModel extends Disposable implements IChatModel {
     private _editingSession;
     get editingSession(): IChatEditingSession | undefined;
     private readonly _initialLocation;
+    readonly sessionTypeSelectionReason: SessionTypeSelectionReason | undefined;
     get initialLocation(): ChatAgentLocation;
     private readonly _canUseTools;
     get canUseTools(): boolean;
@@ -970,9 +1093,11 @@ export declare class ChatModel extends Disposable implements IChatModel {
     constructor(dataRef: ISerializedChatDataReference | undefined, initialModelProps: {
         initialLocation: ChatAgentLocation;
         canUseTools: boolean;
+        sessionTypeSelectionReason?: SessionTypeSelectionReason;
         inputState?: ISerializableChatModelInputState;
         resource?: URI;
         disableBackgroundKeepAlive?: boolean;
+        isReadOnly?: IObservable<boolean>;
     }, logService: ILogService, chatAgentService: IChatAgentService, chatEditingService: IChatEditingService, chatService: IChatService);
     startEditingSession(isGlobalEditingSession?: boolean, transferFromSession?: IChatEditingSession): void;
     private currentEditedFileEvents;
@@ -992,7 +1117,7 @@ export declare class ChatModel extends Disposable implements IChatModel {
     private _checkpoint;
     get checkpoint(): ChatRequestModel | undefined;
     private _setDisabledRequests;
-    addRequest(message: IParsedChatRequest, variableData: IChatRequestVariableData, attempt: number, modeInfo?: IChatRequestModeInfo, chatAgent?: IChatAgentData, slashCommand?: IChatAgentCommand, confirmation?: string, locationData?: IChatLocationData, attachments?: IChatRequestVariableEntry[], isCompleteAddedRequest?: boolean, modelId?: string, userSelectedTools?: UserSelectedTools, id?: string, isSystemInitiated?: boolean, systemInitiatedLabel?: string, terminalExecutionId?: string): ChatRequestModel;
+    addRequest(message: IParsedChatRequest, variableData: IChatRequestVariableData, attempt: number, modeInfo?: IChatRequestModeInfo, chatAgent?: IChatAgentData, slashCommand?: IChatAgentCommand, confirmation?: string, locationData?: IChatLocationData, attachments?: IChatRequestVariableEntry[], isCompleteAddedRequest?: boolean, modelId?: string, userSelectedTools?: UserSelectedTools, id?: string, isSystemInitiated?: boolean, systemInitiatedLabel?: string, terminalExecutionId?: string, isTerminalCommand?: boolean, timestamp?: number | null, hideFromTranscript?: boolean, origin?: IChatRequestOrigin, isRequestHiddenFromTranscript?: boolean, requestSource?: ChatRequestSource): ChatRequestModel;
     setCustomTitle(title: string): void;
     updateRequest(request: ChatRequestModel, variableData: IChatRequestVariableData): void;
     adoptRequest(request: ChatRequestModel): void;