@codingame/monaco-vscode-chat-service-override 32.0.2 → 33.0.4

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

@@ -0,0 +1,6 @@
+export declare enum CopilotToolId {
+    ReadFile = "copilot_readFile"
+}
+export declare enum CopilotChatSettingId {
+    Gpt55ReadFileToolEnabled = "github.copilot.chat.gpt55ReadFileTool.enabled"
+}

package/vscode/src/vs/workbench/contrib/chat/common/tools/copilotToolIds.js

@@ -0,0 +1,12 @@
+
+
+var CopilotToolId;
+(function (CopilotToolId) {
+    CopilotToolId["ReadFile"] = "copilot_readFile";
+})(CopilotToolId || (CopilotToolId = {}));
+var CopilotChatSettingId;
+(function (CopilotChatSettingId) {
+    CopilotChatSettingId["Gpt55ReadFileToolEnabled"] = "github.copilot.chat.gpt55ReadFileTool.enabled";
+})(CopilotChatSettingId || (CopilotChatSettingId = {}));
+
+export { CopilotChatSettingId, CopilotToolId };

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

@@ -0,0 +1,88 @@
+/**
+ * Result of running a {@link IToolResultFilter}.
+ *
+ * `text` is the new text to substitute back into the corresponding text part.
+ * `compressed` is `true` if any compression actually happened — used purely
+ * for telemetry / accounting.
+ */
+export interface IToolResultFilterOutput {
+    readonly text: string;
+    readonly compressed: boolean;
+}
+/**
+ * A pure function that compresses a single text part of a tool result.
+ *
+ * Implementations MUST never make output worse than the input. If a filter
+ * cannot improve a piece of text, it should return the original `text` and
+ * `compressed: false`.
+ */
+export interface IToolResultFilter {
+    readonly id: string;
+    /** Tool ids this filter applies to. */
+    readonly toolIds: readonly string[];
+    /**
+     * Decide whether this filter wants to handle the result. May inspect tool
+     * input (e.g. for `run_in_terminal`, the command being run).
+     */
+    matches(toolId: string, input: unknown): boolean;
+    apply(text: string, input: unknown): IToolResultFilterOutput;
+}
+/**
+ * Result of looking up a tool invocation in an {@link IToolResultCache}.
+ */
+export interface IToolResultCacheHit {
+    /** The cached output content from the previous run. */
+    readonly text: string;
+    /** Wall-clock timestamp (ms since epoch) of when the cached entry was produced. */
+    readonly timestamp: number;
+}
+/**
+ * A read-through / write-through cache for tool results. Used to implement
+ * "same as last run" response dedup for read-only, deterministic tool calls.
+ *
+ * The compressor invokes caches in this order on every `maybeCompress` call:
+ *   1. `observe(toolId, input)` — caches may use this hook to invalidate
+ *      sibling entries (e.g. a `git commit` clears `git status` / `git diff`).
+ *   2. `lookup(toolId, input)` — if any cache returns a hit, the compressor
+ *      substitutes the result with a single-line "same output as last run"
+ *      reply and emits `cacheHit: true` telemetry.
+ *   3. If no hit, after compression the compressor calls `record` so the
+ *      cache can store the (possibly compressed) output.
+ */
+export interface IToolResultCache {
+    readonly id: string;
+    readonly toolIds: readonly string[];
+    observe(toolId: string, input: unknown): void;
+    lookup(toolId: string, input: unknown): IToolResultCacheHit | undefined;
+    record(toolId: string, input: unknown, text: string): void;
+}
+/**
+ * Heuristically decide whether a text part should be excluded from filter
+ * rewriting because it carries structured data the model is likely to parse.
+ *
+ * Currently detects:
+ * - Top-level JSON objects/arrays (parsed to verify)
+ * - YAML documents (leading `---` header)
+ * - TOML-style documents (leading `[section]` header)
+ *
+ * Returning `true` means: the registry will NOT pass this text part to any
+ * filter, even if the filter says it matches.
+ *
+ * This is intentionally cheap and conservative — false negatives just mean
+ * a filter may decline to compress; false positives could corrupt structured
+ * payloads.
+ */
+export declare function isProtectedFromCompression(text: string): boolean;
+/**
+ * Outputs below this many characters (UTF-16 code units, i.e.
+ * `string.length`) are not worth compressing: filter savings on short
+ * outputs rarely outweigh the banner overhead, and skipping them avoids
+ * the agent issuing redundant `read_file` / `get_terminal_output` calls
+ * to recover content that would have fit uncompressed.
+ */
+export declare const MIN_COMPRESSIBLE_LENGTH = 1024;
+/**
+ * Format the banner that gets prepended to compressed text parts so the
+ * model knows compression happened, which filters fired, and how to opt out.
+ */
+export declare function formatCompressionBanner(filterIds: readonly string[], beforeChars: number, afterChars: number): string;

