@codingame/monaco-vscode-katex-common 34.1.2 → 35.0.0

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

@@ -0,0 +1,110 @@
+import type { ErrorInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { ChatEntitlement } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService";
+import { IChatResponseErrorDetails } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+/**
+ * Mirror of the Copilot extension's `ChatFetchResponseType` (see
+ * `extensions/copilot/src/platform/chat/common/commonTypes.ts`). These string
+ * values are forwarded verbatim from the agent host harnesses (Copilot CLI,
+ * Claude, Codex) over `_meta`, so they MUST stay in sync with the extension.
+ */
+export declare enum ChatFetchResponseType {
+    OffTopic = "offTopic",
+    Canceled = "canceled",
+    Filtered = "filtered",
+    FilteredRetry = "filteredRetry",
+    PromptFiltered = "promptFiltered",
+    Length = "length",
+    RateLimited = "rateLimited",
+    QuotaExceeded = "quotaExceeded",
+    ExtensionBlocked = "extensionBlocked",
+    BadRequest = "badRequest",
+    NotFound = "notFound",
+    Failed = "failed",
+    Unknown = "unknown",
+    NetworkError = "networkError",
+    AgentUnauthorized = "agent_unauthorized",
+    AgentFailedDependency = "agent_failed_dependency",
+    InvalidStatefulMarker = "invalid_stateful_marker",
+    Success = "success"
+}
+/**
+ * Mirror of the Copilot extension's `FilterReason` (see
+ * `extensions/copilot/src/platform/networking/common/openai.ts`).
+ */
+export declare enum FilterReason {
+    Hate = "hate",
+    SelfHarm = "self_harm",
+    Sexual = "sexual",
+    Violence = "violence",
+    Copyright = "snippy",
+    Prompt = "prompt"
+}
+/**
+ * Raw error payload forwarded from an agent host harness. This is the
+ * serialized `ChatFetchError` from the Copilot extension. Because it crosses
+ * the extension/core boundary as untyped JSON inside `_meta`, every field is
+ * optional and consumers type-cast based on `type`.
+ */
+export interface IChatFetchErrorPayload {
+    readonly type: ChatFetchResponseType | string;
+    readonly reason?: string;
+    readonly reasonDetail?: string;
+    readonly requestId?: string;
+    readonly serverRequestId?: string | undefined;
+    readonly category?: FilterReason | string;
+    readonly retryAfter?: number;
+    readonly rateLimitKey?: string;
+    readonly isAuto?: boolean;
+    readonly capiError?: {
+        code?: string;
+        message?: string;
+    };
+}
+/**
+ * The full forwarded chat error payload, including the user-context fields that
+ * the extension would normally read from the Copilot token. This is the value
+ * placed at `_meta.chatError` by the harnesses.
+ */
+export interface IForwardedChatError {
+    readonly fetchError: IChatFetchErrorPayload;
+    readonly copilotPlan?: string;
+    readonly isUsageBasedBilling?: boolean;
+    readonly quotaResetDate?: string;
+}
+export declare function getQuotaMessageForPlan(copilotPlan: string | undefined, isUsageBasedBilling?: boolean, quotaResetDate?: string): string;
+export declare function getFilteredMessage(category: FilterReason | string, supportsMarkdown?: boolean): string;
+/**
+ * Builds the user-facing {@link IChatResponseErrorDetails} from a forwarded raw
+ * chat fetch error. This is the core analog of the Copilot extension's
+ * `getErrorDetailsFromChatFetchError`. Unlike the extension, core has no
+ * access to the GitHub outage status, so the outage note is never appended
+ * (assume no outage).
+ */
+export declare function getChatErrorDetailsFromFetchError(fetchError: IChatFetchErrorPayload, copilotPlan: string | undefined, isUsageBasedBilling?: boolean, quotaResetDate?: string): IChatResponseErrorDetails;
+/**
+ * Extracts and formats {@link IChatResponseErrorDetails} from the `_meta`
+ * forwarded by an agent host harness, if present. Returns `undefined` when no
+ * forwarded chat error is found so callers can fall back to their existing
+ * error handling.
+ *
+ * The agent host does not know the signed-in user's plan, so callers in core
+ * pass an {@link IChatErrorContext} (resolved from `IChatEntitlementService`)
+ * whose fields take precedence over the values forwarded in `_meta`.
+ */
+export declare function getChatErrorDetailsFromMeta(error: ErrorInfo | undefined, context?: IChatErrorContext): IChatResponseErrorDetails | undefined;
+/**
+ * User-context overrides for {@link getChatErrorDetailsFromMeta}. When a field
+ * is set it takes precedence over the value forwarded by the agent host. Core
+ * resolves these from `IChatEntitlementService`.
+ */
+export interface IChatErrorContext {
+    readonly copilotPlan?: string;
+    readonly isUsageBasedBilling?: boolean;
+    readonly quotaResetDate?: string;
+}
+/**
+ * Maps a core {@link ChatEntitlement} to the Copilot plan string understood by
+ * the quota/rate-limit message helpers (mirrors the Copilot extension's
+ * `CopilotToken.copilotPlan` values).
+ */
+export declare function getCopilotPlanFromEntitlement(entitlement: ChatEntitlement): string | undefined;

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

@@ -0,0 +1,37 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/nls';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService';
+import '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+
+var ChatFetchResponseType;
+(function(ChatFetchResponseType) {
+    ChatFetchResponseType["OffTopic"] = "offTopic";
+    ChatFetchResponseType["Canceled"] = "canceled";
+    ChatFetchResponseType["Filtered"] = "filtered";
+    ChatFetchResponseType["FilteredRetry"] = "filteredRetry";
+    ChatFetchResponseType["PromptFiltered"] = "promptFiltered";
+    ChatFetchResponseType["Length"] = "length";
+    ChatFetchResponseType["RateLimited"] = "rateLimited";
+    ChatFetchResponseType["QuotaExceeded"] = "quotaExceeded";
+    ChatFetchResponseType["ExtensionBlocked"] = "extensionBlocked";
+    ChatFetchResponseType["BadRequest"] = "badRequest";
+    ChatFetchResponseType["NotFound"] = "notFound";
+    ChatFetchResponseType["Failed"] = "failed";
+    ChatFetchResponseType["Unknown"] = "unknown";
+    ChatFetchResponseType["NetworkError"] = "networkError";
+    ChatFetchResponseType["AgentUnauthorized"] = "agent_unauthorized";
+    ChatFetchResponseType["AgentFailedDependency"] = "agent_failed_dependency";
+    ChatFetchResponseType["InvalidStatefulMarker"] = "invalid_stateful_marker";
+    ChatFetchResponseType["Success"] = "success";
+})(ChatFetchResponseType || (ChatFetchResponseType = {}));
+var FilterReason;
+(function(FilterReason) {
+    FilterReason["Hate"] = "hate";
+    FilterReason["SelfHarm"] = "self_harm";
+    FilterReason["Sexual"] = "sexual";
+    FilterReason["Violence"] = "violence";
+    FilterReason["Copyright"] = "snippy";
+    FilterReason["Prompt"] = "prompt";
+})(FilterReason || (FilterReason = {}));
+
+export { ChatFetchResponseType, FilterReason };

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

@@ -1,7 +1,9 @@
 import { VSBuffer } from "@codingame/monaco-vscode-api/vscode/vs/base/common/buffer";
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import { IChatResponseViewModel, IChatRequestViewModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatViewModel";
 import { IChatToolInvocation, IChatToolInvocationSerialized } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
+import { type IChatRequestVariableEntry } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/attachments/chatVariableEntries";
 export interface IChatExtractedImage {
     readonly id: string;
     readonly uri: URI;
@@ -9,7 +11,7 @@ export interface IChatExtractedImage {
     readonly mimeType: string;
     readonly data: VSBuffer;
     readonly source: string;
-    readonly caption: string | undefined;
+    readonly caption: string | IMarkdownString | undefined;
 }
 export interface IChatExtractedImageCollection {
     readonly id: string;
@@ -29,3 +31,4 @@ export declare function coerceImageBuffer(value: unknown): Uint8Array | undefine
  * Extract images from a chat request's variable attachments (user-attached images).
  */
 export declare function extractImagesFromChatRequest(request: IChatRequestViewModel): IChatExtractedImage[];
+export declare function extractImagesFromChatVariables(variables: readonly IChatRequestVariableEntry[]): IChatExtractedImage[];

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

@@ -26,7 +26,7 @@ async function extractImagesFromChatResponse(response, readFile) {
         }
     }
     const request = response.session.getItems().find(item => isRequestVM(item) && item.id === response.requestId);
-    const title = request ? request.messageText.trim() || getExplicitFileOrImageAttachmentSummary(request.variables) || ( localize(7922, "Images")) : ( localize(7922, "Images"));
+    const title = request ? request.messageText.trim() || getExplicitFileOrImageAttachmentSummary(request.variables) || ( localize(8522, "Images")) : ( localize(8522, "Images"));
     return {
         id: ( response.sessionResource.toString()) + "_" + response.id,
         title,
@@ -36,8 +36,7 @@ async function extractImagesFromChatResponse(response, readFile) {
 function extractImagesFromToolInvocationOutputDetails(toolInvocation, sessionResource) {
     const images = [];
     const resultDetails = IChatToolInvocation.resultDetails(toolInvocation);
-    const msg = toolInvocation.pastTenseMessage ?? toolInvocation.invocationMessage;
-    const caption = msg ? (typeof msg === "string" ? msg : msg.value) : undefined;
+    const caption = toolInvocation.pastTenseMessage ?? toolInvocation.invocationMessage;
     const pushImage = (mimeType, data, outputIndex) => {
         const ext = getExtensionForMimeType(mimeType);
         const permalinkBasename = ext ? `file${ext}` : "file.bin";
@@ -45,10 +44,10 @@ function extractImagesFromToolInvocationOutputDetails(toolInvocation, sessionRes
         images.push({
             id: `${toolInvocation.toolCallId}_${outputIndex}`,
             uri,
-            name: ( localize(7923, "Image {0}", images.length + 1)),
+            name: ( localize(8523, "Image {0}", images.length + 1)),
             mimeType,
             data,
-            source: ( localize(7924, "Tool: {0}", toolInvocation.toolId)),
+            source: ( localize(8524, "Tool: {0}", toolInvocation.toolId)),
             caption
         });
     };
@@ -93,8 +92,8 @@ async function extractImagesFromToolInvocationMessages(toolInvocation, readFile)
                 name,
                 mimeType,
                 data,
-                source: ( localize(7924, "Tool: {0}", toolInvocation.toolId)),
-                caption: message.value
+                source: ( localize(8524, "Tool: {0}", toolInvocation.toolId)),
+                caption: message
             });
         }
     }
@@ -131,7 +130,7 @@ async function extractImageFromInlineReference(part, readFile) {
         name,
         mimeType: mime,
         data,
-        source: ( localize(7925, "File")),
+        source: ( localize(8525, "File")),
         caption: undefined
     };
 }
@@ -139,8 +138,11 @@ function coerceImageBuffer(value) {
     return value instanceof Uint8Array ? value : value instanceof ArrayBuffer ? ( new Uint8Array(value)) : (value && typeof value === "object" && !Array.isArray(value)) ? ( new Uint8Array(( ( Object.keys(value)).sort((a, b) => Number(a) - Number(b)).map(key => value[key])))) : undefined;
 }
 function extractImagesFromChatRequest(request) {
+    return extractImagesFromChatVariables(request.variables);
+}
+function extractImagesFromChatVariables(variables) {
     const images = [];
-    for (const variable of request.variables) {
+    for (const variable of variables) {
         if (!isImageVariableEntry(variable)) {
             continue;
         }
@@ -160,11 +162,11 @@ function extractImagesFromChatRequest(request) {
             name: variable.name,
             mimeType,
             data: VSBuffer.wrap(buffer),
-            source: ( localize(7926, "Attachment")),
+            source: ( localize(8526, "Attachment")),
             caption: undefined
         });
     }
     return images;
 }
 
-export { coerceImageBuffer, extractImagesFromChatRequest, extractImagesFromChatResponse, extractImagesFromToolInvocationMessages, extractImagesFromToolInvocationOutputDetails };
+export { coerceImageBuffer, extractImagesFromChatRequest, extractImagesFromChatResponse, extractImagesFromChatVariables, extractImagesFromToolInvocationMessages, extractImagesFromToolInvocationOutputDetails };

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

@@ -23,5 +23,12 @@ export declare function hasShownElevatedWarning(level: ChatPermissionLevel, stor
  * When the user ticks "Don't show again", the choice is persisted in
  * `StorageScope.PROFILE`, which is shared across the workbench and Agents
  * windows so a dismissal in one applies to the other.
+ *
+ * `options.defaultSettingKey` controls which "make this the default" setting
+ * the dialog links to — local chat uses `chat.permissions.default` (the
+ * default), while agent-host sessions pass
+ * `chat.defaultConfiguration`.
  */
-export declare function maybeConfirmElevatedPermissionLevel(level: ChatPermissionLevel, dialogService: IDialogService, storageService: IStorageService): Promise<boolean>;
+export declare function maybeConfirmElevatedPermissionLevel(level: ChatPermissionLevel, dialogService: IDialogService, storageService: IStorageService, options?: {
+    readonly defaultSettingKey?: string;
+}): Promise<boolean>;

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

@@ -20,48 +20,84 @@ function dontShowAgainKey(level) {
 function resetShownWarnings() {
     shownWarnings.clear();
 }
+const ELEVATION_RANK = ( new Map([[ChatPermissionLevel.AutoApprove, 1], [ChatPermissionLevel.Autopilot, 1]]));
 function hasShownElevatedWarning(level, storageService) {
-    if (( shownWarnings.has(level))) {
-        return true;
+    const rank = ELEVATION_RANK.get(level);
+    if (rank === undefined) {
+        return false;
     }
-    const key = dontShowAgainKey(level);
-    if (key && storageService.getBoolean(key, StorageScope.PROFILE, false)) {
-        return true;
+    for (const [candidate, candidateRank] of ELEVATION_RANK) {
+        if (candidateRank < rank) {
+            continue;
+        }
+        if (( shownWarnings.has(candidate))) {
+            return true;
+        }
+        const key = dontShowAgainKey(candidate);
+        if (key && storageService.getBoolean(key, StorageScope.PROFILE, false)) {
+            return true;
+        }
     }
     return false;
 }
-async function maybeConfirmElevatedPermissionLevel(level, dialogService, storageService) {
+function getElevatedWarningCopy(level, defaultSettingKey) {
+    switch (level) {
+    case ChatPermissionLevel.Autopilot:
+        return {
+            title: ( localize(8530, "Enable Autopilot?")),
+            confirm: ( localize(8531, "Enable")),
+            icon: Codicon.rocket,
+            detail: ( localize(
+                8532,
+                "Autopilot will auto-approve all tool calls and continue working autonomously until the task is complete. This includes terminal commands, file edits, and external tool calls. The agent will make decisions on your behalf without asking for confirmation.\n\nYou can stop the agent at any time by clicking the stop button. This applies to the current session only.\n\nTo make this the starting permission level for new sessions, change the [{0}](command:workbench.action.openSettings?%5B%22{0}%22%5D) setting.",
+                defaultSettingKey
+            ))
+        };
+    case ChatPermissionLevel.AutoApprove:
+        return {
+            title: ( localize(8533, "Enable Bypass Approvals?")),
+            confirm: ( localize(8534, "Enable")),
+            icon: Codicon.warning,
+            detail: ( localize(
+                8535,
+                "Bypass Approvals will auto-approve all tool calls without asking for confirmation. This includes file edits, terminal commands, and external tool calls.\n\nTo make this the starting permission level for new sessions, change the [{0}](command:workbench.action.openSettings?%5B%22{0}%22%5D) setting.",
+                defaultSettingKey
+            ))
+        };
+    default:
+        return undefined;
+    }
+}
+async function maybeConfirmElevatedPermissionLevel(level, dialogService, storageService, options) {
     const key = dontShowAgainKey(level);
     if (!key || hasShownElevatedWarning(level, storageService)) {
         return true;
     }
-    const isAutopilot = level === ChatPermissionLevel.Autopilot;
+    const copy = getElevatedWarningCopy(
+        level,
+        options?.defaultSettingKey ?? ChatConfiguration.DefaultPermissionLevel
+    );
+    if (!copy) {
+        return true;
+    }
     const result = await dialogService.prompt({
         type: Severity.Warning,
-        message: isAutopilot ? ( localize(7930, "Enable Autopilot?")) : ( localize(7931, "Enable Bypass Approvals?")),
+        message: copy.title,
         buttons: [{
-            label: isAutopilot ? ( localize(7932, "Enable")) : ( localize(7933, "Enable")),
+            label: copy.confirm,
             run: () => true
         }, {
-            label: isAutopilot ? ( localize(7934, "Cancel")) : ( localize(7935, "Cancel")),
+            label: ( localize(8536, "Cancel")),
             run: () => false
         }],
         checkbox: {
-            label: ( localize(7936, "Don't show again")),
+            label: ( localize(8537, "Don't show again")),
             checked: false
         },
         custom: {
-            icon: isAutopilot ? Codicon.rocket : Codicon.warning,
+            icon: copy.icon,
             markdownDetails: [{
-                markdown: ( new MarkdownString(isAutopilot ? ( localize(
-                    7937,
-                    "Autopilot will auto-approve all tool calls and continue working autonomously until the task is complete. This includes terminal commands, file edits, and external tool calls. The agent will make decisions on your behalf without asking for confirmation.\n\nYou can stop the agent at any time by clicking the stop button. This applies to the current session only.\n\nTo make this the starting permission level for new chat sessions, change the [{0}](command:workbench.action.openSettings?%5B%22{0}%22%5D) setting.",
-                    ChatConfiguration.DefaultPermissionLevel
-                )) : ( localize(
-                    7938,
-                    "Bypass Approvals will auto-approve all tool calls without asking for confirmation. This includes file edits, terminal commands, and external tool calls.\n\nTo make this the starting permission level for new chat sessions, change the [{0}](command:workbench.action.openSettings?%5B%22{0}%22%5D) setting.",
-                    ChatConfiguration.DefaultPermissionLevel
-                )), {
+                markdown: ( new MarkdownString(copy.detail, {
                     isTrusted: {
                         enabledCommands: ["workbench.action.openSettings"]
                     }

package/vscode/src/vs/workbench/contrib/chat/common/widget/chatColors.js

@@ -18,45 +18,45 @@ registerColor("agentStatusIndicator.background", {
     light: ( Color.black.transparent(0.05)),
     hcDark: null,
     hcLight: null
-}, ( localize(8394, "Background color of the agent status indicator in the titlebar.")));
+}, ( localize(9011, "Background color of the agent status indicator in the titlebar.")));
 registerColor("chat.requestBorder", {
     dark: ( new Color(( new RGBA(255, 255, 255, 0.10)))),
     light: ( new Color(( new RGBA(0, 0, 0, 0.10)))),
     hcDark: contrastBorder,
     hcLight: contrastBorder
-}, ( localize(8395, "The border color of a chat request.")));
+}, ( localize(9012, "The border color of a chat request.")));
 const chatRequestBackground = registerColor("chat.requestBackground", {
     dark: ( transparent(editorBackground, 0.62)),
     light: ( transparent(editorBackground, 0.62)),
     hcDark: editorWidgetBackground,
     hcLight: null
-}, ( localize(8396, "The background color of a chat request.")));
+}, ( localize(9013, "The background color of a chat request.")));
 const chatSlashCommandBackground = registerColor("chat.slashCommandBackground", {
     dark: "#26477866",
     light: "#adceff7a",
     hcDark: Color.white,
     hcLight: badgeBackground
-}, ( localize(8397, "The background color of a chat slash command.")));
+}, ( localize(9014, "The background color of a chat slash command.")));
 const chatSlashCommandForeground = registerColor("chat.slashCommandForeground", {
     dark: "#85b6ff",
     light: "#26569e",
     hcDark: Color.black,
     hcLight: badgeForeground
-}, ( localize(8398, "The foreground color of a chat slash command.")));
+}, ( localize(9015, "The foreground color of a chat slash command.")));
 registerColor("chat.avatarBackground", {
     dark: "#1f1f1f",
     light: "#f2f2f2",
     hcDark: Color.black,
     hcLight: Color.white
-}, ( localize(8399, "The background color of a chat avatar.")));
-registerColor("chat.avatarForeground", foreground, ( localize(8400, "The foreground color of a chat avatar.")));
+}, ( localize(9016, "The background color of a chat avatar.")));
+registerColor("chat.avatarForeground", foreground, ( localize(9017, "The foreground color of a chat avatar.")));
 registerColor("chat.editedFileForeground", {
     light: "#895503",
     dark: "#E2C08D",
     hcDark: "#E2C08D",
     hcLight: "#895503"
 }, ( localize(
-    8401,
+    9018,
     "The foreground color of a chat edited file in the edited file list."
 )));
 registerColor("chat.requestCodeBorder", {
@@ -64,50 +64,50 @@ registerColor("chat.requestCodeBorder", {
     light: "#0e639c40",
     hcDark: null,
     hcLight: null
-}, ( localize(8402, "Border color of code blocks within the chat request bubble.")), true);
+}, ( localize(9019, "Border color of code blocks within the chat request bubble.")), true);
 registerColor("chat.requestBubbleBackground", {
     light: ( transparent(editorSelectionBackground, 0.3)),
     dark: ( transparent(editorSelectionBackground, 0.3)),
     hcDark: null,
     hcLight: null
-}, ( localize(8403, "Background color of the chat request bubble.")), true);
+}, ( localize(9020, "Background color of the chat request bubble.")), true);
 registerColor("chat.requestBubbleHoverBackground", {
     dark: ( transparent(editorSelectionBackground, 0.6)),
     light: ( transparent(editorSelectionBackground, 0.6)),
     hcDark: null,
     hcLight: null
-}, ( localize(8404, "Background color of the chat request bubble on hover.")), true);
+}, ( localize(9021, "Background color of the chat request bubble on hover.")), true);
 registerColor("chat.checkpointSeparator", {
     dark: "#585858",
     light: "#a9a9a9",
     hcDark: "#a9a9a9",
     hcLight: "#a5a5a5"
-}, ( localize(8405, "Chat checkpoint separator color.")));
+}, ( localize(9022, "Chat checkpoint separator color.")));
 registerColor("chat.linesAddedForeground", {
     dark: "#54B054",
     light: "#107C10",
     hcDark: "#54B054",
     hcLight: "#107C10"
-}, ( localize(8406, "Foreground color of lines added in chat code block pill.")), true);
+}, ( localize(9023, "Foreground color of lines added in chat code block pill.")), true);
 registerColor("chat.linesRemovedForeground", {
     dark: "#FC6A6A",
     light: "#BC2F32",
     hcDark: "#F48771",
     hcLight: "#B5200D"
-}, ( localize(8407, "Foreground color of lines removed in chat code block pill.")), true);
+}, ( localize(9024, "Foreground color of lines removed in chat code block pill.")), true);
 registerColor("chat.thinkingShimmer", {
     dark: "#ffffff",
     light: "#000000",
     hcDark: "#ffffff",
     hcLight: "#000000"
-}, ( localize(8408, "Shimmer highlight for thinking/working labels.")), true);
+}, ( localize(9025, "Shimmer highlight for thinking/working labels.")), true);
 registerColor("chat.inputWorkingBorderColor1", {
     dark: buttonBackground,
     light: buttonBackground,
     hcDark: "#FFFFFF",
     hcLight: "#000000"
 }, ( localize(
-    8409,
+    9026,
     "First color stop of the animated chat input border shown while a request is in flight."
 )), true);
 registerColor("chat.inputWorkingBorderColor2", {
@@ -116,7 +116,7 @@ registerColor("chat.inputWorkingBorderColor2", {
     hcDark: "#A0A0A0",
     hcLight: "#555555"
 }, ( localize(
-    8410,
+    9027,
     "Secondary accent color used by other animated chat input affordances. Not used by the in-flight chat input border."
 )), true);
 registerColor("chat.inputWorkingBorderColor3", {
@@ -125,7 +125,7 @@ registerColor("chat.inputWorkingBorderColor3", {
     hcDark: "#000000",
     hcLight: "#000000"
 }, ( localize(
-    8411,
+    9028,
     "Tertiary accent color used by other animated chat input affordances. Not used by the in-flight chat input border."
 )), true);
 

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatController.js

@@ -266,7 +266,7 @@ let InlineChatController = class InlineChatController {
             }
         }));
         const defaultPlaceholderObs = ( visibleSessionObs.map((session, r) => {
-            return session?.initialSelection.isEmpty() ? ( localize(10714, "Generate code")) : ( localize(10715, "Modify selected code"));
+            return session?.initialSelection.isEmpty() ? ( localize(11330, "Generate code")) : ( localize(11331, "Modify selected code"));
         }));
         this.#store.add(autorun(r => {
             const session = visibleSessionObs.read(r);
@@ -379,7 +379,7 @@ let InlineChatController = class InlineChatController {
                 if (lastProgress) {
                     placeholder = renderAsPlaintext(lastProgress.content);
                 }
-                this.#zone.rawValue?.widget.chatWidget.setInputPlaceholder(placeholder || ( localize(10716, "Working...")));
+                this.#zone.rawValue?.widget.chatWidget.setInputPlaceholder(placeholder || ( localize(11332, "Working...")));
             }
         }));
         this.#store.add(autorun(r => {
