@codingame/monaco-vscode-api 26.1.1 → 26.1.2

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

@@ -287,5 +287,31 @@ var ResponseModelState;
     ResponseModelState[ResponseModelState["Failed"] = 3] = "Failed";
     ResponseModelState[ResponseModelState["NeedsInput"] = 4] = "NeedsInput";
 })(ResponseModelState || (ResponseModelState = {}));
+var ChatSendResult;
+(function(ChatSendResult) {
+    function isSent(result) {
+        return result.kind === "sent";
+    }
+    ChatSendResult.isSent = isSent;
+    function isRejected(result) {
+        return result.kind === "rejected";
+    }
+    ChatSendResult.isRejected = isRejected;
+    function isQueued(result) {
+        return result.kind === "queued";
+    }
+    ChatSendResult.isQueued = isQueued;
+    function assertSent(result) {
+        if (result.kind !== "sent") {
+            throw ( new Error(`Expected ChatSendResult to be 'sent', but was '${result.kind}'`));
+        }
+    }
+    ChatSendResult.assertSent = assertSent;
+})(ChatSendResult || (ChatSendResult = {}));
+var ChatRequestQueueKind;
+(function(ChatRequestQueueKind) {
+    ChatRequestQueueKind["Queued"] = "queued";
+    ChatRequestQueueKind["Steering"] = "steering";
+})(ChatRequestQueueKind || (ChatRequestQueueKind = {}));
 
-export { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, isChatContentVariableReference, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };
+export { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatCopyKind, ChatErrorLevel, ChatMcpServersStarting, ChatRequestQueueKind, ChatResponseClearToPreviousToolInvocationReason, ChatResponseReferencePartStatusKind, ChatSendResult, ElicitationState, IChatToolInvocation, ResponseModelState, ToolConfirmKind, convertLegacyChatSessionTiming, isChatContentVariableReference, isChatFollowup, isIDocumentContext, isIUsedContext, isLegacyChatTerminalToolInvocationData };

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

