@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -1,15 +1,46 @@
 
-import { StorageScope } from '../../../../platform/storage/common/storage.js';
+import { StorageScope, StorageTarget } from '../../../../platform/storage/common/storage.js';
 import { ChatContextKeys } from './actions/chatContextKeys.js';
-import { COPILOT_VENDOR_ID } from './languageModels.js';
+import './languageModels.js';
 
 const SELECTED_MODEL_STORAGE_KEY_PREFIX = 'chat.currentLanguageModel.';
-function getSelectedModelStorageKey(location, sessionType) {
-    if (sessionType) {
-        return `${SELECTED_MODEL_STORAGE_KEY_PREFIX}${location}.${sessionType}`;
+const SELECTED_MODEL_STORAGE_SCOPE = StorageScope.PROFILE;
+const SELECTED_MODEL_STORAGE_TARGET = StorageTarget.USER;
+function getSelectedModelStorageKey(location, modelTarget) {
+    if (modelTarget) {
+        return `${SELECTED_MODEL_STORAGE_KEY_PREFIX}${location}.${modelTarget}`;
     }
     return `${SELECTED_MODEL_STORAGE_KEY_PREFIX}${location}`;
 }
+function storeSelectedModel(storageService, location, modelTarget, identifier) {
+    storageService.store(getSelectedModelStorageKey(location, modelTarget), identifier, SELECTED_MODEL_STORAGE_SCOPE, SELECTED_MODEL_STORAGE_TARGET);
+}
+function getStoredSelectedModel(storageService, location, modelTarget) {
+    const key = getSelectedModelStorageKey(location, modelTarget);
+    const isDefaultKey = `${key}.isDefault`;
+    const identifier = storageService.get(key, SELECTED_MODEL_STORAGE_SCOPE);
+    if (identifier) {
+        const wasAutomaticDefault = storageService.getBoolean(isDefaultKey, SELECTED_MODEL_STORAGE_SCOPE);
+        storageService.remove(isDefaultKey, SELECTED_MODEL_STORAGE_SCOPE);
+        if (wasAutomaticDefault) {
+            storageService.remove(key, SELECTED_MODEL_STORAGE_SCOPE);
+            return undefined;
+        }
+        return identifier;
+    }
+    const legacyIdentifier = storageService.get(key, StorageScope.APPLICATION);
+    if (!legacyIdentifier) {
+        return undefined;
+    }
+    const wasAutomaticDefault = storageService.getBoolean(isDefaultKey, StorageScope.APPLICATION, true);
+    storageService.remove(key, StorageScope.APPLICATION);
+    storageService.remove(isDefaultKey, StorageScope.APPLICATION);
+    if (wasAutomaticDefault) {
+        return undefined;
+    }
+    storeSelectedModel(storageService, location, modelTarget, legacyIdentifier);
+    return legacyIdentifier;
+}
 function getSelectedModelIdentifier(contextKeyService, storageService) {
     const contextKeyModelId = contextKeyService.getContextKeyValue(ChatContextKeys.chatModelId.key);
     if (contextKeyModelId) {
@@ -21,55 +52,18 @@ function getPersistedSelectedModelIdentifier(contextKeyService, storageService)
     const location = contextKeyService.getContextKeyValue(ChatContextKeys.location.key) ?? 'panel';
     const sessionType = contextKeyService.getContextKeyValue(ChatContextKeys.chatSessionType.key) ?? '';
     const candidateKeys = sessionType
-        ? [getSelectedModelStorageKey(location, sessionType), getSelectedModelStorageKey(location)]
-        : [getSelectedModelStorageKey(location)];
-    for (const key of candidateKeys) {
-        const persisted = storageService.get(key, StorageScope.APPLICATION);
+        ? [sessionType, undefined]
+        : [undefined];
+    for (const modelTarget of candidateKeys) {
+        const persisted = getStoredSelectedModel(storageService, location, modelTarget);
         if (persisted) {
             return persisted;
         }
     }
     return undefined;
 }
-function getSelectedModelMetadata(contextKeyService, storageService, languageModelsService) {
-    const modelId = getSelectedModelIdentifier(contextKeyService, storageService);
-    if (!modelId) {
-        return undefined;
-    }
-    const direct = languageModelsService.lookupLanguageModel(modelId);
-    if (direct) {
-        return direct;
-    }
-    const persistedId = getPersistedSelectedModelIdentifier(contextKeyService, storageService);
-    if (persistedId && persistedId !== modelId) {
-        return languageModelsService.lookupLanguageModel(persistedId);
-    }
-    return undefined;
-}
-function getSelectedModelVendor(contextKeyService, storageService, languageModelsService) {
-    const metadata = getSelectedModelMetadata(contextKeyService, storageService, languageModelsService);
-    if (metadata) {
-        return metadata.vendor;
-    }
-    const modelId = getSelectedModelIdentifier(contextKeyService, storageService);
-    if (modelId?.includes('/')) {
-        return modelId.split('/')[0];
-    }
-    return undefined;
-}
 function isByokModel(metadata) {
-    return metadata.isBYOK === true;
-}
-function isSelectedModelCopilot(contextKeyService, storageService, languageModelsService) {
-    const metadata = getSelectedModelMetadata(contextKeyService, storageService, languageModelsService);
-    if (metadata) {
-        return !isByokModel(metadata);
-    }
-    const vendor = getSelectedModelVendor(contextKeyService, storageService, languageModelsService);
-    if (!vendor) {
-        return true;
-    }
-    return vendor === COPILOT_VENDOR_ID;
+    return metadata.isBYOK === true || metadata.byokModelIdentifier !== undefined;
 }
 
-export { SELECTED_MODEL_STORAGE_KEY_PREFIX, getPersistedSelectedModelIdentifier, getSelectedModelIdentifier, getSelectedModelMetadata, getSelectedModelStorageKey, getSelectedModelVendor, isByokModel, isSelectedModelCopilot };
+export { SELECTED_MODEL_STORAGE_KEY_PREFIX, SELECTED_MODEL_STORAGE_SCOPE, SELECTED_MODEL_STORAGE_TARGET, getPersistedSelectedModelIdentifier, getSelectedModelIdentifier, getSelectedModelStorageKey, getStoredSelectedModel, isByokModel, storeSelectedModel };

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

@@ -18,13 +18,14 @@ import { IWorkspaceSymbol } from "../../../search/common/search.js";
 import { IChatRequestVariableEntry } from "../attachments/chatVariableEntries.js";
 import { IChatRequestVariableValue } from "../attachments/chatVariables.js";
 import { ReadonlyChatSessionOptionsMap } from "../chatSessionsService.js";
-import { ChatAgentLocation, ChatModeKind } from "../constants.js";
-import { IChatModel, IChatRequestModeInfo, IChatResponseModel } from "../model/chatModel.js";
+import { ChatAgentLocation, SessionTypeSelectionReason, ChatModeKind } from "../constants.js";
+import { IChatModel, IChatRequestModeInfo, IChatRequestVariableData, IChatResponseModel } from "../model/chatModel.js";
 import { IChatAgentCommand, IChatAgentData, IChatAgentResult, UserSelectedTools } from "../participants/chatAgents.js";
 import { HookTypeValue } from "../promptSyntax/hookTypes.js";
+import { IParsedChatRequest } from "../requestParser/chatParserTypes.js";
 import { IChatParserContext } from "../requestParser/chatRequestParser.js";
 import { IPreparedToolInvocation, IToolConfirmationMessages, IToolResult, IToolResultInputOutputDetails, ToolDataSource } from "../tools/languageModelToolsService.js";
-import { ConfirmationOptionKind } from "../../../../../platform/agentHost/common/state/protocol/state.js";
+import { ConfirmationOptionKind, type McpOAuthClient } from "../../../../../platform/agentHost/common/state/protocol/state.js";
 export interface IChatRequest {
     message: string;
     variables: Record<string, IChatRequestVariableValue[]>;
@@ -38,6 +39,10 @@ export interface IChatResponseErrorDetailsConfirmationButton {
     data: any;
     label: string;
     isSecondary?: boolean;
+    /** Replace and resend the request associated with this response instead of adding a new request. */
+    resend?: boolean;
+    /** Reuse the existing request model and identifier when resending. */
+    preserveRequestId?: boolean;
 }
 export interface IChatResponseErrorDetails {
     message: string;
@@ -121,12 +126,43 @@ export interface IChatUsagePromptTokenDetail {
     label: string;
     percentageOfPrompt: number;
 }
+/**
+ * Whole-turn token consumption attributed to a single model. Unlike
+ * {@link IChatUsage.promptTokens}, which describes only the most recent model
+ * call, these are sums across every model call the response made — including
+ * calls made by subagents, which may run on a different model.
+ */
+export interface IChatUsageModelTotal {
+    readonly model: string;
+    readonly inputTokens: number;
+    readonly cachedTokens: number;
+    readonly outputTokens: number;
+}
 export interface IChatUsage {
     promptTokens: number;
     completionTokens: number;
     outputBuffer?: number;
     promptTokenDetails?: readonly IChatUsagePromptTokenDetail[];
+    /**
+     * The Copilot credit cost of whatever this usage describes — a turn's own
+     * cost on a response's usage, a sub-agent's component cost on a sub-agent's.
+     * Scoped to its container, so summing it across responses is only ever a
+     * lower bound on the session; prefer {@link sessionCopilotCredits} for that.
+     */
     copilotCredits?: number;
+    /**
+     * Whole-turn token consumption per model, when the provider reports it.
+     * Only agent host sessions supply this today.
+     */
+    modelTotals?: readonly IChatUsageModelTotal[];
+    /**
+     * The whole session's Copilot credit cost as reported by the backend, rather
+     * than summed from the individual turns. Unlike {@link copilotCredits} this
+     * deliberately describes more than its container: it is authoritative when
+     * present, and covers work billed outside any turn (e.g. a compaction that
+     * ran between turns). Not every backend reports it.
+     */
+    sessionCopilotCredits?: number;
     /**
      * The language-model ID that actually served the request. Set when a
      * meta-model (e.g. "auto") routes to a concrete model so consumers
@@ -139,6 +175,11 @@ export interface IChatUsage {
  * Formats a copilot credit value for display.
  */
 export declare function formatCopilotCredits(credits: number): string;
+/**
+ * Formats a credit value as a pluralized label such as "1 credit" or "2.5 credits".
+ * Shared so every credit readout agrees.
+ */
+export declare function formatCopilotCreditsLabel(credits: number): string;
 export interface IChatContentInlineReference {
     resolveId?: string;
     inlineReference: URI | Location | IWorkspaceSymbol;
@@ -194,10 +235,31 @@ export interface IChatProgressMessage {
     content: IMarkdownString;
     kind: "progressMessage";
     shimmer?: boolean;
+    /**
+     * Stable identity for a progress message that is updated over time. When
+     * set, a later message with the same id replaces this one instead of being
+     * appended, so live progress doesn't stack up rows.
+     */
+    id?: string;
 }
 export interface IChatSystemNotificationPart {
     content: IMarkdownString;
     kind: "systemNotification";
+    /**
+     * Icon shown beside the notification. Defaults to a check, which only suits
+     * notifications that report something completing.
+     */
+    icon?: ThemeIcon;
+    /** Render the first line as an always-visible summary and the remaining Markdown as collapsible details. */
+    collapsible?: boolean;
+    /** Render response timing beside the notification instead of using the response footer. */
+    renderInlineTiming?: boolean;
+    /** Use a quiet transcript boundary treatment instead of a progress row. */
+    presentation?: "workspaceTransition";
+    /** Workspace folder name emphasized by the transition presentation. */
+    workspaceName?: string;
+    /** Complete accessible description for non-visual presentation and announcements. */
+    accessibilityLabel?: string;
 }
 export interface IChatTask extends IChatTaskDto {
     deferred: DeferredPromise<string | void>;
@@ -396,12 +458,18 @@ export interface IChatQuestionCarousel {
     data?: IChatQuestionAnswers;
     /** Whether the carousel has been submitted/skipped */
     isUsed?: boolean;
+    /** True when accepted/answered outside the carousel UI, such as by voice or automatic reply. */
+    answeredExternally?: boolean;
+    /** True when Copilot supplied the answer through automatic reply. */
+    autoReply?: 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;
     /** Terminal ID when the carousel was triggered by a terminal needing input */
     terminalId?: string;
+    /** Visual treatment for the answered state. */
+    answerPresentation?: "conversation";
     kind: "questionCarousel";
 }
 export declare enum ElicitationState {
@@ -448,22 +516,22 @@ export interface IChatThinkingPart {
         readonly [key: string]: any;
     };
     generatedTitle?: string;
+    /** Elapsed reasoning time in milliseconds, persisted so the duration survives reload. */
+    reasoningDurationMs?: number;
 }
 /**
- * A progress part representing an auto-mode model routing resolution.
- * Shown as a collapsible widget in the chat stream: collapsed displays
- * "Routed to <model>", expanded shows routing details and confidence.
+ * Explains what the "Auto" model routed a turn to, as a single status line.
+ *
+ * A resolved part replaces the row that is still routing; Auto can route more
+ * than once per turn, and each later route gets its own row.
  */
 export interface IChatAutoModeResolutionPart {
     kind: "autoModeResolution";
-    /** The model ID that was selected by the router */
-    resolvedModel: string;
-    /** The user-facing display name of the resolved model */
-    resolvedModelName: string;
-    /** The router's classification label */
-    predictedLabel: "needs_reasoning" | "no_reasoning" | "fallback";
-    /** Confidence score (0-1) from the router */
-    confidence: number;
+    /** The model the router picked, or `undefined` while routing is in flight. */
+    resolved?: {
+        readonly id: string;
+        readonly name: string;
+    };
 }
 /**
  * A progress part representing the execution result of a hook.
@@ -486,6 +554,12 @@ export interface IChatHookPart {
     /** If set, this hook was executed within a subagent invocation and should be grouped with it. */
     subAgentInvocationId?: string;
 }
+export type ChatVoiceProgressStage = "investigating" | "planning" | "editing" | "validating" | "recovering";
+export interface IChatVoiceProgressPart {
+    readonly kind: "voiceProgress";
+    readonly id: ChatVoiceProgressStage;
+    readonly value: string;
+}
 export interface IChatTerminalToolInvocationData {
     kind: "terminal";
     commandLine: {
@@ -495,6 +569,17 @@ export interface IChatTerminalToolInvocationData {
         forDisplay?: string;
         isSandboxWrapped?: boolean;
     };
+    /**
+     * Whether the user may edit the command before confirming.
+     *
+     * Omitted means editable, the historical behavior for the built-in terminal
+     * tool, which runs `commandLine.userEdited` when it is set. A producer whose
+     * confirmation does not return the edit — an agent-host session, whose edit
+     * would have to travel back as `chat/toolCallConfirmed.editedToolInput` —
+     * MUST set `false`. Letting someone edit a command they are approving and
+     * then running the original is worse than showing it read-only.
+     */
+    editable?: boolean;
     /**
      * LM-generated intention describing why the command is being run, shown
      * above the command in the terminal tool card. Set by the Agent Host; the
@@ -531,10 +616,14 @@ export interface IChatTerminalToolInvocationData {
     alternativeRecommendation?: string;
     language: string;
     terminalToolSessionId?: string;
+    /** False for output-only data that must not create a workbench terminal instance. */
+    isPty?: boolean;
     /** The predefined command ID that will be used for this terminal command */
     terminalCommandId?: string;
     /** Whether the terminal command was started as a background execution */
     isBackground?: boolean;
+    /** Whether adding a persistent terminal auto-approve rule can suppress future prompts for this confirmation. */
+    autoApproveRuleResolvable?: boolean;
     /** Whether the command was explicitly approved to run outside the sandbox */
     requestUnsandboxedExecution?: boolean;
     /** The model-provided reason for requesting sandbox bypass */
@@ -606,6 +695,8 @@ export type ChatMcpAppData = {
     kind: "agentHost";
     /** URI of the UI resource for rendering (e.g., "ui://weather-server/dashboard") */
     resourceUri: string;
+    /** Sanitized connection identifier used to resolve App-provided resource URIs. */
+    connectionAuthority: string;
     /** AHP `mcp://` channel URI for the originating server. */
     channel: string;
     /**
@@ -623,6 +714,21 @@ export interface IChatToolInputInvocationData {
     rawInput: any;
     /** Optional MCP App UI metadata for rendering during and after tool execution */
     mcpAppData?: ChatMcpAppData;
+    /**
+     * Whether the user may edit {@link rawInput} before confirming.
+     *
+     * Omitted means editable, the historical behavior: the confirmation editor
+     * writes back into `rawInput`, and for an extension-contributed tool
+     * `ILanguageModelToolsService` then invokes it with that value as its
+     * parameters. That path always honours an edit, which is why no opt-out
+     * existed before.
+     *
+     * A producer whose confirmation does not run through it — an agent-host
+     * session, whose edit would have to travel back as
+     * `chat/toolCallConfirmed.editedToolInput` — MUST set `false`. Inviting an
+     * edit and then running the original is worse than showing none.
+     */
+    editable?: boolean;
 }
 export declare enum ToolConfirmKind {
     Denied = 0,
@@ -650,9 +756,17 @@ export type ConfirmedReason = {
 } | {
     type: ToolConfirmKind.Skipped;
 };
+/**
+ * Active-only controls for a tool call executing on another connected client.
+ */
+export interface IChatToolInvocationOtherClientData {
+    readonly cancel: () => void;
+}
 export interface IChatToolInvocation {
     readonly presentation: IPreparedToolInvocation["presentation"];
-    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData;
+    readonly toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData | IChatSessionCreatedData | IChatGeneratedImageData | IChatAutomationConfigurationData | IChatAutomationConfiguredData;
+    /** Active-only metadata that is omitted when the invocation is serialized. */
+    readonly otherClientToolCall?: IChatToolInvocationOtherClientData;
     /**
      * Observable that tracks the `kind` of `toolSpecificData`. Used by the
      * tool invocation part to re-render when the kind changes (e.g. from
@@ -681,7 +795,8 @@ export declare namespace IChatToolInvocation {
         Executing = 2,
         WaitingForPostApproval = 3,
         Completed = 4,
-        Cancelled = 5
+        Cancelled = 5,
+        WaitingForAuthentication = 6
     }
     interface IChatToolInvocationStateBase {
         type: StateKind;
@@ -712,6 +827,11 @@ export declare namespace IChatToolInvocation {
             progress: number | undefined;
         }>;
     }
+    export interface IChatToolInvocationWaitingForAuthenticationState extends IChatToolInvocationStateBase, IChatToolInvocationPostConfirmState {
+        type: StateKind.WaitingForAuthentication;
+        readonly server: IChatMcpAuthenticationRequiredServer;
+        cancel(): void;
+    }
     interface IChatToolInvocationPostExecuteState extends IChatToolInvocationPostConfirmState {
         resultDetails: IToolResult["toolResultDetails"];
     }
@@ -731,12 +851,12 @@ export declare namespace IChatToolInvocation {
         /** Optional message explaining why the tool was cancelled (e.g., from hook denial) */
         reasonMessage?: string | IMarkdownString;
     }
-    export type State = IChatToolInvocationStreamingState | IChatToolInvocationWaitingForConfirmationState | IChatToolInvocationExecutingState | IChatToolWaitingForPostApprovalState | IChatToolInvocationCompleteState | IChatToolInvocationCancelledState;
+    export type State = IChatToolInvocationStreamingState | IChatToolInvocationWaitingForConfirmationState | IChatToolInvocationExecutingState | IChatToolInvocationWaitingForAuthenticationState | IChatToolWaitingForPostApprovalState | IChatToolInvocationCompleteState | IChatToolInvocationCancelledState;
     export function executionConfirmedOrDenied(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): ConfirmedReason | undefined;
     export function awaitConfirmation(invocation: IChatToolInvocation, token?: CancellationToken): Promise<ConfirmedReason>;
     export function confirmWith(invocation: IChatToolInvocation | undefined, reason: ConfirmedReason): boolean;
     export function awaitPostConfirmation(invocation: IChatToolInvocation, token?: CancellationToken): Promise<ConfirmedReason>;
-    export function resultDetails(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): IToolResultInputOutputDetails | import("../tools/languageModelToolsService.js").IToolResultOutputDetails | (URI | Location)[] | IToolResultOutputDetailsSerialized | undefined;
+    export function resultDetails(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): (Location | URI)[] | IToolResultInputOutputDetails | import("../tools/languageModelToolsService.js").IToolResultOutputDetails | IToolResultOutputDetailsSerialized | undefined;
     export function isComplete(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean;
     export function isEffectivelyHidden(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean;
     export function isStreaming(invocation: IChatToolInvocation | IChatToolInvocationSerialized, reader?: IReader): boolean;
@@ -762,7 +882,7 @@ export interface IToolResultOutputDetailsSerialized {
  */
 export interface IChatToolInvocationSerialized {
     presentation: IPreparedToolInvocation["presentation"];
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData;
+    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent | IChatSubagentToolInvocationData | IChatSimpleToolInvocationData | IChatSearchToolInvocationData | IChatToolResourcesInvocationData | IChatModifiedFilesConfirmationData | IChatAgentFeedbackReviewConfirmationData | IChatSessionCreatedData | IChatGeneratedImageData | IChatAutomationConfiguredData;
     invocationMessage: string | IMarkdownString;
     originMessage: string | IMarkdownString | undefined;
     pastTenseMessage: string | IMarkdownString | undefined;
@@ -797,21 +917,33 @@ export interface IChatPullRequestContent {
 }
 export interface IChatSubagentToolInvocationData {
     kind: "subagent";
+    /** Whether the child has reported a turn; false defers its entry, while undefined preserves legacy publication. */
+    hasStarted?: boolean;
     isActive?: boolean;
+    activity?: "markdown" | "reasoning";
     description?: string;
+    /** Provider-supplied display name for the subagent type. */
+    agentDisplayName?: string;
+    /** Internal identifier for the subagent type. */
     agentName?: string;
     prompt?: string;
     result?: string;
     modelName?: string;
     credits?: number;
+    /** Millisecond timestamp when the subagent's first turn started. */
+    startedAt?: number;
+    /** Final elapsed duration in milliseconds. Set when the subagent stops. */
+    duration?: number;
     /**
-     * Resource (URI string) of the subagent's own chat, when the subagent runs as
-     * a distinct chat (e.g. an agent host worker chat). Used to offer an "Open
-     * chat" link that reveals the subagent's read-only chat. Undefined when the
-     * subagent has no separately-openable chat. A string (not a `URI`) so it stays
-     * serializable across the extension host protocol.
+     * Serializable URI of a distinct subagent chat, including a prospective URI; undefined when no target is known.
+     * Presence does not imply readiness: use {@link isChatAvailable} to gate navigation.
      */
     chatResource?: string;
+    /**
+     * `true` means the provider reports the chat available; `false` means it is not yet or no longer available.
+     * `undefined` preserves legacy navigation behavior based on the resource and opener.
+     */
+    isChatAvailable?: boolean;
 }
 /**
  * Progress type for external tool invocation updates from extensions.
@@ -850,11 +982,57 @@ export interface IChatToolResourcesInvocationData {
     readonly kind: "resources";
     readonly values: Array<URI | Location>;
 }
+/**
+ * Tool-specific data for a completed `create_session`, `create_chat`, or
+ * `send_message` agent-host tool call. Carries a clickable link so the renderer
+ * can show the target title without relying on the model to echo a markdown link.
+ */
+export interface IChatSessionCreatedData {
+    readonly kind: "sessionCreated";
+    /** The `agent-host-session://` link that opens the created/owning session. */
+    readonly openLink: string;
+    /** The session title / prompt shown as the link label. */
+    readonly label: string;
+    /** The unabbreviated session title / prompt shown when hovering over the link. */
+    readonly fullTitle?: string;
+    /** Whether the link targets a specific chat rather than its owning session. */
+    readonly isChat?: boolean;
+}
+/**
+ * Marks a successful image-generation tool result as a durable response
+ * outcome. The image bytes remain in the invocation's result details so they
+ * can use the shared image preview, carousel, and save affordances.
+ */
+export interface IChatGeneratedImageData {
+    readonly kind: "generatedImage";
+}
+/**
+ * Tool-specific data for a completed automation create or update. The stable
+ * automation ID lets the renderer open the Automations editor at the affected
+ * entry without relying on model-authored prose.
+ */
+export interface IChatAutomationConfiguredData {
+    readonly kind: "automationConfigured";
+    readonly automationId: string;
+    readonly automationName: string;
+    readonly operation: "created" | "updated";
+}
+/**
+ * Transient preparation data used to guard an automation update across the
+ * confirmation boundary. It is omitted from serialized chat invocations.
+ */
+export interface IChatAutomationConfigurationData {
+    readonly kind: "automationConfiguration";
+    readonly expectedAutomationId: string;
+    readonly expectedEditableState: string;
+}
 export interface IChatModifiedFilesConfirmationData {
     readonly kind: "modifiedFilesConfirmation";
     readonly options: readonly string[];
     readonly modifiedFiles: readonly {
         readonly uri: UriComponents;
+        /** The pending file operation represented by this entry. */
+        readonly editKind?: ChatExternalEditKind;
         readonly originalUri?: UriComponents;
         /**
          * Optional URI to read the modified (after) content from for the diff
@@ -898,25 +1076,39 @@ export interface IChatAgentFeedbackReviewComment {
     /** The file the comment is anchored to. */
     readonly fileUri: UriComponents;
 }
+/**
+ * Links a pull request review thread to the reviewable comment that mirrors it,
+ * so a renderer showing GitHub threads can reveal the local comment. Produced by
+ * {@link AgentFeedbackReviewCommandId.GetPullRequestThreadLinks}.
+ */
+export interface IChatAgentFeedbackPullRequestThreadLink {
+    /** GitHub review thread id the comment mirrors. */
+    readonly pullRequestThreadId: string;
+    /** Comment id to pass to {@link AgentFeedbackReviewCommandId.Reveal}. */
+    readonly commentId: string;
+}
 /**
  * Command ids the agent feedback review confirmation renderer (workbench/chat)
  * uses to fetch unreviewed comments and apply the user's selection. They are
  * implemented by the agent feedback feature in `vs/sessions`, keeping the chat
- * layer decoupled from the feedback model. Most take the owning session resource
- * (`UriComponents`) as their first argument; {@link AgentFeedbackReviewCommandId.RevealAt}
- * instead resolves the session from the file resource so a rendered tool call
- * can link to a comment without knowing the session URI.
+ * layer decoupled from the feedback model. Most take the rendered session or chat
+ * resource (`UriComponents`) as their first argument and resolve it to the owning
+ * session; {@link AgentFeedbackReviewCommandId.RevealAt} instead resolves the
+ * session from the file resource so a rendered tool call can link to a comment
+ * without knowing the session URI.
  */
 export declare enum AgentFeedbackReviewCommandId {
-    /** `(sessionResource)` -> `IChatAgentFeedbackReviewComment[]` (the `created` reviewable comments). */
+    /** `(sessionOrChatResource)` -> `IChatAgentFeedbackReviewComment[]` (the `created` reviewable comments). */
     GetComments = "_agentFeedbackReview.getComments",
-    /** `(sessionResource, commentId)` -> opens the file and reveals the comment. */
+    /** `(sessionOrChatResource)` -> `IChatAgentFeedbackPullRequestThreadLink[]` for comments mirrored from a pull request review thread. */
+    GetPullRequestThreadLinks = "_agentFeedbackReview.getPullRequestThreadLinks",
+    /** `(sessionOrChatResource, commentId)` -> opens the file and reveals the comment. */
     Reveal = "_agentFeedbackReview.reveal",
     /** `(resourceUri, range)` -> resolves the owning session and reveals the comment at that file range. */
     RevealAt = "_agentFeedbackReview.revealAt",
-    /** `(sessionResource, commentId)` -> deletes the comment entirely. */
+    /** `(sessionOrChatResource, commentId)` -> deletes the comment entirely. */
     Delete = "_agentFeedbackReview.delete",
-    /** `(sessionResource, commentIds)` -> accepts (reveals) the given comments. */
+    /** `(sessionOrChatResource, commentIds)` -> accepts (reveals) the given comments. */
     Accept = "_agentFeedbackReview.accept"
 }
 export interface IChatMcpServersStarting {
@@ -940,7 +1132,9 @@ export interface IChatMcpAuthenticationRequiredServer {
     readonly id: string;
     readonly name: string;
     readonly resource: string;
+    readonly oauthClient?: McpOAuthClient;
     readonly authorizationServers?: readonly string[];
+    readonly supportedScopes?: readonly string[];
     readonly requiredScopes?: readonly string[];
     readonly reason?: string;
 }
@@ -1026,6 +1220,8 @@ export interface IChatPlanReview {
     data?: IChatPlanReviewResult;
     /** Whether the widget has been responded to. */
     isUsed?: boolean;
+    /** Whether the backing plan file changed after this summary was generated. */
+    isOutdated?: boolean;
     /** Source attribution. */
     source?: ToolDataSource;
 }
@@ -1038,7 +1234,7 @@ export declare class ChatMcpServersStarting implements IChatMcpServersStarting {
     wait(): Promise<IAutostartResult>;
     toJSON(): IChatMcpServersStartingSerialized;
 }
-export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatUsage | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatSystemNotificationPart | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatInfoMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatExternalEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatPlanReview | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatMcpAuthenticationRequired | IChatMcpServersStartingSlow | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart | IChatAutoModeResolutionPart;
+export type IChatProgress = IChatMarkdownContent | IChatAgentMarkdownContentWithVulnerability | IChatUsage | IChatTreeData | IChatMultiDiffData | IChatMultiDiffDataSerialized | IChatUsedContext | IChatContentReference | IChatContentInlineReference | IChatCodeCitation | IChatProgressMessage | IChatSystemNotificationPart | IChatTask | IChatTaskResult | IChatCommandButton | IChatWarningMessage | IChatInfoMessage | IChatTextEdit | IChatNotebookEdit | IChatWorkspaceEdit | IChatExternalEdit | IChatMoveMessage | IChatResponseCodeblockUriPart | IChatConfirmation | IChatQuestionCarousel | IChatPlanReview | IChatClearToPreviousToolInvocation | IChatToolInvocation | IChatToolInvocationSerialized | IChatExtensionsContent | IChatPullRequestContent | IChatUndoStop | IChatThinkingPart | IChatVoiceProgressPart | IChatTaskSerialized | IChatElicitationRequest | IChatElicitationRequestSerialized | IChatMcpServersStarting | IChatMcpServersStartingSerialized | IChatMcpAuthenticationRequired | IChatMcpServersStartingSlow | IChatHookPart | IChatExternalToolInvocationUpdate | IChatDisabledClaudeHooksPart | IChatAutoModeResolutionPart;
 export interface IChatFollowup {
     kind: "reply";
     message: string;
@@ -1223,6 +1419,8 @@ export type ChatSendResult = ChatSendResultRejected | ChatSendResultSent | ChatS
 export interface ChatSendResultRejected {
     readonly kind: "rejected";
     readonly reason: string;
+    /** Set when the session was replaced before the request was rejected (e.g. untitled -> read-only contributed session). */
+    readonly newSessionResource?: URI;
 }
 export interface ChatSendResultSent {
     readonly kind: "sent";
@@ -1269,8 +1467,22 @@ export declare enum ChatRequestQueueKind {
     /** Request is queued and signals the active request to yield */
     Steering = "steering"
 }
+/**
+ * A queued or steering message that was authored outside of this client, e.g.
+ * by another window connected to the same server-managed session.
+ */
+export interface IRemotePendingRequest {
+    /** Stable id of the message, as known by the server. */
+    readonly id: string;
+    readonly kind: ChatRequestQueueKind;
+    /** The raw message text. */
+    readonly message: string;
+    readonly variableData?: IChatRequestVariableData;
+    readonly timestamp?: number;
+}
 export interface IChatSendRequestOptions {
     modeInfo?: IChatRequestModeInfo;
+    isVoiceModeInput?: boolean;
     userSelectedModelId?: string;
     /**
      * The configuration (e.g. context size, thinking effort) for the selected
@@ -1290,6 +1502,8 @@ export interface IChatSendRequestOptions {
     attachedContext?: IChatRequestVariableEntry[];
     resolvedVariables?: IChatRequestVariableEntry[];
     agentHostSessionConfig?: Record<string, unknown>;
+    /** Provider-specific request metadata, separate from the prompt. */
+    metadata?: Record<string, unknown>;
     /** 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 */
@@ -1315,6 +1529,8 @@ export interface IChatSendRequestOptions {
      * such as terminal command completion.
      */
     isSystemInitiated?: boolean;
+    /** Hide the request and its response from the transcript while retaining them in history. */
+    hideFromTranscript?: boolean;
     /**
      * Display label for system-initiated requests. When set, the request row renders
      * this label as a compact progress-style message instead of the full request text.
@@ -1338,6 +1554,12 @@ export interface IChatSendRequestOptions {
     };
 }
 export type IChatModelReference = IReference<IChatModel>;
+/** Data from a chat request after submission begins. */
+export interface IChatRequestSubmittedEvent {
+    readonly chatSessionResource: URI;
+    readonly message?: IParsedChatRequest;
+    readonly attachedContext?: IChatRequestVariableEntry[];
+}
 export interface IChatSessionContext {
     readonly initialSessionOptions?: ReadonlyChatSessionOptionsMap;
 }
@@ -1346,6 +1568,7 @@ export interface IChatSessionStartOptions {
     canUseTools?: boolean;
     disableBackgroundKeepAlive?: boolean;
     debugOwner?: string;
+    sessionTypeSelectionReason?: SessionTypeSelectionReason;
 }
 export declare const ChatStopCancellationNoopEventName = "chat.stopCancellationNoop";
 export type ChatStopCancellationNoopEvent = {