@codingame/monaco-vscode-katex-common 30.0.1 → 31.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-katex-common",
-  "version": "30.0.1",
+  "version": "31.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package depending on katex",
   "keywords": [],
@@ -15,8 +15,8 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "30.0.1",
-    "katex": "0.16.27",
+    "@codingame/monaco-vscode-api": "31.0.0",
+    "katex": "0.16.45",
     "marked": "14.0.0"
   },
   "exports": {

package/vscode/src/vs/platform/actions/browser/actionbar.d.ts

@@ -0,0 +1,16 @@
+import { ActionBar, IActionBarOptions } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+export interface IWorkbenchActionBarOptions extends IActionBarOptions {
+    /**
+     * When set the `workbenchActionExecuted` is automatically sent for each invoked action. The `from` property
+     * of the event will be the passed `telemetrySource`-value.
+     */
+    telemetrySource?: string;
+}
+/**
+ * A {@link ActionBar action bar} that automatically sends `workbenchActionExecuted` telemetry
+ * events for each invoked action, like {@link import('./toolbar.js').WorkbenchToolBar WorkbenchToolBar} does.
+ */
+export declare class WorkbenchActionBar extends ActionBar {
+    constructor(container: HTMLElement, options: IWorkbenchActionBarOptions, telemetryService: ITelemetryService);
+}

package/vscode/src/vs/platform/actions/browser/actionbar.js

@@ -0,0 +1,22 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { ActionBar } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/actionbar/actionbar';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+
+let WorkbenchActionBar = class WorkbenchActionBar extends ActionBar {
+    constructor(container, options, telemetryService) {
+        super(container, options);
+        const telemetrySource = options.telemetrySource;
+        if (telemetrySource) {
+            this._store.add(
+                this.onDidRun(e => telemetryService.publicLog2("workbenchActionExecuted", {
+                    id: e.action.id,
+                    from: telemetrySource
+                }))
+            );
+        }
+    }
+};
+WorkbenchActionBar = ( __decorate([( __param(2, ITelemetryService))], WorkbenchActionBar));
+
+export { WorkbenchActionBar };

package/vscode/src/vs/platform/actions/browser/buttonbar.js

@@ -137,14 +137,14 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
         if (secondary.length > 0) {
             const btn = this.addButton({
                 secondary: true,
-                ariaLabel: ( localize(1797, "More Actions")),
+                ariaLabel: ( localize(1798, "More Actions")),
                 small: this._options?.small
             });
             btn.icon = Codicon.dropDownButton;
             btn.element.classList.add("default-colors", "monaco-text-button");
             btn.enabled = true;
             this._updateStore.add(
-                this._hoverService.setupManagedHover(hoverDelegate, btn.element, ( localize(1797, "More Actions")))
+                this._hoverService.setupManagedHover(hoverDelegate, btn.element, ( localize(1798, "More Actions")))
             );
             this._updateStore.add(btn.onDidClick(async () => {
                 this._contextMenuService.showContextMenu({

package/vscode/src/vs/platform/networkFilter/common/domainMatcher.d.ts

@@ -0,0 +1,50 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/**
+ * Normalizes and validates a domain string.
+ *
+ * Strips user info, port, trailing dots, and trailing punctuation.
+ * Accepts bare wildcards (`*`) and wildcard prefixes (`*.example.com`).
+ *
+ * @param value The raw domain string to normalize.
+ * @param fromUrl Whether the value was extracted from a URL context (skips file-extension filtering).
+ * @returns The normalized domain string, or `undefined` if the input is invalid.
+ */
+export declare function normalizeDomain(value: string | undefined, fromUrl?: boolean): string | undefined;
+/**
+ * Extracts the domain portion from a pattern string.
+ * If the pattern contains `://`, it is parsed as a URI and the authority is returned.
+ * Otherwise, the trimmed pattern is returned as-is.
+ */
+export declare function extractDomainPattern(pattern: string): string;
+/**
+ * Checks whether a normalized domain matches a given allow/deny pattern.
+ * Supports exact matches, bare wildcards (`*`), and wildcard prefixes (`*.example.com`).
+ *
+ * @param domain A normalized domain (output of {@link normalizeDomain}).
+ * @param pattern An allow/deny pattern (may be a bare domain, URL, or wildcard).
+ * @returns `true` if the domain matches the pattern.
+ */
+export declare function matchesDomainPattern(domain: string, pattern: string): boolean;
+/**
+ * Extracts and normalizes a domain from a URI.
+ * Strips port numbers and trailing dots.
+ *
+ * @param uri The URI to extract the domain from.
+ * @returns The normalized domain, or `undefined` if no valid domain could be extracted.
+ */
+export declare function extractDomainFromUri(uri: URI): string | undefined;
+/**
+ * Determines whether a domain is allowed based on allow and deny lists.
+ *
+ * Rules:
+ * - If both lists are empty, the domain is denied (restrictive default).
+ * - Denied patterns take precedence: if the domain matches any denied pattern, it is blocked.
+ * - If only denied patterns are configured (allowed is empty), any non-denied domain is allowed.
+ * - If allowed patterns are configured, the domain must match at least one to be allowed.
+ *
+ * @param domain A normalized domain string.
+ * @param allowedPatterns Array of allowed domain patterns.
+ * @param deniedPatterns Array of denied domain patterns.
+ * @returns `true` if the domain is allowed, `false` if it is blocked.
+ */
+export declare function isDomainAllowed(domain: string, allowedPatterns: string[], deniedPatterns: string[]): boolean;

package/vscode/src/vs/platform/networkFilter/common/domainMatcher.js

@@ -0,0 +1,138 @@
+
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+
+const fileExtensionSuffixes = ( new Set([
+    "7z",
+    "bz2",
+    "cjs",
+    "class",
+    "cpp",
+    "cs",
+    "css",
+    "csv",
+    "dll",
+    "exe",
+    "gif",
+    "gz",
+    "ico",
+    "jar",
+    "env",
+    "java",
+    "jpeg",
+    "jpg",
+    "js",
+    "json",
+    "jsx",
+    "lock",
+    "log",
+    "md",
+    "mjs",
+    "pdf",
+    "php",
+    "png",
+    "py",
+    "rar",
+    "rs",
+    "so",
+    "sql",
+    "svg",
+    "tar",
+    "tgz",
+    "toml",
+    "ts",
+    "tsx",
+    "txt",
+    "wasm",
+    "webp",
+    "xml",
+    "yaml",
+    "yml",
+    "zip"
+]));
+const wellKnownDomainSuffixes = ( new Set(["ai", "cloud", "com", "dev", "io", "me", "net", "org", "tech"]));
+function normalizeDomain(value, fromUrl = false) {
+    if (!value) {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase().replace(/^[^@]+@/, "").replace(/:\d+$/, "").replace(/\.+$/, "");
+    if (!normalized || normalized.includes("/") || normalized === "." || normalized === "..") {
+        return undefined;
+    }
+    if (normalized === "*") {
+        return "*";
+    }
+    if (!/^\*?\.?[a-z0-9.;,)!?:-]+$/.test(normalized)) {
+        return undefined;
+    }
+    const stripped = normalized.replace(/[),;:!?]+$/, "");
+    if (!stripped) {
+        return undefined;
+    }
+    const domainToValidate = stripped.startsWith("*.") ? stripped.slice(2) : stripped;
+    if (!/^(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?)(?:\.(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?))*$/.test(domainToValidate)) {
+        return undefined;
+    }
+    const hasWildcardPrefix = stripped.startsWith("*.");
+    const host = hasWildcardPrefix ? stripped.slice(2) : stripped;
+    if (!host) {
+        return undefined;
+    }
+    if (!/^[a-z0-9.-]+$/.test(host)) {
+        return undefined;
+    }
+    if (!fromUrl) {
+        const lastLabel = host.slice(host.lastIndexOf(".") + 1);
+        if (( fileExtensionSuffixes.has(lastLabel))) {
+            return undefined;
+        }
+        if (!( wellKnownDomainSuffixes.has(lastLabel))) {
+            return undefined;
+        }
+    }
+    return hasWildcardPrefix ? `*.${host}` : host;
+}
+function extractDomainPattern(pattern) {
+    const trimmed = pattern.trim();
+    if (trimmed === "*") {
+        return trimmed;
+    }
+    if (!trimmed.includes("://")) {
+        return trimmed;
+    }
+    try {
+        return ( URI.parse(trimmed)).authority;
+    } catch {
+        return trimmed;
+    }
+}
+function matchesDomainPattern(domain, pattern) {
+    const normalizedPattern = normalizeDomain(extractDomainPattern(pattern), pattern.includes("://"));
+    if (!normalizedPattern) {
+        return false;
+    }
+    if (normalizedPattern === "*") {
+        return true;
+    }
+    if (normalizedPattern.startsWith("*.")) {
+        const suffix = normalizedPattern.slice(2);
+        return domain === suffix || domain.endsWith(`.${suffix}`);
+    }
+    return domain === normalizedPattern;
+}
+function extractDomainFromUri(uri) {
+    return normalizeDomain(uri.authority, true);
+}
+function isDomainAllowed(domain, allowedPatterns, deniedPatterns) {
+    if (allowedPatterns.length === 0 && deniedPatterns.length === 0) {
+        return false;
+    }
+    if (( deniedPatterns.some(pattern => matchesDomainPattern(domain, pattern)))) {
+        return false;
+    }
+    if (allowedPatterns.length === 0) {
+        return true;
+    }
+    return ( allowedPatterns.some(pattern => matchesDomainPattern(domain, pattern)));
+}
+
+export { extractDomainFromUri, extractDomainPattern, isDomainAllowed, matchesDomainPattern, normalizeDomain };

package/vscode/src/vs/platform/networkFilter/common/settings.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Setting IDs for agent network domain filtering.
+ */
+export declare enum AgentNetworkDomainSettingId {
+    NetworkFilter = "chat.agent.networkFilter",
+    AllowedNetworkDomains = "chat.agent.allowedNetworkDomains",
+    DeniedNetworkDomains = "chat.agent.deniedNetworkDomains",
+    DeprecatedSandboxAllowedNetworkDomains = "chat.agent.sandbox.allowedNetworkDomains",
+    DeprecatedSandboxDeniedNetworkDomains = "chat.agent.sandbox.deniedNetworkDomains",
+    DeprecatedOldAllowedNetworkDomains = "chat.agent.sandboxNetwork.allowedDomains",
+    DeprecatedOldDeniedNetworkDomains = "chat.agent.sandboxNetwork.deniedDomains"
+}

package/vscode/src/vs/platform/networkFilter/common/settings.js

@@ -0,0 +1,14 @@
+
+
+var AgentNetworkDomainSettingId;
+(function (AgentNetworkDomainSettingId) {
+    AgentNetworkDomainSettingId["NetworkFilter"] = "chat.agent.networkFilter";
+    AgentNetworkDomainSettingId["AllowedNetworkDomains"] = "chat.agent.allowedNetworkDomains";
+    AgentNetworkDomainSettingId["DeniedNetworkDomains"] = "chat.agent.deniedNetworkDomains";
+    AgentNetworkDomainSettingId["DeprecatedSandboxAllowedNetworkDomains"] = "chat.agent.sandbox.allowedNetworkDomains";
+    AgentNetworkDomainSettingId["DeprecatedSandboxDeniedNetworkDomains"] = "chat.agent.sandbox.deniedNetworkDomains";
+    AgentNetworkDomainSettingId["DeprecatedOldAllowedNetworkDomains"] = "chat.agent.sandboxNetwork.allowedDomains";
+    AgentNetworkDomainSettingId["DeprecatedOldDeniedNetworkDomains"] = "chat.agent.sandboxNetwork.deniedDomains";
+})(AgentNetworkDomainSettingId || (AgentNetworkDomainSettingId = {}));
+
+export { AgentNetworkDomainSettingId };

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

@@ -0,0 +1,18 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IChannel, IServerChannel } from "@codingame/monaco-vscode-api/vscode/vs/base/parts/ipc/common/ipc";
+import { ISandboxDependencyStatus } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService";
+import { ISandboxHelperService } from "@codingame/monaco-vscode-api/vscode/vs/platform/sandbox/common/sandboxHelperService.service";
+export declare const SANDBOX_HELPER_CHANNEL_NAME = "sandboxHelper";
+export declare class SandboxHelperChannel implements IServerChannel {
+    private readonly service;
+    constructor(service: ISandboxHelperService);
+    listen<T>(_context: unknown, _event: string): Event<T>;
+    call<T>(_context: unknown, command: string, _arg?: unknown, _cancellationToken?: CancellationToken): Promise<T>;
+}
+export declare class SandboxHelperChannelClient implements ISandboxHelperService {
+    private readonly channel;
+    readonly _serviceBrand: undefined;
+    constructor(channel: IChannel);
+    checkSandboxDependencies(): Promise<ISandboxDependencyStatus | undefined>;
+}

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

@@ -0,0 +1,13 @@
+
+
+const SANDBOX_HELPER_CHANNEL_NAME = "sandboxHelper";
+class SandboxHelperChannelClient {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    checkSandboxDependencies() {
+        return this.channel.call("checkSandboxDependencies");
+    }
+}
+
+export { SANDBOX_HELPER_CHANNEL_NAME, SandboxHelperChannelClient };

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

@@ -0,0 +1,73 @@
+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;
+}
+/**
+ * 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>;
+    getOS(): Promise<OperatingSystem>;
+    checkForSandboxingPrereqs(): Promise<ITerminalSandboxPrerequisiteCheckResult>;
+    wrapCommand(command: string): 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/chatAccessibilityProvider.js

@@ -25,7 +25,7 @@ const getToolConfirmationAlert = (accessor, toolInvocation) => {
         if (state.type === IChatToolInvocation.StateKind.WaitingForPostApproval) {
             const detail = isToolResultInputOutputDetails(state.resultDetails) ? state.resultDetails.input : isToolResultOutputDetails(state.resultDetails) ? undefined : toolContentToA11yString(state.contentForModel);
             return {
-                title: ( localize(4685, "Approve results of tool")),
+                title: ( localize(4688, "Approve results of tool")),
                 detail: detail
             };
         }
@@ -42,7 +42,7 @@ const getToolConfirmationAlert = (accessor, toolInvocation) => {
             } else if (v.toolSpecificData.kind === "input") {
                 input = JSON.stringify(v.toolSpecificData.rawInput);
             } else if (v.toolSpecificData.kind === "modifiedFilesConfirmation") {
-                input = ( localize(4686, "{0} files", v.toolSpecificData.modifiedFiles.length));
+                input = ( localize(4689, "{0} files", v.toolSpecificData.modifiedFiles.length));
             }
         }
         const titleObj = state.confirmationMessages?.title;
@@ -53,18 +53,18 @@ const getToolConfirmationAlert = (accessor, toolInvocation) => {
         };
     })).filter(isDefined);
     let message = acceptKb && cancelKb ? ( localize(
-        4687,
+        4690,
         "Chat confirmation required: {0}. Press {1} to accept or {2} to cancel.",
         ( text.map(t => t.title)).join(", "),
         acceptKb,
         cancelKb
     )) : ( localize(
-        4688,
+        4691,
         "Chat confirmation required: {0}",
         ( text.map(t => t.title)).join(", ")
     ));
     if (( text.some(t => t.detail))) {
-        message += " " + ( localize(4689, "Details: {0}", ( text.map(t => t.detail ? t.detail : "")).join(" ")));
+        message += " " + ( localize(4692, "Details: {0}", ( text.map(t => t.detail ? t.detail : "")).join(" ")));
     }
     return message;
 };
@@ -80,7 +80,7 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
         return "listitem";
     }
     getWidgetAriaLabel() {
-        return localize(4690, "Chat");
+        return localize(4693, "Chat");
     }
     getAriaLabel(element) {
         if (isRequestVM(element)) {
@@ -111,10 +111,10 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
         case 0:
             break;
         case 1:
-            tableCountHint = ( localize(4691, "1 table "));
+            tableCountHint = ( localize(4694, "1 table "));
             break;
         default:
-            tableCountHint = ( localize(4692, "{0} tables ", tableCount));
+            tableCountHint = ( localize(4695, "{0} tables ", tableCount));
             break;
         }
         const fileTreeCount = element.response.value.filter(v => v.kind === "treeData").length ?? 0;
@@ -123,10 +123,10 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
         case 0:
             break;
         case 1:
-            fileTreeCountHint = ( localize(4693, "1 file tree "));
+            fileTreeCountHint = ( localize(4696, "1 file tree "));
             break;
         default:
-            fileTreeCountHint = ( localize(4694, "{0} file trees ", fileTreeCount));
+            fileTreeCountHint = ( localize(4697, "{0} file trees ", fileTreeCount));
             break;
         }
         const elicitationCount = element.response.value.filter(v => v.kind === "elicitation2" || v.kind === "elicitationSerialized");
@@ -140,7 +140,7 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
         switch (codeBlockCount) {
         case 0:
             label = accessibleViewHint ? ( localize(
-                4695,
+                4698,
                 "{0}{1}{2}{3}{4} {5}",
                 toolInvocationHint,
                 fileTreeCountHint,
@@ -149,7 +149,7 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
                 (element.response.toString()),
                 accessibleViewHint
             )) : ( localize(
-                4696,
+                4699,
                 "{0}{1}{2} {3}",
                 fileTreeCountHint,
                 elicitationHint,
@@ -159,7 +159,7 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
             break;
         case 1:
             label = accessibleViewHint ? ( localize(
-                4697,
+                4700,
                 "{0}{1}{2}1 code block: {3} {4}{5}",
                 toolInvocationHint,
                 fileTreeCountHint,
@@ -168,7 +168,7 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
                 (element.response.toString()),
                 accessibleViewHint
             )) : ( localize(
-                4698,
+                4701,
                 "{0}{1}1 code block: {2} {3}",
                 fileTreeCountHint,
                 elicitationHint,
@@ -178,7 +178,7 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
             break;
         default:
             label = accessibleViewHint ? ( localize(
-                4699,
+                4702,
                 "{0}{1}{2}{3} code blocks: {4}{5} {6}",
                 toolInvocationHint,
                 fileTreeCountHint,
@@ -188,7 +188,7 @@ let ChatAccessibilityProvider = class ChatAccessibilityProvider {
                 (element.response.toString()),
                 accessibleViewHint
             )) : ( localize(
-                4700,
+                4703,
                 "{0}{1}{2} code blocks: {3} {4}",
                 fileTreeCountHint,
                 elicitationHint,

package/vscode/src/vs/workbench/contrib/chat/browser/actions/chatContinueInAction.d.ts

@@ -12,6 +12,8 @@ import { IOpenerService } from "@codingame/monaco-vscode-api/vscode/vs/platform/
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { ResolvedChatSessionsExtensionPoint } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
 import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
+import { ISCMService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/scm/common/scm.service";
+import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IChatWidget } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/chat";
 export declare enum ActionLocation {
     ChatWidget = "chatWidget",
@@ -25,7 +27,7 @@ export declare class ContinueChatInSessionAction extends Action2 {
 export declare class ChatContinueInSessionActionItem extends ActionWidgetDropdownActionViewItem {
     private readonly location;
     private readonly contextKeyService;
-    constructor(action: MenuItemAction, location: ActionLocation, actionWidgetService: IActionWidgetService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService, openerService: IOpenerService, telemetryService: ITelemetryService);
+    constructor(action: MenuItemAction, location: ActionLocation, actionWidgetService: IActionWidgetService, contextKeyService: IContextKeyService, keybindingService: IKeybindingService, chatSessionsService: IChatSessionsService, instantiationService: IInstantiationService, openerService: IOpenerService, telemetryService: ITelemetryService, scmService: ISCMService, workspaceContextService: IWorkspaceContextService);
     protected static getActionBarActions(openerService: IOpenerService): {
         id: string;
         label: string;