@@ -6,7 +6,7 @@ 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, IChatSendRequestData, IChatProgress, IChatCompleteResponse, IChatDetail, IChatUserActionEvent } from "./chatService.js";
+import { IChatSessionStartOptions, IChatModelReference, IChatSessionContext, IChatSendRequestOptions, ChatSendResult, IChatProgress, ChatRequestQueueKind, IChatCompleteResponse, IChatDetail, IChatUserActionEvent } from "./chatService.js";
 export declare const IChatService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatService>;
 export interface IChatService {
     _serviceBrand: undefined;
@@ -37,9 +37,10 @@ export interface IChatService {
     readonly editingSessions: IChatEditingSession[];
     getChatSessionFromInternalUri(sessionResource: URI): IChatSessionContext | undefined;
     /**
-    * Returns whether the request was accepted.`
+    * 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<IChatSendRequestData | undefined>;
+    sendRequest(sessionResource: URI, message: string, options?: IChatSendRequestOptions): Promise<ChatSendResult>;
     /**
     * Sets a custom title for a chat model.
     */
@@ -49,6 +50,29 @@ export interface IChatService {
     adoptRequest(sessionResource: URI, request: IChatRequestModel): Promise<void>;
     removeRequest(sessionResource: URI, requestId: string): Promise<void>;
     cancelCurrentRequestForSession(sessionResource: URI): void;
+    /**
+    * Sets yieldRequested on the active request for the given session.
+    */
+    setYieldRequested(sessionResource: URI): void;
+    /**
+    * Removes a pending request from the session's queue.
+    */
+    removePendingRequest(sessionResource: URI, requestId: string): void;
+    /**
+    * Sets the pending requests for a session, allowing for deletions/reordering.
+    * Adding new requests should go through sendRequest with the queue option.
+    */
+    setPendingRequests(sessionResource: URI, requests: readonly {
+        requestId: string;
+        kind: ChatRequestQueueKind;
+    }[]): void;
+    /**
+    * Ensures pending requests for the session are processing. If restoring from
+    * storage or after an error, pending requests may be present without an
+    * active chat message 'loop' happening. THis triggers the loop to happen
+    * as needed. Idempotent, safe to call at any time.
+    */
+    processPendingRequests(sessionResource: URI): void;
     addCompleteRequest(sessionResource: URI, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): void;
     setChatSessionTitle(sessionResource: URI, title: string): void;
     getLocalSessionHistory(): Promise<IChatDetail[]>;

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

@@ -9,6 +9,7 @@ import { IChatAgentAttachmentCapabilities, IChatAgentRequest } from "./participa
 import { IChatEditingSession } from "./editing/chatEditingService.js";
 import { IChatRequestVariableData, ISerializableChatModelInputState } from "./model/chatModel.js";
 import { IChatProgress, IChatSessionTiming } from "./chatService/chatService.js";
+import { Target } from "./promptSyntax/service/promptsService.js";
 export declare enum ChatSessionStatus {
     Failed = 0,
     Completed = 1,
@@ -80,7 +81,7 @@ export interface IChatSessionsExtensionPoint {
      * to reuse the standard agent/mode dropdown with filtered custom agents.
      * Custom agents without a `target` property are also shown in all filtered lists
      */
-    readonly customAgentTarget?: string;
+    readonly customAgentTarget?: Target;
 }
 export interface IChatSessionItem {
     resource: URI;

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

@@ -7,6 +7,7 @@ import { IChatService } from "./chatService/chatService.service.js";
 import { IChatSessionItemProvider, IChatSessionsExtensionPoint, IChatSessionItem, IChatSessionContentProvider, IChatSession, IChatSessionProviderOptionItem, IChatSessionProviderOptionGroup, IChatSessionOptionsWillNotifyExtensionEvent } from "./chatSessionsService.js";
 import { IChatModel } from "./model/chatModel.js";
 import { IChatAgentAttachmentCapabilities } 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;
@@ -57,9 +58,9 @@ export interface IChatSessionsService {
     getCapabilitiesForSessionType(chatSessionType: string): IChatAgentAttachmentCapabilities | undefined;
     /**
     * Get the customAgentTarget for a specific session type.
-    * When set, the mode picker should show filtered custom agents matching this target.
+    * When the Target is not `Target.Undefined`, the mode picker should show filtered custom agents matching this target.
     */
-    getCustomAgentTargetForSessionType(chatSessionType: string): string | undefined;
+    getCustomAgentTargetForSessionType(chatSessionType: string): Target;
     onDidChangeOptionGroups: Event<string>;
     getOptionGroupsForSessionType(chatSessionType: string): IChatSessionProviderOptionGroup[] | undefined;
     setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: IChatSessionProviderOptionGroup[]): void;

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

@@ -3,6 +3,8 @@ import { RawContextKey } from "../../../../platform/contextkey/common/contextkey
 export declare enum ChatConfiguration {
     AIDisabled = "chat.disableAIFeatures",
     AgentEnabled = "chat.agent.enabled",
+    RequestQueueingEnabled = "chat.requestQueuing.enabled",
+    RequestQueueingDefaultAction = "chat.requestQueuing.defaultAction",
     AgentStatusEnabled = "chat.agentsControl.enabled",
     EditorAssociations = "chat.editorAssociations",
     UnifiedAgentsBar = "chat.unifiedAgentsBar.enabled",

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

@@ -7,6 +7,8 @@ var ChatConfiguration;
 (function(ChatConfiguration) {
     ChatConfiguration["AIDisabled"] = "chat.disableAIFeatures";
     ChatConfiguration["AgentEnabled"] = "chat.agent.enabled";
+    ChatConfiguration["RequestQueueingEnabled"] = "chat.requestQueuing.enabled";
+    ChatConfiguration["RequestQueueingDefaultAction"] = "chat.requestQueuing.defaultAction";
     ChatConfiguration["AgentStatusEnabled"] = "chat.agentsControl.enabled";
     ChatConfiguration["EditorAssociations"] = "chat.editorAssociations";
     ChatConfiguration["UnifiedAgentsBar"] = "chat.unifiedAgentsBar.enabled";

package/vscode/src/vs/workbench/contrib/chat/common/editing/chatEditingService.js

@@ -45,9 +45,9 @@ var ChatEditingSessionState;
     ChatEditingSessionState[ChatEditingSessionState["Disposed"] = 3] = "Disposed";
 })(ChatEditingSessionState || (ChatEditingSessionState = {}));
 const CHAT_EDITING_MULTI_DIFF_SOURCE_RESOLVER_SCHEME = "chat-editing-multi-diff-source";
-const chatEditingWidgetFileStateContextKey = ( new RawContextKey("chatEditingWidgetFileState", undefined, ( localize(6221, "The current state of the file in the chat editing widget"))));
+const chatEditingWidgetFileStateContextKey = ( new RawContextKey("chatEditingWidgetFileState", undefined, ( localize(6319, "The current state of the file in the chat editing widget"))));
 const chatEditingAgentSupportsReadonlyReferencesContextKey = ( new RawContextKey("chatEditingAgentSupportsReadonlyReferences", undefined, ( localize(
-    6222,
+    6320,
     "Whether the chat editing agent supports readonly references (temporary)"
 ))));
 const decidedChatEditingResourceContextKey = ( new RawContextKey("decidedChatEditingResource", []));

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

@@ -27,13 +27,13 @@ LanguageModelStatsService = ( __decorate([( __param(0, IExtensionFeaturesManagem
 const CopilotUsageExtensionFeatureId = "copilot";
 ( Registry.as(Extensions.ExtensionFeaturesRegistry)).registerExtensionFeature({
     id: CopilotUsageExtensionFeatureId,
-    label: ( localize(6223, "Copilot")),
-    description: ( localize(6224, "Language models usage statistics of this extension.")),
+    label: ( localize(6321, "Copilot")),
+    description: ( localize(6322, "Language models usage statistics of this extension.")),
     icon: Codicon.copilot,
     access: {
         canToggle: false
     },
-    accessDataLabel: ( localize(6225, "chat"))
+    accessDataLabel: ( localize(6323, "chat"))
 });
 
 export { CopilotUsageExtensionFeatureId, LanguageModelStatsService };

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

@@ -84,15 +84,15 @@ const languageModelChatProviderType = {
     properties: {
         vendor: {
             type: "string",
-            description: ( localize(6226, "A globally unique vendor of language model chat provider."))
+            description: ( localize(6324, "A globally unique vendor of language model chat provider."))
         },
         displayName: {
             type: "string",
-            description: ( localize(6227, "The display name of the language model chat provider."))
+            description: ( localize(6325, "The display name of the language model chat provider."))
         },
         configuration: {
             type: "object",
-            description: ( localize(6228, "Configuration options for the language model chat provider.")),
+            description: ( localize(6326, "Configuration options for the language model chat provider.")),
             anyOf: [{
                 $ref: "http://json-schema.org/draft-07/schema#"
             }, {
@@ -104,7 +104,7 @@ const languageModelChatProviderType = {
                             properties: {
                                 secret: {
                                     type: "boolean",
-                                    description: ( localize(6229, "Whether the property is a secret."))
+                                    description: ( localize(6327, "Whether the property is a secret."))
                                 }
                             }
                         }
@@ -114,7 +114,7 @@ const languageModelChatProviderType = {
                         properties: {
                             secret: {
                                 type: "boolean",
-                                description: ( localize(6229, "Whether the property is a secret."))
+                                description: ( localize(6327, "Whether the property is a secret."))
                             }
                         }
                     }
@@ -124,19 +124,19 @@ const languageModelChatProviderType = {
         managementCommand: {
             type: "string",
             description: ( localize(
-                6230,
+                6328,
                 "A command to manage the language model chat provider, e.g. 'Manage Copilot models'. This is used in the chat model picker. If not provided, a gear icon is not rendered during vendor selection."
             )),
             deprecated: true,
             deprecationMessage: ( localize(
-                6231,
+                6329,
                 "The managementCommand property is deprecated and will be removed in a future release. Use the new configuration property instead."
             ))
         },
         when: {
             type: "string",
             description: ( localize(
-                6232,
+                6330,
                 "Condition which must be true to show this language model chat provider in the Manage Models list."
             ))
         }
@@ -145,7 +145,7 @@ const languageModelChatProviderType = {
 const languageModelChatProviderExtensionPoint = ExtensionsRegistry.registerExtensionPoint({
     extensionPoint: "languageModelChatProviders",
     jsonSchema: {
-        description: ( localize(6233, "Contribute language model chat providers of a specific vendor.")),
+        description: ( localize(6331, "Contribute language model chat providers of a specific vendor.")),
         oneOf: [languageModelChatProviderType, {
             type: "array",
             items: languageModelChatProviderType
@@ -221,18 +221,18 @@ let LanguageModelsService = class LanguageModelsService {
                 for (const item of Iterable.wrap(extension.value)) {
                     if (( this._vendors.has(item.vendor))) {
                         extension.collector.error(( localize(
-                            6234,
+                            6332,
                             "The vendor '{0}' is already registered and cannot be registered twice",
                             item.vendor
                         )));
                         continue;
                     }
                     if (isFalsyOrWhitespace(item.vendor)) {
-                        extension.collector.error(( localize(6235, "The vendor field cannot be empty.")));
+                        extension.collector.error(( localize(6333, "The vendor field cannot be empty.")));
                         continue;
                     }
                     if (item.vendor.trim() !== item.vendor) {
-                        extension.collector.error(( localize(6236, "The vendor field cannot start or end with whitespace.")));
+                        extension.collector.error(( localize(6334, "The vendor field cannot start or end with whitespace.")));
                         continue;
                     }
                     addedVendors.push(item);
@@ -674,18 +674,18 @@ let LanguageModelsService = class LanguageModelsService {
         try {
             await ( new Promise(resolve => {
                 const inputBox = disposables.add(this._quickInputService.createInputBox());
-                inputBox.title = ( localize(6237, "Group Name"));
-                inputBox.placeholder = ( localize(6238, "Enter a name for the group"));
+                inputBox.title = ( localize(6335, "Group Name"));
+                inputBox.placeholder = ( localize(6336, "Enter a name for the group"));
                 inputBox.value = providerGroupName;
                 inputBox.ignoreFocusOut = true;
                 disposables.add(inputBox.onDidChangeValue(value => {
                     if (!value) {
-                        inputBox.validationMessage = ( localize(6239, "Please enter a name"));
+                        inputBox.validationMessage = ( localize(6337, "Please enter a name"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
                     if (!existing && ( languageModelProviderGroups.some(g => g.name === value))) {
-                        inputBox.validationMessage = ( localize(6240, "A language models group with this name already exists"));
+                        inputBox.validationMessage = ( localize(6338, "A language models group with this name already exists"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
@@ -766,7 +766,7 @@ let LanguageModelsService = class LanguageModelsService {
                 quickPick.items = ( items.map(item => ({
                     label: item
                 })));
-                quickPick.placeholder = propertySchema.description ?? ( localize(6241, "Select value for {0}", property));
+                quickPick.placeholder = propertySchema.description ?? ( localize(6339, "Select value for {0}", property));
                 quickPick.canSelectMany = true;
                 quickPick.ignoreFocusOut = true;
                 disposables.add(quickPick.onDidAccept(() => {
@@ -788,7 +788,7 @@ let LanguageModelsService = class LanguageModelsService {
             const value = await ( new Promise((resolve, reject) => {
                 const inputBox = disposables.add(this._quickInputService.createInputBox());
                 inputBox.title = `${groupName}: ${propertySchema.title ?? property}`;
-                inputBox.placeholder = ( localize(6242, "Enter value for {0}", property));
+                inputBox.placeholder = ( localize(6340, "Enter value for {0}", property));
                 inputBox.password = !!propertySchema.secret;
                 inputBox.ignoreFocusOut = true;
                 if (existing?.[property]) {
@@ -801,20 +801,20 @@ let LanguageModelsService = class LanguageModelsService {
                 }
                 disposables.add(inputBox.onDidChangeValue(value => {
                     if (!value && required) {
-                        inputBox.validationMessage = ( localize(6243, "Value is required"));
+                        inputBox.validationMessage = ( localize(6341, "Value is required"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }
                     if (propertySchema.type === "number" || propertySchema.type === "integer") {
                         if (isNaN(Number(value))) {
-                            inputBox.validationMessage = ( localize(6244, "Please enter a number"));
+                            inputBox.validationMessage = ( localize(6342, "Please enter a number"));
                             inputBox.severity = Severity$1.Error;
                             return;
                         }
                     }
                     if (propertySchema.type === "boolean") {
                         if (value !== "true" && value !== "false") {
-                            inputBox.validationMessage = ( localize(6245, "Please enter true or false"));
+                            inputBox.validationMessage = ( localize(6343, "Please enter true or false"));
                             inputBox.severity = Severity$1.Error;
                             return;
                         }
@@ -824,7 +824,7 @@ let LanguageModelsService = class LanguageModelsService {
                 }));
                 disposables.add(inputBox.onDidAccept(() => {
                     if (!inputBox.value && required) {
-                        inputBox.validationMessage = ( localize(6243, "Value is required"));
+                        inputBox.validationMessage = ( localize(6341, "Value is required"));
                         inputBox.severity = Severity$1.Error;
                         return;
                     }

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

@@ -10,7 +10,7 @@ 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, ChatAgentVoteDownReason, IChatAgentMarkdownContentWithVulnerability, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExtensionsContent, IChatFollowup, IChatLocationData, IChatMarkdownContent, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSessionContext, IChatSessionTiming, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsedContext, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
+import { ChatAgentVoteDirection, ChatAgentVoteDownReason, ChatRequestQueueKind, IChatAgentMarkdownContentWithVulnerability, IChatClearToPreviousToolInvocation, IChatCodeCitation, IChatCommandButton, IChatConfirmation, IChatContentInlineReference, IChatContentReference, IChatDisabledClaudeHooksPart, IChatEditingSessionAction, IChatElicitationRequest, IChatElicitationRequestSerialized, IChatExtensionsContent, IChatFollowup, IChatHookPart, IChatLocationData, IChatMarkdownContent, IChatMcpServersStarting, IChatMcpServersStartingSerialized, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatProgressMessage, IChatPullRequestContent, IChatQuestionCarousel, IChatResponseCodeblockUriPart, IChatResponseProgressFileTreeData, IChatSendRequestOptions, IChatSessionContext, IChatSessionTiming, IChatTask, IChatTaskSerialized, IChatTextEdit, IChatThinkingPart, IChatToolInvocation, IChatToolInvocationSerialized, IChatTreeData, IChatUndoStop, IChatUsedContext, IChatWarningMessage, IChatWorkspaceEdit, ResponseModelState } from "../chatService/chatService.js";
 import { IChatService } from "../chatService/chatService.service.js";
 import { ChatAgentLocation, ChatModeKind } from "../constants.js";
 import { IChatEditingSession } from "../editing/chatEditingService.js";
@@ -20,6 +20,45 @@ import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools
 import { IChatAgentService } from "../participants/chatAgents.service.js";
 import { IParsedChatRequest } from "../requestParser/chatParserTypes.js";
 import { ObjectMutationLog } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/model/objectMutationLog";
+/**
+ * Represents a queued chat request waiting to be processed.
+ */
+export interface IChatPendingRequest {
+    readonly request: IChatRequestModel;
+    readonly kind: ChatRequestQueueKind;
+    /**
+     * The options that were passed to sendRequest when this request was queued.
+     * userSelectedTools is snapshotted to a static observable at queue time.
+     */
+    readonly sendOptions: IChatSendRequestOptions;
+}
+/**
+ * Serializable version of IChatSendRequestOptions for pending requests.
+ * Excludes observables and non-serializable fields.
+ */
+export interface ISerializableSendOptions {
+    modeInfo?: IChatRequestModeInfo;
+    userSelectedModelId?: string;
+    /** Static snapshot of user-selected tools (not an observable) */
+    userSelectedTools?: UserSelectedTools;
+    location?: ChatAgentLocation;
+    locationData?: IChatLocationData;
+    attempt?: number;
+    noCommandDetection?: boolean;
+    agentId?: string;
+    agentIdSilent?: string;
+    slashCommand?: string;
+    confirmation?: string;
+}
+/**
+ * Serializable representation of a pending chat request.
+ */
+export interface ISerializablePendingRequestData {
+    id: string;
+    request: ISerializableChatRequestData;
+    kind: ChatRequestQueueKind;
+    sendOptions: ISerializableSendOptions;
+}
 export declare const CHAT_ATTACHABLE_IMAGE_MIME_TYPES: Record<string, string>;
 export declare function getAttachableImageExtension(mimeType: string): string | undefined;
 export interface IChatRequestVariableData {
@@ -82,12 +121,12 @@ export interface IChatNotebookEditGroup {
  * Progress kinds that are included in the history of a response.
  * Excludes "internal" types that are included in history.
  */
-export type IChatProgressHistoryResponseContent = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatResponseCodeblockUriPart | IChatTreeData | IChatMultiDiffDataSerialized | IChatContentInlineReference | IChatProgressMessage | IChatCommandButton | IChatWarningMessage | IChatTask | IChatTaskSerialized | IChatTextEditGroup | IChatNotebookEditGroup | IChatConfirmation | IChatQuestionCarousel | IChatExtensionsContent | IChatThinkingPart | IChatPullRequestContent | IChatWorkspaceEdit;
+export type IChatProgressHistoryResponseContent = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatResponseCodeblockUriPart | IChatTreeData | IChatMultiDiffDataSerialized | IChatContentInlineReference | IChatProgressMessage | IChatCommandButton | IChatWarningMessage | IChatTask | IChatTaskSerialized | IChatTextEditGroup | IChatNotebookEditGroup | IChatConfirmation | IChatQuestionCarousel | IChatExtensionsContent | IChatThinkingPart | IChatHookPart | IChatPullRequestContent | IChatWorkspaceEdit;
 /**
  * "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;
-export type IChatProgressResponseContentSerialized = Exclude<IChatProgressResponseContent, IChatToolInvocation | IChatElicitationRequest | IChatTask | IChatMultiDiffData | IChatMcpServersStarting>;
+export type IChatProgressResponseContent = IChatProgressHistoryResponseContent | IChatToolInvocation | IChatToolInvocationSerialized | IChatMultiDiffData | IChatUndoStop | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatClearToPreviousToolInvocation | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatDisabledClaudeHooksPart;
+export type IChatProgressResponseContentSerialized = Exclude<IChatProgressResponseContent, IChatToolInvocation | IChatElicitationRequest | IChatTask | IChatMultiDiffData | IChatMcpServersStarting | IChatDisabledClaudeHooksPart>;
 export declare function toChatHistoryContent(content: ReadonlyArray<IChatProgressResponseContent>): IChatProgressHistoryResponseContent[];
 export type IChatProgressRenderableResponseContent = Exclude<IChatProgressResponseContent, IChatContentInlineReference | IChatAgentMarkdownContentWithVulnerability | IChatResponseCodeblockUriPart>;
 export interface IResponse {
@@ -434,6 +473,8 @@ export interface IChatModel extends IDisposable {
     readonly contributedChatSession: IChatSessionContext | undefined;
     readonly repoData: IExportableRepoData | undefined;
     setRepoData(data: IExportableRepoData | undefined): void;
+    readonly onDidChangePendingRequests: Event<void>;
+    getPendingRequests(): readonly IChatPendingRequest[];
 }
 export interface ISerializableChatsData {
     [sessionId: string]: ISerializableChatData;
@@ -455,7 +496,7 @@ interface ISerializableChatResponseData {
     codeCitations?: ReadonlyArray<IChatCodeCitation>;
     timeSpentWaiting?: number;
 }
-export type SerializedChatResponsePart = IMarkdownString | IChatResponseProgressFileTreeData | IChatContentInlineReference | IChatAgentMarkdownContentWithVulnerability | IChatThinkingPart | IChatProgressResponseContentSerialized;
+export type SerializedChatResponsePart = IMarkdownString | IChatResponseProgressFileTreeData | IChatContentInlineReference | IChatAgentMarkdownContentWithVulnerability | IChatThinkingPart | IChatProgressResponseContentSerialized | IChatQuestionCarousel | IChatDisabledClaudeHooksPart;
 export interface ISerializableChatRequestData extends ISerializableChatResponseData {
     requestId: string;
     message: string | IParsedChatRequest;
@@ -583,6 +624,8 @@ export interface ISerializableChatData3 extends Omit<ISerializableChatData2, "ve
     /** Current draft input state (added later, fully backwards compatible) */
     inputState?: ISerializableChatModelInputState;
     repoData?: IExportableRepoData;
+    /** Pending requests that were queued but not yet processed */
+    pendingRequests?: ISerializablePendingRequestData[];
 }
 /**
  * Input model for managing chat input state independently from the chat model.
@@ -749,6 +792,9 @@ export declare class ChatModel extends Disposable implements IChatModel {
     readonly onDidDispose: Event<void>;
     private readonly _onDidChange;
     readonly onDidChange: Event<IChatChangeEvent>;
+    private readonly _pendingRequests;
+    private readonly _onDidChangePendingRequests;
+    readonly onDidChangePendingRequests: Event<void>;
     private _requests;
     private _contributedChatSession;
     get contributedChatSession(): IChatSessionContext | undefined;
@@ -756,6 +802,28 @@ export declare class ChatModel extends Disposable implements IChatModel {
     private _repoData;
     get repoData(): IExportableRepoData | undefined;
     setRepoData(data: IExportableRepoData | undefined): void;
+    getPendingRequests(): readonly IChatPendingRequest[];
+    setPendingRequests(requests: readonly {
+        requestId: string;
+        kind: ChatRequestQueueKind;
+    }[]): void;
+    /**
+     * @internal Used by ChatService to add a request to the queue.
+     * Steering messages are placed before queued messages.
+     */
+    addPendingRequest(request: ChatRequestModel, kind: ChatRequestQueueKind, sendOptions: IChatSendRequestOptions): IChatPendingRequest;
+    /**
+     * @internal Used by ChatService to remove a pending request
+     */
+    removePendingRequest(id: string): void;
+    /**
+     * @internal Used by ChatService to dequeue the next pending request
+     */
+    dequeuePendingRequest(): IChatPendingRequest | undefined;
+    /**
+     * @internal Used by ChatService to clear all pending requests
+     */
+    clearPendingRequests(): void;
     readonly lastRequestObs: IObservable<IChatRequestModel | undefined>;
     private readonly _sessionId;
     /** @deprecated Use {@link sessionResource} instead */
@@ -802,8 +870,14 @@ export declare class ChatModel extends Disposable implements IChatModel {
     private currentEditedFileEvents;
     notifyEditingAction(action: IChatEditingSessionAction): void;
     private _deserialize;
+    private _deserializeRequest;
     private reviveVariableData;
     private getParsedRequestFromString;
+    /**
+     * Hydrates pending requests from serialized data.
+     * For each serialized pending request, finds the matching request model and adds it to the pending queue.
+     */
+    private _deserializePendingRequests;
     getRequests(): ChatRequestModel[];
     resetCheckpoint(): void;
     setCheckpoint(requestId: string | undefined): void;
@@ -828,6 +902,11 @@ export declare function updateRanges(variableData: IChatRequestVariableData, dif
 export declare function canMergeMarkdownStrings(md1: IMarkdownString, md2: IMarkdownString): boolean;
 export declare function appendMarkdownString(md1: IMarkdownString, md2: IMarkdownString | string): IMarkdownString;
 export declare function getCodeCitationsMessage(citations: ReadonlyArray<IChatCodeCitation>): string;
+/**
+ * Converts IChatSendRequestOptions to a serializable format by extracting only
+ * serializable fields and converting observables to static values.
+ */
+export declare function serializeSendOptions(options: IChatSendRequestOptions): ISerializableSendOptions;
 export declare enum ChatRequestEditedFileEventKind {
     Keep = 1,
     Undo = 2,