@codingame/monaco-vscode-chat-service-override 33.0.8 → 34.0.0

package/vscode/src/vs/platform/sandbox/common/terminalSandboxReadAllowList.d.ts

@@ -0,0 +1,18 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ITerminalSandboxCommand } from "./terminalSandboxService.js";
+export declare enum TerminalSandboxReadAllowListOperation {
+    Git = "git",
+    Node = "node",
+    Rust = "rust",
+    Go = "go",
+    Python = "python",
+    Java = "java",
+    Dotnet = "dotnet",
+    Nuget = "nuget",
+    Msbuild = "msbuild",
+    Ruby = "ruby",
+    NativeBuild = "nativeBuild",
+    Conan = "conan",
+    GnuPG = "gnupg"
+}
+export declare function getTerminalSandboxReadAllowListForCommands(os: OperatingSystem, commandKeywords: readonly string[], commandDetails?: readonly ITerminalSandboxCommand[]): readonly string[];

package/vscode/src/vs/platform/sandbox/common/terminalSandboxReadAllowList.js

@@ -0,0 +1,305 @@
+
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { gitGlobalOptionsWithValue, matchesTerminalSandboxCommandRule } from './terminalSandboxCommandRules.js';
+
+var TerminalSandboxReadAllowListOperation;
+(function(TerminalSandboxReadAllowListOperation) {
+    TerminalSandboxReadAllowListOperation["Git"] = "git";
+    TerminalSandboxReadAllowListOperation["Node"] = "node";
+    TerminalSandboxReadAllowListOperation["Rust"] = "rust";
+    TerminalSandboxReadAllowListOperation["Go"] = "go";
+    TerminalSandboxReadAllowListOperation["Python"] = "python";
+    TerminalSandboxReadAllowListOperation["Java"] = "java";
+    TerminalSandboxReadAllowListOperation["Dotnet"] = "dotnet";
+    TerminalSandboxReadAllowListOperation["Nuget"] = "nuget";
+    TerminalSandboxReadAllowListOperation["Msbuild"] = "msbuild";
+    TerminalSandboxReadAllowListOperation["Ruby"] = "ruby";
+    TerminalSandboxReadAllowListOperation["NativeBuild"] = "nativeBuild";
+    TerminalSandboxReadAllowListOperation["Conan"] = "conan";
+    TerminalSandboxReadAllowListOperation["GnuPG"] = "gnupg";
+})(
+    TerminalSandboxReadAllowListOperation || (TerminalSandboxReadAllowListOperation = {})
+);
+const terminalSandboxReadAllowListKeywordMap = ( new Map([
+    ["git", TerminalSandboxReadAllowListOperation.Git],
+    ["gh", TerminalSandboxReadAllowListOperation.Git],
+    ["node", TerminalSandboxReadAllowListOperation.Node],
+    ["npm", TerminalSandboxReadAllowListOperation.Node],
+    ["npx", TerminalSandboxReadAllowListOperation.Node],
+    ["pnpm", TerminalSandboxReadAllowListOperation.Node],
+    ["yarn", TerminalSandboxReadAllowListOperation.Node],
+    ["corepack", TerminalSandboxReadAllowListOperation.Node],
+    ["bun", TerminalSandboxReadAllowListOperation.Node],
+    ["deno", TerminalSandboxReadAllowListOperation.Node],
+    ["nvm", TerminalSandboxReadAllowListOperation.Node],
+    ["volta", TerminalSandboxReadAllowListOperation.Node],
+    ["fnm", TerminalSandboxReadAllowListOperation.Node],
+    ["asdf", TerminalSandboxReadAllowListOperation.Node],
+    ["mise", TerminalSandboxReadAllowListOperation.Node],
+    ["cargo", TerminalSandboxReadAllowListOperation.Rust],
+    ["rustc", TerminalSandboxReadAllowListOperation.Rust],
+    ["rustup", TerminalSandboxReadAllowListOperation.Rust],
+    ["go", TerminalSandboxReadAllowListOperation.Go],
+    ["gofmt", TerminalSandboxReadAllowListOperation.Go],
+    ["python", TerminalSandboxReadAllowListOperation.Python],
+    ["python3", TerminalSandboxReadAllowListOperation.Python],
+    ["pip", TerminalSandboxReadAllowListOperation.Python],
+    ["pip3", TerminalSandboxReadAllowListOperation.Python],
+    ["poetry", TerminalSandboxReadAllowListOperation.Python],
+    ["uv", TerminalSandboxReadAllowListOperation.Python],
+    ["pipx", TerminalSandboxReadAllowListOperation.Python],
+    ["pyenv", TerminalSandboxReadAllowListOperation.Python],
+    ["java", TerminalSandboxReadAllowListOperation.Java],
+    ["javac", TerminalSandboxReadAllowListOperation.Java],
+    ["jar", TerminalSandboxReadAllowListOperation.Java],
+    ["mvn", TerminalSandboxReadAllowListOperation.Java],
+    ["mvnw", TerminalSandboxReadAllowListOperation.Java],
+    ["gradle", TerminalSandboxReadAllowListOperation.Java],
+    ["gradlew", TerminalSandboxReadAllowListOperation.Java],
+    ["sdk", TerminalSandboxReadAllowListOperation.Java],
+    ["dotnet", TerminalSandboxReadAllowListOperation.Dotnet],
+    ["nuget", TerminalSandboxReadAllowListOperation.Nuget],
+    ["msbuild", TerminalSandboxReadAllowListOperation.Msbuild],
+    ["ruby", TerminalSandboxReadAllowListOperation.Ruby],
+    ["gem", TerminalSandboxReadAllowListOperation.Ruby],
+    ["bundle", TerminalSandboxReadAllowListOperation.Ruby],
+    ["bundler", TerminalSandboxReadAllowListOperation.Ruby],
+    ["rake", TerminalSandboxReadAllowListOperation.Ruby],
+    ["rbenv", TerminalSandboxReadAllowListOperation.Ruby],
+    ["rvm", TerminalSandboxReadAllowListOperation.Ruby],
+    ["ccache", TerminalSandboxReadAllowListOperation.NativeBuild],
+    ["sccache", TerminalSandboxReadAllowListOperation.NativeBuild],
+    ["cmake", TerminalSandboxReadAllowListOperation.NativeBuild],
+    ["conan", TerminalSandboxReadAllowListOperation.Conan]
+]));
+function getTerminalSandboxReadAllowListForOperation(operation, os) {
+    if (os === OperatingSystem.Windows) {
+        return [];
+    }
+    switch (operation) {
+    case TerminalSandboxReadAllowListOperation.Git:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.gitconfig",
+                "~/.config/git/config",
+                "~/.gitignore",
+                "~/.gitignore_global",
+                "~/.config/git/ignore",
+                "~/.config/git/attributes"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Node:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return [
+                "~/.npm",
+                "~/Library/Caches/node",
+                "~/Library/Caches/electron",
+                "~/Library/Caches/ms-playwright",
+                "~/Library/Caches/Yarn",
+                "~/Library/Caches/deno",
+                "~/Library/pnpm",
+                "~/.electron-gyp",
+                "~/.node-gyp",
+                "~/.yarn/berry",
+                "~/.local/share/pnpm",
+                "~/.pnpm-store",
+                "~/.bun/install/cache",
+                "~/.bun/bin",
+                "~/.deno",
+                "~/.nvm/versions",
+                "~/.nvm/alias",
+                "~/.volta/bin",
+                "~/.volta/tools",
+                "~/.fnm",
+                "~/.asdf/installs/nodejs",
+                "~/.asdf/shims",
+                "~/.local/share/mise/installs/node",
+                "~/.local/share/mise/shims"
+            ];
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.npm",
+                "~/.cache/node",
+                "~/.cache/node/corepack",
+                "~/.cache/electron",
+                "~/.cache/ms-playwright",
+                "~/.cache/yarn",
+                "~/.electron-gyp",
+                "~/.node-gyp",
+                "~/.yarn/berry",
+                "~/.local/share/pnpm",
+                "~/.pnpm-store",
+                "~/.bun/install/cache",
+                "~/.bun/bin",
+                "~/.deno",
+                "~/.cache/deno",
+                "~/.nvm/versions",
+                "~/.nvm/alias",
+                "~/.volta/bin",
+                "~/.volta/tools",
+                "~/.fnm",
+                "~/.asdf/installs/nodejs",
+                "~/.asdf/shims",
+                "~/.local/share/mise/installs/node",
+                "~/.local/share/mise/shims"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Rust:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.cargo/bin",
+                "~/.cargo/registry",
+                "~/.cargo/git",
+                "~/.rustup/toolchains"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Go:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/go/pkg/mod", "~/go/bin", "~/Library/Caches/go-build"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/go/pkg/mod", "~/go/bin", "~/.cache/go-build"];
+        }
+    case TerminalSandboxReadAllowListOperation.Python:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return [
+                "~/Library/Caches/pip",
+                "~/Library/Caches/pypoetry",
+                "~/Library/Caches/uv",
+                "~/.local/bin",
+                "~/.local/share/virtualenv",
+                "~/.local/share/pipx",
+                "~/.pyenv/versions",
+                "~/.pyenv/shims"
+            ];
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.cache/pip",
+                "~/.cache/pypoetry",
+                "~/.cache/uv",
+                "~/.local/bin",
+                "~/.local/share/virtualenv",
+                "~/.local/share/pipx",
+                "~/.pyenv/versions",
+                "~/.pyenv/shims"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Java:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [
+                "~/.m2/repository",
+                "~/.gradle/caches",
+                "~/.gradle/wrapper/dists",
+                "~/.sdkman/candidates"
+            ];
+        }
+    case TerminalSandboxReadAllowListOperation.Dotnet:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.dotnet"];
+        }
+    case TerminalSandboxReadAllowListOperation.Nuget:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/.nuget/packages", "~/Library/Caches/NuGet/v3-cache"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.nuget/packages", "~/.local/share/NuGet/v3-cache"];
+        }
+    case TerminalSandboxReadAllowListOperation.Msbuild:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return [];
+        }
+    case TerminalSandboxReadAllowListOperation.Ruby:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/.gem", "~/.rbenv/versions", "~/.rbenv/shims", "~/.rvm/rubies"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.gem", "~/.rbenv/versions", "~/.rbenv/shims", "~/.rvm/rubies"];
+        }
+    case TerminalSandboxReadAllowListOperation.NativeBuild:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+            return ["~/Library/Caches/ccache", "~/Library/Caches/sccache"];
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.cache/ccache", "~/.cache/sccache"];
+        }
+    case TerminalSandboxReadAllowListOperation.Conan:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.conan2/p", "~/.conan2/b"];
+        }
+    case TerminalSandboxReadAllowListOperation.GnuPG:
+        switch (os) {
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return ["~/.gnupg"];
+        }
+    }
+}
+function getTerminalSandboxReadAllowListForCommandDetails(os, commandDetails) {
+    const operations = ( new Set());
+    for (const command of commandDetails) {
+        for (const rule of terminalSandboxReadAllowListCommandDetailRules) {
+            if (matchesTerminalSandboxCommandRule(command, rule, {
+                os
+            })) {
+                operations.add(rule.value);
+            }
+        }
+    }
+    const paths = [...operations].flatMap(operation => getTerminalSandboxReadAllowListForOperation(operation, os));
+    return [...( new Set(paths))];
+}
+const terminalSandboxReadAllowListCommandDetailRules = [{
+    keywords: ["gpg", "gpg2"],
+    value: TerminalSandboxReadAllowListOperation.GnuPG
+}, {
+    keywords: ["git"],
+    value: TerminalSandboxReadAllowListOperation.GnuPG,
+    subcommands: ["commit"],
+    optionsWithValue: gitGlobalOptionsWithValue
+}];
+function getTerminalSandboxReadAllowListForCommands(os, commandKeywords, commandDetails = []) {
+    if (commandKeywords.length === 0) {
+        return getTerminalSandboxReadAllowListForCommandDetails(os, commandDetails);
+    }
+    const operations = ( new Set());
+    for (const keyword of commandKeywords) {
+        const operation = terminalSandboxReadAllowListKeywordMap.get(keyword.toLowerCase());
+        if (operation) {
+            operations.add(operation);
+        }
+    }
+    const paths = [...operations].flatMap(operation => getTerminalSandboxReadAllowListForOperation(operation, os));
+    return [...( new Set([
+        ...paths,
+        ...getTerminalSandboxReadAllowListForCommandDetails(os, commandDetails)
+    ]))];
+}
+
+export { TerminalSandboxReadAllowListOperation, getTerminalSandboxReadAllowListForCommands };