package/vscode/src/vs/workbench/contrib/chat/common/tools/toolResultCompressor.js

@@ -0,0 +1,25 @@
+
+
+function isProtectedFromCompression(text) {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return false;
+    }
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if ((first === '{' && last === '}') || (first === '[' && last === ']')) {
+        try {
+            JSON.parse(trimmed);
+            return true;
+        }
+        catch {
+        }
+    }
+    if (/^---\s*\n/.test(trimmed) || /^\[[A-Za-z_][A-Za-z0-9_.-]*\]\s*\n/.test(trimmed)) {
+        return true;
+    }
+    return false;
+}
+const MIN_COMPRESSIBLE_LENGTH = 1024;
+
+export { MIN_COMPRESSIBLE_LENGTH, isProtectedFromCompression };

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

@@ -20,7 +20,7 @@ var PhraseTextType;
 })(PhraseTextType || (PhraseTextType = {}));
 const VoiceChatInProgress = ( new RawContextKey("voiceChatInProgress", false, {
     type: "boolean",
-    description: ( localize(8155, "A speech-to-text session is in progress for chat."))
+    description: ( localize(8240, "A speech-to-text session is in progress for chat."))
 }));
 let VoiceChatService = class VoiceChatService extends Disposable {
     static {

package/vscode/src/vs/workbench/contrib/imageCarousel/browser/imageCarousel.contribution.d.ts

@@ -0,0 +1 @@
+

package/vscode/src/vs/workbench/contrib/imageCarousel/browser/imageCarousel.contribution.js

@@ -0,0 +1,237 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import * as imageCarousel from './media/imageCarousel.css';
+import { localize, localize2 } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SyncDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/descriptors';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { EditorPaneDescriptor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/editor';
+import { EditorExtensions } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
+import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
+import { ImageCarouselEditor } from './imageCarouselEditor.js';
+import { ImageCarouselEditorInput } from './imageCarouselEditorInput.js';
+import { Action2, registerAction2, MenuId } from '@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { ExplorerFolderContext } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/common/files';
+import { IExplorerService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/files/browser/files.service';
+import { ResourceContextKey } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/contextkeys';
+import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
+import { getMediaMime } from '@codingame/monaco-vscode-api/vscode/vs/base/common/mime';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { extname, basename, dirname } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { ResourceSet } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { IWorkspaceContextService } from '@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+
+registerCss(imageCarousel);
+( Registry.as(Extensions.Configuration)).registerConfiguration({
+    id: "imageCarousel",
+    title: ( localize(10509, "Images Preview")),
+    type: "object",
+    properties: {
+        "imageCarousel.explorerContextMenu.enabled": {
+            type: "boolean",
+            default: true,
+            markdownDescription: ( localize(
+                10510,
+                "Controls whether the **Open in Images Preview** option appears in the Explorer context menu."
+            )),
+            tags: ["experimental"]
+        },
+        "imageCarousel.chat.enabled": {
+            type: "boolean",
+            default: true,
+            description: ( localize(
+                10511,
+                "Controls whether clicking an image attachment in chat opens the Images Preview viewer."
+            )),
+            tags: ["experimental"]
+        }
+    }
+});
+( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(
+    EditorPaneDescriptor.create(ImageCarouselEditor, ImageCarouselEditor.ID, ( localize(10512, "Images Preview"))),
+    [( new SyncDescriptor(ImageCarouselEditorInput))]
+);
+class ImageCarouselEditorInputSerializer {
+    canSerialize() {
+        return false;
+    }
+    serialize() {
+        return undefined;
+    }
+    deserialize() {
+        return undefined;
+    }
+}
+( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(ImageCarouselEditorInput.ID, ImageCarouselEditorInputSerializer);
+function isCollectionArgs(args) {
+    return typeof args === "object" && args !== null && typeof args.collection === "object" && typeof args.startIndex === "number";
+}
+function isSingleImageArgs(args) {
+    return typeof args === "object" && args !== null && typeof args.name === "string" && typeof args.mimeType === "string" && args.data instanceof Uint8Array;
+}
+class OpenImageInCarouselAction extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.chat.openImageInCarousel",
+            title: ( localize2(10513, "Open in Images Preview")),
+            f1: false
+        });
+    }
+    async run(accessor, args) {
+        const editorService = accessor.get(IEditorService);
+        let collection;
+        let startIndex;
+        if (isCollectionArgs(args)) {
+            collection = args.collection;
+            startIndex = args.startIndex;
+        } else if (isSingleImageArgs(args)) {
+            collection = {
+                id: generateUuid(),
+                title: args.title ?? ( localize(10514, "Images Preview")),
+                sections: [{
+                    title: "",
+                    images: [{
+                        id: generateUuid(),
+                        name: args.name,
+                        mimeType: args.mimeType,
+                        data: VSBuffer.wrap(args.data)
+                    }]
+                }]
+            };
+            startIndex = 0;
+        } else {
+            return;
+        }
+        const input = ( new ImageCarouselEditorInput(collection, startIndex));
+        await editorService.openEditor(input, {
+            pinned: true
+        });
+    }
+}
+registerAction2(OpenImageInCarouselAction);
+const MEDIA_EXTENSION_REGEX = /^\.(png|jpg|jpeg|jpe|gif|webp|svg|bmp|ico|mp4|webm|mov)$/i;
+function isMediaResource(uri) {
+    return MEDIA_EXTENSION_REGEX.test(extname(uri));
+}
+async function collectImageFilesFromFolder(fileService, folderUri) {
+    const stat = await fileService.resolve(folderUri);
+    const imageUris = [];
+    if (stat.children) {
+        for (const child of stat.children) {
+            if (child.isFile && isMediaResource(child.resource)) {
+                imageUris.push(child.resource);
+            }
+        }
+    }
+    imageUris.sort((a, b) => basename(a).localeCompare(basename(b)));
+    return imageUris;
+}
+function createImageEntries(uris) {
+    return ( uris.map(uri => ({
+        id: generateUuid(),
+        name: basename(uri),
+        mimeType: getMediaMime(uri.path) ?? "image/png",
+        uri
+    })));
+}
+class OpenImagesInCarouselFromExplorerAction extends Action2 {
+    constructor() {
+        super({
+            id: "workbench.action.openImagesInCarousel",
+            title: ( localize2(10515, "Open in Images Preview")),
+            f1: false,
+            menu: [{
+                id: MenuId.ExplorerContext,
+                group: "navigation",
+                order: 25,
+                when: ( ContextKeyExpr.and(( ContextKeyExpr.has("config.imageCarousel.explorerContextMenu.enabled")), ( ContextKeyExpr.or(ExplorerFolderContext, ( ContextKeyExpr.regex(ResourceContextKey.Extension.key, MEDIA_EXTENSION_REGEX))))))
+            }]
+        });
+    }
+    async run(accessor, resource) {
+        const explorerService = accessor.get(IExplorerService);
+        const fileService = accessor.get(IFileService);
+        const editorService = accessor.get(IEditorService);
+        const notificationService = accessor.get(INotificationService);
+        const contextService = accessor.get(IWorkspaceContextService);
+        const context = explorerService.getContext(true);
+        let imageUris = [];
+        let startUri;
+        try {
+            if (context.length === 0) {
+                let folderUri;
+                if (URI.isUri(resource)) {
+                    folderUri = resource;
+                } else {
+                    const folders = contextService.getWorkspace().folders;
+                    if (folders.length > 0) {
+                        folderUri = folders[0].uri;
+                    }
+                }
+                if (folderUri) {
+                    imageUris = await collectImageFilesFromFolder(fileService, folderUri);
+                }
+            } else {
+                const hasSingleImageFile = context.length === 1 && !context[0].isDirectory && isMediaResource(context[0].resource);
+                if (hasSingleImageFile) {
+                    startUri = context[0].resource;
+                    const parentUri = dirname(context[0].resource);
+                    imageUris = await collectImageFilesFromFolder(fileService, parentUri);
+                } else {
+                    const seen = ( new ResourceSet());
+                    for (const item of context) {
+                        if (item.isDirectory) {
+                            const folderImages = await collectImageFilesFromFolder(fileService, item.resource);
+                            for (const uri of folderImages) {
+                                if (!( seen.has(uri))) {
+                                    seen.add(uri);
+                                    imageUris.push(uri);
+                                }
+                            }
+                        } else if (isMediaResource(item.resource)) {
+                            if (!( seen.has(item.resource))) {
+                                seen.add(item.resource);
+                                imageUris.push(item.resource);
+                                if (!startUri) {
+                                    startUri = item.resource;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        } catch {
+            notificationService.error(( localize(10516, "Could not read folder contents.")));
+            return;
+        }
+        if (imageUris.length === 0) {
+            notificationService.info(( localize(10517, "No images found in this folder.")));
+            return;
+        }
+        const images = createImageEntries(imageUris);
+        let startIndex = 0;
+        if (startUri) {
+            const idx = images.findIndex(img => img.uri?.toString() === ( startUri.toString()));
+            if (idx >= 0) {
+                startIndex = idx;
+            }
+        }
+        const collection = {
+            id: generateUuid(),
+            title: ( localize(10518, "Images Preview")),
+            sections: [{
+                title: "",
+                images
+            }]
+        };
+        const input = ( new ImageCarouselEditorInput(collection, startIndex));
+        await editorService.openEditor(input, {
+            pinned: true
+        });
+    }
+}
+registerAction2(OpenImagesInCarouselFromExplorerAction);

package/vscode/src/vs/workbench/contrib/imageCarousel/browser/imageCarouselEditor.d.ts

@@ -0,0 +1,66 @@
+import { Dimension } from "@codingame/monaco-vscode-api/vscode/vs/base/browser/dom";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { EditorPane } from "@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IWebviewService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/webview/browser/webview.service";
+import { ImageCarouselEditorInput } from "./imageCarouselEditorInput.js";
+export declare class ImageCarouselEditor extends EditorPane {
+    private readonly _fileService;
+    private readonly _webviewService;
+    static readonly ID = "workbench.editor.imageCarousel";
+    private _container;
+    private _currentIndex;
+    private _zoomScale;
+    private _sections;
+    private _flatImages;
+    private readonly _contentDisposables;
+    private readonly _imageDisposables;
+    private readonly _blobUrlCache;
+    private _videoWebview;
+    private _elements;
+    private _thumbnailElements;
+    constructor(group: IEditorGroup, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService, _fileService: IFileService, _webviewService: IWebviewService);
+    protected createEditor(parent: HTMLElement): void;
+    setInput(input: ImageCarouselEditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    clearInput(): void;
+    private _isCurrentVideo;
+    /**
+     * Build the full DOM skeleton. Called once per setInput.
+     */
+    private buildSlideshow;
+    /**
+     * Update only the changing parts: main image src, caption, button states, thumbnail selection.
+     * No DOM teardown/rebuild — eliminates the blank flash.
+     */
+    private updateCurrentImage;
+    private _loadBlobUrl;
+    private _revokeCachedBlobUrls;
+    private _loadRawData;
+    private _preloadAdjacentImages;
+    previous(): void;
+    next(): void;
+    /**
+     * Compute the current display scale when transitioning from 'fit' to numeric zoom.
+     */
+    private _initZoomFromFit;
+    /**
+     * Zoom in to the next predefined zoom level.
+     */
+    private _zoomIn;
+    /**
+     * Zoom out to the previous predefined zoom level.
+     */
+    private _zoomOut;
+    /**
+     * Apply fit-to-container or numeric zoom with scroll-center preservation.
+     */
+    private _applyZoom;
+    focus(): void;
+    layout(dimension: Dimension): void;
+}