@@ -455,7 +455,7 @@ let InlineChatController = class InlineChatController {
                 }
                 if (entries.length > 0) {
                     this.#zone.value.widget.chatWidget.attachmentModel.addContext(...entries);
-                    const msg = entries.length > 1 ? ( localize(10717, "Fix the attached problems")) : ( localize(10718, "Fix the attached problem"));
+                    const msg = entries.length > 1 ? ( localize(11333, "Fix the attached problems")) : ( localize(11334, "Fix the attached problem"));
                     this.#zone.value.widget.chatWidget.input.setValue(msg, true);
                     arg.message = msg;
                     this.#zone.value.widget.chatWidget.inputEditor.setSelection(( new Selection(1, 1, Number.MAX_SAFE_INTEGER, 1)));
@@ -488,7 +488,7 @@ let InlineChatController = class InlineChatController {
                     this.#zone.value.widget.chatWidget.input.setCurrentLanguageModel({
                         metadata: model,
                         identifier: id
-                    });
+                    }, true);
                 }
                 if (arg.message) {
                     this.#zone.value.widget.chatWidget.setInput(arg.message);

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatWidget.js

@@ -257,7 +257,7 @@ let InlineChatWidget = class InlineChatWidget {
         );
         this._store.add(this.#chatService.onDidPerformUserAction(e => {
             if (isEqual(e.sessionResource, this.chatWidget.viewModel?.model.sessionResource) && e.action.kind === "vote") {
-                this.updateStatus(( localize(10725, "Thank you for your feedback!")), {
+                this.updateStatus(( localize(11341, "Thank you for your feedback!")), {
                     resetAfter: 1250
                 });
             }
@@ -270,11 +270,11 @@ let InlineChatWidget = class InlineChatWidget {
             if (this.#configurationService.getValue(AccessibilityVerbositySettingId.InlineChat)) {
                 const kbLabel = this.#keybindingService.lookupKeybinding(AccessibilityCommandId.OpenAccessibilityHelp)?.getLabel();
                 label = kbLabel ? ( localize(
-                    10726,
+                    11342,
                     "Inline Chat Input, Use {0} for Inline Chat Accessibility Help.",
                     kbLabel
                 )) : ( localize(
-                    10727,
+                    11343,
                     "Inline Chat Input, Run the Inline Chat Accessibility Help command for more information."
                 ));
             }
@@ -295,7 +295,7 @@ let InlineChatWidget = class InlineChatWidget {
             this._elements.disclaimerLabel.classList.toggle("hidden", !showDisclaimer);
             if (showDisclaimer) {
                 const renderedMarkdown = disposables.add(this.#markdownRendererService.render(( new MarkdownString(( localize(
-                    10728,
+                    11344,
                     "By continuing with {0} Copilot, you agree to {1}'s [Terms]({2}) and [Privacy Statement]({3})",
                     product.defaultChatAgent?.provider?.default?.name ?? "",
                     product.defaultChatAgent?.provider?.default?.name ?? "",
@@ -417,7 +417,7 @@ let InlineChatWidget = class InlineChatWidget {
     }
 };
 InlineChatWidget = ( __decorate([( __param(2, IInstantiationService)), ( __param(3, IContextKeyService)), ( __param(4, IKeybindingService)), ( __param(5, IAccessibilityService)), ( __param(6, IConfigurationService)), ( __param(7, IAccessibleViewService)), ( __param(8, ITextModelService)), ( __param(9, IChatService)), ( __param(10, IHoverService)), ( __param(11, IChatEntitlementService)), ( __param(12, IMarkdownRendererService))], InlineChatWidget));
-const defaultAriaLabel = ( localize(10729, "Inline Chat Input"));
+const defaultAriaLabel = ( localize(11345, "Inline Chat Input"));
 let EditorBasedInlineChatWidget = class EditorBasedInlineChatWidget extends InlineChatWidget {
     constructor(
         location,

package/vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatZoneWidget.js

@@ -421,7 +421,7 @@ let InlineChatZoneWidget = class InlineChatZoneWidget extends ZoneWidget {
         this.widget.domNode.style.display = "";
         this.widget.chatWidget.setVisible(false);
         super.hide();
-        status(( localize(10730, "Closed inline chat widget")));
+        status(( localize(11346, "Closed inline chat widget")));
         scrollState.restore(this.editor);
     }
 };