@codingame/monaco-vscode-api 20.1.1 → 20.2.1

package/vscode/src/vs/workbench/common/panecomposite.d.ts

@@ -1,6 +1,9 @@
 import { IView, IViewPaneContainer } from "./views.js";
 import { IComposite } from "./composite.js";
 export interface IPaneComposite extends IComposite {
+    /**
+     * Returns the minimal width needed to avoid any content horizontal truncation
+     */
     getOptimalWidth(): number | undefined;
     openView<T extends IView>(id: string, focus?: boolean): T | undefined;
     getViewPaneContainer(): IViewPaneContainer | undefined;

package/vscode/src/vs/workbench/common/views.d.ts

@@ -37,15 +37,49 @@ type OpenCommandActionDescriptor = {
         when?: ContextKeyExpression;
     };
 };
+/**
+ * View Container Contexts
+ */
 export interface IViewContainerDescriptor {
+    /**
+     * The id of the view container
+     */
     readonly id: string;
+    /**
+     * The title of the view container
+     */
     readonly title: ILocalizedString;
+    /**
+     * Icon representation of the View container
+     */
     readonly icon?: ThemeIcon | URI;
+    /**
+     * Order of the view container.
+     */
     readonly order?: number;
+    /**
+     * IViewPaneContainer Ctor to instantiate
+     */
     readonly ctorDescriptor: SyncDescriptor<IViewPaneContainer>;
+    /**
+     * Descriptor for open view container command
+     * If not provided, view container info (id, title) is used.
+     *
+     * Note: To prevent registering open command, use `doNotRegisterOpenCommand` flag while registering the view container
+     */
     readonly openCommandActionDescriptor?: OpenCommandActionDescriptor;
+    /**
+     * Storage id to use to store the view container state.
+     * If not provided, it will be derived.
+     */
     readonly storageId?: string;
+    /**
+     * If enabled, view container is not shown if it has no active views.
+     */
     readonly hideIfEmpty?: boolean;
+    /**
+     * Id of the extension that contributed the view container
+     */
     readonly extensionId?: ExtensionIdentifier;
     readonly alwaysUseContainerInfo?: boolean;
     readonly viewOrderDelegate?: ViewOrderDelegate;
@@ -53,23 +87,59 @@ export interface IViewContainerDescriptor {
     requestedIndex?: number;
 }
 export interface IViewContainersRegistry {
+    /**
+     * An event that is triggered when a view container is registered.
+     */
     readonly onDidRegister: Event<{
         viewContainer: ViewContainer;
         viewContainerLocation: ViewContainerLocation;
     }>;
+    /**
+     * An event that is triggered when a view container is deregistered.
+     */
     readonly onDidDeregister: Event<{
         viewContainer: ViewContainer;
         viewContainerLocation: ViewContainerLocation;
     }>;
+    /**
+     * All registered view containers
+     */
     readonly all: ViewContainer[];
+    /**
+     * Registers a view container to given location.
+     * No op if a view container is already registered.
+     *
+     * @param viewContainerDescriptor descriptor of view container
+     * @param location location of the view container
+     *
+     * @returns the registered ViewContainer.
+     */
     registerViewContainer(viewContainerDescriptor: IViewContainerDescriptor, location: ViewContainerLocation, options?: {
         isDefault?: boolean;
         doNotRegisterOpenCommand?: boolean;
     }): ViewContainer;
+    /**
+     * Deregisters the given view container
+     * No op if the view container is not registered
+     */
     deregisterViewContainer(viewContainer: ViewContainer): void;
+    /**
+     * Returns the view container with given id.
+     *
+     * @returns the view container with given id.
+     */
     get(id: string): ViewContainer | undefined;
+    /**
+     * Returns all view containers in the given location
+     */
     getViewContainers(location: ViewContainerLocation): ViewContainer[];
+    /**
+     * Returns the view container location
+     */
     getViewContainerLocation(container: ViewContainer): ViewContainerLocation;
+    /**
+     * Return the default view container from the given location
+     */
     getDefaultViewContainer(location: ViewContainerLocation): ViewContainer | undefined;
 }
 interface ViewOrderDelegate {
@@ -168,6 +238,10 @@ export declare enum ViewContentGroups {
 }
 export interface IViewContentDescriptor {
     readonly content: string;
+    /**
+     * Whether to render all but the first button as secondary
+     * if there are buttons in the `content` property.
+     */
     readonly renderSecondaryButtons?: boolean;
     readonly when?: ContextKeyExpression | "default";
     readonly group?: string;

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibilityConfiguration.d.ts

@@ -15,6 +15,10 @@ export declare const accessibleViewInCodeBlock: RawContextKey<boolean>;
 export declare const accessibleViewContainsCodeBlocks: RawContextKey<boolean>;
 export declare const accessibleViewHasUnassignedKeybindings: RawContextKey<boolean>;
 export declare const accessibleViewHasAssignedKeybindings: RawContextKey<boolean>;
+/**
+ * Miscellaneous settings tagged with accessibility and implemented in the accessibility contrib but
+ * were better to live under workbench for discoverability.
+ */
 export declare enum AccessibilityWorkbenchSettingId {
     DimUnfocusedEnabled = "accessibility.dimUnfocused.enabled",
     DimUnfocusedOpacity = "accessibility.dimUnfocused.opacity",

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

@@ -8,6 +8,9 @@ import { IChatWidget, type ICodeBlockActionContextProvider, type IQuickChatOpenO
 export declare const IChatWidgetService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatWidgetService>;
 export interface IChatWidgetService {
     readonly _serviceBrand: undefined;
+    /**
+    * Returns the most recently focused widget if any.
+    */
     readonly lastFocusedWidget: IChatWidget | undefined;
     readonly onDidAddWidget: Event<IChatWidget>;
     getAllWidgets(): ReadonlyArray<IChatWidget>;

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

@@ -3,8 +3,19 @@ import { ChatTreeItem, IChatCodeBlockInfo } from "@codingame/monaco-vscode-b9949
 import { IChatRendererContent } from "@codingame/monaco-vscode-c2deffc4-ad68-5e63-8f95-9b89e0fc6898-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
 export interface IChatContentPart extends IDisposable {
     domNode: HTMLElement | undefined;
+    /**
+     * Used to indicate a part's ownership of a code block.
+     */
     codeblocksPartId?: string;
+    /**
+     * Codeblocks that were rendered by this part into CodeBlockModelCollection.
+     */
     codeblocks?: IChatCodeBlockInfo[];
+    /**
+     * Returns true if the other content is equivalent to what is already rendered in this content part.
+     * Returns false if a rerender is needed.
+     * followingContent is all the content that will be rendered after this content part (to support progress messages' behavior).
+     */
     hasSameContent(other: IChatRendererContent, followingContent: IChatRendererContent[], element: ChatTreeItem): boolean;
     addDisposable?(disposable: IDisposable): void;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/chatContentParts/chatMarkdownAnchorService.service.d.ts

@@ -3,6 +3,9 @@ import { InlineAnchorWidget } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-
 export declare const IChatMarkdownAnchorService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatMarkdownAnchorService>;
 export interface IChatMarkdownAnchorService {
     readonly _serviceBrand: undefined;
+    /**
+    * Returns the currently focused anchor if any
+    */
     readonly lastFocusedAnchor: InlineAnchorWidget | undefined;
     register(widget: InlineAnchorWidget): IDisposable;
 }

package/vscode/src/vs/workbench/contrib/chat/browser/chatContextPickService.service.d.ts

@@ -3,6 +3,11 @@ import { IChatContextValueItem, IChatContextPickerItem } from "@codingame/monaco
 export interface IChatContextPickService {
     _serviceBrand: undefined;
     items: Iterable<IChatContextValueItem | IChatContextPickerItem>;
+    /**
+    * Register a value or  picker to the "Add Context" flow. A value directly resolved to a
+    * chat attachment and a picker first shows a list of items to pick from and then
+    * resolves the selected item to a chat attachment.
+    */
     registerChatContextItem(item: IChatContextValueItem | IChatContextPickerItem): IDisposable;
 }
 export declare const IChatContextPickService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatContextPickService>;

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

@@ -7,6 +7,9 @@ import { ChatAgentLocation, ChatModeKind } from "./constants.js";
 export declare const IChatAgentService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatAgentService>;
 export interface IChatAgentService {
     _serviceBrand: undefined;
+    /**
+    * undefined when an agent was removed
+    */
     readonly onDidChangeAgents: Event<IChatAgent | undefined>;
     readonly hasToolsAgent: boolean;
     registerAgent(id: string, data: IChatAgentData): IDisposable;
@@ -34,7 +37,13 @@ export interface IChatAgentService {
     getActivatedAgents(): Array<IChatAgent>;
     getAgentsByName(name: string): IChatAgentData[];
     agentHasDupeName(id: string): boolean;
+    /**
+    * Get the default agent (only if activated)
+    */
     getDefaultAgent(location: ChatAgentLocation, mode?: ChatModeKind): IChatAgent | undefined;
+    /**
+    * Get the default agent data that has been contributed (may not be activated yet)
+    */
     getContributedDefaultAgent(location: ChatAgentLocation): IChatAgentData | undefined;
     updateAgent(id: string, updateMetadata: IChatAgentMetadata): void;
 }

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

@@ -28,6 +28,9 @@ export declare namespace ChatContextKeys {
     const chatToolGroupingThreshold: RawContextKey<number>;
     const supported: import("../../../../platform/contextkey/common/contextkey.js").ContextKeyExpression | undefined;
     const enabled: RawContextKey<boolean>;
+    /**
+     * True when the chat widget is locked to the coding agent session.
+     */
     const lockedToCodingAgent: RawContextKey<boolean>;
     const extensionParticipantRegistered: RawContextKey<boolean>;
     const panelParticipantRegistered: RawContextKey<boolean>;

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

@@ -33,6 +33,7 @@ export interface IStreamingEdits {
     pushText(edits: TextEdit[], isLastEdits: boolean): void;
     pushNotebookCellText(cell: URI, edits: TextEdit[], isLastEdits: boolean): void;
     pushNotebook(edits: ICellEditOperation[], isLastEdits: boolean): void;
+    /** Marks edits as done, idempotent */
     complete(): void;
 }
 export declare const chatEditingSnapshotScheme = "chat-editing-snapshot-text-model";
@@ -64,11 +65,29 @@ export interface IChatEditingSession extends IDisposable {
     getEntry(uri: URI): IModifiedFileEntry | undefined;
     readEntry(uri: URI, reader?: IReader): IModifiedFileEntry | undefined;
     restoreSnapshot(requestId: string, stopId: string | undefined): Promise<void>;
+    /**
+     * Gets the snapshot URI of a file at the request and _after_ changes made in the undo stop.
+     * @param uri File in the workspace
+     */
     getSnapshotUri(requestId: string, uri: URI, stopId: string | undefined): URI | undefined;
     getSnapshotModel(requestId: string, undoStop: string | undefined, snapshotUri: URI): Promise<ITextModel | null>;
     getSnapshot(requestId: string, undoStop: string | undefined, snapshotUri: URI): ISnapshotEntry | undefined;
+    /**
+     * Will lead to this object getting disposed
+     */
     stop(clearState?: boolean): Promise<void>;
+    /**
+     * Starts making edits to the resource.
+     * @param resource URI that's being edited
+     * @param responseModel The response model making the edits
+     * @param inUndoStop The undo stop the edits will be grouped in
+     */
     startStreamingEdits(resource: URI, responseModel: IChatResponseModel, inUndoStop: string | undefined): IStreamingEdits;
+    /**
+     * Gets the document diff of a change made to a URI between one undo stop and
+     * the next one.
+     * @returns The observable or undefined if there is no diff between the stops.
+     */
     getEntryDiffBetweenStops(uri: URI, requestId: string | undefined, stopId: string | undefined): IObservable<IEditSessionEntryDiff | undefined> | undefined;
     readonly canUndo: IObservable<boolean>;
     readonly canRedo: IObservable<boolean>;
@@ -76,11 +95,15 @@ export interface IChatEditingSession extends IDisposable {
     redoInteraction(): Promise<void>;
 }
 export interface IEditSessionEntryDiff {
+    /** LHS and RHS of a diff editor, if opened: */
     originalURI: URI;
     modifiedURI: URI;
+    /** Diff state information: */
     quitEarly: boolean;
     identical: boolean;
+    /** Added data (e.g. line numbers) to show in the UI */
     added: number;
+    /** Removed data (e.g. line numbers) to show in the UI */
     removed: number;
 }
 export declare enum ModifiedFileEntryState {
@@ -88,18 +111,50 @@ export declare enum ModifiedFileEntryState {
     Accepted = 1,
     Rejected = 2
 }
+/**
+ * Represents a part of a change
+ */
 export interface IModifiedFileEntryChangeHunk {
     accept(): Promise<boolean>;
     reject(): Promise<boolean>;
 }
 export interface IModifiedFileEntryEditorIntegration extends IDisposable {
+    /**
+     * The index of a change
+     */
     currentIndex: IObservable<number>;
+    /**
+     * Reveal the first (`true`) or last (`false`) change
+     */
     reveal(firstOrLast: boolean, preserveFocus?: boolean): void;
+    /**
+     * Go to next change and increate `currentIndex`
+     * @param wrap When at the last, start over again or not
+     * @returns If it went next
+     */
     next(wrap: boolean): boolean;
+    /**
+     * @see `next`
+     */
     previous(wrap: boolean): boolean;
+    /**
+     * Enable the accessible diff viewer for this editor
+     */
     enableAccessibleDiffView(): void;
+    /**
+     * Accept the change given or the nearest
+     * @param change An opaque change object
+     */
     acceptNearestChange(change?: IModifiedFileEntryChangeHunk): Promise<void>;
+    /**
+     * @see `acceptNearestChange`
+     */
     rejectNearestChange(change?: IModifiedFileEntryChangeHunk): Promise<void>;
+    /**
+     * Toggle between diff-editor and normal editor
+     * @param change An opaque change object
+     * @param show Optional boolean to control if the diff should show
+     */
     toggleDiff(change: IModifiedFileEntryChangeHunk | undefined, show?: boolean): Promise<void>;
 }
 export interface IModifiedFileEntry {
@@ -121,6 +176,9 @@ export interface IModifiedFileEntry {
         cancel(): void;
     } | undefined>;
     enableReviewModeUntilSettled(): void;
+    /**
+     * Number of changes for this file
+     */
     readonly changesCount: IObservable<number>;
     getEditorIntegration(editor: IEditorPane): IModifiedFileEntryEditorIntegration;
 }

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

@@ -9,7 +9,13 @@ export interface IChatEditingService {
     _serviceBrand: undefined;
     startOrContinueGlobalEditingSession(chatModel: ChatModel): Promise<IChatEditingSession>;
     getEditingSession(chatSessionId: string): IChatEditingSession | undefined;
+    /**
+    * All editing sessions, sorted by recency, e.g the last created session comes first.
+    */
     readonly editingSessionsObs: IObservable<readonly IChatEditingSession[]>;
+    /**
+    * Creates a new short lived editing session
+    */
     createEditingSession(chatModel: ChatModel): Promise<IChatEditingSession>;
     hasRelatedFilesProviders(): boolean;
     registerRelatedFilesProvider(handle: number, provider: IChatRelatedFilesProvider): IDisposable;

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

@@ -226,6 +226,10 @@ export interface IChatTerminalToolInvocationData {
     };
     language: string;
 }
+/**
+ * @deprecated This is the old API shape, we should support this for a while before removing it so
+ * we don't break existing chats
+ */
 export interface ILegacyChatTerminalToolInvocationData {
     kind: "terminal";
     command: string;
@@ -238,8 +242,10 @@ export interface IChatToolInputInvocationData {
 export interface IChatToolInvocation {
     presentation: IPreparedToolInvocation["presentation"];
     toolSpecificData?: IChatTerminalToolInvocationData | ILegacyChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent;
+    /** Presence of this property says that confirmation is required */
     confirmationMessages?: IToolConfirmationMessages;
     confirmed: DeferredPromise<boolean>;
+    /** A 3-way: undefined=don't know yet. */
     isConfirmed: boolean | undefined;
     originMessage: string | IMarkdownString | undefined;
     invocationMessage: string | IMarkdownString;
@@ -263,6 +269,9 @@ export interface IToolResultOutputDetailsSerialized {
         base64Data: string;
     };
 }
+/**
+ * This is a IChatToolInvocation that has been serialized, like after window reload, so it is no longer an active tool invocation.
+ */
 export interface IChatToolInvocationSerialized {
     presentation: IPreparedToolInvocation["presentation"];
     toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatPullRequestContent | IChatTodoListContent;
@@ -410,7 +419,13 @@ export interface IChatUserActionEvent {
     result: IChatAgentResult | undefined;
 }
 export interface IChatDynamicRequest {
+    /**
+     * The message that will be displayed in the UI
+     */
     message: string;
+    /**
+     * Any extra metadata/context that will go to the provider.
+     */
     metadata?: any;
 }
 export interface IChatCompleteResponse {
@@ -468,8 +483,12 @@ export interface IChatSendRequestOptions {
     acceptedConfirmationData?: any[];
     rejectedConfirmationData?: any[];
     attachedContext?: IChatRequestVariableEntry[];
+    /** The target agent ID can be specified with this property instead of using @ in 'message' */
     agentId?: string;
     slashCommand?: string;
+    /**
+     * The label of the confirmation action that was selected.
+     */
     confirmation?: string;
 }
 export declare const KEYWORD_ACTIVIATION_SETTING_ID = "accessibility.voice.keywordActivation";

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

@@ -21,6 +21,9 @@ export interface IChatService {
     isPersistedSessionEmpty(sessionId: string): boolean;
     loadSessionFromContent(data: IExportableChatData | ISerializableChatData | URI): IChatModel | undefined;
     loadSessionForResource(resource: URI, location: ChatAgentLocation, token: CancellationToken): Promise<IChatModel | undefined>;
+    /**
+    * Returns whether the request was accepted.
+    */
     sendRequest(sessionId: string, message: string, options?: IChatSendRequestOptions): Promise<IChatSendRequestData | undefined>;
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     adoptRequest(sessionId: string, request: IChatRequestModel): Promise<void>;

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

@@ -7,6 +7,9 @@ import { IChatSlashData, IChatSlashCallback } from "@codingame/monaco-vscode-cha
 import { ChatAgentLocation, ChatModeKind } from "./constants.js";
 import { IChatMessage } from "./languageModels.js";
 export declare const IChatSlashCommandService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatSlashCommandService>;
+/**
+* This currently only exists to drive /clear and /help
+*/
 export interface IChatSlashCommandService {
     _serviceBrand: undefined;
     readonly onDidChangeCommands: Event<void>;

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

@@ -13,6 +13,10 @@ interface IBaseChatRequestVariableEntry {
     readonly icon?: ThemeIcon;
     readonly name: string;
     readonly modelDescription?: string;
+    /**
+     * The offset-range in the prompt. This means this entry has been explicitly typed out
+     * by the user.
+     */
     readonly range?: IOffsetRange;
     readonly value: IChatRequestVariableValue;
     readonly references?: IChatContentReference[];
@@ -118,6 +122,9 @@ export interface ISCMHistoryItemVariableEntry extends IBaseChatRequestVariableEn
 }
 export type IChatRequestVariableEntry = IGenericChatRequestVariableEntry | IChatRequestImplicitVariableEntry | IChatRequestPasteVariableEntry | ISymbolVariableEntry | ICommandResultVariableEntry | IDiagnosticVariableEntry | IImageVariableEntry | IChatRequestToolEntry | IChatRequestToolSetEntry | IChatRequestDirectoryEntry | IChatRequestFileEntry | INotebookOutputVariableEntry | IElementVariableEntry | IPromptFileVariableEntry | IPromptTextVariableEntry | ISCMHistoryItemVariableEntry;
 export declare namespace IChatRequestVariableEntry {
+    /**
+     * Returns URI of the passed variant entry. Return undefined if not found.
+     */
     function toUri(entry: IChatRequestVariableEntry): URI | undefined;
 }
 export declare function isImplicitVariableEntry(obj: IChatRequestVariableEntry): obj is IChatRequestImplicitVariableEntry;
@@ -136,6 +143,17 @@ export declare enum PromptFileVariableKind {
     InstructionReference = "vscode.prompt.instructions",
     PromptFile = "vscode.prompt.file"
 }
+/**
+ * Utility to convert a {@link uri} to a chat variable entry.
+ * The `id` of the chat variable can be one of the following:
+ *
+ * - `vscode.prompt.instructions__<URI>`: for all non-root prompt instructions references
+ * - `vscode.prompt.instructions.root__<URI>`: for *root* prompt instructions references
+ * - `vscode.prompt.file__<URI>`: for prompt file references
+ *
+ * @param uri A resource URI that points to a prompt instructions file.
+ * @param kind The kind of the prompt file variable entry.
+ */
 export declare function toPromptFileVariableEntry(uri: URI, kind: PromptFileVariableKind, originLabel?: string, automaticallyAdded?: boolean): IPromptFileVariableEntry;
 export declare function toPromptTextVariableEntry(content: string, settingId?: string, automaticallyAdded?: boolean): IPromptTextVariableEntry;
 export declare function toFileVariableEntry(uri: URI, range?: IRange): IChatRequestFileEntry;

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

@@ -8,6 +8,9 @@ export declare enum ChatConfiguration {
     CheckpointsEnabled = "chat.checkpoints.enabled",
     AgentSessionsViewLocation = "chat.agentSessionsViewLocation"
 }
+/**
+ * The "kind" of the chat mode- "Agent" for custom modes.
+ */
 export declare enum ChatModeKind {
     Ask = "ask",
     Edit = "edit",

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

@@ -27,6 +27,10 @@ export interface IToolData {
     modelDescription: string;
     inputSchema?: IJSONSchema;
     canBeReferencedInPrompt?: boolean;
+    /**
+     * True if the tool runs in the (possibly remote) workspace, false if it runs
+     * on the host, undefined if known.
+     */
     runsInWorkspace?: boolean;
     alwaysDisplayInputOutput?: boolean;
 }
@@ -86,13 +90,17 @@ export interface IToolInvocationPreparationContext {
     chatInteractionId?: string;
 }
 export type ToolInputOutputBase = {
+    /** Mimetype of the value, optional */
     mimeType?: string;
+    /** URI of the resource on the MCP server. */
     uri?: URI;
+    /** If true, this part came in as a resource reference rather than direct data. */
     asResource?: boolean;
 };
 export type ToolInputOutputEmbedded = ToolInputOutputBase & {
     type: "embed";
     value: string;
+    /** If true, value is text. If false or not given, value is base64 */
     isText?: boolean;
 };
 export type ToolInputOutputReference = ToolInputOutputBase & {
@@ -165,6 +173,9 @@ export declare class ToolSet {
     readonly description?: string | undefined;
     protected readonly _tools: ObservableSet<IToolData>;
     protected readonly _toolSets: ObservableSet<ToolSet>;
+    /**
+     * A homogenous tool set only contains tools from the same source as the tool set itself
+     */
     readonly isHomogenous: IObservable<boolean>;
     constructor(id: string, referenceName: string, icon: ThemeIcon, source: ToolDataSource, description?: string | undefined);
     addTool(data: IToolData, tx?: ITransaction): IDisposable;

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

@@ -34,9 +34,18 @@ export interface IChatMessageDataPart {
     audience?: ToolResultAudience[];
 }
 export interface IChatImageURLPart {
+    /**
+     * The image's MIME type (e.g., "image/png", "image/jpeg").
+     */
     mimeType: ChatImageMimeType;
+    /**
+     * The raw binary data of the image, encoded as a Uint8Array. Note: do not use base64 encoding. Maximum image size is 5MB.
+     */
     data: VSBuffer;
 }
+/**
+ * Enum for supported image MIME types.
+ */
 export declare enum ChatImageMimeType {
     PNG = "image/png",
     JPEG = "image/jpeg",
@@ -44,6 +53,9 @@ export declare enum ChatImageMimeType {
     WEBP = "image/webp",
     BMP = "image/bmp"
 }
+/**
+ * Specifies the detail level of the image.
+ */
 export declare enum ImageDetailLevel {
     Low = "low",
     High = "high"

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

@@ -11,6 +11,11 @@ export interface ILanguageModelsService {
     getLanguageModelIds(): string[];
     getVendors(): IUserFriendlyLanguageModel[];
     lookupLanguageModel(modelId: string): ILanguageModelChatMetadata | undefined;
+    /**
+    * Given a selector, returns a list of model identifiers
+    * @param selector The selector to lookup for language models. If the selector is empty, all language models are returned.
+    * @param allowPromptingUser If true the user may be prompted for things like API keys for us to select the model.
+    */
     selectLanguageModels(selector: ILanguageModelChatSelector, allowPromptingUser?: boolean): Promise<string[]>;
     registerLanguageModelProvider(vendor: string, provider: ILanguageModelChatProvider): IDisposable;
     sendChatRequest(modelId: string, from: ExtensionIdentifier, messages: IChatMessage[], options: {

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/types.d.ts

@@ -6,15 +6,49 @@ import { VSBufferReadableStream } from "../../../../../../base/common/buffer.js"
 import { PromptsType } from "@codingame/monaco-vscode-e28ac690-06d5-5ee9-92d1-02df70296354-common/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
 import { CancellationToken } from "../../../../../../base/common/cancellation.js";
 import { IPromptContentsProviderOptions } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/promptSyntax/contentProviders/promptContentsProviderBase";
+/**
+ * Interface for a prompt contents provider. Prompt contents providers are
+ * responsible for providing contents of a prompt as a byte streams and
+ * allow to subscribe to the change events of the prompt contents.
+ */
 export interface IPromptContentsProvider extends IDisposable {
+    /**
+     * URI component of the prompt associated with this contents provider.
+     */
     readonly uri: URI;
+    /**
+     * Language ID of the prompt contents.
+     */
     readonly languageId: string;
+    /**
+     * Prompt type used to determine how to interpret file contents.
+     */
     readonly promptType: PromptsType | "non-prompt";
+    /**
+     * Prompt contents stream.
+     */
     readonly contents: Promise<VSBufferReadableStream>;
+    /**
+     * Prompt contents source name.
+     */
     readonly sourceName: string;
+    /**
+     * Event that fires when the prompt contents change. The event is either a
+     * {@linkcode VSBufferReadableStream} stream with changed contents or
+     * an instance of the {@linkcode ResolveError} error.
+     */
     readonly onContentChanged: Event<VSBufferReadableStream | ResolveError>;
+    /**
+     * Subscribe to `onDispose` event of the contents provider.
+     */
     readonly onDispose: Event<void>;
+    /**
+     * Start the contents provider to produce the underlying contents.
+     */
     start(token?: CancellationToken): this;
+    /**
+     * Create a new instance of prompt contents provider.
+     */
     createNew(promptContentsSource: {
         uri: URI;
     }, options: IPromptContentsProviderOptions): IPromptContentsProvider;