package/vscode/src/vs/platform/sandbox/common/terminalSandboxRuntimeConfigurationPerOperation.d.ts

@@ -0,0 +1,7 @@
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import type { ITerminalSandboxCommand } from "./terminalSandboxService.js";
+export declare enum TerminalSandboxRuntimeConfigurationOperation {
+    GnuPG = "gnupg",
+    Node = "node"
+}
+export declare function getTerminalSandboxRuntimeConfigurationForCommands(os: OperatingSystem, commandDetails: readonly ITerminalSandboxCommand[]): Record<string, unknown>;

package/vscode/src/vs/platform/sandbox/common/terminalSandboxRuntimeConfigurationPerOperation.js

@@ -0,0 +1,120 @@
+
+import { OperatingSystem } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { gitGlobalOptionsWithValue, matchesTerminalSandboxCommandRule } from './terminalSandboxCommandRules.js';
+
+var TerminalSandboxRuntimeConfigurationOperation;
+(function(TerminalSandboxRuntimeConfigurationOperation) {
+    TerminalSandboxRuntimeConfigurationOperation["GnuPG"] = "gnupg";
+    TerminalSandboxRuntimeConfigurationOperation["Node"] = "node";
+})(
+    TerminalSandboxRuntimeConfigurationOperation || (TerminalSandboxRuntimeConfigurationOperation = {})
+);
+const terminalSandboxRuntimeConfigurationCommandRules = [{
+    keywords: [
+        "node",
+        "npm",
+        "npx",
+        "pnpm",
+        "yarn",
+        "corepack",
+        "bun",
+        "deno",
+        "nvm",
+        "volta",
+        "fnm",
+        "asdf",
+        "mise"
+    ],
+    value: TerminalSandboxRuntimeConfigurationOperation.Node
+}, {
+    keywords: ["git"],
+    value: TerminalSandboxRuntimeConfigurationOperation.GnuPG,
+    subcommands: ["commit"],
+    optionsWithValue: gitGlobalOptionsWithValue,
+    condition: (
+        {
+            os
+        }
+    ) => os !== OperatingSystem.Windows,
+    when: isGpgSignedGitCommit
+}];
+function getTerminalSandboxRuntimeConfigurationForOperation(operation, os) {
+    switch (operation) {
+    case TerminalSandboxRuntimeConfigurationOperation.GnuPG:
+        switch (os) {
+        case OperatingSystem.Windows:
+            return {};
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return {
+                network: {
+                    allowAllUnixSockets: true
+                },
+                filesystem: {
+                    allowRead: ["~/.gnupg"],
+                    allowWrite: ["~/.gnupg"]
+                }
+            };
+        }
+    case TerminalSandboxRuntimeConfigurationOperation.Node:
+        switch (os) {
+        case OperatingSystem.Windows:
+            return {};
+        case OperatingSystem.Macintosh:
+        case OperatingSystem.Linux:
+        default:
+            return {
+                filesystem: {
+                    allowWrite: ["~/.volta/"]
+                }
+            };
+        }
+    }
+}
+function getTerminalSandboxRuntimeConfigurationForCommands(os, commandDetails) {
+    const operations = ( new Set());
+    for (const command of commandDetails) {
+        for (const rule of terminalSandboxRuntimeConfigurationCommandRules) {
+            if (matchesTerminalSandboxCommandRule(command, rule, {
+                os
+            })) {
+                operations.add(rule.value);
+            }
+        }
+    }
+    const configuration = {};
+    for (const operation of operations) {
+        mergeAdditionalSandboxConfigProperties(
+            configuration,
+            getTerminalSandboxRuntimeConfigurationForOperation(operation, os)
+        );
+    }
+    return configuration;
+}
+function isGpgSignedGitCommit(command) {
+    return ( command.args.some(
+        arg => arg === "-S" || arg.startsWith("-S") || arg === "--gpg-sign" || arg.startsWith("--gpg-sign=")
+    ));
+}
+function mergeAdditionalSandboxConfigProperties(target, additional) {
+    for (const [key, value] of Object.entries(additional)) {
+        if (!Object.prototype.hasOwnProperty.call(target, key)) {
+            target[key] = value;
+            continue;
+        }
+        const existingValue = target[key];
+        if (Array.isArray(existingValue) && Array.isArray(value)) {
+            target[key] = [...( new Set([...existingValue, ...value]))];
+            continue;
+        }
+        if (isObjectForSandboxConfigMerge(existingValue) && isObjectForSandboxConfigMerge(value)) {
+            mergeAdditionalSandboxConfigProperties(existingValue, value);
+        }
+    }
+}
+function isObjectForSandboxConfigMerge(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export { TerminalSandboxRuntimeConfigurationOperation, getTerminalSandboxRuntimeConfigurationForCommands };

package/vscode/src/vs/platform/sandbox/common/terminalSandboxService.d.ts

@@ -0,0 +1,100 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { OperatingSystem } from "@codingame/monaco-vscode-api/vscode/vs/base/common/platform";
+import { TerminalCapability } from "@codingame/monaco-vscode-api/vscode/vs/platform/terminal/common/capabilities/capabilities";
+import { ITerminalSandboxService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/terminalSandboxService.service";
+export interface ITerminalSandboxResolvedNetworkDomains {
+    allowedDomains: string[];
+    deniedDomains: string[];
+}
+export declare enum TerminalSandboxPrerequisiteCheck {
+    Config = "config",
+    Dependencies = "dependencies"
+}
+export interface ITerminalSandboxPrerequisiteCheckResult {
+    enabled: boolean;
+    sandboxConfigPath: string | undefined;
+    failedCheck: TerminalSandboxPrerequisiteCheck | undefined;
+    missingDependencies?: string[];
+}
+export interface ITerminalSandboxWrapResult {
+    command: string;
+    isSandboxWrapped: boolean;
+    blockedDomains?: string[];
+    deniedDomains?: string[];
+    requiresUnsandboxConfirmation?: boolean;
+    requiresAllowNetworkConfirmation?: boolean;
+}
+export interface ITerminalSandboxPrecheckInputs {
+    /**
+     * Whether the current caller is using the default approval permission flow.
+     */
+    readonly isDefaultApprovalPermissionEnabled?: boolean;
+}
+export interface ITerminalSandboxPrecheckInputs {
+    /**
+     * Whether the current caller is using the default approval permission flow.
+     */
+    readonly isDefaultApprovalPermissionEnabled?: boolean;
+}
+export interface ITerminalSandboxCommand {
+    /**
+     * Normalized command name without path or executable suffix.
+     * For example, `/usr/bin/git` and `git.exe` both normalize to `git`.
+     */
+    keyword: string;
+    /**
+     * Command arguments after the executable token. These are used for
+     * argument-sensitive sandbox allow-list rules, such as matching a specific
+     * subcommand while ignoring global options.
+     */
+    args: readonly string[];
+}
+/**
+ * Abstraction over terminal operations needed by the install flow.
+ * Provided by the browser-layer caller so the common-layer service
+ * does not import browser types directly.
+ */
+export interface ISandboxDependencyInstallTerminal {
+    sendText(text: string, addNewLine?: boolean): Promise<void>;
+    focus(): void;
+    capabilities: {
+        get(id: TerminalCapability.CommandDetection): {
+            onCommandFinished: Event<{
+                exitCode: number | undefined;
+            }>;
+        } | undefined;
+        onDidAddCapability: Event<{
+            id: TerminalCapability;
+        }>;
+    };
+    onDidInputData: Event<string>;
+    onDisposed: Event<unknown>;
+}
+export interface ISandboxDependencyInstallOptions {
+    /**
+     * Creates or obtains a terminal for running the install command.
+     */
+    createTerminal(): Promise<ISandboxDependencyInstallTerminal>;
+    /**
+     * Focuses the terminal for password entry.
+     */
+    focusTerminal(terminal: ISandboxDependencyInstallTerminal): Promise<void>;
+}
+export interface ISandboxDependencyInstallResult {
+    exitCode: number | undefined;
+}
+export declare class NullTerminalSandboxService implements ITerminalSandboxService {
+    readonly _serviceBrand: undefined;
+    isEnabled(): Promise<boolean>;
+    isSandboxAllowNetworkEnabled(): Promise<boolean>;
+    getOS(): Promise<OperatingSystem>;
+    checkForSandboxingPrereqs(): Promise<ITerminalSandboxPrerequisiteCheckResult>;
+    wrapCommand(command: string): Promise<ITerminalSandboxWrapResult>;
+    getSandboxConfigPath(): Promise<string | undefined>;
+    getTempDir(): URI | undefined;
+    setNeedsForceUpdateConfigFile(): void;
+    getResolvedNetworkDomains(): ITerminalSandboxResolvedNetworkDomains;
+    getMissingSandboxDependencies(): Promise<string[]>;
+    installMissingSandboxDependencies(): Promise<ISandboxDependencyInstallResult>;
+}

package/vscode/src/vs/platform/sandbox/common/terminalSandboxService.js

@@ -0,0 +1,10 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+
+var TerminalSandboxPrerequisiteCheck;
+(function (TerminalSandboxPrerequisiteCheck) {
+    TerminalSandboxPrerequisiteCheck["Config"] = "config";
+    TerminalSandboxPrerequisiteCheck["Dependencies"] = "dependencies";
+})(TerminalSandboxPrerequisiteCheck || (TerminalSandboxPrerequisiteCheck = {}));
+
+export { TerminalSandboxPrerequisiteCheck };

package/vscode/src/vs/workbench/contrib/chat/browser/accessibility/chatAccessibilityService.js

@@ -117,7 +117,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             });
         }
         this.toasts.clearAndDisposeAll();
-        const title = widget?.viewModel?.model.title ? ( localize(4784, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4785, "Untitled Chat"));
+        const title = widget?.viewModel?.model.title ? ( localize(4844, "Chat: {0}", widget.viewModel.model.title)) : ( localize(4845, "Untitled Chat"));
         const cts = ( new CancellationTokenSource());
         const disposable = toDisposable(() => cts.dispose(true));
         this.toasts.add(disposable);
@@ -125,7 +125,7 @@ let ChatAccessibilityService = class ChatAccessibilityService extends Disposable
             clicked
         } = await this._hostService.showToast({
             title,
-            body: ( localize(4786, "New chat response."))
+            body: ( localize(4846, "New chat response."))
         }, cts.token);
         this.toasts.deleteAndDispose(disposable);
         if (clicked) {