src/vs/workbench/api/common/extHost.protocol.ts
4204 LOC · 4196 covered · 8 uncovered · 3 ranges · 122 concepts · 1 introducers · 82 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
extHost.protocol.ts ×3
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { VSBuffer } from '../../../base/common/buffer.js';
7
>
import { CancellationToken } from '../../../base/common/cancellation.js';
8
>
import { IRemoteConsoleLog } from '../../../base/common/console.js';
9
>
import { SerializedError } from '../../../base/common/errors.js';
10
>
import { IRelativePattern } from '../../../base/common/glob.js';
11
>
import { IMarkdownString } from '../../../base/common/htmlContent.js';
12
>
import { IJSONSchema } from '../../../base/common/jsonSchema.js';
13
>
import { IDisposable } from '../../../base/common/lifecycle.js';
14
>
import { IAuthorizationProtectedResourceMetadata, IAuthorizationServerMetadata, IAuthorizationTokenResponse } from '../../../base/common/oauth.js';
15
>
import * as performance from '../../../base/common/performance.js';
16
>
import Severity from '../../../base/common/severity.js';
17
>
import { ThemeColor, ThemeIcon } from '../../../base/common/themables.js';
18
>
import { URI, UriComponents, UriDto } from '../../../base/common/uri.js';
19
>
import { RenderLineNumbersType, TextEditorCursorStyle } from '../../../editor/common/config/editorOptions.js';
20
>
import { ISingleEditOperation } from '../../../editor/common/core/editOperation.js';
21
>
import { IPosition } from '../../../editor/common/core/position.js';
22
>
import { IRange } from '../../../editor/common/core/range.js';
23
>
import { ISelection, Selection } from '../../../editor/common/core/selection.js';
24
>
import { IChange } from '../../../editor/common/diff/legacyLinesDiffComputer.js';
25
>
import * as editorCommon from '../../../editor/common/editorCommon.js';
26
>
import { StandardTokenType } from '../../../editor/common/encodedTokenAttributes.js';
27
>
import * as languages from '../../../editor/common/languages.js';
28
>
import { CompletionItemLabel } from '../../../editor/common/languages.js';
29
>
import { CharacterPair, CommentRule, EnterAction } from '../../../editor/common/languages/languageConfiguration.js';
30
>
import { EndOfLineSequence } from '../../../editor/common/model.js';
31
>
import { EditSuggestionId } from '../../../editor/common/textModelEditSource.js';
32
>
import { ISerializedModelContentChangedEvent } from '../../../editor/common/textModelEvents.js';
33
>
import { IAccessibilityInformation } from '../../../platform/accessibility/common/accessibility.js';
34
>
import { ILocalizedString } from '../../../platform/action/common/action.js';
35
>
import { ConfigurationTarget, IConfigurationChange, IConfigurationData, IConfigurationOverrides } from '../../../platform/configuration/common/configuration.js';
36
>
import { ConfigurationScope } from '../../../platform/configuration/common/configurationRegistry.js';
37
>
import { IEditorOptions } from '../../../platform/editor/common/editor.js';
38
>
import { IExtensionIdWithVersion } from '../../../platform/extensionManagement/common/extensionStorage.js';
39
>
import { ExtensionIdentifier, IExtensionDescription } from '../../../platform/extensions/common/extensions.js';
40
>
import * as files from '../../../platform/files/common/files.js';
41
>
import { ResourceLabelFormatter } from '../../../platform/label/common/label.js';
42
>
import { ILoggerOptions, ILoggerResource, LogLevel } from '../../../platform/log/common/log.js';
43
>
import { IMarkerData } from '../../../platform/markers/common/markers.js';
44
>
import { IProgressOptions, IProgressStep } from '../../../platform/progress/common/progress.js';
45
>
import * as quickInput from '../../../platform/quickinput/common/quickInput.js';
46
>
import { IRemoteConnectionData, TunnelDescription } from '../../../platform/remote/common/remoteAuthorityResolver.js';
47
>
import { AuthInfo, Credentials } from '../../../platform/request/common/request.js';
48
>
import { ClassifiedEvent, IGDPRProperty, OmitMetadata, StrictPropertyCheck } from '../../../platform/telemetry/common/gdprTypings.js';
49
>
import { TelemetryLevel } from '../../../platform/telemetry/common/telemetry.js';
50
>
import { ISerializableEnvironmentDescriptionMap, ISerializableEnvironmentVariableCollection } from '../../../platform/terminal/common/environmentVariable.js';
51
>
import { ICreateContributedTerminalProfileOptions, IProcessProperty, IProcessReadyWindowsPty, IShellLaunchConfigDto, ITerminalEnvironment, ITerminalLaunchError, ITerminalProfile, TerminalExitReason, TerminalLocation, TerminalShellType } from '../../../platform/terminal/common/terminal.js';
52
>
import { ProvidedPortAttributes, TunnelCreationOptions, TunnelOptions, TunnelPrivacyId, TunnelProviderFeatures } from '../../../platform/tunnel/common/tunnel.js';
53
>
import { ITunnelProxyInfo } from '../../../platform/tunnel/common/tunnelProxy.js';
54
>
import { EditSessionIdentityMatch } from '../../../platform/workspace/common/editSessions.js';
55
>
import { WorkspaceTrustRequestOptions } from '../../../platform/workspace/common/workspaceTrust.js';
56
>
import { SaveReason } from '../../common/editor.js';
57
>
import { IRevealOptions, ITreeItem, IViewBadge } from '../../common/views.js';
58
>
import { CallHierarchyItem } from '../../contrib/callHierarchy/common/callHierarchy.js';
59
>
import { IChatAgentMetadata, IChatAgentRequest, IChatAgentResult, UserSelectedTools } from '../../contrib/chat/common/participants/chatAgents.js';
60
>
import { ICodeMapperRequest, ICodeMapperResult } from '../../contrib/chat/common/editing/chatCodeMapperService.js';
61
>
import { IChatContextItem } from '../../contrib/chat/common/contextContrib/chatContext.js';
62
>
import { IChatProgressHistoryResponseContent, IChatRequestModeInstructions, IChatRequestVariableData } from '../../contrib/chat/common/model/chatModel.js';
63
>
import { ChatResponseClearToPreviousToolInvocationReason, IChatContentInlineReference, IChatExternalEditsDto, IChatFollowup, IChatMultiDiffData, IChatMultiDiffDataSerialized, IChatNotebookEdit, IChatProgress, IChatTask, IChatTaskDto, IChatUserActionEvent, IChatVoteAction } from '../../contrib/chat/common/chatService/chatService.js';
64
>
import { IChatSessionItem, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem } from '../../contrib/chat/common/chatSessionsService.js';
65
>
import { IChatRequestVariableValue } from '../../contrib/chat/common/attachments/chatVariables.js';
66
>
import { ChatAgentLocation } from '../../contrib/chat/common/constants.js';
67
>
import { IChatMessage, IChatResponsePart, ILanguageModelChatInfoOptions, ILanguageModelChatMetadataAndIdentifier, ILanguageModelChatRequestOptions, ILanguageModelChatSelector } from '../../contrib/chat/common/languageModels.js';
68
>
import { IPreparedToolInvocation, IStreamedToolInvocation, IToolInvocation, IToolInvocationPreparationContext, IToolInvocationStreamContext, IToolProgressStep, IToolResult, ToolDataSource } from '../../contrib/chat/common/tools/languageModelToolsService.js';
69
>
import { IPromptFileContext, IPromptFileResource } from '../../contrib/chat/common/promptSyntax/service/promptsService.js';
70
>
import { DebugConfigurationProviderTriggerKind, IAdapterDescriptor, IConfig, IDebugSessionReplMode, IDebugTestRunReference, IDebugVisualization, IDebugVisualizationContext, IDebugVisualizationTreeItem, MainThreadDebugVisualization } from '../../contrib/debug/common/debug.js';
71
>
import { McpCollectionDefinition, McpConnectionState, McpServerDefinition, McpServerLaunch } from '../../contrib/mcp/common/mcpTypes.js';
72
>
import * as notebookCommon from '../../contrib/notebook/common/notebookCommon.js';
73
>
import { CellExecutionUpdateType } from '../../contrib/notebook/common/notebookExecutionService.js';
74
>
import { ICellExecutionComplete, ICellExecutionStateUpdate } from '../../contrib/notebook/common/notebookExecutionStateService.js';
75
>
import { ICellRange } from '../../contrib/notebook/common/notebookRange.js';
76
>
import { ISCMHistoryOptions } from '../../contrib/scm/common/history.js';
77
>
import { InputValidationType } from '../../contrib/scm/common/scm.js';
78
>
import { IWorkspaceSymbol, NotebookPriorityInfo } from '../../contrib/search/common/search.js';
79
>
import { IRawClosedNotebookFileMatch } from '../../contrib/search/common/searchNotebookHelpers.js';
80
>
import { IKeywordRecognitionEvent, ISpeechProviderMetadata, ISpeechToTextEvent, ITextToSpeechEvent } from '../../contrib/speech/common/speechService.js';
81
>
import { CoverageDetails, ExtensionRunTestsRequest, ICallProfileRunHandler, IFileCoverage, ISerializedTestResults, IStartControllerTests, ITestItem, ITestMessage, ITestRunProfile, ITestRunTask, ResolvedTestRunRequest, TestControllerCapability, TestMessageFollowupRequest, TestMessageFollowupResponse, TestResultState, TestsDiffOp } from '../../contrib/testing/common/testTypes.js';
82
>
import { Timeline, TimelineChangeEvent, TimelineOptions, TimelineProviderDescriptor } from '../../contrib/timeline/common/timeline.js';
83
>
import { TypeHierarchyItem } from '../../contrib/typeHierarchy/common/typeHierarchy.js';
84
>
import { RelatedInformationResult, RelatedInformationType } from '../../services/aiRelatedInformation/common/aiRelatedInformation.js';
85
>
import { AiSettingsSearchProviderOptions, AiSettingsSearchResult } from '../../services/aiSettingsSearch/common/aiSettingsSearch.js';
86
>
import { AuthenticationSession, AuthenticationSessionAccount, AuthenticationSessionsChangeEvent, IAuthenticationConstraint, IAuthenticationCreateSessionOptions, IAuthenticationGetSessionsOptions, IAuthenticationWwwAuthenticateRequest } from '../../services/authentication/common/authentication.js';
87
>
import { EditorGroupColumn } from '../../services/editor/common/editorGroupColumn.js';
88
>
import { IExtensionDescriptionDelta, IStaticWorkspaceData } from '../../services/extensions/common/extensionHostProtocol.js';
89
>
import { IResolveAuthorityResult } from '../../services/extensions/common/extensionHostProxy.js';
90
>
import { ActivationKind, ExtensionActivationReason, MissingExtensionDependency } from '../../services/extensions/common/extensions.js';
91
>
import { Dto, IRPCProtocol, SerializableObjectWithBuffers, createProxyIdentifier } from '../../services/extensions/common/proxyIdentifier.js';
92
>
import { IInlineCompletionsUnificationState } from '../../services/inlineCompletions/common/inlineCompletionsUnification.js';
93
>
import { ILanguageStatus } from '../../services/languageStatus/common/languageStatusService.js';
94
>
import { OutputChannelUpdateMode } from '../../services/output/common/output.js';
95
>
import { CandidatePort } from '../../services/remote/common/tunnelModel.js';
96
>
import { IFileQueryBuilderOptions, ITextQueryBuilderOptions } from '../../services/search/common/queryBuilder.js';
97
>
import * as search from '../../services/search/common/search.js';
98
>
import { AISearchKeyword, TextSearchCompleteMessage } from '../../services/search/common/searchExtTypes.js';
99
>
import { ISaveProfileResult } from '../../services/userDataProfile/common/userDataProfile.js';
100
>
import { IExtHostDocumentSaveDelegate } from './extHostDocumentData.js';
101
>
import { TerminalShellExecutionCommandLineConfidence } from './extHostTypes.js';
102
>
import * as tasks from './shared/tasks.js';
103
>
import { PromptsType } from '../../contrib/chat/common/promptSyntax/promptTypes.js';
104
>
import { CDPEvent, CDPRequest, CDPResponse } from '../../../platform/browserView/common/cdp/types.js';
105
>
106
>
export type IconPathDto =
107
>
| UriComponents
108
>
| { light: UriComponents; dark: UriComponents }
109
>
| ThemeIcon;
110
>
111
>
export interface IWorkspaceData extends IStaticWorkspaceData {
112
>
folders: { uri: UriComponents; name: string; index: number }[];
113
>
}
114
>
115
>
export interface IConfigurationInitData extends IConfigurationData {
116
>
configurationScopes: [string, ConfigurationScope | undefined][];
117
>
}
118
>
119
>
export interface IMainContext extends IRPCProtocol {
120
>
}
121
>
122
>
// --- main thread
123
>
124
>
export interface MainThreadGitExtensionShape extends IDisposable {
125
>
$onDidChangeRepository(handle: number): Promise<void>;
126
>
}
127
>
128
>
export interface MainThreadClipboardShape extends IDisposable {
129
>
$readText(): Promise<string>;
130
>
$writeText(value: string): Promise<void>;
131
>
}
132
>
133
>
export interface MainThreadCommandsShape extends IDisposable {
134
>
$registerCommand(id: string): void;
135
>
$unregisterCommand(id: string): void;
136
>
$fireCommandActivationEvent(id: string): void;
137
>
$executeCommand(id: string, args: unknown[] | SerializableObjectWithBuffers<unknown[]>, retry: boolean): Promise<unknown | undefined>;
138
>
$getCommands(): Promise<string[]>;
139
>
}
140
>
141
>
export interface CommentProviderFeatures {
142
>
reactionGroup?: languages.CommentReaction[];
143
>
reactionHandler?: boolean;
144
>
options?: languages.CommentOptions;
145
>
}
146
>
147
>
export interface CommentChanges {
148
>
readonly uniqueIdInThread: number;
149
>
readonly body: string | IMarkdownString;
150
>
readonly userName: string;
151
>
readonly userIconPath?: UriComponents;
152
>
readonly contextValue?: string;
153
>
readonly commentReactions?: languages.CommentReaction[];
154
>
readonly label?: string;
155
>
readonly mode?: languages.CommentMode;
156
>
readonly state?: languages.CommentState;
157
>
readonly timestamp?: string;
158
>
}
159
>
160
>
export type CommentThreadChanges<T = IRange> = Partial<{
161
>
range: T | undefined;
162
>
label: string;
163
>
contextValue: string | null;
164
>
comments: CommentChanges[];
165
>
collapseState: languages.CommentThreadCollapsibleState;
166
>
canReply: boolean | languages.CommentAuthorInformation;
167
>
state: languages.CommentThreadState;
168
>
applicability: languages.CommentThreadApplicability;
169
>
isTemplate: boolean;
170
>
}>;
171
>
172
>
export interface MainThreadCommentsShape extends IDisposable {
173
>
$registerCommentController(handle: number, id: string, label: string, extensionId: string): void;
174
>
$unregisterCommentController(handle: number): void;
175
>
$updateCommentControllerFeatures(handle: number, features: CommentProviderFeatures): void;
176
>
$createCommentThread(handle: number, commentThreadHandle: number, threadId: string, resource: UriComponents, range: IRange | ICellRange | undefined, comments: languages.Comment[], extensionId: ExtensionIdentifier, isTemplate: boolean, editorId?: string): languages.CommentThread<IRange | ICellRange> | undefined;
177
>
$updateCommentThread(handle: number, commentThreadHandle: number, threadId: string, resource: UriComponents, changes: CommentThreadChanges): void;
178
>
$deleteCommentThread(handle: number, commentThreadHandle: number): void;
179
>
$updateCommentingRanges(handle: number, resourceHints?: languages.CommentingRangeResourceHint): void;
180
>
$revealCommentThread(handle: number, commentThreadHandle: number, commentUniqueIdInThread: number, options: languages.CommentThreadRevealOptions): Promise<void>;
181
>
$hideCommentThread(handle: number, commentThreadHandle: number): void;
182
>
}
183
>
184
>
export interface AuthenticationForceNewSessionOptions {
185
>
detail?: string;
186
>
sessionToRecreate?: AuthenticationSession;
187
>
}
188
>
189
>
export interface AuthenticationInteractiveOptions {
190
>
detail?: string;
191
>
learnMore?: UriComponents;
192
>
sessionToRecreate?: AuthenticationSession;
193
>
}
194
>
195
>
export interface AuthenticationGetSessionOptions {
196
>
clearSessionPreference?: boolean;
197
>
createIfNone?: boolean | AuthenticationInteractiveOptions;
198
>
forceNewSession?: boolean | AuthenticationInteractiveOptions;
199
>
silent?: boolean;
200
>
account?: AuthenticationSessionAccount;
201
>
}
202
>
export interface IRegisterAuthenticationProviderDetails {
203
>
id: string;
204
>
label: string;
205
>
supportsMultipleAccounts: boolean;
206
>
supportedAuthorizationServers?: UriComponents[];
207
>
supportsChallenges?: boolean;
208
>
resourceServer?: UriComponents;
209
>
}
210
>
211
>
export interface IRegisterDynamicAuthenticationProviderDetails extends IRegisterAuthenticationProviderDetails {
212
>
clientId: string;
213
>
clientSecret?: string;
214
>
authorizationServer: UriComponents;
215
>
}
216
>
217
>
export interface IXaaProviderDiscovery {
218
>
issuer: UriComponents;
219
>
serverMetadata: IAuthorizationServerMetadata;
220
>
clientId?: string;
221
>
}
222
>
223
>
export interface MainThreadAuthenticationShape extends IDisposable {
224
>
$registerAuthenticationProvider(details: IRegisterAuthenticationProviderDetails): Promise<void>;
225
>
$unregisterAuthenticationProvider(id: string): Promise<void>;
226
>
$ensureProvider(id: string): Promise<void>;
227
>
$sendDidChangeSessions(providerId: string, event: AuthenticationSessionsChangeEvent): Promise<void>;
228
>
$getSession(providerId: string, scopeListOrRequest: ReadonlyArray<string> | IAuthenticationWwwAuthenticateRequest, extensionId: string, extensionName: string, options: AuthenticationGetSessionOptions): Promise<AuthenticationSession | undefined>;
229
>
$getAccounts(providerId: string): Promise<ReadonlyArray<AuthenticationSessionAccount>>;
230
>
$removeSession(providerId: string, sessionId: string): Promise<void>;
231
>
$waitForUriHandler(expectedUri: UriComponents): Promise<UriComponents>;
232
>
$showContinueNotification(message: string): Promise<boolean>;
233
>
$showDeviceCodeModal(userCode: string, verificationUri: string): Promise<boolean>;
234
>
$promptForClientRegistration(authorizationServerUrl: string): Promise<{ clientId: string; clientSecret?: string } | undefined>;
235
>
$promptForResourceClientSecret(resourceClientId: string, resource: string): Promise<string | undefined>;
236
>
$registerDynamicAuthenticationProvider(details: IRegisterDynamicAuthenticationProviderDetails): Promise<void>;
237
>
$setSessionsForDynamicAuthProvider(authProviderId: string, clientId: string, sessions: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<void>;
238
>
$sendDidChangeDynamicProviderInfo({ providerId, clientId, authorizationServer, label, clientSecret }: { providerId: string; clientId?: string; authorizationServer?: UriComponents; label?: string; clientSecret?: string }): Promise<void>;
239
>
}
240
>
241
>
export interface MainThreadSecretStateShape extends IDisposable {
242
>
$getPassword(extensionId: string, key: string): Promise<string | undefined>;
243
>
$setPassword(extensionId: string, key: string, value: string): Promise<void>;
244
>
$deletePassword(extensionId: string, key: string): Promise<void>;
245
>
$getKeys(extensionId: string): Promise<string[]>;
246
>
}
247
>
248
>
export interface MainThreadConfigurationShape extends IDisposable {
249
>
$updateConfigurationOption(target: ConfigurationTarget | null, key: string, value: unknown, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
250
>
$removeConfigurationOption(target: ConfigurationTarget | null, key: string, overrides: IConfigurationOverrides | undefined, scopeToLanguage: boolean | undefined): Promise<void>;
251
>
}
252
>
253
>
export interface MainThreadDiagnosticsShape extends IDisposable {
254
>
$changeMany(owner: string, entries: [UriComponents, IMarkerData[] | undefined][]): void;
255
>
$clear(owner: string): void;
256
>
}
257
>
258
>
export interface MainThreadDialogOpenOptions {
259
>
defaultUri?: UriComponents;
260
>
openLabel?: string;
261
>
canSelectFiles?: boolean;
262
>
canSelectFolders?: boolean;
263
>
canSelectMany?: boolean;
264
>
filters?: { [name: string]: string[] };
265
>
title?: string;
266
>
allowUIResources?: boolean;
267
>
}
268
>
269
>
export interface MainThreadDialogSaveOptions {
270
>
defaultUri?: UriComponents;
271
>
saveLabel?: string;
272
>
filters?: { [name: string]: string[] };
273
>
title?: string;
274
>
}
275
>
276
>
export interface MainThreadDiaglogsShape extends IDisposable {
277
>
$showOpenDialog(options?: MainThreadDialogOpenOptions): Promise<UriComponents[] | undefined>;
278
>
$showSaveDialog(options?: MainThreadDialogSaveOptions): Promise<UriComponents | undefined>;
279
>
}
280
>
281
>
export interface MainThreadDecorationsShape extends IDisposable {
282
>
$registerDecorationProvider(handle: number, label: string): void;
283
>
$unregisterDecorationProvider(handle: number): void;
284
>
$onDidChange(handle: number, resources: UriComponents[] | null): void;
285
>
}
286
>
287
>
export interface MainThreadDocumentContentProvidersShape extends IDisposable {
288
>
$registerTextContentProvider(handle: number, scheme: string): void;
289
>
$unregisterTextContentProvider(handle: number): void;
290
>
$onVirtualDocumentChange(uri: UriComponents, value: string): Promise<void>;
291
>
}
292
>
293
>
export interface MainThreadDocumentsShape extends IDisposable, IExtHostDocumentSaveDelegate {
294
>
$tryCreateDocument(options?: { language?: string; content?: string; encoding?: string }): Promise<UriComponents>;
295
>
$tryOpenDocument(uri: UriComponents, options?: { encoding?: string }): Promise<UriComponents>;
296
>
$trySaveDocument(uri: UriComponents): Promise<boolean>;
297
>
}
298
>
299
>
export interface ITextEditorConfigurationUpdate {
300
>
tabSize?: number | 'auto';
301
>
indentSize?: number | 'tabSize';
302
>
insertSpaces?: boolean | 'auto';
303
>
cursorStyle?: TextEditorCursorStyle;
304
>
lineNumbers?: RenderLineNumbersType;
305
>
}
306
>
307
>
export interface IResolvedTextEditorConfiguration {
308
>
tabSize: number;
309
>
indentSize: number;
310
>
originalIndentSize: number | 'tabSize';
311
>
insertSpaces: boolean;
312
>
cursorStyle: TextEditorCursorStyle;
313
>
lineNumbers: RenderLineNumbersType;
314
>
}
315
>
316
>
export enum TextEditorRevealType {
317
>
Default = 0,
318
>
InCenter = 1,
319
>
InCenterIfOutsideViewport = 2,
320
>
AtTop = 3
321
>
}
322
>
323
>
export interface IUndoStopOptions {
324
>
undoStopBefore: boolean;
325
>
undoStopAfter: boolean;
326
>
}
327
>
328
>
export interface IApplyEditsOptions extends IUndoStopOptions {
329
>
setEndOfLine?: EndOfLineSequence;
330
>
}
331
>
332
>
export interface ISnippetOptions extends IUndoStopOptions {
333
>
keepWhitespace?: boolean;
334
>
}
335
>
export interface ITextDocumentShowOptions {
336
>
position?: EditorGroupColumn;
337
>
preserveFocus?: boolean;
338
>
pinned?: boolean;
339
>
selection?: IRange;
340
>
}
341
>
342
>
export interface MainThreadBulkEditsShape extends IDisposable {
343
>
$tryApplyWorkspaceEdit(workspaceEditDto: SerializableObjectWithBuffers<IWorkspaceEditDto>, undoRedoGroupId?: number, respectAutoSaveConfig?: boolean): Promise<boolean>;
344
>
}
345
>
346
>
export interface MainThreadTextEditorsShape extends IDisposable {
347
>
$tryShowTextDocument(resource: UriComponents, options: ITextDocumentShowOptions): Promise<string | undefined>;
348
>
$registerTextEditorDecorationType(extensionId: ExtensionIdentifier, key: string, options: editorCommon.IDecorationRenderOptions): void;
349
>
$removeTextEditorDecorationType(key: string): void;
350
>
$tryShowEditor(id: string, position: EditorGroupColumn): Promise<void>;
351
>
$tryHideEditor(id: string): Promise<void>;
352
>
$trySetOptions(id: string, options: ITextEditorConfigurationUpdate): Promise<void>;
353
>
$trySetDecorations(id: string, key: string, ranges: editorCommon.IDecorationOptions[]): Promise<void>;
354
>
$trySetDecorationsFast(id: string, key: string, ranges: number[]): Promise<void>;
355
>
$tryRevealRange(id: string, range: IRange, revealType: TextEditorRevealType): Promise<void>;
356
>
$trySetSelections(id: string, selections: ISelection[]): Promise<void>;
357
>
$tryApplyEdits(id: string, modelVersionId: number, edits: ISingleEditOperation[], opts: IApplyEditsOptions): Promise<boolean>;
358
>
$tryInsertSnippet(id: string, modelVersionId: number, template: string, selections: readonly IRange[], opts: IUndoStopOptions): Promise<boolean>;
359
>
$getDiffInformation(id: string): Promise<IChange[]>;
360
>
}
361
>
362
>
export interface MainThreadTreeViewsShape extends IDisposable {
363
>
$registerTreeViewDataProvider(treeViewId: string, options: { showCollapseAll: boolean; canSelectMany: boolean; dropMimeTypes: readonly string[]; dragMimeTypes: readonly string[]; hasHandleDrag: boolean; hasHandleDrop: boolean; manuallyManageCheckboxes: boolean }): Promise<void>;
364
>
$refresh(treeViewId: string, itemsToRefresh?: { [treeItemHandle: string]: ITreeItem }): Promise<void>;
365
>
$reveal(treeViewId: string, itemInfo: { item: ITreeItem; parentChain: ITreeItem[] } | undefined, options: IRevealOptions): Promise<void>;
366
>
$setMessage(treeViewId: string, message: string | IMarkdownString): void;
367
>
$setTitle(treeViewId: string, title: string, description: string | undefined): void;
368
>
$setBadge(treeViewId: string, badge: IViewBadge | undefined): void;
369
>
$resolveDropFileData(destinationViewId: string, requestId: number, dataItemId: string): Promise<VSBuffer>;
370
>
$disposeTree(treeViewId: string): Promise<void>;
371
>
$logResolveTreeNodeFailure(extensionId: string): void;
372
>
}
373
>
374
>
export interface MainThreadDownloadServiceShape extends IDisposable {
375
>
$download(uri: UriComponents, to: UriComponents): Promise<void>;
376
>
}
377
>
378
>
export interface MainThreadErrorsShape extends IDisposable {
379
>
$onUnexpectedError(err: any | SerializedError): void;
380
>
}
381
>
382
>
export interface MainThreadConsoleShape extends IDisposable {
383
>
$logExtensionHostMessage(msg: IRemoteConsoleLog): void;
384
>
}
385
>
386
>
export interface IRegExpDto {
387
>
pattern: string;
388
>
flags?: string;
389
>
}
390
>
export interface IIndentationRuleDto {
391
>
decreaseIndentPattern: IRegExpDto;
392
>
increaseIndentPattern: IRegExpDto;
393
>
indentNextLinePattern?: IRegExpDto;
394
>
unIndentedLinePattern?: IRegExpDto;
395
>
}
396
>
export interface IOnEnterRuleDto {
397
>
beforeText: IRegExpDto;
398
>
afterText?: IRegExpDto;
399
>
previousLineText?: IRegExpDto;
400
>
action: EnterAction;
401
>
}
402
>
export interface ILanguageConfigurationDto {
403
>
comments?: CommentRule;
404
>
brackets?: CharacterPair[];
405
>
wordPattern?: IRegExpDto;
406
>
indentationRules?: IIndentationRuleDto;
407
>
onEnterRules?: IOnEnterRuleDto[];
408
>
__electricCharacterSupport?: {
409
>
brackets?: any;
410
>
docComment?: {
411
>
scope: string;
412
>
open: string;
413
>
lineStart: string;
414
>
close?: string;
415
>
};
416
>
};
417
>
__characterPairSupport?: {
418
>
autoClosingPairs: {
419
>
open: string;
420
>
close: string;
421
>
notIn?: string[];
422
>
}[];
423
>
};
424
>
autoClosingPairs?: {
425
>
open: string;
426
>
close: string;
427
>
notIn?: string[];
428
>
}[];
429
>
}
430
>
431
>
export type GlobPattern = string | IRelativePattern;
432
>
433
>
export interface IRelativePatternDto extends IRelativePattern {
434
>
baseUri: UriComponents;
435
>
}
436
>
437
>
export interface IDocumentFilterDto {
438
>
$serialized: true;
439
>
language?: string;
440
>
scheme?: string;
441
>
pattern?: string | IRelativePattern;
442
>
exclusive?: boolean;
443
>
notebookType?: string;
444
>
isBuiltin?: boolean;
445
>
}
446
>
447
>
export type ITabSelectorDto = { uri: IDocumentFilterDto[] } | { viewType: string };
448
>
449
>
export interface IShareableItemDto {
450
>
resourceUri: UriComponents;
451
>
selection?: IRange;
452
>
}
453
>
454
>
export interface IDocumentContextItemDto {
455
>
readonly uri: UriComponents;
456
>
readonly version: number;
457
>
readonly ranges: IRange[];
458
>
}
459
>
460
>
export interface IConversationItemDto {
461
>
readonly type: 'request' | 'response';
462
>
readonly message: string;
463
>
readonly references?: IDocumentContextItemDto[];
464
>
}
465
>
466
>
export interface IMappedEditsContextDto {
467
>
documents: IDocumentContextItemDto[][];
468
>
conversation?: IConversationItemDto[];
469
>
}
470
>
471
>
export interface ICodeBlockDto {
472
>
code: string;
473
>
resource: UriComponents;
474
>
}
475
>
476
>
export interface IMappedEditsRequestDto {
477
>
readonly codeBlocks: ICodeBlockDto[];
478
>
readonly conversation?: IConversationItemDto[];
479
>
}
480
>
481
>
export interface IMappedEditsResultDto {
482
>
readonly errorMessage?: string;
483
>
}
484
>
485
>
export interface ISignatureHelpProviderMetadataDto {
486
>
readonly triggerCharacters: readonly string[];
487
>
readonly retriggerCharacters: readonly string[];
488
>
}
489
>
490
>
export interface IdentifiableInlineCompletions extends languages.InlineCompletions<IdentifiableInlineCompletion> {
491
>
pid: number;
492
>
languageId: string;
493
>
}
494
>
495
>
export interface IdentifiableInlineCompletion extends languages.InlineCompletion {
496
>
pid: number;
497
>
idx: number;
498
>
suggestionId: EditSuggestionId | undefined;
499
>
}
500
>
501
>
export interface IInlineCompletionModelDto {
502
>
readonly id: string;
503
>
readonly name: string;
504
>
}
505
>
506
>
export interface IInlineCompletionModelInfoDto {
507
>
readonly models: IInlineCompletionModelDto[];
508
>
readonly currentModelId: string;
509
>
}
510
>
511
>
export interface IInlineCompletionProviderOptionValueDto {
512
>
readonly id: string;
513
>
readonly label: string;
514
>
}
515
>
516
>
export interface IInlineCompletionProviderOptionDto {
517
>
readonly id: string;
518
>
readonly label: string;
519
>
readonly values: readonly IInlineCompletionProviderOptionValueDto[];
520
>
readonly currentValueId: string;
521
>
}
522
>
523
>
export interface IInlineCompletionChangeHintDto {
524
>
readonly data?: unknown;
525
>
}
526
>
527
>
export interface MainThreadLanguageFeaturesShape extends IDisposable {
528
>
$unregister(handle: number): void;
529
>
$registerDocumentSymbolProvider(handle: number, selector: IDocumentFilterDto[], label: string): void;
530
>
$registerCodeLensSupport(handle: number, selector: IDocumentFilterDto[], eventHandle: number | undefined): void;
531
>
$emitCodeLensEvent(eventHandle: number, event?: any): void;
532
>
$registerDefinitionSupport(handle: number, selector: IDocumentFilterDto[]): void;
533
>
$registerDeclarationSupport(handle: number, selector: IDocumentFilterDto[]): void;
534
>
$registerImplementationSupport(handle: number, selector: IDocumentFilterDto[]): void;
535
>
$registerTypeDefinitionSupport(handle: number, selector: IDocumentFilterDto[]): void;
536
>
$registerHoverProvider(handle: number, selector: IDocumentFilterDto[]): void;
537
>
$registerEvaluatableExpressionProvider(handle: number, selector: IDocumentFilterDto[]): void;
538
>
$registerInlineValuesProvider(handle: number, selector: IDocumentFilterDto[], eventHandle: number | undefined): void;
539
>
$emitInlineValuesEvent(eventHandle: number, event?: any): void;
540
>
$registerDocumentHighlightProvider(handle: number, selector: IDocumentFilterDto[]): void;
541
>
$registerMultiDocumentHighlightProvider(handle: number, selector: IDocumentFilterDto[]): void;
542
>
$registerLinkedEditingRangeProvider(handle: number, selector: IDocumentFilterDto[]): void;
543
>
$registerReferenceSupport(handle: number, selector: IDocumentFilterDto[]): void;
544
>
$registerCodeActionSupport(handle: number, selector: IDocumentFilterDto[], metadata: ICodeActionProviderMetadataDto, displayName: string, extensionID: string, supportsResolve: boolean): void;
545
>
$registerPasteEditProvider(handle: number, selector: IDocumentFilterDto[], metadata: IPasteEditProviderMetadataDto): void;
546
>
$registerDocumentFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string): void;
547
>
$registerRangeFormattingSupport(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, displayName: string, supportRanges: boolean): void;
548
>
$registerOnTypeFormattingSupport(handle: number, selector: IDocumentFilterDto[], autoFormatTriggerCharacters: string[], extensionId: ExtensionIdentifier): void;
549
>
$registerNavigateTypeSupport(handle: number, supportsResolve: boolean): void;
550
>
$registerRenameSupport(handle: number, selector: IDocumentFilterDto[], supportsResolveInitialValues: boolean): void;
551
>
$registerNewSymbolNamesProvider(handle: number, selector: IDocumentFilterDto[]): void;
552
>
$registerDocumentSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: languages.SemanticTokensLegend, eventHandle: number | undefined): void;
553
>
$emitDocumentSemanticTokensEvent(eventHandle: number): void;
554
>
$registerDocumentRangeSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: languages.SemanticTokensLegend, eventHandle: number | undefined): void;
555
>
$emitDocumentRangeSemanticTokensEvent(eventHandle: number): void;
556
>
$registerCompletionsProvider(handle: number, selector: IDocumentFilterDto[], triggerCharacters: string[], supportsResolveDetails: boolean, extensionId: ExtensionIdentifier): void;
557
>
$registerInlineCompletionsSupport(
558
>
handle: number,
559
>
selector: IDocumentFilterDto[],
560
>
supportsHandleEvents: boolean,
561
>
extensionId: string,
562
>
extensionVersion: string,
563
>
groupId: string | undefined,
564
>
yieldsToExtensionIds: string[],
565
>
displayName: string | undefined,
566
>
debounceDelayMs: number | undefined,
567
>
excludesExtensionIds: string[],
568
>
supportsSetModelId: boolean,
569
>
supportsOnDidChange: boolean,
570
>
initialModelInfo: IInlineCompletionModelInfoDto | undefined,
571
>
supportsOnDidChangeModelInfo: boolean,
572
>
supportsSetProviderOption: boolean,
573
>
initialProviderOptions: readonly IInlineCompletionProviderOptionDto[] | undefined,
574
>
supportsOnDidChangeProviderOptions: boolean,
575
>
): void;
576
>
$emitInlineCompletionsChange(handle: number, changeHint: IInlineCompletionChangeHintDto | undefined): void;
577
>
$emitInlineCompletionModelInfoChange(handle: number, data: IInlineCompletionModelInfoDto | undefined): void;
578
>
$emitInlineCompletionProviderOptionsChange(handle: number, data: readonly IInlineCompletionProviderOptionDto[] | undefined): void;
579
>
$registerSignatureHelpProvider(handle: number, selector: IDocumentFilterDto[], metadata: ISignatureHelpProviderMetadataDto): void;
580
>
$registerInlayHintsProvider(handle: number, selector: IDocumentFilterDto[], supportsResolve: boolean, eventHandle: number | undefined, displayName: string | undefined): void;
581
>
$emitInlayHintsEvent(eventHandle: number): void;
582
>
$registerDocumentLinkProvider(handle: number, selector: IDocumentFilterDto[], supportsResolve: boolean): void;
583
>
$registerDocumentColorProvider(handle: number, selector: IDocumentFilterDto[]): void;
584
>
$registerFoldingRangeProvider(handle: number, selector: IDocumentFilterDto[], extensionId: ExtensionIdentifier, eventHandle: number | undefined): void;
585
>
$emitFoldingRangeEvent(eventHandle: number, event?: any): void;
586
>
$registerSelectionRangeProvider(handle: number, selector: IDocumentFilterDto[]): void;
587
>
$registerCallHierarchyProvider(handle: number, selector: IDocumentFilterDto[]): void;
588
>
$registerTypeHierarchyProvider(handle: number, selector: IDocumentFilterDto[]): void;
589
>
$registerDocumentOnDropEditProvider(handle: number, selector: IDocumentFilterDto[], metadata?: IDocumentDropEditProviderMetadata): void;
590
>
$resolvePasteFileData(handle: number, requestId: number, dataId: string): Promise<VSBuffer>;
591
>
$resolveDocumentOnDropFileData(handle: number, requestId: number, dataId: string): Promise<VSBuffer>;
592
>
$setLanguageConfiguration(handle: number, languageId: string, configuration: ILanguageConfigurationDto): void;
593
>
}
594
>
595
>
export interface MainThreadLanguagesShape extends IDisposable {
596
>
$changeLanguage(resource: UriComponents, languageId: string): Promise<void>;
597
>
$tokensAtPosition(resource: UriComponents, position: IPosition): Promise<undefined | { type: StandardTokenType; range: IRange }>;
598
>
$computeFullSyntaxHighlighting(source: string, languageId: string): Promise<ISyntaxHighlightingResultDto>;
599
>
$setLanguageStatus(handle: number, status: ILanguageStatus): void;
600
>
$removeLanguageStatus(handle: number): void;
601
>
}
602
>
603
>
export interface ISyntaxHighlightingTokenDto {
604
>
readonly length: number;
605
>
readonly foreground: number;
606
>
readonly fontStyle: number;
607
>
}
608
>
609
>
export interface ISyntaxHighlightingResultDto {
610
>
readonly tokens: ISyntaxHighlightingTokenDto[];
611
>
readonly colorMap: string[];
612
>
}
613
>
614
>
export interface MainThreadMessageOptions {
615
>
source?: { identifier: ExtensionIdentifier; label: string };
616
>
modal?: boolean;
617
>
detail?: string;
618
>
useCustom?: boolean;
619
>
}
620
>
621
>
export interface MainThreadMessageServiceShape extends IDisposable {
622
>
$showMessage(severity: Severity, message: string, options: MainThreadMessageOptions, commands: { title: string; isCloseAffordance: boolean; handle: number }[]): Promise<number | undefined>;
623
>
}
624
>
625
>
export interface MainThreadOutputServiceShape extends IDisposable {
626
>
$register(label: string, file: UriComponents, languageId: string | undefined, extensionId: string): Promise<string>;
627
>
$update(channelId: string, mode: OutputChannelUpdateMode, till?: number): Promise<void>;
628
>
$reveal(channelId: string, preserveFocus: boolean): Promise<void>;
629
>
$close(channelId: string): Promise<void>;
630
>
$dispose(channelId: string): Promise<void>;
631
>
}
632
>
633
>
export interface MainThreadProgressShape extends IDisposable {
634
>
635
>
$startProgress(handle: number, options: IProgressOptions, extensionId?: string): Promise<void>;
636
>
$progressReport(handle: number, message: IProgressStep): void;
637
>
$progressEnd(handle: number): void;
638
>
}
639
>
640
>
/**
641
>
* A terminal that is created on the extension host side is temporarily assigned
642
>
* a UUID by the extension host that created it. Once the renderer side has assigned
643
>
* a real numeric id, the numeric id will be used.
644
>
*
645
>
* All other terminals (that are not created on the extension host side) always
646
>
* use the numeric id.
647
>
*/
648
>
export type ExtHostTerminalIdentifier = number | string;
649
>
650
>
export interface TerminalLaunchConfig {
651
>
name?: string;
652
>
shellPath?: string;
653
>
shellArgs?: string[] | string;
654
>
cwd?: string | UriComponents;
655
>
env?: ITerminalEnvironment;
656
>
icon?: URI | { light: URI; dark: URI } | ThemeIcon;
657
>
color?: string;
658
>
initialText?: string;
659
>
waitOnExit?: boolean;
660
>
strictEnv?: boolean;
661
>
hideFromUser?: boolean;
662
>
isExtensionCustomPtyTerminal?: boolean;
663
>
forceShellIntegration?: boolean;
664
>
isFeatureTerminal?: boolean;
665
>
isExtensionOwnedTerminal?: boolean;
666
>
useShellEnvironment?: boolean;
667
>
location?: TerminalLocation | { viewColumn: number; preserveFocus?: boolean } | { parentTerminal: ExtHostTerminalIdentifier } | { splitActiveTerminal: boolean };
668
>
isTransient?: boolean;
669
>
shellIntegrationNonce?: string;
670
>
titleTemplate?: string;
671
>
}
672
>
673
>
674
>
export interface MainThreadTerminalServiceShape extends IDisposable {
675
>
$createTerminal(extHostTerminalId: string, config: TerminalLaunchConfig): Promise<void>;
676
>
$dispose(id: ExtHostTerminalIdentifier): void;
677
>
$hide(id: ExtHostTerminalIdentifier): void;
678
>
$sendText(id: ExtHostTerminalIdentifier, text: string, shouldExecute: boolean): void;
679
>
$show(id: ExtHostTerminalIdentifier, preserveFocus: boolean): void;
680
>
$registerProcessSupport(isSupported: boolean): void;
681
>
$registerProfileProvider(id: string, extensionIdentifier: string): void;
682
>
$unregisterProfileProvider(id: string): void;
683
>
$registerCompletionProvider(id: string, extensionIdentifier: string, ...triggerCharacters: string[]): void;
684
>
$unregisterCompletionProvider(id: string): void;
685
>
$registerQuickFixProvider(id: string, extensionIdentifier: string): void;
686
>
$unregisterQuickFixProvider(id: string): void;
687
>
$setEnvironmentVariableCollection(extensionIdentifier: string, persistent: boolean, collection: ISerializableEnvironmentVariableCollection | undefined, descriptionMap: ISerializableEnvironmentDescriptionMap): void;
688
>
689
>
// Optional event toggles
690
>
$startSendingDataEvents(): void;
691
>
$stopSendingDataEvents(): void;
692
>
$startSendingCommandEvents(): void;
693
>
$stopSendingCommandEvents(): void;
694
>
$startLinkProvider(): void;
695
>
$stopLinkProvider(): void;
696
>
697
>
// Process
698
>
$sendProcessData(terminalId: number, data: string): void;
699
>
$sendProcessReady(terminalId: number, pid: number, cwd: string, windowsPty: IProcessReadyWindowsPty | undefined): void;
700
>
$sendProcessProperty(terminalId: number, property: IProcessProperty<any>): void;
701
>
$sendProcessExit(terminalId: number, exitCode: number | undefined): void;
702
>
}
703
>
704
>
export interface MainThreadTerminalShellIntegrationShape extends IDisposable {
705
>
$executeCommand(terminalId: number, commandLine: string): void;
706
>
}
707
>
708
>
export type TransferQuickPickItemOrSeparator = TransferQuickPickItem | quickInput.IQuickPickSeparator;
709
>
export interface TransferQuickPickItem {
710
>
handle: number;
711
>
712
>
// shared properties from IQuickPickItem
713
>
type?: 'item';
714
>
label: string;
715
>
iconPathDto?: IconPathDto;
716
>
description?: string;
717
>
detail?: string;
718
>
picked?: boolean;
719
>
alwaysShow?: boolean;
720
>
buttons?: TransferQuickInputButton[];
721
>
resourceUri?: UriComponents;
722
>
723
>
// TODO: These properties are not used for transfer (iconPathDto is used instead) but they cannot be removed
724
>
// because this type is used as IQuickPickItem on the main thread. Ideally IQuickPickItem should also use IconPath.
725
>
iconPath?: { light?: URI; dark: URI };
726
>
iconClass?: string;
727
>
}
728
>
729
>
export interface TransferQuickInputButton extends quickInput.IQuickInputButton {
730
>
handle: number;
731
>
iconPathDto: IconPathDto;
732
>
toggle?: { checked: boolean };
733
>
734
>
// TODO: These properties are not used for transfer (iconPathDto is used instead) but they cannot be removed
735
>
// because this type is used as IQuickInputButton on the main thread. Ideally IQuickInputButton should also use IconPath.
736
>
iconPath?: { light?: URI; dark: URI };
737
>
iconClass?: string;
738
>
}
739
>
740
>
export type TransferQuickInput = TransferQuickPick | TransferInputBox;
741
>
742
>
export interface BaseTransferQuickInput {
743
>
744
>
[key: string]: any;
745
>
746
>
id: number;
747
>
748
>
title?: string;
749
>
750
>
type?: 'quickPick' | 'inputBox';
751
>
752
>
enabled?: boolean;
753
>
754
>
busy?: boolean;
755
>
756
>
visible?: boolean;
757
>
}
758
>
759
>
export interface TransferQuickPick extends BaseTransferQuickInput {
760
>
761
>
type?: 'quickPick';
762
>
763
>
value?: string;
764
>
765
>
placeholder?: string;
766
>
767
>
prompt?: string;
768
>
769
>
buttons?: TransferQuickInputButton[];
770
>
771
>
items?: TransferQuickPickItemOrSeparator[];
772
>
773
>
activeItems?: number[];
774
>
775
>
selectedItems?: number[];
776
>
777
>
canSelectMany?: boolean;
778
>
779
>
ignoreFocusOut?: boolean;
780
>
781
>
matchOnDescription?: boolean;
782
>
783
>
matchOnDetail?: boolean;
784
>
785
>
sortByLabel?: boolean;
786
>
}
787
>
788
>
export interface TransferInputBox extends BaseTransferQuickInput {
789
>
790
>
type?: 'inputBox';
791
>
792
>
value?: string;
793
>
794
>
valueSelection?: Readonly<[number, number]>;
795
>
796
>
placeholder?: string;
797
>
798
>
password?: boolean;
799
>
800
>
buttons?: TransferQuickInputButton[];
801
>
802
>
prompt?: string;
803
>
804
>
validationMessage?: string;
805
>
}
806
>
807
>
export interface IInputBoxOptions {
808
>
title?: string;
809
>
value?: string;
810
>
valueSelection?: Readonly<[number, number]>;
811
>
prompt?: string;
812
>
placeHolder?: string;
813
>
password?: boolean;
814
>
ignoreFocusOut?: boolean;
815
>
}
816
>
817
>
export interface MainThreadQuickOpenShape extends IDisposable {
818
>
$show(instance: number, options: quickInput.IPickOptions<TransferQuickPickItem>, token: CancellationToken): Promise<number | number[] | undefined>;
819
>
$setItems(instance: number, items: TransferQuickPickItemOrSeparator[]): Promise<void>;
820
>
$setError(instance: number, error: Error): Promise<void>;
821
>
$input(options: IInputBoxOptions | undefined, validateInput: boolean, token: CancellationToken): Promise<string | undefined>;
822
>
$createOrUpdate(params: TransferQuickInput): Promise<void>;
823
>
$dispose(id: number): Promise<void>;
824
>
}
825
>
826
>
export interface MainThreadStatusBarShape extends IDisposable {
827
>
$setEntry(id: string, statusId: string, extensionId: string | undefined, statusName: string, text: string, tooltip: IMarkdownString | string | undefined, hasTooltipProvider: boolean, command: ICommandDto | undefined, color: string | ThemeColor | undefined, backgroundColor: string | ThemeColor | undefined, alignLeft: boolean, priority: number | undefined, accessibilityInformation: IAccessibilityInformation | undefined): void;
828
>
$disposeEntry(id: string): void;
829
>
}
830
>
831
>
export type StatusBarItemDto = {
832
>
entryId: string;
833
>
alignLeft: boolean;
834
>
priority?: number;
835
>
name: string;
836
>
text: string;
837
>
tooltip?: string;
838
>
command?: string;
839
>
accessibilityInformation?: IAccessibilityInformation;
840
>
};
841
>
842
>
export interface ExtHostStatusBarShape {
843
>
$acceptStaticEntries(added?: StatusBarItemDto[]): void;
844
>
$provideTooltip(entryId: string, cancellation: CancellationToken): Promise<string | IMarkdownString | undefined>;
845
>
}
846
>
847
>
export interface MainThreadStorageShape extends IDisposable {
848
>
$initializeExtensionStorage(shared: boolean, extensionId: string): Promise<string | undefined>;
849
>
$setValue(shared: boolean, extensionId: string, value: object): Promise<void>;
850
>
$registerExtensionStorageKeysToSync(extension: IExtensionIdWithVersion, keys: string[]): void;
851
>
}
852
>
853
>
export interface MainThreadTelemetryShape extends IDisposable {
854
>
$publicLog(eventName: string, data?: any): void;
855
>
$publicLog2<E extends ClassifiedEvent<OmitMetadata<T>> = never, T extends IGDPRProperty = never>(eventName: string, data?: StrictPropertyCheck<T, E>): void;
856
>
}
857
>
858
>
export interface MainThreadEditorInsetsShape extends IDisposable {
859
>
$createEditorInset(handle: number, id: string, uri: UriComponents, line: number, height: number, options: IWebviewContentOptions, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): Promise<void>;
860
>
$disposeEditorInset(handle: number): void;
861
>
862
>
$setHtml(handle: number, value: string): void;
863
>
$setOptions(handle: number, options: IWebviewContentOptions): void;
864
>
$postMessage(handle: number, value: any): Promise<boolean>;
865
>
}
866
>
867
>
export interface ExtHostEditorInsetsShape {
868
>
$onDidDispose(handle: number): void;
869
>
$onDidReceiveMessage(handle: number, message: any): void;
870
>
}
871
>
872
>
//#region --- tabs model
873
>
874
>
export const enum TabInputKind {
875
>
UnknownInput,
876
>
TextInput,
877
>
TextDiffInput,
878
>
TextMergeInput,
879
>
NotebookInput,
880
>
NotebookDiffInput,
881
>
CustomEditorInput,
882
>
WebviewEditorInput,
883
>
TerminalEditorInput,
884
>
InteractiveEditorInput,
885
>
ChatEditorInput,
886
>
MultiDiffEditorInput
887
>
}
888
>
889
>
export const enum TabModelOperationKind {
890
>
TAB_OPEN,
891
>
TAB_CLOSE,
892
>
TAB_UPDATE,
893
>
TAB_MOVE
894
>
}
895
>
896
>
export interface UnknownInputDto {
897
>
kind: TabInputKind.UnknownInput;
898
>
}
899
>
900
>
export interface TextInputDto {
901
>
kind: TabInputKind.TextInput;
902
>
uri: UriComponents;
903
>
}
904
>
905
>
export interface TextDiffInputDto {
906
>
kind: TabInputKind.TextDiffInput;
907
>
original: UriComponents;
908
>
modified: UriComponents;
909
>
}
910
>
911
>
export interface TextMergeInputDto {
912
>
kind: TabInputKind.TextMergeInput;
913
>
base: UriComponents;
914
>
input1: UriComponents;
915
>
input2: UriComponents;
916
>
result: UriComponents;
917
>
}
918
>
919
>
export interface NotebookInputDto {
920
>
kind: TabInputKind.NotebookInput;
921
>
notebookType: string;
922
>
uri: UriComponents;
923
>
}
924
>
925
>
export interface NotebookDiffInputDto {
926
>
kind: TabInputKind.NotebookDiffInput;
927
>
notebookType: string;
928
>
original: UriComponents;
929
>
modified: UriComponents;
930
>
}
931
>
932
>
export interface CustomInputDto {
933
>
kind: TabInputKind.CustomEditorInput;
934
>
viewType: string;
935
>
uri: UriComponents;
936
>
}
937
>
938
>
export interface WebviewInputDto {
939
>
kind: TabInputKind.WebviewEditorInput;
940
>
viewType: string;
941
>
}
942
>
943
>
export interface InteractiveEditorInputDto {
944
>
kind: TabInputKind.InteractiveEditorInput;
945
>
uri: UriComponents;
946
>
inputBoxUri: UriComponents;
947
>
}
948
>
949
>
export interface ChatEditorInputDto {
950
>
kind: TabInputKind.ChatEditorInput;
951
>
}
952
>
953
>
export interface MultiDiffEditorInputDto {
954
>
kind: TabInputKind.MultiDiffEditorInput;
955
>
diffEditors: TextDiffInputDto[];
956
>
}
957
>
958
>
export interface TabInputDto {
959
>
kind: TabInputKind.TerminalEditorInput;
960
>
}
961
>
962
>
export type AnyInputDto = UnknownInputDto | TextInputDto | TextDiffInputDto | MultiDiffEditorInputDto | TextMergeInputDto | NotebookInputDto | NotebookDiffInputDto | CustomInputDto | WebviewInputDto | InteractiveEditorInputDto | ChatEditorInputDto | TabInputDto;
963
>
964
>
export interface MainThreadEditorTabsShape extends IDisposable {
965
>
// manage tabs: move, close, rearrange etc
966
>
$moveTab(tabId: string, index: number, viewColumn: EditorGroupColumn, preserveFocus?: boolean): void;
967
>
$closeTab(tabIds: string[], preserveFocus?: boolean): Promise<boolean>;
968
>
$closeGroup(groupIds: number[], preservceFocus?: boolean): Promise<boolean>;
969
>
}
970
>
971
>
export interface IEditorTabGroupDto {
972
>
isActive: boolean;
973
>
viewColumn: EditorGroupColumn;
974
>
// Decided not to go with simple index here due to opening and closing causing index shifts
975
>
// This allows us to patch the model without having to do full rebuilds
976
>
tabs: IEditorTabDto[];
977
>
groupId: number;
978
>
}
979
>
980
>
export interface TabOperation {
981
>
readonly kind: TabModelOperationKind.TAB_OPEN | TabModelOperationKind.TAB_CLOSE | TabModelOperationKind.TAB_UPDATE | TabModelOperationKind.TAB_MOVE;
982
>
// TODO @lramos15 Possibly get rid of index for tab update, it's only needed for open and close
983
>
readonly index: number;
984
>
readonly tabDto: IEditorTabDto;
985
>
readonly groupId: number;
986
>
readonly oldIndex?: number;
987
>
}
988
>
989
>
export interface IEditorTabDto {
990
>
id: string;
991
>
label: string;
992
>
input: AnyInputDto;
993
>
editorId?: string;
994
>
isActive: boolean;
995
>
isPinned: boolean;
996
>
isPreview: boolean;
997
>
isDirty: boolean;
998
>
}
999
>
1000
>
export interface IExtHostEditorTabsShape {
1001
>
// Accepts a whole new model
1002
>
$acceptEditorTabModel(tabGroups: IEditorTabGroupDto[]): void;
1003
>
// Only when group property changes (not the tabs inside)
1004
>
$acceptTabGroupUpdate(groupDto: IEditorTabGroupDto): void;
1005
>
// When a tab is added, removed, or updated
1006
>
$acceptTabOperation(operation: TabOperation): void;
1007
>
}
1008
>
1009
>
//#endregion
1010
>
1011
>
export type WebviewHandle = string;
1012
>
1013
>
export interface WebviewPanelShowOptions {
1014
>
readonly viewColumn?: EditorGroupColumn;
1015
>
readonly preserveFocus?: boolean;
1016
>
}
1017
>
1018
>
export interface WebviewExtensionDescription {
1019
>
readonly id: ExtensionIdentifier;
1020
>
readonly location: UriComponents;
1021
>
}
1022
>
1023
>
export enum WebviewEditorCapabilities {
1024
>
Editable,
1025
>
SupportsHotExit,
1026
>
}
1027
>
1028
>
export interface IWebviewPortMapping {
1029
>
readonly webviewPort: number;
1030
>
readonly extensionHostPort: number;
1031
>
}
1032
>
1033
>
export interface IWebviewContentOptions {
1034
>
readonly enableScripts?: boolean;
1035
>
readonly enableForms?: boolean;
1036
>
readonly enableCommandUris?: boolean | readonly string[];
1037
>
readonly localResourceRoots?: readonly UriComponents[];
1038
>
readonly portMapping?: readonly IWebviewPortMapping[];
1039
>
}
1040
>
1041
>
export interface IWebviewPanelOptions {
1042
>
readonly enableFindWidget?: boolean;
1043
>
readonly retainContextWhenHidden?: boolean;
1044
>
}
1045
>
1046
>
export interface CustomEditorProviderCapabilities {
1047
>
readonly supportsMove?: boolean;
1048
>
readonly supportsInlineDiff?: boolean;
1049
>
readonly supportsSideBySideDiff?: boolean;
1050
>
}
1051
>
1052
>
export interface CustomEditorDiffInitData {
1053
>
readonly title: string;
1054
>
readonly contentOptions: IWebviewContentOptions;
1055
>
readonly options: IWebviewPanelOptions;
1056
>
readonly active: boolean;
1057
>
}
1058
>
1059
>
export interface CustomEditorSideBySideDiffWebviewHandles {
1060
>
readonly original: WebviewHandle;
1061
>
readonly modified: WebviewHandle;
1062
>
}
1063
>
1064
>
export interface CustomEditorSideBySideDiffInitData {
1065
>
readonly original: CustomEditorDiffInitData;
1066
>
readonly modified: CustomEditorDiffInitData;
1067
>
}
1068
>
1069
>
export const enum WebviewMessageArrayBufferViewType {
1070
>
Int8Array = 1,
1071
>
Uint8Array = 2,
1072
>
Uint8ClampedArray = 3,
1073
>
Int16Array = 4,
1074
>
Uint16Array = 5,
1075
>
Int32Array = 6,
1076
>
Uint32Array = 7,
1077
>
Float32Array = 8,
1078
>
Float64Array = 9,
1079
>
BigInt64Array = 10,
1080
>
BigUint64Array = 11,
1081
>
}
1082
>
1083
>
export interface WebviewMessageArrayBufferReference {
1084
>
readonly $$vscode_array_buffer_reference$$: true;
1085
>
1086
>
readonly index: number;
1087
>
1088
>
/**
1089
>
* Tracks if the reference is to a view instead of directly to an ArrayBuffer.
1090
>
*/
1091
>
readonly view?: {
1092
>
readonly type: WebviewMessageArrayBufferViewType;
1093
>
readonly byteLength: number;
1094
>
readonly byteOffset: number;
1095
>
};
1096
>
}
1097
>
1098
>
export interface MainThreadWebviewsShape extends IDisposable {
1099
>
$setHtml(handle: WebviewHandle, value: string): void;
1100
>
$setOptions(handle: WebviewHandle, options: IWebviewContentOptions): void;
1101
>
$postMessage(handle: WebviewHandle, value: string, ...buffers: VSBuffer[]): Promise<boolean>;
1102
>
}
1103
>
1104
>
export type IWebviewIconPath = ThemeIcon | {
1105
>
readonly light: UriComponents;
1106
>
readonly dark: UriComponents;
1107
>
};
1108
>
1109
>
export interface IWebviewInitData {
1110
>
readonly title: string;
1111
>
readonly webviewOptions: IWebviewContentOptions;
1112
>
readonly panelOptions: IWebviewPanelOptions;
1113
>
readonly serializeBuffersForPostMessage: boolean;
1114
>
}
1115
>
1116
>
export interface MainThreadWebviewPanelsShape extends IDisposable {
1117
>
$createWebviewPanel(
1118
>
extension: WebviewExtensionDescription,
1119
>
handle: WebviewHandle,
1120
>
viewType: string,
1121
>
initData: IWebviewInitData,
1122
>
showOptions: WebviewPanelShowOptions,
1123
>
): void;
1124
>
$disposeWebview(handle: WebviewHandle): void;
1125
>
$reveal(handle: WebviewHandle, showOptions: WebviewPanelShowOptions): void;
1126
>
$setTitle(handle: WebviewHandle, value: string): void;
1127
>
$setIconPath(handle: WebviewHandle, value: IWebviewIconPath | undefined): void;
1128
>
1129
>
$registerSerializer(viewType: string, options: { serializeBuffersForPostMessage: boolean }): void;
1130
>
$unregisterSerializer(viewType: string): void;
1131
>
}
1132
>
1133
>
export interface MainThreadCustomEditorsShape extends IDisposable {
1134
>
$registerTextEditorProvider(extension: WebviewExtensionDescription, viewType: string, options: IWebviewPanelOptions, capabilities: CustomEditorProviderCapabilities, serializeBuffersForPostMessage: boolean): void;
1135
>
$registerCustomEditorProvider(extension: WebviewExtensionDescription, viewType: string, options: IWebviewPanelOptions, capabilities: CustomEditorProviderCapabilities, supportsMultipleEditorsPerDocument: boolean, serializeBuffersForPostMessage: boolean): void;
1136
>
$unregisterEditorProvider(viewType: string): void;
1137
>
1138
>
$onDidEdit(resource: UriComponents, viewType: string, editId: number, label: string | undefined): void;
1139
>
$onContentChange(resource: UriComponents, viewType: string): void;
1140
>
}
1141
>
1142
>
export interface MainThreadWebviewViewsShape extends IDisposable {
1143
>
$registerWebviewViewProvider(extension: WebviewExtensionDescription, viewType: string, options: { retainContextWhenHidden?: boolean; serializeBuffersForPostMessage: boolean }): void;
1144
>
$unregisterWebviewViewProvider(viewType: string): void;
1145
>
1146
>
$setWebviewViewTitle(handle: WebviewHandle, value: string | undefined): void;
1147
>
$setWebviewViewDescription(handle: WebviewHandle, value: string | undefined): void;
1148
>
$setWebviewViewBadge(handle: WebviewHandle, badge: IViewBadge | undefined): void;
1149
>
1150
>
$show(handle: WebviewHandle, preserveFocus: boolean): void;
1151
>
}
1152
>
1153
>
export interface WebviewPanelViewStateData {
1154
>
[handle: string]: {
1155
>
readonly active: boolean;
1156
>
readonly visible: boolean;
1157
>
readonly position: EditorGroupColumn;
1158
>
};
1159
>
}
1160
>
1161
>
export interface ExtHostWebviewsShape {
1162
>
$onMessage(handle: WebviewHandle, jsonSerializedMessage: string, buffers: SerializableObjectWithBuffers<VSBuffer[]>): void;
1163
>
$onMissingCsp(handle: WebviewHandle, extensionId: string): void;
1164
>
}
1165
>
1166
>
export interface ExtHostWebviewPanelsShape {
1167
>
$onDidChangeWebviewPanelViewStates(newState: WebviewPanelViewStateData): void;
1168
>
$onDidDisposeWebviewPanel(handle: WebviewHandle): Promise<void>;
1169
>
$deserializeWebviewPanel(
1170
>
newWebviewHandle: WebviewHandle,
1171
>
viewType: string,
1172
>
initData: {
1173
>
title: string;
1174
>
state: any;
1175
>
webviewOptions: IWebviewContentOptions;
1176
>
panelOptions: IWebviewPanelOptions;
1177
>
active: boolean;
1178
>
},
1179
>
position: EditorGroupColumn,
1180
>
): Promise<void>;
1181
>
}
1182
>
1183
>
export interface ExtHostCustomEditorsShape {
1184
>
$resolveCustomEditor(
1185
>
resource: UriComponents,
1186
>
newWebviewHandle: WebviewHandle,
1187
>
viewType: string,
1188
>
initData: {
1189
>
title: string;
1190
>
contentOptions: IWebviewContentOptions;
1191
>
options: IWebviewPanelOptions;
1192
>
active: boolean;
1193
>
},
1194
>
position: EditorGroupColumn,
1195
>
cancellation: CancellationToken
1196
>
): Promise<void>;
1197
>
$resolveCustomEditorInlineDiff(
1198
>
originalResource: UriComponents,
1199
>
modifiedResource: UriComponents,
1200
>
newWebviewHandle: WebviewHandle,
1201
>
viewType: string,
1202
>
initData: CustomEditorDiffInitData,
1203
>
position: EditorGroupColumn,
1204
>
cancellation: CancellationToken
1205
>
): Promise<void>;
1206
>
$resolveCustomEditorSideBySideDiff(
1207
>
originalResource: UriComponents,
1208
>
modifiedResource: UriComponents,
1209
>
webviewHandles: CustomEditorSideBySideDiffWebviewHandles,
1210
>
viewType: string,
1211
>
initData: CustomEditorSideBySideDiffInitData,
1212
>
position: EditorGroupColumn,
1213
>
cancellation: CancellationToken
1214
>
): Promise<void>;
1215
>
$createCustomDocument(resource: UriComponents, viewType: string, backupId: string | undefined, untitledDocumentData: VSBuffer | undefined, cancellation: CancellationToken): Promise<{ editable: boolean }>;
1216
>
$disposeCustomDocument(resource: UriComponents, viewType: string): Promise<void>;
1217
>
1218
>
$undo(resource: UriComponents, viewType: string, editId: number, isDirty: boolean): Promise<void>;
1219
>
$redo(resource: UriComponents, viewType: string, editId: number, isDirty: boolean): Promise<void>;
1220
>
$revert(resource: UriComponents, viewType: string, cancellation: CancellationToken): Promise<void>;
1221
>
$disposeEdits(resourceComponents: UriComponents, viewType: string, editIds: number[]): void;
1222
>
1223
>
$onSave(resource: UriComponents, viewType: string, cancellation: CancellationToken): Promise<void>;
1224
>
$onSaveAs(resource: UriComponents, viewType: string, targetResource: UriComponents, cancellation: CancellationToken): Promise<void>;
1225
>
1226
>
$backup(resource: UriComponents, viewType: string, cancellation: CancellationToken): Promise<string>;
1227
>
1228
>
$onMoveCustomEditor(handle: WebviewHandle, newResource: UriComponents, viewType: string): Promise<void>;
1229
>
}
1230
>
1231
>
export interface ExtHostWebviewViewsShape {
1232
>
$resolveWebviewView(webviewHandle: WebviewHandle, viewType: string, title: string | undefined, state: any, cancellation: CancellationToken): Promise<void>;
1233
>
1234
>
$onDidChangeWebviewViewVisibility(webviewHandle: WebviewHandle, visible: boolean): void;
1235
>
1236
>
$disposeWebviewView(webviewHandle: WebviewHandle): void;
1237
>
}
1238
>
1239
>
export interface MainThreadManagedSocketsShape extends IDisposable {
1240
>
$registerSocketFactory(socketFactoryId: number): Promise<void>;
1241
>
$unregisterSocketFactory(socketFactoryId: number): Promise<void>;
1242
>
$onDidManagedSocketHaveData(socketId: number, data: VSBuffer): void;
1243
>
$onDidManagedSocketClose(socketId: number, error: string | undefined): void;
1244
>
$onDidManagedSocketEnd(socketId: number): void;
1245
>
}
1246
>
1247
>
export interface ExtHostManagedSocketsShape {
1248
>
$openRemoteSocket(socketFactoryId: number): Promise<number>;
1249
>
$remoteSocketWrite(socketId: number, buffer: VSBuffer): void;
1250
>
$remoteSocketEnd(socketId: number): void;
1251
>
$remoteSocketDrain(socketId: number): Promise<void>;
1252
>
}
1253
>
1254
>
export interface MainThreadBrowserTunnelProxyShape extends IDisposable {
1255
>
$updateProxyInfo(info: ITunnelProxyInfo | undefined): void;
1256
>
}
1257
>
1258
>
export interface ExtHostBrowserTunnelProxyShape {
1259
>
$setEnabled(enabled: boolean): void;
1260
>
}
1261
>
1262
>
export enum CellOutputKind {
1263
>
Text = 1,
1264
>
Error = 2,
1265
>
Rich = 3
1266
>
}
1267
>
1268
>
export enum NotebookEditorRevealType {
1269
>
Default = 0,
1270
>
InCenter = 1,
1271
>
InCenterIfOutsideViewport = 2,
1272
>
AtTop = 3
1273
>
}
1274
>
1275
>
export interface INotebookDocumentShowOptions {
1276
>
position?: EditorGroupColumn;
1277
>
preserveFocus?: boolean;
1278
>
pinned?: boolean;
1279
>
selections?: ICellRange[];
1280
>
label?: string;
1281
>
}
1282
>
1283
>
export type INotebookCellStatusBarEntryDto = Dto<notebookCommon.INotebookCellStatusBarItem>;
1284
>
1285
>
export interface INotebookCellStatusBarListDto {
1286
>
items: INotebookCellStatusBarEntryDto[];
1287
>
cacheId: number;
1288
>
}
1289
>
1290
>
export interface MainThreadNotebookShape extends IDisposable {
1291
>
$registerNotebookSerializer(handle: number, extension: notebookCommon.NotebookExtensionDescription, viewType: string, options: notebookCommon.TransientOptions, registration: notebookCommon.INotebookContributionData | undefined): void;
1292
>
$unregisterNotebookSerializer(handle: number): void;
1293
>
1294
>
$registerNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined, viewType: string): Promise<void>;
1295
>
$unregisterNotebookCellStatusBarItemProvider(handle: number, eventHandle: number | undefined): Promise<void>;
1296
>
$emitCellStatusBarEvent(eventHandle: number): void;
1297
>
}
1298
>
1299
>
export interface MainThreadNotebookEditorsShape extends IDisposable {
1300
>
$tryShowNotebookDocument(uriComponents: UriComponents, viewType: string, options: INotebookDocumentShowOptions): Promise<string>;
1301
>
$tryRevealRange(id: string, range: ICellRange, revealType: NotebookEditorRevealType): Promise<void>;
1302
>
$trySetSelections(id: string, range: ICellRange[]): void;
1303
>
}
1304
>
1305
>
export interface MainThreadNotebookDocumentsShape extends IDisposable {
1306
>
$tryCreateNotebook(options: { viewType: string; content?: NotebookDataDto }): Promise<UriComponents>;
1307
>
$tryOpenNotebook(uriComponents: UriComponents): Promise<UriComponents>;
1308
>
$trySaveNotebook(uri: UriComponents): Promise<boolean>;
1309
>
}
1310
>
1311
>
export interface INotebookKernelDto2 {
1312
>
id: string;
1313
>
notebookType: string;
1314
>
extensionId: ExtensionIdentifier;
1315
>
extensionLocation: UriComponents;
1316
>
label: string;
1317
>
detail?: string;
1318
>
description?: string;
1319
>
supportedLanguages?: string[];
1320
>
supportsInterrupt?: boolean;
1321
>
supportsExecutionOrder?: boolean;
1322
>
preloads?: { uri: UriComponents; provides: readonly string[] }[];
1323
>
hasVariableProvider?: boolean;
1324
>
}
1325
>
1326
>
export interface INotebookProxyKernelDto {
1327
>
id: string;
1328
>
notebookType: string;
1329
>
extensionId: ExtensionIdentifier;
1330
>
extensionLocation: UriComponents;
1331
>
label: string;
1332
>
detail?: string;
1333
>
description?: string;
1334
>
kind?: string;
1335
>
}
1336
>
1337
>
export interface ICellExecuteOutputEditDto {
1338
>
editType: CellExecutionUpdateType.Output;
1339
>
cellHandle: number;
1340
>
append?: boolean;
1341
>
outputs: NotebookOutputDto[];
1342
>
}
1343
>
1344
>
export interface ICellExecuteOutputItemEditDto {
1345
>
editType: CellExecutionUpdateType.OutputItems;
1346
>
append?: boolean;
1347
>
outputId: string;
1348
>
items: NotebookOutputItemDto[];
1349
>
}
1350
>
1351
>
export interface ICellExecutionStateUpdateDto extends ICellExecutionStateUpdate {
1352
>
}
1353
>
1354
>
export interface ICellExecutionCompleteDto extends ICellExecutionComplete {
1355
>
}
1356
>
1357
>
export type ICellExecuteUpdateDto = ICellExecuteOutputEditDto | ICellExecuteOutputItemEditDto | ICellExecutionStateUpdateDto;
1358
>
1359
>
export interface VariablesResult {
1360
>
id: number;
1361
>
name: string;
1362
>
value: string;
1363
>
type?: string;
1364
>
language?: string;
1365
>
expression?: string;
1366
>
hasNamedChildren: boolean;
1367
>
indexedChildrenCount: number;
1368
>
extensionId: string;
1369
>
}
1370
>
1371
>
export interface MainThreadNotebookKernelsShape extends IDisposable {
1372
>
$postMessage(handle: number, editorId: string | undefined, message: any): Promise<boolean>;
1373
>
$addKernel(handle: number, data: INotebookKernelDto2): Promise<void>;
1374
>
$updateKernel(handle: number, data: Partial<INotebookKernelDto2>): void;
1375
>
$removeKernel(handle: number): void;
1376
>
$updateNotebookPriority(handle: number, uri: UriComponents, value: number | undefined): void;
1377
>
1378
>
$createExecution(handle: number, controllerId: string, uri: UriComponents, cellHandle: number): void;
1379
>
$updateExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecuteUpdateDto[]>): void;
1380
>
$completeExecution(handle: number, data: SerializableObjectWithBuffers<ICellExecutionCompleteDto>): void;
1381
>
1382
>
$createNotebookExecution(handle: number, controllerId: string, uri: UriComponents): void;
1383
>
$beginNotebookExecution(handle: number,): void;
1384
>
$completeNotebookExecution(handle: number): void;
1385
>
1386
>
$addKernelDetectionTask(handle: number, notebookType: string): Promise<void>;
1387
>
$removeKernelDetectionTask(handle: number): void;
1388
>
1389
>
$addKernelSourceActionProvider(handle: number, eventHandle: number, notebookType: string): Promise<void>;
1390
>
$removeKernelSourceActionProvider(handle: number, eventHandle: number): void;
1391
>
$emitNotebookKernelSourceActionsChangeEvent(eventHandle: number): void;
1392
>
$receiveVariable(requestId: string, variable: VariablesResult): void;
1393
>
$variablesUpdated(notebookUri: UriComponents): void;
1394
>
}
1395
>
1396
>
export interface MainThreadNotebookRenderersShape extends IDisposable {
1397
>
$postMessage(editorId: string | undefined, rendererId: string, message: unknown): Promise<boolean>;
1398
>
}
1399
>
1400
>
export interface MainThreadInteractiveShape extends IDisposable {
1401
>
}
1402
>
1403
>
export interface MainThreadSpeechShape extends IDisposable {
1404
>
$registerProvider(handle: number, identifier: string, metadata: ISpeechProviderMetadata): void;
1405
>
$unregisterProvider(handle: number): void;
1406
>
1407
>
$emitSpeechToTextEvent(session: number, event: ISpeechToTextEvent): void;
1408
>
$emitTextToSpeechEvent(session: number, event: ITextToSpeechEvent): void;
1409
>
$emitKeywordRecognitionEvent(session: number, event: IKeywordRecognitionEvent): void;
1410
>
}
1411
>
1412
>
export interface ExtHostSpeechShape {
1413
>
$createSpeechToTextSession(handle: number, session: number, language?: string): Promise<void>;
1414
>
$cancelSpeechToTextSession(session: number): Promise<void>;
1415
>
1416
>
$createTextToSpeechSession(handle: number, session: number, language?: string): Promise<void>;
1417
>
$synthesizeSpeech(session: number, text: string): Promise<void>;
1418
>
$cancelTextToSpeechSession(session: number): Promise<void>;
1419
>
1420
>
$createKeywordRecognitionSession(handle: number, session: number): Promise<void>;
1421
>
$cancelKeywordRecognitionSession(session: number): Promise<void>;
1422
>
}
1423
>
1424
>
export interface BrowserTabDto {
1425
>
id: string;
1426
>
url: string;
1427
>
title: string;
1428
>
favicon: string | undefined;
1429
>
}
1430
>
1431
>
export interface MainThreadBrowsersShape extends IDisposable {
1432
>
$openBrowserTab(url: string, viewColumn?: EditorGroupColumn, options?: IEditorOptions): Promise<BrowserTabDto>;
1433
>
$closeBrowserTab(browserId: string): Promise<void>;
1434
>
$startCDPSession(sessionId: string, browserId: string): Promise<void>;
1435
>
$closeCDPSession(sessionId: string): Promise<void>;
1436
>
$sendCDPMessage(sessionId: string, message: CDPRequest): Promise<void>;
1437
>
}
1438
>
1439
>
export interface ExtHostBrowsersShape {
1440
>
$onDidOpenBrowserTab(browser: BrowserTabDto): void;
1441
>
$onDidCloseBrowserTab(browserId: string): void;
1442
>
$onDidChangeActiveBrowserTab(browserId: string | undefined): void;
1443
>
$onDidChangeBrowserTabState(browser: BrowserTabDto): void;
1444
>
$onCDPSessionMessage(sessionId: string, message: CDPResponse | CDPEvent): void;
1445
>
$onCDPSessionClosed(sessionId: string): void;
1446
>
}
1447
>
1448
>
export interface MainThreadLanguageModelsShape extends IDisposable {
1449
>
$registerLanguageModelProvider(vendor: string): void;
1450
>
$onLMProviderChange(vendor: string): void;
1451
>
$unregisterProvider(vendor: string): void;
1452
>
$tryStartChatRequest(extension: ExtensionIdentifier, modelIdentifier: string, requestId: number, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: {}, token: CancellationToken): Promise<void>;
1453
>
$reportResponsePart(requestId: number, chunk: SerializableObjectWithBuffers<IChatResponsePart | IChatResponsePart[]>): Promise<void>;
1454
>
$reportResponseDone(requestId: number, error: SerializedError | undefined): Promise<void>;
1455
>
$selectChatModels(selector: ILanguageModelChatSelector): Promise<string[]>;
1456
>
$countTokens(modelId: string, value: string | IChatMessage, token: CancellationToken): Promise<number>;
1457
>
$cancelLanguageModelChatRequest(requestId: number): void;
1458
>
$fileIsIgnored(uri: UriComponents, token: CancellationToken): Promise<boolean>;
1459
>
$registerFileIgnoreProvider(handle: number): void;
1460
>
$unregisterFileIgnoreProvider(handle: number): void;
1461
>
}
1462
>
1463
>
export interface ExtHostLanguageModelsShape {
1464
>
$provideLanguageModelChatInfo(vendor: string, options: ILanguageModelChatInfoOptions, token: CancellationToken): Promise<ILanguageModelChatMetadataAndIdentifier[]>;
1465
>
$updateModelAccesslist(data: { from: ExtensionIdentifier; to: ExtensionIdentifier; enabled: boolean }[]): void;
1466
>
$onChatModelsChange(): void;
1467
>
$startChatRequest(modelId: string, requestId: number, from: ExtensionIdentifier | undefined, messages: SerializableObjectWithBuffers<IChatMessage[]>, options: ILanguageModelChatRequestOptions, token: CancellationToken): Promise<void>;
1468
>
$acceptResponsePart(requestId: number, chunk: SerializableObjectWithBuffers<IChatResponsePart | IChatResponsePart[]>): Promise<void>;
1469
>
$acceptResponseDone(requestId: number, error: SerializedError | undefined): Promise<void>;
1470
>
$cancelLanguageModelChatRequest(requestId: number): void;
1471
>
$provideTokenLength(modelId: string, value: string | IChatMessage, token: CancellationToken): Promise<number>;
1472
>
$isFileIgnored(handle: number, uri: UriComponents, token: CancellationToken): Promise<boolean>;
1473
>
}
1474
>
1475
>
export type IChatContextItemDto = Dto<IChatContextItem>;
1476
>
1477
>
export interface ExtHostChatContextShape {
1478
>
$provideWorkspaceChatContext(handle: number, token: CancellationToken): Promise<IChatContextItem[]>;
1479
>
$provideExplicitChatContext(handle: number, token: CancellationToken): Promise<IChatContextItem[]>;
1480
>
$resolveExplicitChatContext(handle: number, context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
1481
>
$provideResourceChatContext(handle: number, options: { resource: UriComponents; withValue: boolean; viewType?: string }, token: CancellationToken): Promise<IChatContextItem | undefined>;
1482
>
$resolveResourceChatContext(handle: number, context: IChatContextItem, token: CancellationToken): Promise<IChatContextItem>;
1483
>
$executeChatContextItemCommand(itemHandle: number): Promise<void>;
1484
>
}
1485
>
1486
>
export interface MainThreadChatContextShape extends IDisposable {
1487
>
$registerChatWorkspaceContextProvider(handle: number, id: string): void;
1488
>
$registerChatExplicitContextProvider(handle: number, id: string): void;
1489
>
$registerChatResourceContextProvider(handle: number, id: string, selector: ITabSelectorDto): void;
1490
>
$unregisterChatContextProvider(handle: number): void;
1491
>
$updateWorkspaceContextItems(handle: number, items: IChatContextItemDto[]): void;
1492
>
$executeChatContextItemCommand(itemHandle: number): Promise<void>;
1493
>
}
1494
>
1495
>
export interface IChatDebugEventCommonDto {
1496
>
readonly id?: string;
1497
>
readonly sessionResource?: UriComponents;
1498
>
readonly created: number;
1499
>
readonly parentEventId?: string;
1500
>
}
1501
>
1502
>
export interface IChatDebugToolCallEventDto extends IChatDebugEventCommonDto {
1503
>
readonly kind: 'toolCall';
1504
>
readonly toolName: string;
1505
>
readonly toolCallId?: string;
1506
>
readonly input?: string;
1507
>
readonly output?: string;
1508
>
readonly result?: 'success' | 'error';
1509
>
readonly durationInMillis?: number;
1510
>
}
1511
>
1512
>
export interface IChatDebugModelTurnEventDto extends IChatDebugEventCommonDto {
1513
>
readonly kind: 'modelTurn';
1514
>
readonly model?: string;
1515
>
readonly requestName?: string;
1516
>
readonly inputTokens?: number;
1517
>
readonly outputTokens?: number;
1518
>
readonly cachedTokens?: number;
1519
>
readonly totalTokens?: number;
1520
>
readonly copilotUsageNanoAiu?: number;
1521
>
readonly durationInMillis?: number;
1522
>
}
1523
>
1524
>
export interface IChatDebugGenericEventDto extends IChatDebugEventCommonDto {
1525
>
readonly kind: 'generic';
1526
>
readonly name: string;
1527
>
readonly details?: string;
1528
>
readonly level: number;
1529
>
readonly category?: string;
1530
>
}
1531
>
1532
>
export interface IChatDebugSubagentInvocationEventDto extends IChatDebugEventCommonDto {
1533
>
readonly kind: 'subagentInvocation';
1534
>
readonly agentName: string;
1535
>
readonly description?: string;
1536
>
readonly status?: 'running' | 'completed' | 'failed';
1537
>
readonly durationInMillis?: number;
1538
>
readonly toolCallCount?: number;
1539
>
readonly modelTurnCount?: number;
1540
>
}
1541
>
1542
>
export interface IChatDebugMessageSectionDto {
1543
>
readonly name: string;
1544
>
readonly content: string;
1545
>
}
1546
>
1547
>
export interface IChatDebugUserMessageEventDto extends IChatDebugEventCommonDto {
1548
>
readonly kind: 'userMessage';
1549
>
readonly message: string;
1550
>
readonly sections: readonly IChatDebugMessageSectionDto[];
1551
>
}
1552
>
1553
>
export interface IChatDebugAgentResponseEventDto extends IChatDebugEventCommonDto {
1554
>
readonly kind: 'agentResponse';
1555
>
readonly message: string;
1556
>
readonly sections: readonly IChatDebugMessageSectionDto[];
1557
>
}
1558
>
1559
>
export type IChatDebugEventDto = IChatDebugToolCallEventDto | IChatDebugModelTurnEventDto | IChatDebugGenericEventDto | IChatDebugSubagentInvocationEventDto | IChatDebugUserMessageEventDto | IChatDebugAgentResponseEventDto;
1560
>
1561
>
export interface IChatDebugEventTextContentDto {
1562
>
readonly kind: 'text';
1563
>
readonly value: string;
1564
>
}
1565
>
1566
>
export interface IChatDebugEventMessageContentDto {
1567
>
readonly kind: 'message';
1568
>
readonly type: 'user' | 'agent';
1569
>
readonly message: string;
1570
>
readonly sections: readonly IChatDebugMessageSectionDto[];
1571
>
}
1572
>
1573
>
export interface IChatDebugEventToolCallContentDto {
1574
>
readonly kind: 'toolCall';
1575
>
readonly toolName: string;
1576
>
readonly result?: 'success' | 'error';
1577
>
readonly durationInMillis?: number;
1578
>
readonly input?: string;
1579
>
readonly output?: string;
1580
>
}
1581
>
1582
>
export interface IChatDebugEventModelTurnContentDto {
1583
>
readonly kind: 'modelTurn';
1584
>
readonly requestName: string;
1585
>
readonly model?: string;
1586
>
readonly status?: string;
1587
>
readonly durationInMillis?: number;
1588
>
readonly timeToFirstTokenInMillis?: number;
1589
>
readonly requestId?: string;
1590
>
readonly maxInputTokens?: number;
1591
>
readonly maxOutputTokens?: number;
1592
>
readonly inputTokens?: number;
1593
>
readonly outputTokens?: number;
1594
>
readonly cachedTokens?: number;
1595
>
readonly totalTokens?: number;
1596
>
readonly requestOptions?: string;
1597
>
readonly errorMessage?: string;
1598
>
readonly sections?: readonly IChatDebugMessageSectionDto[];
1599
>
}
1600
>
1601
>
export interface IChatDebugEventHookContentDto {
1602
>
readonly kind: 'hook';
1603
>
readonly hookType: string;
1604
>
readonly command?: string;
1605
>
readonly result?: 'success' | 'error' | 'nonBlockingError';
1606
>
readonly durationInMillis?: number;
1607
>
readonly input?: string;
1608
>
readonly output?: string;
1609
>
readonly exitCode?: number;
1610
>
readonly errorMessage?: string;
1611
>
}
1612
>
1613
>
export type IChatDebugResolvedEventContentDto = IChatDebugEventTextContentDto | IChatDebugEventMessageContentDto | IChatDebugEventToolCallContentDto | IChatDebugEventModelTurnContentDto | IChatDebugEventHookContentDto;
1614
>
1615
>
export interface ExtHostChatDebugShape {
1616
>
$provideChatDebugLog(handle: number, sessionResource: UriComponents, token: CancellationToken): Promise<IChatDebugEventDto[] | undefined>;
1617
>
$resolveChatDebugLogEvent(handle: number, eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContentDto | undefined>;
1618
>
$exportChatDebugLog(handle: number, sessionResource: UriComponents, coreEvents: IChatDebugEventDto[], sessionTitle: string | undefined, token: CancellationToken): Promise<VSBuffer | undefined>;
1619
>
$importChatDebugLog(handle: number, data: VSBuffer, token: CancellationToken): Promise<{ uri: UriComponents; sessionTitle?: string } | undefined>;
1620
>
$getAvailableDebugSessionResources(handle: number, token: CancellationToken): Promise<{ uri: UriComponents; title?: string }[]>;
1621
>
$onCoreDebugEvent(event: IChatDebugEventDto): void;
1622
>
}
1623
>
1624
>
export interface MainThreadChatDebugShape extends IDisposable {
1625
>
$registerChatDebugLogProvider(handle: number): void;
1626
>
$unregisterChatDebugLogProvider(handle: number): void;
1627
>
$acceptChatDebugEvent(handle: number, event: IChatDebugEventDto): void;
1628
>
$subscribeToCoreDebugEvents(): void;
1629
>
$unsubscribeFromCoreDebugEvents(): void;
1630
>
}
1631
>
1632
>
export interface MainThreadEmbeddingsShape extends IDisposable {
1633
>
$registerEmbeddingProvider(handle: number, identifier: string): void;
1634
>
$unregisterEmbeddingProvider(handle: number): void;
1635
>
$computeEmbeddings(embeddingsModel: string, input: string[], token: CancellationToken): Promise<({ values: number[] }[])>;
1636
>
}
1637
>
1638
>
export interface ExtHostEmbeddingsShape {
1639
>
$provideEmbeddings(handle: number, input: string[], token: CancellationToken): Promise<{ values: number[] }[]>;
1640
>
$acceptEmbeddingModels(models: string[]): void;
1641
>
}
1642
>
1643
>
export interface IExtensionChatAgentMetadata extends Dto<IChatAgentMetadata> {
1644
>
hasFollowups?: boolean;
1645
>
}
1646
>
1647
>
export interface IDynamicChatAgentProps {
1648
>
name: string;
1649
>
publisherName: string;
1650
>
description?: string;
1651
>
fullName?: string;
1652
>
}
1653
>
1654
>
export interface IChatAgentProgressShape {
1655
>
$handleProgressChunk(requestId: string, chunks: (IChatProgressDto | [IChatProgressDto, number])[]): Promise<void>;
1656
>
$handleAnchorResolve(requestId: string, handle: string, anchor: Dto<IChatContentInlineReference>): void;
1657
>
}
1658
>
1659
>
export interface MainThreadChatAgentsShape2 extends IChatAgentProgressShape, IDisposable {
1660
>
$registerAgent(handle: number, extension: ExtensionIdentifier, id: string, metadata: IExtensionChatAgentMetadata, dynamicProps: IDynamicChatAgentProps | undefined): void;
1661
>
$registerChatParticipantDetectionProvider(handle: number): void;
1662
>
$unregisterChatParticipantDetectionProvider(handle: number): void;
1663
>
$registerPromptFileProvider(handle: number, type: string, extension: ExtensionIdentifier): void;
1664
>
$unregisterPromptFileProvider(handle: number): void;
1665
>
$onDidChangePromptFiles(handle: number): void;
1666
>
$registerChatSessionCustomizationProvider(handle: number, chatSessionType: string, metadata: IChatSessionCustomizationProviderMetadataDto, extension: ExtensionIdentifier): void;
1667
>
$unregisterChatSessionCustomizationProvider(handle: number): void;
1668
>
$onDidChangeCustomizations(handle: number): void;
1669
>
$registerAgentCompletionsProvider(handle: number, id: string, triggerCharacters: string[]): void;
1670
>
$unregisterAgentCompletionsProvider(handle: number, id: string): void;
1671
>
$updateAgent(handle: number, metadataUpdate: IExtensionChatAgentMetadata): void;
1672
>
$unregisterAgent(handle: number): void;
1673
>
1674
>
$transferActiveChatSession(toWorkspace: UriComponents): Promise<void>;
1675
>
$provideCustomAgents(token: CancellationToken): Promise<ICustomAgentDto[]>;
1676
>
$provideInstructions(token: CancellationToken): Promise<IInstructionDto[]>;
1677
>
$provideSkills(token: CancellationToken): Promise<ISkillDto[]>;
1678
>
$provideSlashCommands(token: CancellationToken): Promise<ISlashCommandDto[]>;
1679
>
$provideHooks(token: CancellationToken): Promise<IHookDto[]>;
1680
>
$providePlugins(token: CancellationToken): Promise<IPluginDto[]>;
1681
>
}
1682
>
1683
>
export interface ICodeMapperTextEdit {
1684
>
uri: URI;
1685
>
edits: languages.TextEdit[];
1686
>
}
1687
>
1688
>
export interface ICodeMapperNotebookEditDto {
1689
>
uri: URI;
1690
>
edits: ICellEditOperationDto[];
1691
>
}
1692
>
1693
>
export type ICodeMapperProgressDto = Dto<ICodeMapperTextEdit> | Dto<ICodeMapperNotebookEditDto>;
1694
>
1695
>
export interface MainThreadCodeMapperShape extends IDisposable {
1696
>
$registerCodeMapperProvider(handle: number, displayName: string): void;
1697
>
$unregisterCodeMapperProvider(handle: number): void;
1698
>
$handleProgress(requestId: string, data: ICodeMapperProgressDto): Promise<void>;
1699
>
}
1700
>
1701
>
export interface IChatAgentCompletionItem {
1702
>
id: string;
1703
>
fullName?: string;
1704
>
icon?: string;
1705
>
insertText?: string;
1706
>
label: string | languages.CompletionItemLabel;
1707
>
value: IChatRequestVariableValueDto;
1708
>
detail?: string;
1709
>
documentation?: string | IMarkdownString;
1710
>
command?: ICommandDto;
1711
>
}
1712
>
1713
>
export type IChatContentProgressDto =
1714
>
| Dto<Exclude<IChatProgressHistoryResponseContent, IChatTask | IChatMultiDiffData>>
1715
>
| IChatMultiDiffDataSerialized
1716
>
| IChatTaskDto;
1717
>
1718
>
export type IChatAgentHistoryEntryDto = {
1719
>
request: IChatAgentRequest;
1720
>
response: ReadonlyArray<IChatContentProgressDto>;
1721
>
result: IChatAgentResult;
1722
>
};
1723
>
1724
>
export interface IChatSessionContextDto {
1725
>
readonly chatSessionResource: UriComponents;
1726
>
readonly isUntitled: boolean;
1727
>
readonly initialSessionOptions?: ReadonlyArray<{ optionId: string; value: string }>;
1728
>
}
1729
>
1730
>
export interface IChatAgentInvokeResult extends IChatAgentResult {
1731
>
/** Error callstack for telemetry only. Stripped at the RPC boundary — never persisted or sent to the model. */
1732
>
errorCallstack?: string;
1733
>
/** Error name (e.g. 'ChatQuotaExceeded', 'TypeError') for telemetry only. */
1734
>
errorName?: string;
1735
>
}
1736
>
1737
>
export interface ExtHostChatAgentsShape2 {
1738
>
$invokeAgent(handle: number, request: Dto<IChatAgentRequest>, context: { history: IChatAgentHistoryEntryDto[]; chatSessionContext?: IChatSessionContextDto }, token: CancellationToken): Promise<IChatAgentInvokeResult | undefined>;
1739
>
$provideFollowups(request: Dto<IChatAgentRequest>, handle: number, result: IChatAgentResult, context: { history: IChatAgentHistoryEntryDto[] }, token: CancellationToken): Promise<IChatFollowup[]>;
1740
>
$acceptFeedback(handle: number, result: IChatAgentResult, voteAction: IChatVoteAction): void;
1741
>
$handleQuestionCarouselAnswer(requestId: string, resolveId: string, answers: Record<string, unknown> | undefined): void;
1742
>
$acceptAction(handle: number, result: IChatAgentResult, action: IChatUserActionEvent): void;
1743
>
$invokeCompletionProvider(handle: number, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
1744
>
$provideChatTitle(handle: number, context: IChatAgentHistoryEntryDto[], token: CancellationToken): Promise<string | undefined>;
1745
>
$provideChatSummary(handle: number, context: IChatAgentHistoryEntryDto[], token: CancellationToken): Promise<string | undefined>;
1746
>
$releaseSession(sessionResource: UriComponents): void;
1747
>
$detectChatParticipant(handle: number, request: Dto<IChatAgentRequest>, context: { history: IChatAgentHistoryEntryDto[] }, options: { participants: IChatParticipantMetadata[]; location: ChatAgentLocation }, token: CancellationToken): Promise<IChatParticipantDetectionResult | null | undefined>;
1748
>
$providePromptFiles(handle: number, type: PromptsType, context: IPromptFileContext, token: CancellationToken): Promise<Dto<IPromptFileResource>[] | undefined>;
1749
>
$provideChatSessionCustomizations(handle: number, sessionResource: UriComponents, token: CancellationToken): Promise<IChatSessionCustomizationItemDto[] | undefined>;
1750
>
$provideSourceFolders(handle: number, sessionResource: UriComponents, type: string, token: CancellationToken): Promise<IChatSessionCustomizationSourceFolderDto[] | undefined>;
1751
>
$setRequestTools(requestId: string, tools: UserSelectedTools): void;
1752
>
$setYieldRequested(requestId: string, value: boolean): void;
1753
>
$acceptActiveChatSession(sessionResource: UriComponents | undefined): void;
1754
>
$onDidChangeCustomAgents(): void;
1755
>
$onDidChangeInstructions(): void;
1756
>
$onDidChangeSkills(): void;
1757
>
$onDidChangeSlashCommands(): void;
1758
>
$onDidChangeHooks(): void;
1759
>
$onDidChangePlugins(): void;
1760
>
}
1761
>
1762
>
export type IChatResourceSourceDto = 'local' | 'user' | 'extension' | 'plugin' | 'builtin';
1763
>
1764
>
export interface IChatResourceDto {
1765
>
readonly uri: UriComponents;
1766
>
readonly name: string;
1767
>
readonly description?: string;
1768
>
readonly source: IChatResourceSourceDto;
1769
>
readonly extensionId?: string;
1770
>
readonly pluginUri?: UriComponents;
1771
>
readonly sessionTypes?: readonly string[];
1772
>
}
1773
>
1774
>
export interface ICustomAgentDto extends IChatResourceDto {
1775
>
readonly argumentHint?: string;
1776
>
readonly tools?: readonly string[];
1777
>
readonly model?: readonly string[];
1778
>
readonly userInvocable: boolean;
1779
>
readonly disableModelInvocation: boolean;
1780
>
readonly enabled: boolean;
1781
>
}
1782
>
1783
>
export interface IInstructionDto extends IChatResourceDto {
1784
>
readonly pattern?: string;
1785
>
}
1786
>
1787
>
export interface ISkillDto extends IChatResourceDto {
1788
>
readonly userInvocable: boolean;
1789
>
readonly disableModelInvocation: boolean;
1790
>
}
1791
>
1792
>
export interface ISlashCommandDto extends IChatResourceDto {
1793
>
readonly argumentHint?: string;
1794
>
readonly userInvocable: boolean;
1795
>
}
1796
>
1797
>
export interface IHookDto {
1798
>
readonly uri: UriComponents;
1799
>
readonly sessionTypes?: readonly string[];
1800
>
readonly source: IChatResourceSourceDto;
1801
>
readonly extensionId?: string;
1802
>
readonly pluginUri?: UriComponents;
1803
>
}
1804
>
1805
>
export interface IPluginDto {
1806
>
readonly uri: UriComponents;
1807
>
}
1808
>
1809
>
export interface IChatSessionCustomizationProviderMetadataDto {
1810
>
readonly label: string;
1811
>
readonly iconId?: string;
1812
>
readonly supportedTypes?: readonly string[];
1813
>
}
1814
>
1815
>
export interface IChatSessionCustomizationItemDto {
1816
>
readonly uri: UriComponents;
1817
>
readonly type: string;
1818
>
readonly name: string;
1819
>
readonly source: IChatResourceSourceDto;
1820
>
readonly description?: string;
1821
>
readonly groupKey?: string;
1822
>
readonly badge?: string;
1823
>
readonly extensionId?: string;
1824
>
readonly pluginUri?: UriComponents;
1825
>
readonly pluginLabel?: string;
1826
>
readonly badgeTooltip?: string;
1827
>
readonly userInvocable?: boolean;
1828
>
}
1829
>
1830
>
export interface IChatSessionCustomizationSourceFolderDto {
1831
>
readonly uri: UriComponents;
1832
>
readonly label: string;
1833
>
readonly source: IChatResourceSourceDto;
1834
>
}
1835
>
export interface IChatParticipantMetadata {
1836
>
participant: string;
1837
>
command?: string;
1838
>
disambiguation: { category: string; description: string; examples: string[] }[];
1839
>
}
1840
>
1841
>
export interface IChatParticipantDetectionResult {
1842
>
participant: string;
1843
>
command?: string;
1844
>
}
1845
>
1846
>
export interface IToolDataDto {
1847
>
id: string;
1848
>
toolReferenceName?: string;
1849
>
legacyToolReferenceFullNames?: readonly string[];
1850
>
fullReferenceName: string | undefined;
1851
>
tags?: readonly string[];
1852
>
displayName: string;
1853
>
userDescription?: string;
1854
>
modelDescription: string;
1855
>
source: Dto<ToolDataSource>;
1856
>
inputSchema?: IJSONSchema;
1857
>
}
1858
>
1859
>
export interface ILanguageModelChatSelectorDto {
1860
>
vendor?: string;
1861
>
family?: string;
1862
>
version?: string;
1863
>
id?: string;
1864
>
}
1865
>
1866
>
export interface IToolDefinitionDto extends IToolDataDto {
1867
>
icon?: IconPathDto;
1868
>
models?: ILanguageModelChatSelectorDto[];
1869
>
toolSet?: string;
1870
>
}
1871
>
1872
>
export interface MainThreadLanguageModelToolsShape extends IDisposable {
1873
>
$getTools(): Promise<Dto<IToolDataDto>[]>;
1874
>
$acceptToolProgress(callId: string, progress: IToolProgressStep): void;
1875
>
$invokeTool(dto: Dto<IToolInvocation>, token?: CancellationToken): Promise<Dto<IToolResult> | SerializableObjectWithBuffers<Dto<IToolResult>>>;
1876
>
$countTokensForInvocation(callId: string, input: string, token: CancellationToken): Promise<number>;
1877
>
$registerTool(id: string, hasHandleToolStream: boolean): void;
1878
>
$registerToolWithDefinition(extensionId: ExtensionIdentifier, definition: IToolDefinitionDto, hasHandleToolStream: boolean): void;
1879
>
$unregisterTool(name: string): void;
1880
>
}
1881
>
1882
>
export type IChatRequestVariableValueDto = Dto<IChatRequestVariableValue>;
1883
>
1884
>
export interface ExtHostLanguageModelToolsShape {
1885
>
$onDidChangeTools(tools: IToolDataDto[]): void;
1886
>
$invokeTool(dto: Dto<IToolInvocation>, token: CancellationToken): Promise<Dto<IToolResult> | SerializableObjectWithBuffers<Dto<IToolResult>>>;
1887
>
$countTokensForInvocation(callId: string, input: string, token: CancellationToken): Promise<number>;
1888
>
1889
>
$handleToolStream(toolId: string, context: IToolInvocationStreamContext, token: CancellationToken): Promise<IStreamedToolInvocation | undefined>;
1890
>
$prepareToolInvocation(toolId: string, context: IToolInvocationPreparationContext, token: CancellationToken): Promise<IPreparedToolInvocation | undefined>;
1891
>
}
1892
>
1893
>
export interface MainThreadUrlsShape extends IDisposable {
1894
>
$registerUriHandler(handle: number, extensionId: ExtensionIdentifier, extensionDisplayName: string): Promise<void>;
1895
>
$unregisterUriHandler(handle: number): Promise<void>;
1896
>
$createAppUri(uri: UriComponents): Promise<UriComponents>;
1897
>
}
1898
>
1899
>
export interface IChatResponseProgressFileTreeData {
1900
>
label: string;
1901
>
uri: URI;
1902
>
children?: IChatResponseProgressFileTreeData[];
1903
>
}
1904
>
1905
>
export type IDocumentContextDto = {
1906
>
uri: UriComponents;
1907
>
version: number;
1908
>
ranges: IRange[];
1909
>
};
1910
>
1911
>
export type IChatProgressDto =
1912
>
| Dto<Exclude<IChatProgress, IChatTask | IChatNotebookEdit>>
1913
>
| IChatTaskDto
1914
>
| IChatNotebookEditDto
1915
>
| IChatExternalEditsDto
1916
>
| IChatResponseClearToPreviousToolInvocationDto
1917
>
| IChatBeginToolInvocationDto
1918
>
| IChatUpdateToolInvocationDto
1919
>
| IChatUsageDto;
1920
>
1921
>
export interface ExtHostUrlsShape {
1922
>
$handleExternalUri(handle: number, uri: UriComponents): Promise<void>;
1923
>
}
1924
>
1925
>
export interface MainThreadUriOpenersShape extends IDisposable {
1926
>
$registerUriOpener(id: string, schemes: readonly string[], extensionId: ExtensionIdentifier, label: string): Promise<void>;
1927
>
$unregisterUriOpener(id: string): Promise<void>;
1928
>
}
1929
>
1930
>
export interface ExtHostUriOpenersShape {
1931
>
$canOpenUri(id: string, uri: UriComponents, token: CancellationToken): Promise<languages.ExternalUriOpenerPriority>;
1932
>
$openUri(id: string, context: { resolvedUri: UriComponents; sourceUri: UriComponents }, token: CancellationToken): Promise<void>;
1933
>
}
1934
>
1935
>
export interface MainThreadChatOutputRendererShape extends IDisposable {
1936
>
$registerChatOutputRenderer(viewType: string, extensionId: ExtensionIdentifier, extensionLocation: UriComponents): void;
1937
>
$unregisterChatOutputRenderer(viewType: string): void;
1938
>
}
1939
>
1940
>
export interface IChatOutputRenderContextDto {
1941
>
readonly codeBlockContext?: {
1942
>
readonly languageIdentifier: string;
1943
>
};
1944
>
}
1945
>
1946
>
export interface ExtHostChatOutputRendererShape {
1947
>
$renderChatOutput(viewType: string, mime: string, valueData: VSBuffer, webviewHandle: string, context: IChatOutputRenderContextDto, token: CancellationToken): Promise<void>;
1948
>
}
1949
>
1950
>
export interface MainThreadProfileContentHandlersShape {
1951
>
$registerProfileContentHandler(id: string, name: string, description: string | undefined, extensionId: string): Promise<void>;
1952
>
$unregisterProfileContentHandler(id: string): Promise<void>;
1953
>
}
1954
>
1955
>
export interface ExtHostProfileContentHandlersShape {
1956
>
$saveProfile(id: string, name: string, content: string, token: CancellationToken): Promise<UriDto<ISaveProfileResult> | null>;
1957
>
$readProfile(id: string, idOrUri: string | UriComponents, token: CancellationToken): Promise<string | null>;
1958
>
}
1959
>
1960
>
export interface ITextSearchComplete {
1961
>
limitHit?: boolean;
1962
>
message?: TextSearchCompleteMessage | TextSearchCompleteMessage[];
1963
>
}
1964
>
1965
>
export interface ResourceTrustRequestOptionsDto {
1966
>
readonly uri: UriComponents;
1967
>
readonly message?: string;
1968
>
}
1969
>
1970
>
export interface MainThreadWorkspaceShape extends IDisposable {
1971
>
$startFileSearch(includeFolder: UriComponents | null, options: IFileQueryBuilderOptions, token: CancellationToken): Promise<UriComponents[] | null>;
1972
>
$startTextSearch(query: search.IPatternInfo, folder: UriComponents | null, options: ITextQueryBuilderOptions, requestId: number, token: CancellationToken): Promise<ITextSearchComplete | null>;
1973
>
$checkExists(folders: readonly UriComponents[], includes: string[], token: CancellationToken): Promise<boolean>;
1974
>
$save(uri: UriComponents, options: { saveAs: boolean }): Promise<UriComponents | undefined>;
1975
>
$saveAll(includeUntitled?: boolean): Promise<boolean>;
1976
>
$updateWorkspaceFolders(extensionName: string, index: number, deleteCount: number, workspaceFoldersToAdd: { uri: UriComponents; name?: string }[]): Promise<void>;
1977
>
$resolveProxy(url: string): Promise<string | undefined>;
1978
>
$lookupAuthorization(authInfo: AuthInfo): Promise<Credentials | undefined>;
1979
>
$lookupKerberosAuthorization(url: string): Promise<string | undefined>;
1980
>
$loadCertificates(): Promise<string[]>;
1981
>
$requestResourceTrust(options: ResourceTrustRequestOptionsDto): Promise<boolean | undefined>;
1982
>
$requestWorkspaceTrust(options?: WorkspaceTrustRequestOptions): Promise<boolean | undefined>;
1983
>
$isResourceTrusted(resource: UriComponents): Promise<boolean>;
1984
>
$registerEditSessionIdentityProvider(handle: number, scheme: string): void;
1985
>
$unregisterEditSessionIdentityProvider(handle: number): void;
1986
>
$registerCanonicalUriProvider(handle: number, scheme: string): void;
1987
>
$unregisterCanonicalUriProvider(handle: number): void;
1988
>
$resolveDecoding(resource: UriComponents | undefined, options?: { encoding?: string }): Promise<{ preferredEncoding: string; guessEncoding: boolean; candidateGuessEncodings: string[] }>;
1989
>
$validateDetectedEncoding(resource: UriComponents | undefined, detectedEncoding: string, options?: { encoding?: string }): Promise<string>;
1990
>
$resolveEncoding(resource: UriComponents | undefined, options?: { encoding?: string }): Promise<{ encoding: string; addBOM: boolean }>;
1991
>
}
1992
>
1993
>
export interface IFileChangeDto {
1994
>
resource: UriComponents;
1995
>
type: files.FileChangeType;
1996
>
}
1997
>
1998
>
export interface MainThreadFileSystemShape extends IDisposable {
1999
>
$registerFileSystemProvider(handle: number, scheme: string, capabilities: files.FileSystemProviderCapabilities, readonlyMessage?: IMarkdownString): Promise<void>;
2000
>
$unregisterProvider(handle: number): void;
2001
>
$onFileSystemChange(handle: number, resource: IFileChangeDto[]): void;
2002
>
2003
>
$stat(resource: UriComponents): Promise<files.IStat>;
2004
>
$readdir(resource: UriComponents): Promise<[string, files.FileType][]>;
2005
>
$readFile(resource: UriComponents): Promise<VSBuffer>;
2006
>
$writeFile(resource: UriComponents, content: VSBuffer): Promise<void>;
2007
>
$rename(resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2008
>
$copy(resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2009
>
$mkdir(resource: UriComponents): Promise<void>;
2010
>
$delete(resource: UriComponents, opts: files.IFileDeleteOptions): Promise<void>;
2011
>
2012
>
$ensureActivation(scheme: string): Promise<void>;
2013
>
}
2014
>
2015
>
export interface MainThreadFileSystemEventServiceShape extends IDisposable {
2016
>
$watch(extensionId: string, session: number, resource: UriComponents, opts: files.IWatchOptions, correlate: boolean): void;
2017
>
$unwatch(session: number): void;
2018
>
}
2019
>
2020
>
export interface MainThreadLabelServiceShape extends IDisposable {
2021
>
$registerResourceLabelFormatter(handle: number, formatter: ResourceLabelFormatter): void;
2022
>
$unregisterResourceLabelFormatter(handle: number): void;
2023
>
}
2024
>
2025
>
export interface MainThreadSearchShape extends IDisposable {
2026
>
$registerFileSearchProvider(handle: number, scheme: string): void;
2027
>
$registerAITextSearchProvider(handle: number, scheme: string): void;
2028
>
$registerTextSearchProvider(handle: number, scheme: string): void;
2029
>
$unregisterProvider(handle: number): void;
2030
>
$handleFileMatch(handle: number, session: number, data: UriComponents[]): void;
2031
>
$handleTextMatch(handle: number, session: number, data: search.IRawFileMatch2[]): void;
2032
>
$handleKeywordResult(handle: number, session: number, data: AISearchKeyword): void;
2033
>
$handleTelemetry(eventName: string, data: any): void;
2034
>
}
2035
>
2036
>
export interface MainThreadShareShape extends IDisposable {
2037
>
$registerShareProvider(handle: number, selector: IDocumentFilterDto[], id: string, label: string, priority: number): void;
2038
>
$unregisterShareProvider(handle: number): void;
2039
>
}
2040
>
2041
>
export interface MainThreadTaskShape extends IDisposable {
2042
>
$createTaskId(task: tasks.ITaskDTO): Promise<string>;
2043
>
$registerTaskProvider(handle: number, type: string): Promise<void>;
2044
>
$unregisterTaskProvider(handle: number): Promise<void>;
2045
>
$fetchTasks(filter?: tasks.ITaskFilterDTO): Promise<tasks.ITaskDTO[]>;
2046
>
$getTaskExecution(value: tasks.ITaskHandleDTO | tasks.ITaskDTO): Promise<tasks.ITaskExecutionDTO>;
2047
>
$executeTask(task: tasks.ITaskHandleDTO | tasks.ITaskDTO): Promise<tasks.ITaskExecutionDTO>;
2048
>
$terminateTask(id: string): Promise<void>;
2049
>
$registerTaskSystem(scheme: string, info: tasks.ITaskSystemInfoDTO): void;
2050
>
$customExecutionComplete(id: string, result?: number): Promise<void>;
2051
>
$registerSupportedExecutions(custom?: boolean, shell?: boolean, process?: boolean): Promise<void>;
2052
>
}
2053
>
2054
>
export interface MainThreadExtensionServiceShape extends IDisposable {
2055
>
$getExtension(extensionId: string): Promise<Dto<IExtensionDescription> | undefined>;
2056
>
$activateExtension(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<void>;
2057
>
$onWillActivateExtension(extensionId: ExtensionIdentifier): Promise<void>;
2058
>
$onDidActivateExtension(extensionId: ExtensionIdentifier, codeLoadingTime: number, activateCallTime: number, activateResolvedTime: number, activationReason: ExtensionActivationReason): void;
2059
>
$onExtensionActivationError(extensionId: ExtensionIdentifier, error: SerializedError, missingExtensionDependency: MissingExtensionDependency | null): Promise<void>;
2060
>
$onExtensionRuntimeError(extensionId: ExtensionIdentifier, error: SerializedError): void;
2061
>
$setPerformanceMarks(marks: performance.PerformanceMark[]): Promise<void>;
2062
>
$asBrowserUri(uri: UriComponents): Promise<UriComponents>;
2063
>
}
2064
>
2065
>
export interface SCMProviderFeatures {
2066
>
hasArtifactProvider?: boolean;
2067
>
hasHistoryProvider?: boolean;
2068
>
hasQuickDiffProvider?: boolean;
2069
>
quickDiffLabel?: string;
2070
>
hasSecondaryQuickDiffProvider?: boolean;
2071
>
secondaryQuickDiffLabel?: string;
2072
>
count?: number;
2073
>
commitTemplate?: string;
2074
>
acceptInputCommand?: languages.Command;
2075
>
actionButton?: SCMActionButtonDto | null;
2076
>
statusBarCommands?: ICommandDto[];
2077
>
contextValue?: string;
2078
>
}
2079
>
2080
>
export interface SCMActionButtonDto {
2081
>
command: ICommandDto & { shortTitle?: string };
2082
>
secondaryCommands?: ICommandDto[][];
2083
>
enabled: boolean;
2084
>
}
2085
>
2086
>
export interface SCMGroupFeatures {
2087
>
hideWhenEmpty?: boolean;
2088
>
contextValue?: string;
2089
>
}
2090
>
2091
>
export type SCMRawResource = [
2092
>
number /*handle*/,
2093
>
UriComponents /*resourceUri*/,
2094
>
[UriComponents | ThemeIcon | undefined, UriComponents | ThemeIcon | undefined] /*icons: light, dark*/,
2095
>
string /*tooltip*/,
2096
>
boolean /*strike through*/,
2097
>
boolean /*faded*/,
2098
>
string /*context value*/,
2099
>
ICommandDto | undefined /*command*/,
2100
>
UriComponents | undefined /* multiFileDiffEditorOriginalUri */,
2101
>
UriComponents | undefined /* multiFileDiffEditorModifiedUri */,
2102
>
];
2103
>
2104
>
export type SCMRawResourceSplice = [
2105
>
number /* start */,
2106
>
number /* delete count */,
2107
>
SCMRawResource[]
2108
>
];
2109
>
2110
>
export type SCMRawResourceSplices = [
2111
>
number, /*handle*/
2112
>
SCMRawResourceSplice[]
2113
>
];
2114
>
2115
>
export interface SCMHistoryItemRefDto {
2116
>
readonly id: string;
2117
>
readonly name: string;
2118
>
readonly revision?: string;
2119
>
readonly category?: string;
2120
>
readonly description?: string;
2121
>
readonly icon?: IconPathDto;
2122
>
}
2123
>
2124
>
export interface SCMHistoryItemRefsChangeEventDto {
2125
>
readonly added: readonly SCMHistoryItemRefDto[];
2126
>
readonly modified: readonly SCMHistoryItemRefDto[];
2127
>
readonly removed: readonly SCMHistoryItemRefDto[];
2128
>
readonly silent: boolean;
2129
>
}
2130
>
2131
>
export interface SCMHistoryItemDto {
2132
>
readonly id: string;
2133
>
readonly parentIds: string[];
2134
>
readonly subject: string;
2135
>
readonly message: string;
2136
>
readonly displayId?: string;
2137
>
readonly author?: string;
2138
>
readonly authorIcon?: IconPathDto;
2139
>
readonly authorEmail?: string;
2140
>
readonly timestamp?: number;
2141
>
readonly statistics?: {
2142
>
readonly files: number;
2143
>
readonly insertions: number;
2144
>
readonly deletions: number;
2145
>
};
2146
>
readonly references?: SCMHistoryItemRefDto[];
2147
>
readonly tooltip?: IMarkdownString | Array<IMarkdownString> | undefined;
2148
>
}
2149
>
2150
>
export interface SCMHistoryItemChangeDto {
2151
>
readonly uri: UriComponents;
2152
>
readonly originalUri: UriComponents | undefined;
2153
>
readonly modifiedUri: UriComponents | undefined;
2154
>
}
2155
>
2156
>
export interface SCMArtifactGroupDto {
2157
>
readonly id: string;
2158
>
readonly name: string;
2159
>
readonly icon?: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon;
2160
>
readonly supportsFolders?: boolean;
2161
>
}
2162
>
2163
>
export interface SCMArtifactDto {
2164
>
readonly id: string;
2165
>
readonly name: string;
2166
>
readonly description?: string;
2167
>
readonly icon?: UriComponents | { light: UriComponents; dark: UriComponents } | ThemeIcon;
2168
>
readonly timestamp?: number;
2169
>
readonly command?: ICommandDto;
2170
>
}
2171
>
2172
>
export interface MainThreadSCMShape extends IDisposable {
2173
>
$registerSourceControl(handle: number, parentHandle: number | undefined, id: string, label: string, rootUri: UriComponents | undefined, iconPath: IconPathDto | undefined, isHidden: boolean | undefined, inputBoxDocumentUri: UriComponents): Promise<void>;
2174
>
$updateSourceControl(handle: number, features: SCMProviderFeatures): Promise<void>;
2175
>
$unregisterSourceControl(handle: number): Promise<void>;
2176
>
2177
>
$registerGroups(sourceControlHandle: number, groups: [number /*handle*/, string /*id*/, string /*label*/, SCMGroupFeatures, /* multiDiffEditorEnableViewChanges */ boolean][], splices: SCMRawResourceSplices[]): Promise<void>;
2178
>
$updateGroup(sourceControlHandle: number, handle: number, features: SCMGroupFeatures): Promise<void>;
2179
>
$updateGroupLabel(sourceControlHandle: number, handle: number, label: string): Promise<void>;
2180
>
$unregisterGroup(sourceControlHandle: number, handle: number): Promise<void>;
2181
>
2182
>
$spliceResourceStates(sourceControlHandle: number, splices: SCMRawResourceSplices[]): Promise<void>;
2183
>
2184
>
$setInputBoxValue(sourceControlHandle: number, value: string): Promise<void>;
2185
>
$setInputBoxPlaceholder(sourceControlHandle: number, placeholder: string): Promise<void>;
2186
>
$setInputBoxEnablement(sourceControlHandle: number, enabled: boolean): Promise<void>;
2187
>
$setInputBoxVisibility(sourceControlHandle: number, visible: boolean): Promise<void>;
2188
>
$showValidationMessage(sourceControlHandle: number, message: string | IMarkdownString, type: InputValidationType): Promise<void>;
2189
>
$setValidationProviderIsEnabled(sourceControlHandle: number, enabled: boolean): Promise<void>;
2190
>
2191
>
$onDidChangeHistoryProviderCurrentHistoryItemRefs(sourceControlHandle: number, historyItemRef?: SCMHistoryItemRefDto, historyItemRemoteRef?: SCMHistoryItemRefDto, historyItemBaseRef?: SCMHistoryItemRefDto): Promise<void>;
2192
>
$onDidChangeHistoryProviderHistoryItemRefs(sourceControlHandle: number, historyItemRefs: SCMHistoryItemRefsChangeEventDto): Promise<void>;
2193
>
2194
>
$onDidChangeArtifacts(sourceControlHandle: number, groups: string[]): Promise<void>;
2195
>
}
2196
>
2197
>
export interface MainThreadQuickDiffShape extends IDisposable {
2198
>
$registerQuickDiffProvider(handle: number, selector: IDocumentFilterDto[], id: string, label: string, rootUri: UriComponents | undefined): Promise<void>;
2199
>
$unregisterQuickDiffProvider(handle: number): Promise<void>;
2200
>
$createSourceControlDiffInformation(handle: number, uri: UriComponents): Promise<void>;
2201
>
$disposeSourceControlDiffInformation(handle: number): Promise<void>;
2202
>
}
2203
>
2204
>
export interface IAgentEditorCommentDto {
2205
>
id: string;
2206
>
range: IRange;
2207
>
body: string;
2208
>
author?: string;
2209
>
}
2210
>
2211
>
export interface MainThreadAgentEditorCommentsShape extends IDisposable {
2212
>
$createAgentEditorComments(handle: number, uri: UriComponents): Promise<void>;
2213
>
$addComment(handle: number, range: IRange, body: string): Promise<void>;
2214
>
$deleteComment(handle: number, id: string): Promise<void>;
2215
>
$disposeAgentEditorComments(handle: number): Promise<void>;
2216
>
}
2217
>
2218
>
export interface ExtHostAgentEditorCommentsShape {
2219
>
$acceptAgentEditorComments(handle: number, comments: IAgentEditorCommentDto[], acceptsComments: boolean): void;
2220
>
}
2221
>
2222
>
export interface IDocumentDiffLineChangeDto {
2223
>
originalRange: IRange;
2224
>
modifiedRange: IRange;
2225
>
innerChanges: { originalRange: IRange; modifiedRange: IRange }[] | undefined;
2226
>
}
2227
>
2228
>
export interface IDocumentDiffMoveDto {
2229
>
originalRange: IRange;
2230
>
modifiedRange: IRange;
2231
>
changes: IDocumentDiffLineChangeDto[];
2232
>
}
2233
>
2234
>
export interface IDocumentDiffResultDto {
2235
>
identical: boolean;
2236
>
quitEarly: boolean;
2237
>
changes: IDocumentDiffLineChangeDto[];
2238
>
moves: IDocumentDiffMoveDto[];
2239
>
}
2240
>
2241
>
export interface MainThreadDocumentDiffShape extends IDisposable {
2242
>
$computeDocumentDiff(originalUri: UriComponents, modifiedUri: UriComponents, ignoreTrimWhitespace: boolean, maxComputationTimeMs: number, computeMoves: boolean): Promise<IDocumentDiffResultDto | null>;
2243
>
}
2244
>
2245
>
export type DebugSessionUUID = string;
2246
>
2247
>
export interface IDebugConfiguration {
2248
>
type: string;
2249
>
name: string;
2250
>
request: string;
2251
>
[key: string]: any;
2252
>
}
2253
>
2254
>
export interface IStartDebuggingOptions {
2255
>
parentSessionID?: DebugSessionUUID;
2256
>
lifecycleManagedByParent?: boolean;
2257
>
repl?: IDebugSessionReplMode;
2258
>
noDebug?: boolean;
2259
>
compact?: boolean;
2260
>
suppressDebugToolbar?: boolean;
2261
>
suppressDebugStatusbar?: boolean;
2262
>
suppressDebugView?: boolean;
2263
>
suppressSaveBeforeStart?: boolean;
2264
>
testRun?: IDebugTestRunReference;
2265
>
}
2266
>
2267
>
export interface MainThreadDebugServiceShape extends IDisposable {
2268
>
$registerDebugTypes(debugTypes: string[]): void;
2269
>
$sessionCached(sessionID: string): void;
2270
>
$acceptDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): void;
2271
>
$acceptDAError(handle: number, name: string, message: string, stack: string | undefined): void;
2272
>
$acceptDAExit(handle: number, code: number | undefined, signal: string | undefined): void;
2273
>
$registerDebugConfigurationProvider(type: string, triggerKind: DebugConfigurationProviderTriggerKind, hasProvideMethod: boolean, hasResolveMethod: boolean, hasResolve2Method: boolean, handle: number): Promise<void>;
2274
>
$registerDebugAdapterDescriptorFactory(type: string, handle: number): Promise<void>;
2275
>
$unregisterDebugConfigurationProvider(handle: number): void;
2276
>
$unregisterDebugAdapterDescriptorFactory(handle: number): void;
2277
>
$startDebugging(folder: UriComponents | undefined, nameOrConfig: string | IDebugConfiguration, options: IStartDebuggingOptions): Promise<boolean>;
2278
>
$stopDebugging(sessionId: DebugSessionUUID | undefined): Promise<void>;
2279
>
$setDebugSessionName(id: DebugSessionUUID, name: string): void;
2280
>
$customDebugAdapterRequest(id: DebugSessionUUID, command: string, args: any): Promise<any>;
2281
>
$getDebugProtocolBreakpoint(id: DebugSessionUUID, breakpoinId: string): Promise<DebugProtocol.Breakpoint | undefined>;
2282
>
$appendDebugConsole(value: string): void;
2283
>
$registerBreakpoints(breakpoints: Array<ISourceMultiBreakpointDto | IFunctionBreakpointDto | IDataBreakpointDto>): Promise<void>;
2284
>
$unregisterBreakpoints(breakpointIds: string[], functionBreakpointIds: string[], dataBreakpointIds: string[]): Promise<void>;
2285
>
$registerDebugVisualizer(extensionId: string, id: string): void;
2286
>
$unregisterDebugVisualizer(extensionId: string, id: string): void;
2287
>
$registerDebugVisualizerTree(treeId: string, canEdit: boolean): void;
2288
>
$unregisterDebugVisualizerTree(treeId: string): void;
2289
>
}
2290
>
2291
>
export interface IOpenUriOptions {
2292
>
readonly allowTunneling?: boolean;
2293
>
readonly allowContributedOpeners?: boolean | string;
2294
>
}
2295
>
2296
>
export interface MainThreadWindowShape extends IDisposable {
2297
>
$getInitialState(): Promise<{ isFocused: boolean; isActive: boolean }>;
2298
>
$openUri(uri: UriComponents, uriString: string | undefined, options: IOpenUriOptions): Promise<boolean>;
2299
>
$asExternalUri(uri: UriComponents, options: IOpenUriOptions): Promise<UriComponents>;
2300
>
}
2301
>
2302
>
export enum CandidatePortSource {
2303
>
None = 0,
2304
>
Process = 1,
2305
>
Output = 2,
2306
>
Hybrid = 3
2307
>
}
2308
>
2309
>
export interface PortAttributesSelector {
2310
>
portRange?: [number, number] | number;
2311
>
commandPattern?: RegExp;
2312
>
}
2313
>
2314
>
export interface MainThreadTunnelServiceShape extends IDisposable {
2315
>
$openTunnel(tunnelOptions: TunnelOptions, source: string | undefined): Promise<TunnelDto | undefined>;
2316
>
$closeTunnel(remote: { host: string; port: number }): Promise<void>;
2317
>
$getTunnels(): Promise<TunnelDescription[]>;
2318
>
$setTunnelProvider(features: TunnelProviderFeatures | undefined, enablePortsView: boolean): Promise<void>;
2319
>
$hasTunnelProvider(): Promise<boolean>;
2320
>
$setRemoteTunnelService(processId: number): Promise<void>;
2321
>
$setCandidateFilter(): Promise<void>;
2322
>
$onFoundNewCandidates(candidates: CandidatePort[]): Promise<void>;
2323
>
$setCandidatePortSource(source: CandidatePortSource): Promise<void>;
2324
>
$registerPortsAttributesProvider(selector: PortAttributesSelector, providerHandle: number): Promise<void>;
2325
>
$unregisterPortsAttributesProvider(providerHandle: number): Promise<void>;
2326
>
}
2327
>
2328
>
export interface MainThreadTimelineShape extends IDisposable {
2329
>
$registerTimelineProvider(provider: TimelineProviderDescriptor): void;
2330
>
$unregisterTimelineProvider(source: string): void;
2331
>
$emitTimelineChangeEvent(e: TimelineChangeEvent | undefined): void;
2332
>
}
2333
>
2334
>
export interface HoverWithId extends languages.Hover {
2335
>
/**
2336
>
* Id of the hover
2337
>
*/
2338
>
id: number;
2339
>
}
2340
>
2341
>
// -- extension host
2342
>
2343
>
export interface ICommandMetadataDto {
2344
>
/**
2345
>
* NOTE: Please use an ILocalizedString. string is in the type for backcompat for now.
2346
>
* A short summary of what the command does. This will be used in:
2347
>
* - API commands
2348
>
* - when showing keybindings that have no other UX
2349
>
* - when searching for commands in the Command Palette
2350
>
*/
2351
>
readonly description: ILocalizedString | string;
2352
>
readonly args?: ReadonlyArray<{
2353
>
readonly name: string;
2354
>
readonly isOptional?: boolean;
2355
>
readonly description?: string;
2356
>
}>;
2357
>
readonly returns?: string;
2358
>
}
2359
>
2360
>
export interface ICodeMapperRequestDto extends Dto<ICodeMapperRequest> {
2361
>
requestId: string;
2362
>
}
2363
>
2364
>
export interface ExtHostCodeMapperShape {
2365
>
$mapCode(handle: number, request: ICodeMapperRequestDto, token: CancellationToken): Promise<ICodeMapperResult | null | undefined>;
2366
>
}
2367
>
2368
>
export interface ExtHostCommandsShape {
2369
>
$executeContributedCommand(id: string, ...args: unknown[]): Promise<unknown>;
2370
>
$getContributedCommandMetadata(): Promise<{ [id: string]: string | ICommandMetadataDto }>;
2371
>
}
2372
>
2373
>
export interface ExtHostConfigurationShape {
2374
>
$initializeConfiguration(data: IConfigurationInitData): void;
2375
>
$acceptConfigurationChanged(data: IConfigurationInitData, change: IConfigurationChange): void;
2376
>
}
2377
>
2378
>
export interface ExtHostDiagnosticsShape {
2379
>
$acceptMarkersChange(data: [UriComponents, IMarkerData[]][]): void;
2380
>
}
2381
>
2382
>
export interface ExtHostDocumentContentProvidersShape {
2383
>
$provideTextDocumentContent(handle: number, uri: UriComponents): Promise<string | null | undefined>;
2384
>
}
2385
>
2386
>
export interface IModelAddedData {
2387
>
uri: UriComponents;
2388
>
versionId: number;
2389
>
lines: string[];
2390
>
EOL: string;
2391
>
languageId: string;
2392
>
isDirty: boolean;
2393
>
encoding: string;
2394
>
}
2395
>
export interface ExtHostDocumentsShape {
2396
>
$acceptModelLanguageChanged(strURL: UriComponents, newLanguageId: string): void;
2397
>
$acceptModelSaved(strURL: UriComponents): void;
2398
>
$acceptDirtyStateChanged(strURL: UriComponents, isDirty: boolean): void;
2399
>
$acceptEncodingChanged(strURL: UriComponents, encoding: string): void;
2400
>
$acceptModelChanged(strURL: UriComponents, e: ISerializedModelContentChangedEvent, isDirty: boolean): void;
2401
>
}
2402
>
2403
>
export interface ExtHostDocumentSaveParticipantShape {
2404
>
$participateInSave(resource: UriComponents, reason: SaveReason): Promise<boolean[]>;
2405
>
}
2406
>
2407
>
export interface ITextEditorAddData {
2408
>
id: string;
2409
>
documentUri: UriComponents;
2410
>
options: IResolvedTextEditorConfiguration;
2411
>
selections: ISelection[];
2412
>
visibleRanges: IRange[];
2413
>
editorPosition: EditorGroupColumn | undefined;
2414
>
}
2415
>
export interface ITextEditorPositionData {
2416
>
[id: string]: EditorGroupColumn;
2417
>
}
2418
>
2419
>
export type ITextEditorChange = [
2420
>
originalStartLineNumber: number,
2421
>
originalEndLineNumberExclusive: number,
2422
>
modifiedStartLineNumber: number,
2423
>
modifiedEndLineNumberExclusive: number
2424
>
];
2425
>
2426
>
export interface ITextEditorDiffInformation {
2427
>
readonly documentVersion: number;
2428
>
readonly original: UriComponents | undefined;
2429
>
readonly modified: UriComponents;
2430
>
readonly changes: readonly ITextEditorChange[];
2431
>
}
2432
>
2433
>
export interface IEditorPropertiesChangeData {
2434
>
options: IResolvedTextEditorConfiguration | null;
2435
>
selections: ISelectionChangeEvent | null;
2436
>
visibleRanges: IRange[] | null;
2437
>
}
2438
>
export interface ISelectionChangeEvent {
2439
>
selections: Selection[];
2440
>
source?: string;
2441
>
}
2442
>
2443
>
export interface ExtHostEditorsShape {
2444
>
$acceptEditorPropertiesChanged(id: string, props: IEditorPropertiesChangeData): void;
2445
>
$acceptEditorPositionData(data: ITextEditorPositionData): void;
2446
>
$acceptEditorDiffInformation(id: string, diffInformation: ITextEditorDiffInformation[] | undefined): void;
2447
>
}
2448
>
2449
>
export interface IDocumentsAndEditorsDelta {
2450
>
removedDocuments?: UriComponents[];
2451
>
addedDocuments?: IModelAddedData[];
2452
>
removedEditors?: string[];
2453
>
addedEditors?: ITextEditorAddData[];
2454
>
newActiveEditor?: string | null;
2455
>
}
2456
>
2457
>
export interface ExtHostDocumentsAndEditorsShape {
2458
>
$acceptDocumentsAndEditorsDelta(delta: IDocumentsAndEditorsDelta): void;
2459
>
}
2460
>
2461
>
export interface IDataTransferFileDTO {
2462
>
readonly id: string;
2463
>
readonly name: string;
2464
>
readonly uri?: UriComponents;
2465
>
}
2466
>
2467
>
export interface DataTransferItemDTO {
2468
>
id: string;
2469
>
readonly asString: string;
2470
>
readonly fileData: IDataTransferFileDTO | undefined;
2471
>
readonly uriListData?: ReadonlyArray<string | UriComponents>;
2472
>
}
2473
>
2474
>
export interface DataTransferDTO {
2475
>
items: Array<readonly [/* type */string, DataTransferItemDTO]>;
2476
>
}
2477
>
2478
>
export interface CheckboxUpdate {
2479
>
treeItemHandle: string;
2480
>
newState: boolean;
2481
>
}
2482
>
2483
>
export interface ExtHostTreeViewsShape {
2484
>
/**
2485
>
* To reduce what is sent on the wire:
2486
>
* w
2487
>
* x
2488
>
* y
2489
>
* z
2490
>
*
2491
>
* for [x,y] returns
2492
>
* [[1,z]], where the inner array is [original index, ...children]
2493
>
*/
2494
>
$getChildren(treeViewId: string, treeItemHandles?: string[]): Promise<(readonly (number | ITreeItem)[])[] | undefined>;
2495
>
$handleDrop(destinationViewId: string, requestId: number, treeDataTransfer: DataTransferDTO, targetHandle: string | undefined, token: CancellationToken, operationUuid?: string, sourceViewId?: string, sourceTreeItemHandles?: string[]): Promise<void>;
2496
>
$handleDrag(sourceViewId: string, sourceTreeItemHandles: string[], operationUuid: string, token: CancellationToken): Promise<DataTransferDTO | undefined>;
2497
>
$setExpanded(treeViewId: string, treeItemHandle: string, expanded: boolean): void;
2498
>
$setSelectionAndFocus(treeViewId: string, selectionHandles: string[], focusHandle: string): void;
2499
>
$setVisible(treeViewId: string, visible: boolean): void;
2500
>
$changeCheckboxState(treeViewId: string, checkboxUpdates: CheckboxUpdate[]): void;
2501
>
$hasResolve(treeViewId: string): Promise<boolean>;
2502
>
$resolve(treeViewId: string, treeItemHandle: string, token: CancellationToken): Promise<ITreeItem | undefined>;
2503
>
}
2504
>
2505
>
export interface ExtHostWorkspaceShape {
2506
>
$initializeWorkspace(workspace: IWorkspaceData | null, trusted: boolean): void;
2507
>
$acceptWorkspaceData(workspace: IWorkspaceData | null): void;
2508
>
$handleTextSearchResult(result: search.IRawFileMatch2, requestId: number): void;
2509
>
$onDidGrantWorkspaceTrust(): void;
2510
>
$onDidChangeWorkspaceTrustedFolders(): void;
2511
>
$getEditSessionIdentifier(folder: UriComponents, token: CancellationToken): Promise<string | undefined>;
2512
>
$provideEditSessionIdentityMatch(folder: UriComponents, identity1: string, identity2: string, token: CancellationToken): Promise<EditSessionIdentityMatch | undefined>;
2513
>
$onWillCreateEditSessionIdentity(folder: UriComponents, token: CancellationToken, timeout: number): Promise<void>;
2514
>
$provideCanonicalUri(uri: UriComponents, targetScheme: string, token: CancellationToken): Promise<UriComponents | undefined>;
2515
>
}
2516
>
2517
>
export interface ExtHostFileSystemInfoShape {
2518
>
$acceptProviderInfos(uri: UriComponents, capabilities: number | null): void;
2519
>
}
2520
>
2521
>
export interface ExtHostFileSystemShape {
2522
>
$stat(handle: number, resource: UriComponents): Promise<files.IStat>;
2523
>
$readdir(handle: number, resource: UriComponents): Promise<[string, files.FileType][]>;
2524
>
$readFile(handle: number, resource: UriComponents): Promise<VSBuffer>;
2525
>
$writeFile(handle: number, resource: UriComponents, content: VSBuffer, opts: files.IFileWriteOptions): Promise<void>;
2526
>
$rename(handle: number, resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2527
>
$copy(handle: number, resource: UriComponents, target: UriComponents, opts: files.IFileOverwriteOptions): Promise<void>;
2528
>
$mkdir(handle: number, resource: UriComponents): Promise<void>;
2529
>
$delete(handle: number, resource: UriComponents, opts: files.IFileDeleteOptions): Promise<void>;
2530
>
$watch(handle: number, session: number, resource: UriComponents, opts: files.IWatchOptions): void;
2531
>
$unwatch(handle: number, session: number): void;
2532
>
$open(handle: number, resource: UriComponents, opts: files.IFileOpenOptions): Promise<number>;
2533
>
$close(handle: number, fd: number): Promise<void>;
2534
>
$read(handle: number, fd: number, pos: number, length: number): Promise<VSBuffer>;
2535
>
$write(handle: number, fd: number, pos: number, data: VSBuffer): Promise<number>;
2536
>
}
2537
>
2538
>
export interface ExtHostLabelServiceShape {
2539
>
$registerResourceLabelFormatter(formatter: ResourceLabelFormatter): IDisposable;
2540
>
}
2541
>
2542
>
export interface ExtHostAuthenticationShape {
2543
>
$getSessions(id: string, scopes: string[] | undefined, options: IAuthenticationGetSessionsOptions): Promise<ReadonlyArray<AuthenticationSession>>;
2544
>
$createSession(id: string, scopes: string[], options: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
2545
>
$getSessionsFromChallenges(id: string, constraint: IAuthenticationConstraint, options: IAuthenticationGetSessionsOptions): Promise<ReadonlyArray<AuthenticationSession>>;
2546
>
$createSessionFromChallenges(id: string, constraint: IAuthenticationConstraint, options: IAuthenticationCreateSessionOptions): Promise<AuthenticationSession>;
2547
>
$removeSession(id: string, sessionId: string): Promise<void>;
2548
>
$onDidChangeAuthenticationSessions(id: string, label: string, extensionIdFilter?: string[]): Promise<void>;
2549
>
$onDidUnregisterAuthenticationProvider(id: string): Promise<void>;
2550
>
$registerDynamicAuthProvider(authorizationServer: UriComponents, serverMetadata: IAuthorizationServerMetadata, resource?: IAuthorizationProtectedResourceMetadata, clientId?: string, clientSecret?: string, initialTokens?: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<string>;
2551
>
$registerXaaAuthProvider(issuer: UriComponents, serverMetadata: IAuthorizationServerMetadata, clientId?: string, clientSecret?: string, initialTokens?: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<string>;
2552
>
$onDidChangeDynamicAuthProviderTokens(authProviderId: string, clientId: string, tokens?: (IAuthorizationTokenResponse & { created_at: number })[]): Promise<void>;
2553
>
}
2554
>
2555
>
export interface ExtHostAiRelatedInformationShape {
2556
>
$provideAiRelatedInformation(handle: number, query: string, token: CancellationToken): Promise<RelatedInformationResult[]>;
2557
>
}
2558
>
2559
>
export interface MainThreadAiRelatedInformationShape {
2560
>
$getAiRelatedInformation(query: string, types: RelatedInformationType[]): Promise<RelatedInformationResult[]>;
2561
>
$registerAiRelatedInformationProvider(handle: number, type: RelatedInformationType): void;
2562
>
$unregisterAiRelatedInformationProvider(handle: number): void;
2563
>
}
2564
>
2565
>
export interface ExtHostAiSettingsSearchShape {
2566
>
$startSearch(handle: number, query: string, option: AiSettingsSearchProviderOptions, token: CancellationToken): Promise<void>;
2567
>
}
2568
>
2569
>
export interface MainThreadAiSettingsSearchShape {
2570
>
$registerAiSettingsSearchProvider(handle: number): void;
2571
>
$unregisterAiSettingsSearchProvider(handle: number): void;
2572
>
$handleSearchResult(handle: number, result: AiSettingsSearchResult): void;
2573
>
}
2574
>
2575
>
export interface ExtHostAiEmbeddingVectorShape {
2576
>
$provideAiEmbeddingVector(handle: number, strings: string[], token: CancellationToken): Promise<number[][]>;
2577
>
}
2578
>
2579
>
export interface MainThreadAiEmbeddingVectorShape {
2580
>
$registerAiEmbeddingVectorProvider(model: string, handle: number): void;
2581
>
$unregisterAiEmbeddingVectorProvider(handle: number): void;
2582
>
}
2583
>
2584
>
export interface ExtHostSecretStateShape {
2585
>
$onDidChangePassword(e: { extensionId: string; key: string }): Promise<void>;
2586
>
}
2587
>
2588
>
export interface ExtHostSearchShape {
2589
>
$enableExtensionHostSearch(): void;
2590
>
$getAIName(handle: number): Promise<string | undefined>;
2591
>
$provideFileSearchResults(handle: number, session: number, query: search.IRawQuery, token: CancellationToken): Promise<search.ISearchCompleteStats>;
2592
>
$provideAITextSearchResults(handle: number, session: number, query: search.IRawAITextQuery, token: CancellationToken): Promise<search.ISearchCompleteStats>;
2593
>
$provideTextSearchResults(handle: number, session: number, query: search.IRawTextQuery, token: CancellationToken): Promise<search.ISearchCompleteStats>;
2594
>
$clearCache(cacheKey: string): Promise<void>;
2595
>
}
2596
>
2597
>
export interface ExtHostExtensionServiceShape {
2598
>
$resolveAuthority(remoteAuthority: string, resolveAttempt: number): Promise<Dto<IResolveAuthorityResult>>;
2599
>
/**
2600
>
* Returns `null` if no resolver for `remoteAuthority` is found.
2601
>
*/
2602
>
$getCanonicalURI(remoteAuthority: string, uri: UriComponents): Promise<UriComponents | null>;
2603
>
$startExtensionHost(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
2604
>
$extensionTestsExecute(): Promise<number>;
2605
>
$activateByEvent(activationEvent: string, activationKind: ActivationKind): Promise<void>;
2606
>
$activate(extensionId: ExtensionIdentifier, reason: ExtensionActivationReason): Promise<boolean>;
2607
>
$setRemoteEnvironment(env: { [key: string]: string | null }): Promise<void>;
2608
>
$updateRemoteConnectionData(connectionData: IRemoteConnectionData): Promise<void>;
2609
>
2610
>
$deltaExtensions(extensionsDelta: IExtensionDescriptionDelta): Promise<void>;
2611
>
2612
>
$test_latency(n: number): Promise<number>;
2613
>
$test_up(b: VSBuffer): Promise<number>;
2614
>
$test_down(size: number): Promise<VSBuffer>;
2615
>
}
2616
>
2617
>
export interface FileSystemEvents {
2618
>
session?: number;
2619
>
created: UriComponents[];
2620
>
changed: UriComponents[];
2621
>
deleted: UriComponents[];
2622
>
}
2623
>
2624
>
export interface SourceTargetPair {
2625
>
source?: UriComponents;
2626
>
target: UriComponents;
2627
>
}
2628
>
2629
>
export interface IWillRunFileOperationParticipation {
2630
>
edit: IWorkspaceEditDto;
2631
>
extensionNames: string[];
2632
>
}
2633
>
2634
>
export interface ExtHostFileSystemEventServiceShape {
2635
>
$onFileEvent(events: FileSystemEvents): void;
2636
>
$onWillRunFileOperation(operation: files.FileOperation, files: readonly SourceTargetPair[], timeout: number, token: CancellationToken): Promise<IWillRunFileOperationParticipation | undefined>;
2637
>
$onDidRunFileOperation(operation: files.FileOperation, files: readonly SourceTargetPair[]): void;
2638
>
}
2639
>
2640
>
export interface ExtHostLanguagesShape {
2641
>
$acceptLanguageIds(ids: string[]): void;
2642
>
$acceptSyntaxHighlightingThemeChanged(): void;
2643
>
}
2644
>
2645
>
export interface ExtHostHeapServiceShape {
2646
>
$onGarbageCollection(ids: number[]): void;
2647
>
}
2648
>
export interface IRawColorInfo {
2649
>
color: [number, number, number, number];
2650
>
range: IRange;
2651
>
}
2652
>
2653
>
export class IdObject {
2654
>
_id?: number;
2655
>
private static _n = 0;
2656
>
static mixin<T extends object>(object: T): T & IdObject {
2657
// eslint-disable-next-line local/code-no-any-casts
2658
(<any>object)._id = IdObject._n++;
2659
// eslint-disable-next-line local/code-no-any-casts
2660
return <any>object;
2661
}
2663
>
2664
>
export const enum ISuggestDataDtoField {
2665
>
label = 'a',
2666
>
kind = 'b',
2667
>
detail = 'c',
2668
>
documentation = 'd',
2669
>
sortText = 'e',
2670
>
filterText = 'f',
2671
>
preselect = 'g',
2672
>
insertText = 'h',
2673
>
insertTextRules = 'i',
2674
>
range = 'j',
2675
>
commitCharacters = 'k',
2676
>
additionalTextEdits = 'l',
2677
>
kindModifier = 'm',
2678
>
commandIdent = 'n',
2679
>
commandId = 'o',
2680
>
commandArguments = 'p',
2681
>
}
2682
>
2683
>
export interface ISuggestDataDto {
2684
>
[ISuggestDataDtoField.label]: string | languages.CompletionItemLabel;
2685
>
[ISuggestDataDtoField.kind]?: languages.CompletionItemKind;
2686
>
[ISuggestDataDtoField.detail]?: string;
2687
>
[ISuggestDataDtoField.documentation]?: string | IMarkdownString;
2688
>
[ISuggestDataDtoField.sortText]?: string;
2689
>
[ISuggestDataDtoField.filterText]?: string;
2690
>
[ISuggestDataDtoField.preselect]?: true;
2691
>
[ISuggestDataDtoField.insertText]?: string;
2692
>
[ISuggestDataDtoField.insertTextRules]?: languages.CompletionItemInsertTextRule;
2693
>
[ISuggestDataDtoField.range]?: IRange | { insert: IRange; replace: IRange };
2694
>
[ISuggestDataDtoField.commitCharacters]?: string;
2695
>
[ISuggestDataDtoField.additionalTextEdits]?: ISingleEditOperation[];
2696
>
[ISuggestDataDtoField.kindModifier]?: languages.CompletionItemTag[];
2697
>
// Command
2698
>
[ISuggestDataDtoField.commandIdent]?: string;
2699
>
[ISuggestDataDtoField.commandId]?: string;
2700
>
[ISuggestDataDtoField.commandArguments]?: unknown[];
2701
>
// not-standard
2702
>
x?: ChainedCacheId;
2703
>
}
2704
>
2705
>
export const enum ISuggestResultDtoField {
2706
>
defaultRanges = 'a',
2707
>
completions = 'b',
2708
>
isIncomplete = 'c',
2709
>
duration = 'd',
2710
>
}
2711
>
2712
>
export interface ISuggestResultDto {
2713
>
[ISuggestResultDtoField.defaultRanges]: { insert: IRange; replace: IRange };
2714
>
[ISuggestResultDtoField.completions]: ISuggestDataDto[];
2715
>
[ISuggestResultDtoField.isIncomplete]: undefined | true;
2716
>
[ISuggestResultDtoField.duration]: number;
2717
>
x?: number;
2718
>
}
2719
>
2720
>
export interface ISignatureHelpDto {
2721
>
id: CacheId;
2722
>
signatures: languages.SignatureInformation[];
2723
>
activeSignature: number;
2724
>
activeParameter: number;
2725
>
}
2726
>
2727
>
export interface ISignatureHelpContextDto {
2728
>
readonly triggerKind: languages.SignatureHelpTriggerKind;
2729
>
readonly triggerCharacter: string | undefined;
2730
>
readonly isRetrigger: boolean;
2731
>
readonly activeSignatureHelp: ISignatureHelpDto | undefined;
2732
>
}
2733
>
2734
>
export type IInlayHintDto = CachedSessionItem<Dto<languages.InlayHint>>;
2735
>
2736
>
export type IInlayHintsDto = CachedSession<{ hints: IInlayHintDto[] }>;
2737
>
2738
>
export type ILocationDto = Dto<languages.Location>;
2739
>
export type ILocationLinkDto = Dto<languages.LocationLink>;
2740
>
2741
>
export type IWorkspaceSymbolDto = CachedSessionItem<Dto<IWorkspaceSymbol>>;
2742
>
export type IWorkspaceSymbolsDto = CachedSession<{ symbols: IWorkspaceSymbolDto[] }>;
2743
>
2744
>
export interface IWorkspaceEditEntryMetadataDto {
2745
>
needsConfirmation: boolean;
2746
>
label: string;
2747
>
description?: string;
2748
>
iconPath?: IconPathDto;
2749
>
}
2750
>
2751
>
export interface IChatNotebookEditDto {
2752
>
uri: UriComponents;
2753
>
edits: ICellEditOperationDto[];
2754
>
kind: 'notebookEdit';
2755
>
done?: boolean;
2756
>
}
2757
>
2758
>
export interface IChatResponseClearToPreviousToolInvocationDto {
2759
>
kind: 'clearToPreviousToolInvocation';
2760
>
reason: ChatResponseClearToPreviousToolInvocationReason;
2761
>
}
2762
>
2763
>
export interface IChatBeginToolInvocationDto {
2764
>
kind: 'beginToolInvocation';
2765
>
toolCallId: string;
2766
>
toolName: string;
2767
>
streamData?: {
2768
>
partialInput?: unknown;
2769
>
};
2770
>
subagentInvocationId?: string;
2771
>
}
2772
>
2773
>
export interface IChatUpdateToolInvocationDto {
2774
>
kind: 'updateToolInvocation';
2775
>
toolCallId: string;
2776
>
streamData: {
2777
>
partialInput?: unknown;
2778
>
};
2779
>
}
2780
>
2781
>
export interface IChatUsageDto {
2782
>
kind: 'usage';
2783
>
promptTokens: number;
2784
>
completionTokens: number;
2785
>
outputBuffer?: number;
2786
>
copilotCredits?: number;
2787
>
promptTokenDetails?: readonly { category: string; label: string; percentageOfPrompt: number }[];
2788
>
}
2789
>
2790
>
export interface IQuotaSnapshotDto {
2791
>
readonly percentRemaining: number;
2792
>
readonly unlimited: boolean;
2793
>
readonly hasQuota?: boolean;
2794
>
readonly resetAt?: number;
2795
>
readonly usageBasedBilling?: boolean;
2796
>
readonly entitlement?: number;
2797
>
readonly quotaRemaining?: number;
2798
>
}
2799
>
2800
>
export interface IRateLimitSnapshotDto {
2801
>
readonly percentRemaining: number;
2802
>
readonly unlimited: boolean;
2803
>
readonly resetDate?: string;
2804
>
}
2805
>
2806
>
export interface IQuotaSnapshotsDto {
2807
>
readonly resetDate?: string;
2808
>
readonly resetDateHasTime?: boolean;
2809
>
readonly usageBasedBilling?: boolean;
2810
>
readonly canUpgradePlan?: boolean;
2811
>
readonly chat?: IQuotaSnapshotDto;
2812
>
readonly completions?: IQuotaSnapshotDto;
2813
>
readonly premiumChat?: IQuotaSnapshotDto;
2814
>
readonly additionalUsageEnabled?: boolean;
2815
>
readonly additionalUsageCount?: number;
2816
>
readonly sessionRateLimit?: IRateLimitSnapshotDto;
2817
>
readonly weeklyRateLimit?: IRateLimitSnapshotDto;
2818
>
}
2819
>
2820
>
export type ICellEditOperationDto =
2821
>
notebookCommon.ICellMetadataEdit
2822
>
| notebookCommon.IDocumentMetadataEdit
2823
>
| {
2824
>
editType: notebookCommon.CellEditType.Replace;
2825
>
index: number;
2826
>
count: number;
2827
>
cells: NotebookCellDataDto[];
2828
>
};
2829
>
2830
>
export type IWorkspaceCellEditDto = Dto<Omit<notebookCommon.IWorkspaceNotebookCellEdit, 'cellEdit'>> & { cellEdit: ICellEditOperationDto };
2831
>
2832
>
export type IWorkspaceFileEditDto = Dto<
2833
>
Omit<languages.IWorkspaceFileEdit, 'options'> & {
2834
>
options?: Omit<languages.WorkspaceFileEditOptions, 'contents'> & { contents?: { type: 'base64'; value: string } | { type: 'dataTransferItem'; id: string } };
2835
>
}>;
2836
>
2837
>
export type IWorkspaceTextEditDto = Dto<languages.IWorkspaceTextEdit>;
2838
>
2839
>
export interface IWorkspaceEditDto {
2840
>
edits: Array<IWorkspaceFileEditDto | IWorkspaceTextEditDto | IWorkspaceCellEditDto>;
2841
>
}
2842
>
2843
>
export type ICommandDto = { $ident?: string } & languages.Command;
2844
>
2845
>
export interface ICodeActionDto {
2846
>
cacheId?: ChainedCacheId;
2847
>
title: string;
2848
>
edit?: IWorkspaceEditDto;
2849
>
diagnostics?: Dto<IMarkerData[]>;
2850
>
command?: ICommandDto;
2851
>
kind?: string;
2852
>
isPreferred?: boolean;
2853
>
isAI?: boolean;
2854
>
disabled?: string;
2855
>
ranges?: IRange[];
2856
>
}
2857
>
2858
>
export interface ICodeActionListDto {
2859
>
cacheId: CacheId;
2860
>
actions: ReadonlyArray<ICodeActionDto>;
2861
>
}
2862
>
2863
>
export interface ICodeActionProviderMetadataDto {
2864
>
readonly providedKinds?: readonly string[];
2865
>
readonly documentation?: ReadonlyArray<{ readonly kind: string; readonly command: ICommandDto }>;
2866
>
}
2867
>
2868
>
export type CacheId = number;
2869
>
export type ChainedCacheId = [CacheId, CacheId];
2870
>
2871
>
type CachedSessionItem<T> = T & { cacheId?: ChainedCacheId };
2872
>
type CachedSession<T> = T & { cacheId?: CacheId };
2873
>
2874
>
export type ILinksListDto = CachedSession<{ links: ILinkDto[] }>;
2875
>
export type ILinkDto = CachedSessionItem<Dto<languages.ILink>>;
2876
>
2877
>
export type ICodeLensListDto = CachedSession<{ lenses: ICodeLensDto[] }>;
2878
>
export type ICodeLensDto = CachedSessionItem<Dto<languages.CodeLens>>;
2879
>
2880
>
export type ICallHierarchyItemDto = Dto<CallHierarchyItem>;
2881
>
2882
>
export interface IIncomingCallDto {
2883
>
from: ICallHierarchyItemDto;
2884
>
fromRanges: IRange[];
2885
>
}
2886
>
2887
>
export interface IOutgoingCallDto {
2888
>
fromRanges: IRange[];
2889
>
to: ICallHierarchyItemDto;
2890
>
}
2891
>
2892
>
export interface ILanguageWordDefinitionDto {
2893
>
languageId: string;
2894
>
regexSource: string;
2895
>
regexFlags: string;
2896
>
}
2897
>
2898
>
export interface ILinkedEditingRangesDto {
2899
>
ranges: IRange[];
2900
>
wordPattern?: IRegExpDto;
2901
>
}
2902
>
2903
>
export interface IInlineValueContextDto {
2904
>
frameId: number;
2905
>
stoppedLocation: IRange;
2906
>
}
2907
>
2908
>
export type ITypeHierarchyItemDto = Dto<TypeHierarchyItem>;
2909
>
2910
>
export interface IPasteEditProviderMetadataDto {
2911
>
readonly supportsCopy: boolean;
2912
>
readonly supportsPaste: boolean;
2913
>
readonly supportsResolve: boolean;
2914
>
2915
>
readonly providedPasteEditKinds?: readonly string[];
2916
>
readonly copyMimeTypes?: readonly string[];
2917
>
readonly pasteMimeTypes?: readonly string[];
2918
>
}
2919
>
2920
>
export interface IDocumentPasteContextDto {
2921
>
readonly only: string | undefined;
2922
>
readonly triggerKind: languages.DocumentPasteTriggerKind;
2923
>
}
2924
>
2925
>
export interface IPasteEditDto {
2926
>
_cacheId?: ChainedCacheId;
2927
>
title: string;
2928
>
kind: { value: string } | undefined;
2929
>
insertText: string | { snippet: string };
2930
>
additionalEdit?: IWorkspaceEditDto;
2931
>
yieldTo?: readonly string[];
2932
>
}
2933
>
2934
>
export interface IDocumentDropEditProviderMetadata {
2935
>
readonly supportsResolve: boolean;
2936
>
2937
>
readonly dropMimeTypes: readonly string[];
2938
>
readonly providedDropKinds?: readonly string[];
2939
>
}
2940
>
2941
>
export interface IDocumentDropEditDto {
2942
>
_cacheId?: ChainedCacheId;
2943
>
title: string;
2944
>
kind: string | undefined;
2945
>
insertText: string | { snippet: string };
2946
>
additionalEdit?: IWorkspaceEditDto;
2947
>
yieldTo?: readonly string[];
2948
>
}
2949
>
2950
>
export interface ExtHostLanguageFeaturesShape {
2951
>
$provideDocumentSymbols(handle: number, resource: UriComponents, token: CancellationToken): Promise<languages.DocumentSymbol[] | undefined>;
2952
>
$provideCodeLenses(handle: number, resource: UriComponents, token: CancellationToken): Promise<ICodeLensListDto | undefined>;
2953
>
$resolveCodeLens(handle: number, symbol: ICodeLensDto, token: CancellationToken): Promise<ICodeLensDto | undefined>;
2954
>
$releaseCodeLenses(handle: number, id: number): void;
2955
>
$provideDefinition(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<ILocationLinkDto[]>;
2956
>
$provideDeclaration(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<ILocationLinkDto[]>;
2957
>
$provideImplementation(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<ILocationLinkDto[]>;
2958
>
$provideTypeDefinition(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<ILocationLinkDto[]>;
2959
>
$provideHover(handle: number, resource: UriComponents, position: IPosition, context: languages.HoverContext<{ id: number }> | undefined, token: CancellationToken): Promise<HoverWithId | undefined>;
2960
>
$releaseHover(handle: number, id: number): void;
2961
>
$provideEvaluatableExpression(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<languages.EvaluatableExpression | undefined>;
2962
>
$provideInlineValues(handle: number, resource: UriComponents, range: IRange, context: languages.InlineValueContext, token: CancellationToken): Promise<languages.InlineValue[] | undefined>;
2963
>
$provideDocumentHighlights(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<languages.DocumentHighlight[] | undefined>;
2964
>
$provideMultiDocumentHighlights(handle: number, resource: UriComponents, position: IPosition, otherModels: UriComponents[], token: CancellationToken): Promise<Dto<languages.MultiDocumentHighlight[]> | undefined>;
2965
>
$provideLinkedEditingRanges(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<ILinkedEditingRangesDto | undefined>;
2966
>
$provideReferences(handle: number, resource: UriComponents, position: IPosition, context: languages.ReferenceContext, token: CancellationToken): Promise<ILocationDto[] | undefined>;
2967
>
$provideCodeActions(handle: number, resource: UriComponents, rangeOrSelection: IRange | ISelection, context: languages.CodeActionContext, token: CancellationToken): Promise<ICodeActionListDto | undefined>;
2968
>
$resolveCodeAction(handle: number, id: ChainedCacheId, token: CancellationToken): Promise<{ edit?: IWorkspaceEditDto; command?: ICommandDto }>;
2969
>
$releaseCodeActions(handle: number, cacheId: number): void;
2970
>
$prepareDocumentPaste(handle: number, uri: UriComponents, ranges: readonly IRange[], dataTransfer: DataTransferDTO, token: CancellationToken): Promise<DataTransferDTO | undefined>;
2971
>
$providePasteEdits(handle: number, requestId: number, uri: UriComponents, ranges: IRange[], dataTransfer: DataTransferDTO, context: IDocumentPasteContextDto, token: CancellationToken): Promise<IPasteEditDto[] | undefined>;
2972
>
$resolvePasteEdit(handle: number, id: ChainedCacheId, token: CancellationToken): Promise<{ insertText?: string; additionalEdit?: IWorkspaceEditDto }>;
2973
>
$releasePasteEdits(handle: number, cacheId: number): void;
2974
>
$provideDocumentFormattingEdits(handle: number, resource: UriComponents, options: languages.FormattingOptions, token: CancellationToken): Promise<languages.TextEdit[] | undefined>;
2975
>
$provideDocumentRangeFormattingEdits(handle: number, resource: UriComponents, range: IRange, options: languages.FormattingOptions, token: CancellationToken): Promise<languages.TextEdit[] | undefined>;
2976
>
$provideDocumentRangesFormattingEdits(handle: number, resource: UriComponents, range: IRange[], options: languages.FormattingOptions, token: CancellationToken): Promise<languages.TextEdit[] | undefined>;
2977
>
$provideOnTypeFormattingEdits(handle: number, resource: UriComponents, position: IPosition, ch: string, options: languages.FormattingOptions, token: CancellationToken): Promise<languages.TextEdit[] | undefined>;
2978
>
$provideWorkspaceSymbols(handle: number, search: string, token: CancellationToken): Promise<IWorkspaceSymbolsDto>;
2979
>
$resolveWorkspaceSymbol(handle: number, symbol: IWorkspaceSymbolDto, token: CancellationToken): Promise<IWorkspaceSymbolDto | undefined>;
2980
>
$releaseWorkspaceSymbols(handle: number, id: number): void;
2981
>
$provideRenameEdits(handle: number, resource: UriComponents, position: IPosition, newName: string, token: CancellationToken): Promise<IWorkspaceEditDto & { rejectReason?: string } | undefined>;
2982
>
$resolveRenameLocation(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<languages.RenameLocation | undefined>;
2983
>
$supportsAutomaticNewSymbolNamesTriggerKind(handle: number): Promise<boolean | undefined>;
2984
>
$provideNewSymbolNames(handle: number, resource: UriComponents, range: IRange, triggerKind: languages.NewSymbolNameTriggerKind, token: CancellationToken): Promise<languages.NewSymbolName[] | undefined>;
2985
>
$provideDocumentSemanticTokens(handle: number, resource: UriComponents, previousResultId: number, token: CancellationToken): Promise<VSBuffer | null>;
2986
>
$releaseDocumentSemanticTokens(handle: number, semanticColoringResultId: number): void;
2987
>
$provideDocumentRangeSemanticTokens(handle: number, resource: UriComponents, range: IRange, token: CancellationToken): Promise<VSBuffer | null>;
2988
>
$provideCompletionItems(handle: number, resource: UriComponents, position: IPosition, context: languages.CompletionContext, token: CancellationToken): Promise<ISuggestResultDto | undefined>;
2989
>
$resolveCompletionItem(handle: number, id: ChainedCacheId, token: CancellationToken): Promise<ISuggestDataDto | undefined>;
2990
>
$releaseCompletionItems(handle: number, id: number): void;
2991
>
$provideInlineCompletions(handle: number, resource: UriComponents, position: IPosition, context: languages.InlineCompletionContext, token: CancellationToken): Promise<IdentifiableInlineCompletions | undefined>;
2992
>
$handleInlineCompletionDidShow(handle: number, pid: number, idx: number, updatedInsertText: string): void;
2993
>
$handleInlineCompletionPartialAccept(handle: number, pid: number, idx: number, acceptedCharacters: number, info: languages.PartialAcceptInfo): void;
2994
>
$handleInlineCompletionEndOfLifetime(handle: number, pid: number, idx: number, reason: languages.InlineCompletionEndOfLifeReason<{ pid: number; idx: number }>): void;
2995
>
$handleInlineCompletionRejection(handle: number, pid: number, idx: number): void;
2996
>
$freeInlineCompletionsList(handle: number, pid: number, reason: languages.InlineCompletionsDisposeReason): void;
2997
>
$acceptInlineCompletionsUnificationState(state: IInlineCompletionsUnificationState): void;
2998
>
$handleInlineCompletionSetCurrentModelId(handle: number, modelId: string): void;
2999
>
$handleInlineCompletionSetProviderOption(handle: number, optionId: string, valueId: string): void;
3000
>
$provideSignatureHelp(handle: number, resource: UriComponents, position: IPosition, context: languages.SignatureHelpContext, token: CancellationToken): Promise<ISignatureHelpDto | undefined>;
3001
>
$releaseSignatureHelp(handle: number, id: number): void;
3002
>
$provideInlayHints(handle: number, resource: UriComponents, range: IRange, token: CancellationToken): Promise<IInlayHintsDto | undefined>;
3003
>
$resolveInlayHint(handle: number, id: ChainedCacheId, token: CancellationToken): Promise<IInlayHintDto | undefined>;
3004
>
$releaseInlayHints(handle: number, id: number): void;
3005
>
$provideDocumentLinks(handle: number, resource: UriComponents, token: CancellationToken): Promise<ILinksListDto | undefined>;
3006
>
$resolveDocumentLink(handle: number, id: ChainedCacheId, token: CancellationToken): Promise<ILinkDto | undefined>;
3007
>
$releaseDocumentLinks(handle: number, id: number): void;
3008
>
$provideDocumentColors(handle: number, resource: UriComponents, token: CancellationToken): Promise<IRawColorInfo[]>;
3009
>
$provideColorPresentations(handle: number, resource: UriComponents, colorInfo: IRawColorInfo, token: CancellationToken): Promise<languages.IColorPresentation[] | undefined>;
3010
>
$provideFoldingRanges(handle: number, resource: UriComponents, context: languages.FoldingContext, token: CancellationToken): Promise<languages.FoldingRange[] | undefined>;
3011
>
$provideSelectionRanges(handle: number, resource: UriComponents, positions: IPosition[], token: CancellationToken): Promise<languages.SelectionRange[][]>;
3012
>
$prepareCallHierarchy(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<ICallHierarchyItemDto[] | undefined>;
3013
>
$provideCallHierarchyIncomingCalls(handle: number, sessionId: string, itemId: string, token: CancellationToken): Promise<IIncomingCallDto[] | undefined>;
3014
>
$provideCallHierarchyOutgoingCalls(handle: number, sessionId: string, itemId: string, token: CancellationToken): Promise<IOutgoingCallDto[] | undefined>;
3015
>
$releaseCallHierarchy(handle: number, sessionId: string): void;
3016
>
$setWordDefinitions(wordDefinitions: ILanguageWordDefinitionDto[]): void;
3017
>
$prepareTypeHierarchy(handle: number, resource: UriComponents, position: IPosition, token: CancellationToken): Promise<ITypeHierarchyItemDto[] | undefined>;
3018
>
$provideTypeHierarchySupertypes(handle: number, sessionId: string, itemId: string, token: CancellationToken): Promise<ITypeHierarchyItemDto[] | undefined>;
3019
>
$provideTypeHierarchySubtypes(handle: number, sessionId: string, itemId: string, token: CancellationToken): Promise<ITypeHierarchyItemDto[] | undefined>;
3020
>
$releaseTypeHierarchy(handle: number, sessionId: string): void;
3021
>
$provideDocumentOnDropEdits(handle: number, requestId: number, resource: UriComponents, position: IPosition, dataTransferDto: DataTransferDTO, token: CancellationToken): Promise<IDocumentDropEditDto[] | undefined>;
3022
>
$releaseDocumentOnDropEdits(handle: number, cacheId: number): void;
3023
>
}
3024
>
3025
>
export interface ExtHostQuickOpenShape {
3026
>
$onItemSelected(handle: number): void;
3027
>
$validateInput(input: string): Promise<string | { content: string; severity: Severity } | null | undefined>;
3028
>
$onDidChangeActive(sessionId: number, handles: number[]): void;
3029
>
$onDidChangeSelection(sessionId: number, handles: number[]): void;
3030
>
$onDidAccept(sessionId: number): void;
3031
>
$onDidChangeValue(sessionId: number, value: string): void;
3032
>
$onDidTriggerButton(sessionId: number, handle: number, checked?: boolean): void;
3033
>
$onDidTriggerItemButton(sessionId: number, itemHandle: number, buttonHandle: number, checked?: boolean): void;
3034
>
$onDidHide(sessionId: number): void;
3035
>
}
3036
>
3037
>
export interface ExtHostTelemetryShape {
3038
>
$initializeTelemetryLevel(level: TelemetryLevel, supportsTelemetry: boolean, productConfig?: { usage: boolean; error: boolean }): void;
3039
>
$onDidChangeTelemetryLevel(level: TelemetryLevel): void;
3040
>
}
3041
>
3042
>
export interface MainThreadMeteredConnectionShape extends IDisposable {
3043
>
}
3044
>
3045
>
export interface ExtHostMeteredConnectionShape {
3046
>
$initializeIsConnectionMetered(isMetered: boolean): void;
3047
>
$onDidChangeIsConnectionMetered(isMetered: boolean): void;
3048
>
}
3049
>
3050
>
export interface ITerminalLinkDto {
3051
>
/** The ID of the link to enable activation and disposal. */
3052
>
id: number;
3053
>
/** The startIndex of the link in the line. */
3054
>
startIndex: number;
3055
>
/** The length of the link in the line. */
3056
>
length: number;
3057
>
/** The descriptive label for what the link does when activated. */
3058
>
label?: string;
3059
>
}
3060
>
3061
>
export interface ITerminalDimensionsDto {
3062
>
columns: number;
3063
>
rows: number;
3064
>
}
3065
>
3066
>
type SingleOrMany<T> = T[] | T;
3067
>
3068
>
export interface ITerminalQuickFixTerminalCommandDto {
3069
>
terminalCommand: string;
3070
>
shouldExecute?: boolean;
3071
>
}
3072
>
3073
>
export interface ITerminalQuickFixOpenerDto {
3074
>
uri: UriComponents;
3075
>
}
3076
>
3077
>
export type TerminalQuickFix = ITerminalQuickFixTerminalCommandDto | ITerminalQuickFixOpenerDto | ICommandDto;
3078
>
3079
>
export interface TerminalCommandMatchResultDto {
3080
>
commandLine: string;
3081
>
commandLineMatch: RegExpMatchArray;
3082
>
outputMatch?: {
3083
>
regexMatch: RegExpMatchArray;
3084
>
outputLines: string[];
3085
>
};
3086
>
}
3087
>
3088
>
export interface ITerminalCommandDto {
3089
>
commandLine: string | undefined;
3090
>
cwd: URI | string | undefined;
3091
>
exitCode: number | undefined;
3092
>
output: string | undefined;
3093
>
}
3094
>
3095
>
export interface ITerminalCompletionContextDto {
3096
>
commandLine: string;
3097
>
cursorIndex: number;
3098
>
}
3099
>
3100
>
export interface ITerminalCompletionItemDto {
3101
>
label: string | CompletionItemLabel;
3102
>
detail?: string;
3103
>
documentation?: string | IMarkdownString;
3104
>
icon?: ThemeIcon | undefined;
3105
>
kind?: number | undefined;
3106
>
isFile?: boolean | undefined;
3107
>
isDirectory?: boolean | undefined;
3108
>
isKeyword?: boolean | undefined;
3109
>
replacementRange: readonly [number, number];
3110
>
}
3111
>
3112
>
export interface ITerminalCompletionProvider {
3113
>
id: string;
3114
>
shellTypes?: TerminalShellType[];
3115
>
provideCompletions(value: string, cursorPosition: number, token: CancellationToken): Promise<TerminalCompletionListDto<ITerminalCompletionItemDto> | undefined>;
3116
>
triggerCharacters?: string[];
3117
>
isBuiltin?: boolean;
3118
>
}
3119
>
/**
3120
>
* Represents a collection of {@link CompletionItem completion items} to be presented
3121
>
* in the editor.
3122
>
*/
3123
>
export class TerminalCompletionListDto<T extends ITerminalCompletionItemDto = ITerminalCompletionItemDto> {
3124
>
3125
>
/**
3126
>
* Resources should be shown in the completions list
3127
>
*/
3128
>
resourceOptions?: TerminalCompletionResourceOptionsDto;
3129
>
3130
>
/**
3131
>
* The completion items.
3132
>
*/
3133
>
items: T[];
3134
>
3135
>
/**
3136
>
* Creates a new completion list.
3137
>
*
3138
>
* @param items The completion items.
3139
>
* @param isIncomplete The list is not complete.
3140
>
*/
3141
>
constructor(items?: T[], resourceOptions?: TerminalCompletionResourceOptionsDto) {
3142
this.items = items ?? [];
3143
this.resourceOptions = resourceOptions;
3144
}
3146
>
3147
>
export interface TerminalCompletionResourceOptionsDto {
3148
>
showFiles?: boolean;
3149
>
showDirectories?: boolean;
3150
>
globPattern?: string | IRelativePattern;
3151
>
cwd: UriComponents;
3152
>
pathSeparator: string;
3153
>
}
3154
>
3155
>
export interface ExtHostTerminalServiceShape {
3156
>
$acceptTerminalClosed(id: number, exitCode: number | undefined, exitReason: TerminalExitReason): void;
3157
>
$acceptTerminalOpened(id: number, extHostTerminalId: string | undefined, name: string, shellLaunchConfig: IShellLaunchConfigDto): void;
3158
>
$acceptActiveTerminalChanged(id: number | null): void;
3159
>
$acceptTerminalProcessId(id: number, processId: number): void;
3160
>
$acceptTerminalProcessData(id: number, data: string): void;
3161
>
$acceptDidExecuteCommand(id: number, command: ITerminalCommandDto): void;
3162
>
$acceptTerminalTitleChange(id: number, name: string): void;
3163
>
$acceptTerminalDimensions(id: number, cols: number, rows: number): void;
3164
>
$acceptTerminalMaximumDimensions(id: number, cols: number, rows: number): void;
3165
>
$acceptTerminalInteraction(id: number): void;
3166
>
$acceptTerminalSelection(id: number, selection: string | undefined): void;
3167
>
$acceptTerminalShellType(id: number, shellType: TerminalShellType | undefined): void;
3168
>
$startExtensionTerminal(id: number, initialDimensions: ITerminalDimensionsDto | undefined): Promise<ITerminalLaunchError | undefined>;
3169
>
$acceptProcessAckDataEvent(id: number, charCount: number): void;
3170
>
$acceptProcessInput(id: number, data: string): void;
3171
>
$acceptProcessResize(id: number, cols: number, rows: number): void;
3172
>
$acceptProcessShutdown(id: number, immediate: boolean): void;
3173
>
$acceptProcessRequestInitialCwd(id: number): void;
3174
>
$acceptProcessRequestCwd(id: number): void;
3175
>
$acceptProcessRequestLatency(id: number): Promise<number>;
3176
>
$provideLinks(id: number, line: string): Promise<ITerminalLinkDto[]>;
3177
>
$activateLink(id: number, linkId: number): void;
3178
>
$initEnvironmentVariableCollections(collections: [string, ISerializableEnvironmentVariableCollection][]): void;
3179
>
$acceptDefaultProfile(profile: ITerminalProfile, automationProfile: ITerminalProfile): void;
3180
>
$createContributedProfileTerminal(id: string, options: ICreateContributedTerminalProfileOptions): Promise<void>;
3181
>
$provideTerminalQuickFixes(id: string, matchResult: TerminalCommandMatchResultDto, token: CancellationToken): Promise<SingleOrMany<TerminalQuickFix> | undefined>;
3182
>
$provideTerminalCompletions(id: string, options: ITerminalCompletionContextDto, token: CancellationToken): Promise<TerminalCompletionListDto | undefined>;
3183
>
}
3184
>
3185
>
export interface ExtHostTerminalShellIntegrationShape {
3186
>
$shellIntegrationChange(instanceId: number, supportsExecuteCommandApi: boolean): void;
3187
>
$shellExecutionStart(instanceId: number, supportsExecuteCommandApi: boolean, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, cwd: string | undefined): void;
3188
>
$shellExecutionEnd(instanceId: number, commandLineValue: string, commandLineConfidence: TerminalShellExecutionCommandLineConfidence, isTrusted: boolean, exitCode: number | undefined): void;
3189
>
$shellExecutionData(instanceId: number, data: string): void;
3190
>
$shellEnvChange(instanceId: number, shellEnvKeys: string[], shellEnvValues: string[], isTrusted: boolean): void;
3191
>
$cwdChange(instanceId: number, cwd: string | undefined): void;
3192
>
$closeTerminal(instanceId: number): void;
3193
>
}
3194
>
3195
>
export interface ExtHostSCMShape {
3196
>
$provideOriginalResource(sourceControlHandle: number, uri: UriComponents, token: CancellationToken): Promise<UriComponents | null>;
3197
>
$provideSecondaryOriginalResource(sourceControlHandle: number, uri: UriComponents, token: CancellationToken): Promise<UriComponents | null>;
3198
>
$onInputBoxValueChange(sourceControlHandle: number, value: string): void;
3199
>
$executeResourceCommand(sourceControlHandle: number, groupHandle: number, handle: number, preserveFocus: boolean): Promise<void>;
3200
>
$validateInput(sourceControlHandle: number, value: string, cursorPosition: number): Promise<[string | IMarkdownString, number] | undefined>;
3201
>
$setSelectedSourceControl(selectedSourceControlHandle: number | undefined): Promise<void>;
3202
>
$provideHistoryItemRefs(sourceControlHandle: number, historyItemRefs: string[] | undefined, token: CancellationToken): Promise<SCMHistoryItemRefDto[] | undefined>;
3203
>
$provideHistoryItems(sourceControlHandle: number, options: ISCMHistoryOptions, token: CancellationToken): Promise<SCMHistoryItemDto[] | undefined>;
3204
>
$provideHistoryItemChanges(sourceControlHandle: number, historyItemId: string, historyItemParentId: string | undefined, token: CancellationToken): Promise<SCMHistoryItemChangeDto[] | undefined>;
3205
>
$resolveHistoryItem(sourceControlHandle: number, historyItemId: string, token: CancellationToken): Promise<SCMHistoryItemDto | undefined>;
3206
>
$resolveHistoryItemChatContext(sourceControlHandle: number, historyItemId: string, token: CancellationToken): Promise<string | undefined>;
3207
>
$resolveHistoryItemChangeRangeChatContext(sourceControlHandle: number, historyItemId: string, historyItemParentId: string, path: string, token: CancellationToken): Promise<string | undefined>;
3208
>
$resolveHistoryItemRefsCommonAncestor(sourceControlHandle: number, historyItemRefs: string[], token: CancellationToken): Promise<string | undefined>;
3209
>
3210
>
$provideArtifactGroups(sourceControlHandle: number, token: CancellationToken): Promise<SCMArtifactGroupDto[] | undefined>;
3211
>
$provideArtifacts(sourceControlHandle: number, group: string, token: CancellationToken): Promise<SCMArtifactDto[] | undefined>;
3212
>
}
3213
>
3214
>
export interface ExtHostQuickDiffShape {
3215
>
$provideOriginalResource(sourceControlHandle: number, uri: UriComponents, token: CancellationToken): Promise<UriComponents | null>;
3216
>
$acceptSourceControlDiffInformation(handle: number, diffInformation: ITextEditorDiffInformation | undefined): void;
3217
>
}
3218
>
3219
>
export interface ExtHostShareShape {
3220
>
$provideShare(handle: number, shareableItem: IShareableItemDto, token: CancellationToken): Promise<UriComponents | string | undefined>;
3221
>
}
3222
>
3223
>
export interface ExtHostTaskShape {
3224
>
$provideTasks(handle: number, validTypes: { [key: string]: boolean }): Promise<tasks.ITaskSetDTO>;
3225
>
$resolveTask(handle: number, taskDTO: tasks.ITaskDTO): Promise<tasks.ITaskDTO | undefined>;
3226
>
$onDidStartTask(execution: tasks.ITaskExecutionDTO, terminalId: number, resolvedDefinition: tasks.ITaskDefinitionDTO): void;
3227
>
$onDidStartTaskProcess(value: tasks.ITaskProcessStartedDTO): void;
3228
>
$onDidEndTaskProcess(value: tasks.ITaskProcessEndedDTO): void;
3229
>
$OnDidEndTask(execution: tasks.ITaskExecutionDTO): void;
3230
>
$onDidStartTaskProblemMatchers(status: tasks.ITaskProblemMatcherStartedDto): void;
3231
>
$onDidEndTaskProblemMatchers(status: tasks.ITaskProblemMatcherEndedDto): void;
3232
>
$resolveVariables(workspaceFolder: UriComponents, toResolve: { process?: { name: string; cwd?: string }; variables: string[] }): Promise<{ process?: string; variables: { [key: string]: string } }>;
3233
>
$jsonTasksSupported(): Promise<boolean>;
3234
>
$findExecutable(command: string, cwd?: string, paths?: string[]): Promise<string | undefined>;
3235
>
}
3236
>
3237
>
export interface IBreakpointDto {
3238
>
type: string;
3239
>
id?: string;
3240
>
enabled: boolean;
3241
>
condition?: string;
3242
>
hitCondition?: string;
3243
>
logMessage?: string;
3244
>
mode?: string;
3245
>
}
3246
>
3247
>
export interface IFunctionBreakpointDto extends IBreakpointDto {
3248
>
type: 'function';
3249
>
functionName: string;
3250
>
mode?: string;
3251
>
}
3252
>
3253
>
export interface IDataBreakpointDto extends IBreakpointDto {
3254
>
type: 'data';
3255
>
dataId: string;
3256
>
canPersist: boolean;
3257
>
label: string;
3258
>
accessTypes?: DebugProtocol.DataBreakpointAccessType[];
3259
>
accessType: DebugProtocol.DataBreakpointAccessType;
3260
>
mode?: string;
3261
>
}
3262
>
3263
>
export interface ISourceBreakpointDto extends IBreakpointDto {
3264
>
type: 'source';
3265
>
uri: UriComponents;
3266
>
line: number;
3267
>
character: number;
3268
>
}
3269
>
3270
>
export interface IBreakpointsDeltaDto {
3271
>
added?: Array<ISourceBreakpointDto | IFunctionBreakpointDto | IDataBreakpointDto>;
3272
>
removed?: string[];
3273
>
changed?: Array<ISourceBreakpointDto | IFunctionBreakpointDto | IDataBreakpointDto>;
3274
>
}
3275
>
3276
>
export interface ISourceMultiBreakpointDto {
3277
>
type: 'sourceMulti';
3278
>
uri: UriComponents;
3279
>
lines: {
3280
>
id: string;
3281
>
enabled: boolean;
3282
>
condition?: string;
3283
>
hitCondition?: string;
3284
>
logMessage?: string;
3285
>
line: number;
3286
>
character: number;
3287
>
mode?: string;
3288
>
}[];
3289
>
}
3290
>
3291
>
export interface IDebugSessionFullDto {
3292
>
id: DebugSessionUUID;
3293
>
type: string;
3294
>
name: string;
3295
>
parent: DebugSessionUUID | undefined;
3296
>
folderUri: UriComponents | undefined;
3297
>
configuration: IConfig;
3298
>
}
3299
>
3300
>
export type IDebugSessionDto = IDebugSessionFullDto | DebugSessionUUID;
3301
>
3302
>
export interface IThreadFocusDto {
3303
>
kind: 'thread';
3304
>
sessionId: string;
3305
>
threadId: number;
3306
>
}
3307
>
3308
>
export interface IStackFrameFocusDto {
3309
>
kind: 'stackFrame';
3310
>
sessionId: string;
3311
>
threadId: number;
3312
>
frameId: number;
3313
>
}
3314
>
3315
>
3316
>
export interface ExtHostDebugServiceShape {
3317
>
$substituteVariables(folder: UriComponents | undefined, config: IConfig): Promise<IConfig>;
3318
>
$runInTerminal(args: DebugProtocol.RunInTerminalRequestArguments, sessionId: string): Promise<number | undefined>;
3319
>
$startDASession(handle: number, session: IDebugSessionDto): Promise<void>;
3320
>
$stopDASession(handle: number): Promise<void>;
3321
>
$sendDAMessage(handle: number, message: DebugProtocol.ProtocolMessage): void;
3322
>
$resolveDebugConfiguration(handle: number, folder: UriComponents | undefined, debugConfiguration: IConfig, token: CancellationToken): Promise<IConfig | null | undefined>;
3323
>
$resolveDebugConfigurationWithSubstitutedVariables(handle: number, folder: UriComponents | undefined, debugConfiguration: IConfig, token: CancellationToken): Promise<IConfig | null | undefined>;
3324
>
$provideDebugConfigurations(handle: number, folder: UriComponents | undefined, token: CancellationToken): Promise<IConfig[]>;
3325
>
$provideDebugAdapter(handle: number, session: IDebugSessionDto): Promise<Dto<IAdapterDescriptor>>;
3326
>
$acceptDebugSessionStarted(session: IDebugSessionDto): void;
3327
>
$acceptDebugSessionTerminated(session: IDebugSessionDto): void;
3328
>
$acceptDebugSessionActiveChanged(session: IDebugSessionDto | undefined): void;
3329
>
$acceptDebugSessionCustomEvent(session: IDebugSessionDto, event: any): void;
3330
>
$acceptBreakpointsDelta(delta: IBreakpointsDeltaDto): void;
3331
>
$acceptDebugSessionNameChanged(session: IDebugSessionDto, name: string): void;
3332
>
$acceptStackFrameFocus(focus: IThreadFocusDto | IStackFrameFocusDto | undefined): void;
3333
>
$provideDebugVisualizers(extensionId: string, id: string, context: IDebugVisualizationContext, token: CancellationToken): Promise<IDebugVisualization.Serialized[]>;
3334
>
$resolveDebugVisualizer(id: number, token: CancellationToken): Promise<MainThreadDebugVisualization>;
3335
>
$executeDebugVisualizerCommand(id: number): Promise<void>;
3336
>
$disposeDebugVisualizers(ids: number[]): void;
3337
>
$getVisualizerTreeItem(treeId: string, element: IDebugVisualizationContext): Promise<IDebugVisualizationTreeItem.Serialized | undefined>;
3338
>
$getVisualizerTreeItemChildren(treeId: string, element: number): Promise<IDebugVisualizationTreeItem.Serialized[]>;
3339
>
$editVisualizerTreeItem(element: number, value: string): Promise<IDebugVisualizationTreeItem.Serialized | undefined>;
3340
>
$disposeVisualizedTree(element: number): void;
3341
>
}
3342
>
3343
>
3344
>
export interface DecorationRequest {
3345
>
readonly id: number;
3346
>
readonly uri: UriComponents;
3347
>
}
3348
>
3349
>
export type DecorationData = [boolean, string, string | ThemeIcon, ThemeColor];
3350
>
export type DecorationReply = { [id: number]: DecorationData };
3351
>
3352
>
export interface ExtHostDecorationsShape {
3353
>
$provideDecorations(handle: number, requests: DecorationRequest[], token: CancellationToken): Promise<DecorationReply>;
3354
>
}
3355
>
3356
>
export interface ExtHostWindowShape {
3357
>
$onDidChangeWindowFocus(value: boolean): void;
3358
>
$onDidChangeWindowActive(value: boolean): void;
3359
>
$onDidChangeActiveNativeWindowHandle(handle: string | undefined): void;
3360
>
}
3361
>
3362
>
export type PowerSystemIdleState = 'active' | 'idle' | 'locked' | 'unknown';
3363
>
export type PowerThermalState = 'unknown' | 'nominal' | 'fair' | 'serious' | 'critical';
3364
>
export type PowerSaveBlockerType = 'prevent-app-suspension' | 'prevent-display-sleep';
3365
>
3366
>
export interface MainThreadPowerShape extends IDisposable {
3367
>
$getSystemIdleState(idleThreshold: number): Promise<PowerSystemIdleState>;
3368
>
$getSystemIdleTime(): Promise<number>;
3369
>
$getCurrentThermalState(): Promise<PowerThermalState>;
3370
>
$isOnBatteryPower(): Promise<boolean>;
3371
>
$startPowerSaveBlocker(type: PowerSaveBlockerType): Promise<number>;
3372
>
$stopPowerSaveBlocker(id: number): Promise<boolean>;
3373
>
$isPowerSaveBlockerStarted(id: number): Promise<boolean>;
3374
>
}
3375
>
3376
>
export interface ExtHostPowerShape {
3377
>
$onDidSuspend(): void;
3378
>
$onDidResume(): void;
3379
>
$onDidChangeOnBatteryPower(isOnBattery: boolean): void;
3380
>
$onDidChangeThermalState(state: PowerThermalState): void;
3381
>
$onDidChangeSpeedLimit(limit: number): void;
3382
>
$onWillShutdown(): void;
3383
>
$onDidLockScreen(): void;
3384
>
$onDidUnlockScreen(): void;
3385
>
}
3386
>
3387
>
export interface ExtHostLogLevelServiceShape {
3388
>
$setLogLevel(level: LogLevel, resource?: UriComponents): void;
3389
>
}
3390
>
3391
>
export interface MainThreadLoggerShape {
3392
>
$log(file: UriComponents, messages: [LogLevel, string][]): void;
3393
>
$flush(file: UriComponents): void;
3394
>
$createLogger(file: UriComponents, options?: ILoggerOptions): Promise<void>;
3395
>
$registerLogger(logger: UriDto<ILoggerResource>): Promise<void>;
3396
>
$deregisterLogger(resource: UriComponents): Promise<void>;
3397
>
$setVisibility(resource: UriComponents, visible: boolean): Promise<void>;
3398
>
}
3399
>
3400
>
export interface ExtHostOutputServiceShape {
3401
>
$setVisibleChannel(channelId: string | null): void;
3402
>
}
3403
>
3404
>
export interface ExtHostProgressShape {
3405
>
$acceptProgressCanceled(handle: number): void;
3406
>
}
3407
>
3408
>
export interface ExtHostCommentsShape {
3409
>
$createCommentThreadTemplate(commentControllerHandle: number, uriComponents: UriComponents, range: IRange | undefined, editorId?: string): Promise<void>;
3410
>
$updateCommentThreadTemplate(commentControllerHandle: number, threadHandle: number, range: IRange): Promise<void>;
3411
>
$updateCommentThread(commentControllerHandle: number, threadHandle: number, changes: CommentThreadChanges): Promise<void>;
3412
>
$deleteCommentThread(commentControllerHandle: number, commentThreadHandle: number): void;
3413
>
$provideCommentingRanges(commentControllerHandle: number, uriComponents: UriComponents, token: CancellationToken): Promise<{ ranges: IRange[]; fileComments: boolean } | undefined>;
3414
>
$toggleReaction(commentControllerHandle: number, threadHandle: number, uri: UriComponents, comment: languages.Comment, reaction: languages.CommentReaction): Promise<void>;
3415
>
$setActiveComment(controllerHandle: number, commentInfo: { commentThreadHandle: number; uniqueIdInThread?: number } | undefined): Promise<void>;
3416
>
}
3417
>
3418
>
export interface INotebookSelectionChangeEvent {
3419
>
selections: ICellRange[];
3420
>
}
3421
>
3422
>
export interface INotebookVisibleRangesEvent {
3423
>
ranges: ICellRange[];
3424
>
}
3425
>
3426
>
export interface INotebookEditorPropertiesChangeData {
3427
>
visibleRanges?: INotebookVisibleRangesEvent;
3428
>
selections?: INotebookSelectionChangeEvent;
3429
>
}
3430
>
3431
>
export interface INotebookDocumentPropertiesChangeData {
3432
>
metadata?: notebookCommon.NotebookDocumentMetadata;
3433
>
}
3434
>
3435
>
export interface INotebookModelAddedData {
3436
>
uri: UriComponents;
3437
>
versionId: number;
3438
>
cells: NotebookCellDto[];
3439
>
viewType: string;
3440
>
metadata?: notebookCommon.NotebookDocumentMetadata;
3441
>
}
3442
>
3443
>
export interface INotebookEditorAddData {
3444
>
id: string;
3445
>
documentUri: UriComponents;
3446
>
selections: ICellRange[];
3447
>
visibleRanges: ICellRange[];
3448
>
viewColumn?: number;
3449
>
viewType: string;
3450
>
}
3451
>
3452
>
export interface INotebookDocumentsAndEditorsDelta {
3453
>
removedDocuments?: UriComponents[];
3454
>
addedDocuments?: INotebookModelAddedData[];
3455
>
removedEditors?: string[];
3456
>
addedEditors?: INotebookEditorAddData[];
3457
>
newActiveEditor?: string | null;
3458
>
visibleEditors?: string[];
3459
>
}
3460
>
3461
>
export interface NotebookOutputItemDto {
3462
>
readonly mime: string;
3463
>
readonly valueBytes: VSBuffer;
3464
>
}
3465
>
3466
>
export interface NotebookOutputDto {
3467
>
items: NotebookOutputItemDto[];
3468
>
outputId: string;
3469
>
metadata?: Record<string, any>;
3470
>
}
3471
>
3472
>
export interface NotebookCellDataDto {
3473
>
source: string;
3474
>
language: string;
3475
>
mime: string | undefined;
3476
>
cellKind: notebookCommon.CellKind;
3477
>
outputs: NotebookOutputDto[];
3478
>
metadata?: notebookCommon.NotebookCellMetadata;
3479
>
internalMetadata?: notebookCommon.NotebookCellInternalMetadata;
3480
>
}
3481
>
3482
>
export interface NotebookDataDto {
3483
>
readonly cells: NotebookCellDataDto[];
3484
>
readonly metadata: notebookCommon.NotebookDocumentMetadata;
3485
>
}
3486
>
3487
>
export interface NotebookCellDto {
3488
>
handle: number;
3489
>
uri: UriComponents;
3490
>
eol: string;
3491
>
source: string[];
3492
>
language: string;
3493
>
mime?: string;
3494
>
cellKind: notebookCommon.CellKind;
3495
>
outputs: NotebookOutputDto[];
3496
>
metadata?: notebookCommon.NotebookCellMetadata;
3497
>
internalMetadata?: notebookCommon.NotebookCellInternalMetadata;
3498
>
}
3499
>
3500
>
export type INotebookPartialFileStatsWithMetadata = Omit<files.IFileStatWithMetadata, 'resource' | 'children'>;
3501
>
3502
>
export interface ExtHostNotebookShape extends ExtHostNotebookDocumentsAndEditorsShape {
3503
>
$provideNotebookCellStatusBarItems(handle: number, uri: UriComponents, index: number, token: CancellationToken): Promise<INotebookCellStatusBarListDto | undefined>;
3504
>
$releaseNotebookCellStatusBarItems(id: number): void;
3505
>
3506
>
$dataToNotebook(handle: number, data: VSBuffer, token: CancellationToken): Promise<SerializableObjectWithBuffers<NotebookDataDto>>;
3507
>
$notebookToData(handle: number, data: SerializableObjectWithBuffers<NotebookDataDto>, token: CancellationToken): Promise<VSBuffer>;
3508
>
$saveNotebook(handle: number, uri: UriComponents, versionId: number, options: files.IWriteFileOptions, token: CancellationToken): Promise<INotebookPartialFileStatsWithMetadata | files.FileOperationError>;
3509
>
3510
>
$searchInNotebooks(handle: number, textQuery: search.ITextQuery, viewTypeFileTargets: NotebookPriorityInfo[], otherViewTypeFileTargets: NotebookPriorityInfo[], token: CancellationToken): Promise<{ results: IRawClosedNotebookFileMatch[]; limitHit: boolean }>;
3511
>
}
3512
>
3513
>
export interface ExtHostNotebookDocumentSaveParticipantShape {
3514
>
$participateInSave(resource: UriComponents, reason: SaveReason, token: CancellationToken): Promise<boolean>;
3515
>
}
3516
>
3517
>
export interface ExtHostNotebookRenderersShape {
3518
>
$postRendererMessage(editorId: string, rendererId: string, message: unknown): void;
3519
>
}
3520
>
3521
>
export interface ExtHostNotebookDocumentsAndEditorsShape {
3522
>
$acceptDocumentAndEditorsDelta(delta: SerializableObjectWithBuffers<INotebookDocumentsAndEditorsDelta>): void;
3523
>
}
3524
>
3525
>
export type NotebookRawContentEventDto =
3526
>
// notebookCommon.NotebookCellsInitializeEvent<NotebookCellDto>
3527
>
| {
3528
>
3529
>
readonly kind: notebookCommon.NotebookCellsChangeType.ModelChange;
3530
>
readonly changes: notebookCommon.NotebookCellTextModelSplice<NotebookCellDto>[];
3531
>
}
3532
>
| {
3533
>
readonly kind: notebookCommon.NotebookCellsChangeType.Move;
3534
>
readonly index: number;
3535
>
readonly length: number;
3536
>
readonly newIdx: number;
3537
>
}
3538
>
| {
3539
>
readonly kind: notebookCommon.NotebookCellsChangeType.Output;
3540
>
readonly index: number;
3541
>
readonly outputs: NotebookOutputDto[];
3542
>
}
3543
>
| {
3544
>
readonly kind: notebookCommon.NotebookCellsChangeType.OutputItem;
3545
>
readonly index: number;
3546
>
readonly outputId: string;
3547
>
readonly outputItems: NotebookOutputItemDto[];
3548
>
readonly append: boolean;
3549
>
}
3550
>
| notebookCommon.NotebookCellsChangeLanguageEvent
3551
>
| notebookCommon.NotebookCellsChangeMimeEvent
3552
>
| notebookCommon.NotebookCellsChangeMetadataEvent
3553
>
| notebookCommon.NotebookCellsChangeInternalMetadataEvent
3554
>
// | notebookCommon.NotebookDocumentChangeMetadataEvent
3555
>
| notebookCommon.NotebookCellContentChangeEvent
3556
>
// | notebookCommon.NotebookDocumentUnknownChangeEvent
3557
>
;
3558
>
3559
>
export type NotebookCellsChangedEventDto = {
3560
>
readonly rawEvents: NotebookRawContentEventDto[];
3561
>
readonly versionId: number;
3562
>
};
3563
>
3564
>
export interface ExtHostNotebookDocumentsShape {
3565
>
$acceptModelChanged(uriComponents: UriComponents, event: SerializableObjectWithBuffers<NotebookCellsChangedEventDto>, isDirty: boolean, newMetadata?: notebookCommon.NotebookDocumentMetadata): void;
3566
>
$acceptDirtyStateChanged(uriComponents: UriComponents, isDirty: boolean): void;
3567
>
$acceptModelSaved(uriComponents: UriComponents): void;
3568
>
}
3569
>
3570
>
export type INotebookEditorViewColumnInfo = Record<string, number>;
3571
>
3572
>
export interface ExtHostNotebookEditorsShape {
3573
>
$acceptEditorPropertiesChanged(id: string, data: INotebookEditorPropertiesChangeData): void;
3574
>
$acceptEditorViewColumns(data: INotebookEditorViewColumnInfo): void;
3575
>
}
3576
>
3577
>
export interface ExtHostNotebookKernelsShape {
3578
>
$acceptNotebookAssociation(handle: number, uri: UriComponents, value: boolean): void;
3579
>
$executeCells(handle: number, uri: UriComponents, handles: number[]): Promise<void>;
3580
>
$cancelCells(handle: number, uri: UriComponents, handles: number[]): Promise<void>;
3581
>
$acceptKernelMessageFromRenderer(handle: number, editorId: string, message: any): void;
3582
>
$provideKernelSourceActions(handle: number, token: CancellationToken): Promise<notebookCommon.INotebookKernelSourceAction[]>;
3583
>
$provideVariables(handle: number, requestId: string, notebookUri: UriComponents, parentId: number | undefined, kind: 'named' | 'indexed', start: number, token: CancellationToken): Promise<void>;
3584
>
}
3585
>
3586
>
export interface ExtHostInteractiveShape {
3587
>
$willAddInteractiveDocument(uri: UriComponents, eol: string, languageId: string, notebookUri: UriComponents): void;
3588
>
$willRemoveInteractiveDocument(uri: UriComponents, notebookUri: UriComponents): void;
3589
>
}
3590
>
3591
>
export interface ExtHostStorageShape {
3592
>
$acceptValue(shared: boolean, extensionId: string, value: string): void;
3593
>
}
3594
>
3595
>
export interface ExtHostThemingShape {
3596
>
$onColorThemeChange(themeType: string): void;
3597
>
}
3598
>
3599
>
export interface MainThreadThemingShape extends IDisposable {
3600
>
}
3601
>
3602
>
export interface MainThreadLocalizationShape extends IDisposable {
3603
>
$fetchBuiltInBundleUri(id: string, language: string): Promise<UriComponents | undefined>;
3604
>
$fetchBundleContents(uriComponents: UriComponents): Promise<string>;
3605
>
}
3606
>
3607
>
export interface TunnelDto {
3608
>
remoteAddress: { port: number; host: string };
3609
>
localAddress: { port: number; host: string } | string;
3610
>
public: boolean;
3611
>
privacy: TunnelPrivacyId | string;
3612
>
protocol: string | undefined;
3613
>
}
3614
>
3615
>
3616
>
export interface ExtHostTunnelServiceShape {
3617
>
$forwardPort(tunnelOptions: TunnelOptions, tunnelCreationOptions: TunnelCreationOptions): Promise<TunnelDto | string | undefined>;
3618
>
$closeTunnel(remote: { host: string; port: number }, silent?: boolean): Promise<void>;
3619
>
$onDidTunnelsChange(): Promise<void>;
3620
>
$registerCandidateFinder(enable: boolean): Promise<void>;
3621
>
$applyCandidateFilter(candidates: CandidatePort[]): Promise<CandidatePort[]>;
3622
>
$providePortAttributes(handles: number[], ports: number[], pid: number | undefined, commandline: string | undefined, cancellationToken: CancellationToken): Promise<ProvidedPortAttributes[]>;
3623
>
}
3624
>
3625
>
export interface ExtHostTimelineShape {
3626
>
$getTimeline(source: string, uri: UriComponents, options: TimelineOptions, token: CancellationToken): Promise<Dto<Timeline> | undefined>;
3627
>
}
3628
>
3629
>
export const enum ExtHostTestingResource {
3630
>
Workspace,
3631
>
TextDocument
3632
>
}
3633
>
3634
>
export interface ExtHostTestingShape {
3635
>
$runControllerTests(req: IStartControllerTests[], token: CancellationToken): Promise<{ error?: string }[]>;
3636
>
$startContinuousRun(req: ICallProfileRunHandler[], token: CancellationToken): Promise<{ error?: string }[]>;
3637
>
$cancelExtensionTestRun(runId: string | undefined, taskId: string | undefined): void;
3638
>
/** Handles a diff of tests, as a result of a subscribeToDiffs() call */
3639
>
$acceptDiff(diff: TestsDiffOp.Serialized[]): void;
3640
>
/** Expands a test item's children, by the given number of levels. */
3641
>
$expandTest(testId: string, levels: number): Promise<void>;
3642
>
/** Requests coverage details for a test run. Errors if not available. */
3643
>
$getCoverageDetails(coverageId: string, testId: string | undefined, token: CancellationToken): Promise<CoverageDetails.Serialized[]>;
3644
>
/** Disposes resources associated with a test run. */
3645
>
$disposeRun(runId: string): void;
3646
>
/** Configures a test run config. */
3647
>
$configureRunProfile(controllerId: string, configId: number): void;
3648
>
/** Asks the controller to refresh its tests */
3649
>
$refreshTests(controllerId: string, token: CancellationToken): Promise<void>;
3650
>
/** Ensures any pending test diffs are flushed */
3651
>
$syncTests(): Promise<void>;
3652
>
/** Sets the active test run profiles */
3653
>
$setDefaultRunProfiles(profiles: Record</* controller id */string, /* profile id */ number[]>): void;
3654
>
$getTestsRelatedToCode(uri: UriComponents, position: IPosition, token: CancellationToken): Promise<string[]>;
3655
>
$getCodeRelatedToTest(testId: string, token: CancellationToken): Promise<ILocationDto[]>;
3656
>
3657
>
// --- test results:
3658
>
3659
>
/** Publishes that a test run finished. */
3660
>
$publishTestResults(results: ISerializedTestResults[]): void;
3661
>
/** Requests followup actions for a test (failure) message */
3662
>
$provideTestFollowups(req: TestMessageFollowupRequest, token: CancellationToken): Promise<TestMessageFollowupResponse[]>;
3663
>
/** Actions a followup actions for a test (failure) message */
3664
>
$executeTestFollowup(id: number): Promise<void>;
3665
>
/** Disposes followup actions for a test (failure) message */
3666
>
$disposeTestFollowups(id: number[]): void;
3667
>
}
3668
>
3669
>
export interface IStartMcpOptions {
3670
>
launch: McpServerLaunch.Serialized;
3671
>
defaultCwd?: UriComponents;
3672
>
errorOnUserInteraction?: boolean;
3673
>
}
3674
>
3675
>
export interface ExtHostMcpShape {
3676
>
$substituteVariables(workspaceFolder: UriComponents | undefined, value: McpServerLaunch.Serialized): Promise<McpServerLaunch.Serialized>;
3677
>
$resolveMcpLaunch(collectionId: string, label: string): Promise<McpServerLaunch.Serialized | undefined>;
3678
>
$startMcp(id: number, opts: IStartMcpOptions): void;
3679
>
$stopMcp(id: number): void;
3680
>
$sendMessage(id: number, message: string): void;
3681
>
$waitForInitialCollectionProviders(): Promise<void>;
3682
>
$onDidChangeMcpServerDefinitions(servers: McpServerDefinition.Serialized[]): void;
3683
>
$onDidChangeGatewayServers(gatewayId: string, servers: { label: string; address: UriComponents }[]): void;
3684
>
}
3685
>
3686
>
export interface IMcpAuthenticationDetails {
3687
>
authorizationServer: UriComponents;
3688
>
authorizationServerMetadata: IAuthorizationServerMetadata;
3689
>
resourceMetadata: IAuthorizationProtectedResourceMetadata | undefined;
3690
>
scopes: string[] | undefined;
3691
>
clientId?: string;
3692
>
/**
3693
>
* When true, the MCP server has opted into enterprise-managed authentication
3694
>
* (OAuth Identity Assertion Authorization Grant). The main thread is expected
3695
>
* to route token acquisition through the XAA authentication provider for the
3696
>
* configured issuer rather than the per-resource dynamic auth provider.
3697
>
*/
3698
>
enterpriseManaged?: boolean;
3699
>
}
3700
>
3701
>
export interface IMcpAuthenticationOptions {
3702
>
errorOnUserInteraction?: boolean;
3703
>
forceNewRegistration?: boolean;
3704
>
clientId?: string;
3705
>
}
3706
>
3707
>
export const enum IAuthResourceMetadataSource {
3708
>
Header = 'header',
3709
>
WellKnown = 'wellKnown',
3710
>
None = 'none',
3711
>
}
3712
>
3713
>
export const enum IAuthServerMetadataSource {
3714
>
ResourceMetadata = 'resourceMetadata',
3715
>
WellKnown = 'wellKnown',
3716
>
Default = 'default',
3717
>
}
3718
>
3719
>
export interface IAuthMetadataSource {
3720
>
resourceMetadataSource: IAuthResourceMetadataSource;
3721
>
serverMetadataSource: IAuthServerMetadataSource;
3722
>
}
3723
>
3724
>
export interface MainThreadMcpShape {
3725
>
$onDidChangeState(id: number, state: McpConnectionState): void;
3726
>
$onDidPublishLog(id: number, level: LogLevel, log: string): void;
3727
>
$onDidReceiveMessage(id: number, message: string): void;
3728
>
$upsertMcpCollection(collection: McpCollectionDefinition.FromExtHost, servers: McpServerDefinition.Serialized[]): void;
3729
>
$deleteMcpCollection(collectionId: string): void;
3730
>
$getTokenFromServerMetadata(id: number, authDetails: IMcpAuthenticationDetails, options?: IMcpAuthenticationOptions): Promise<string | undefined>;
3731
>
$getTokenForProviderId(id: number, providerId: string, scopes: string[], options?: IMcpAuthenticationOptions): Promise<string | undefined>;
3732
>
$logMcpAuthSetup(data: IAuthMetadataSource): void;
3733
>
$startMcpGateway(chatSessionResource?: UriComponents): Promise<{ servers: { label: string; address: UriComponents }[]; gatewayId: string } | undefined>;
3734
>
$disposeMcpGateway(gatewayId: string): void;
3735
>
}
3736
>
3737
>
export interface MainThreadDataChannelsShape extends IDisposable {
3738
>
}
3739
>
3740
>
export interface ExtHostDataChannelsShape {
3741
>
$onDidReceiveData(channelId: string, data: unknown): void;
3742
>
}
3743
>
3744
>
export interface ExtHostLocalizationShape {
3745
>
getMessage(extensionId: string, details: IStringDetails): string;
3746
>
getBundle(extensionId: string): { [key: string]: string } | undefined;
3747
>
getBundleUri(extensionId: string): URI | undefined;
3748
>
initializeLocalizedMessages(extension: IExtensionDescription): Promise<void>;
3749
>
}
3750
>
3751
>
export interface IStringDetails {
3752
>
message: string;
3753
>
args?: Record<string | number, any>;
3754
>
comment?: string | string[];
3755
>
}
3756
>
3757
>
export interface ITestControllerPatch {
3758
>
label?: string;
3759
>
capabilities?: TestControllerCapability;
3760
>
}
3761
>
3762
>
export interface MainThreadTestingShape {
3763
>
// --- test lifecycle:
3764
>
3765
>
/** Registers that there's a test controller with the given ID */
3766
>
$registerTestController(controllerId: string, label: string, capability: TestControllerCapability): void;
3767
>
/** Updates the label of an existing test controller. */
3768
>
$updateController(controllerId: string, patch: ITestControllerPatch): void;
3769
>
/** Diposes of the test controller with the given ID */
3770
>
$unregisterTestController(controllerId: string): void;
3771
>
/** Requests tests published to VS Code. */
3772
>
$subscribeToDiffs(): void;
3773
>
/** Stops requesting tests published to VS Code. */
3774
>
$unsubscribeFromDiffs(): void;
3775
>
/** Publishes that new tests were available on the given source. */
3776
>
$publishDiff(controllerId: string, diff: TestsDiffOp.Serialized[]): void;
3777
>
/** Gets coverage details from a test result. */
3778
>
$getCoverageDetails(resultId: string, taskIndex: number, uri: UriComponents, token: CancellationToken): Promise<CoverageDetails.Serialized[]>;
3779
>
3780
>
// --- test run configurations:
3781
>
3782
>
/** Called when a new test run configuration is available */
3783
>
$publishTestRunProfile(config: ITestRunProfile): void;
3784
>
/** Updates an existing test run configuration */
3785
>
$updateTestRunConfig(controllerId: string, configId: number, update: Partial<ITestRunProfile>): void;
3786
>
/** Removes a previously-published test run config */
3787
>
$removeTestProfile(controllerId: string, configId: number): void;
3788
>
3789
>
3790
>
// --- test run handling:
3791
>
3792
>
/** Request by an extension to run tests. */
3793
>
$runTests(req: ResolvedTestRunRequest, token: CancellationToken): Promise<string>;
3794
>
/**
3795
>
* Adds tests to the run. The tests are given in descending depth. The first
3796
>
* item will be a previously-known test, or a test root.
3797
>
*/
3798
>
$addTestsToRun(controllerId: string, runId: string, tests: ITestItem.Serialized[]): void;
3799
>
/** Updates the state of a test run in the given run. */
3800
>
$updateTestStateInRun(runId: string, taskId: string, testId: string, state: TestResultState, duration?: number): void;
3801
>
/** Appends a message to a test in the run. */
3802
>
$appendTestMessagesInRun(runId: string, taskId: string, testId: string, messages: ITestMessage.Serialized[]): void;
3803
>
/** Appends raw output to the test run.. */
3804
>
$appendOutputToRun(runId: string, taskId: string, output: VSBuffer, location?: ILocationDto, testId?: string): void;
3805
>
/** Triggered when coverage is added to test results. */
3806
>
$appendCoverage(runId: string, taskId: string, coverage: IFileCoverage.Serialized): void;
3807
>
/** Signals a task in a test run started. */
3808
>
$startedTestRunTask(runId: string, task: ITestRunTask): void;
3809
>
/** Signals a task in a test run ended. */
3810
>
$finishedTestRunTask(runId: string, taskId: string): void;
3811
>
/** Start a new extension-provided test run. */
3812
>
$startedExtensionTestRun(req: ExtensionRunTestsRequest): void;
3813
>
/** Signals that an extension-provided test run finished. */
3814
>
$finishedExtensionTestRun(runId: string): void;
3815
>
/** Marks a test (or controller) as retired in all results. */
3816
>
$markTestRetired(testIds: string[] | undefined): void;
3817
>
}
3818
>
3819
>
export type ChatStatusItemDto = {
3820
>
id: string;
3821
>
title: string | { label: string; link: string; helpText?: string };
3822
>
description: string;
3823
>
detail: string | undefined;
3824
>
tooltip: string | undefined;
3825
>
};
3826
>
3827
>
export interface MainThreadChatStatusShape {
3828
>
$setEntry(id: string, entry: ChatStatusItemDto): void;
3829
>
$disposeEntry(id: string): void;
3830
>
}
3831
>
3832
>
export interface MainThreadChatQuotaShape extends IDisposable {
3833
>
$updateQuotas(quotas: IQuotaSnapshotsDto): void;
3834
>
}
3835
>
3836
>
export interface ExtHostChatQuotaShape {
3837
>
}
3838
>
3839
>
export const enum ChatInputNotificationSeverityDto {
3840
>
Info = 0,
3841
>
Warning = 1,
3842
>
Error = 2,
3843
>
}
3844
>
3845
>
export type ChatInputNotificationActionDto = {
3846
>
label: string;
3847
>
commandId: string;
3848
>
commandArgs?: unknown[];
3849
>
};
3850
>
3851
>
export type ChatInputNotificationDto = {
3852
>
id: string;
3853
>
severity: ChatInputNotificationSeverityDto;
3854
>
message: string;
3855
>
description: string | undefined;
3856
>
actions: ChatInputNotificationActionDto[];
3857
>
dismissible: boolean;
3858
>
autoDismissOnMessage: boolean;
3859
>
};
3860
>
3861
>
export interface MainThreadChatInputNotificationShape {
3862
>
$setNotification(notification: ChatInputNotificationDto): void;
3863
>
$disposeNotification(id: string): void;
3864
>
}
3865
>
3866
>
export type IChatSessionHistoryItemDto = {
3867
>
id?: string;
3868
>
type: 'request';
3869
>
prompt: string;
3870
>
participant: string;
3871
>
command?: string;
3872
>
variableData?: Dto<IChatRequestVariableData>;
3873
>
modelId?: string;
3874
>
modeInstructions?: Dto<IChatRequestModeInstructions>;
3875
>
} | {
3876
>
type: 'response';
3877
>
parts: IChatProgressDto[];
3878
>
participant: string;
3879
>
details?: string;
3880
>
};
3881
>
3882
>
export type IChatSessionRequestHistoryItemDto = Extract<IChatSessionHistoryItemDto, { type: 'request' }>;
3883
>
3884
>
3885
>
3886
>
export interface ChatSessionContentContextDto {
3887
>
readonly initialSessionOptions?: ReadonlyArray<{ optionId: string; value: string }>;
3888
>
}
3889
>
3890
>
export interface IChatNewSessionRequestDto {
3891
>
readonly prompt: string;
3892
>
readonly command?: string;
3893
>
3894
>
readonly initialSessionOptions?: ReadonlyArray<{ optionId: string; value: string }>;
3895
>
}
3896
>
3897
>
export interface IChatSessionDto {
3898
>
resource: UriComponents;
3899
>
title?: string;
3900
>
history: Array<IChatSessionHistoryItemDto>;
3901
>
hasActiveResponseCallback: boolean;
3902
>
hasRequestHandler: boolean;
3903
>
hasForkHandler: boolean;
3904
>
supportsInterruption: boolean;
3905
>
options?: Record<string, string | IChatSessionProviderOptionItem>;
3906
>
}
3907
>
3908
>
export interface IChatSessionProviderOptions {
3909
>
optionGroups?: readonly IChatSessionProviderOptionGroup[];
3910
>
newSessionOptions?: Record<string, string | IChatSessionProviderOptionItem>;
3911
>
}
3912
>
3913
>
export interface IChatSessionItemsChange {
3914
>
readonly addedOrUpdated: readonly Dto<IChatSessionItem>[];
3915
>
readonly removed: readonly UriComponents[];
3916
>
}
3917
>
3918
>
export interface MainThreadChatSessionsShape extends IDisposable {
3919
>
$registerChatSessionItemController(controllerHandle: number, chatSessionType: string, supportsResolve: boolean): void;
3920
>
$updateChatSessionItemControllerCapabilities(controllerHandle: number, supportsResolve: boolean): void;
3921
>
$unregisterChatSessionItemController(controllerHandle: number): void;
3922
>
$updateChatSessionItems(controllerHandle: number, change: IChatSessionItemsChange): Promise<void>;
3923
>
$addOrUpdateChatSessionItem(controllerHandle: number, item: Dto<IChatSessionItem>): Promise<void>;
3924
>
$onDidCommitChatSessionItem(controllerHandle: number, original: UriComponents, modified: UriComponents): void;
3925
>
$registerChatSessionContentProvider(handle: number, chatSessionScheme: string): void;
3926
>
$unregisterChatSessionContentProvider(handle: number): void;
3927
>
$onDidChangeChatSessionOptions(handle: number, sessionResource: UriComponents, updates: Record<string, string | IChatSessionProviderOptionItem>): void;
3928
>
$onDidChangeChatSessionProviderOptions(handle: number): void;
3929
>
3930
>
$updateChatSessionInputState(controllerHandle: number, sessionResource: UriComponents, optionGroups: readonly IChatSessionProviderOptionGroup[]): void;
3931
>
3932
>
$handleProgressChunk(handle: number, sessionResource: UriComponents, requestId: string, chunks: (IChatProgressDto | [IChatProgressDto, number])[]): Promise<void>;
3933
>
$handleAnchorResolve(handle: number, sessionResource: UriComponents, requestId: string, requestHandle: string, anchor: Dto<IChatContentInlineReference>): void;
3934
>
$handleProgressComplete(handle: number, sessionResource: UriComponents, requestId: string): void;
3935
>
}
3936
>
3937
>
export interface ExtHostChatSessionsShape {
3938
>
$refreshChatSessionItems(providerHandle: number, token: CancellationToken): Promise<void>;
3939
>
$onDidChangeChatSessionItemState(providerHandle: number, sessionResource: UriComponents, archived: boolean): void;
3940
>
$newChatSessionItem(controllerHandle: number, request: IChatNewSessionRequestDto, token: CancellationToken): Promise<Dto<IChatSessionItem> | undefined>;
3941
>
3942
>
$provideChatSessionContent(providerHandle: number, sessionResource: UriComponents, context: ChatSessionContentContextDto, token: CancellationToken): Promise<IChatSessionDto>;
3943
>
$interruptChatSessionActiveResponse(providerHandle: number, sessionResource: UriComponents, requestId: string): Promise<void>;
3944
>
$disposeChatSessionContent(providerHandle: number, sessionResource: UriComponents): Promise<void>;
3945
>
$invokeChatSessionRequestHandler(providerHandle: number, sessionResource: UriComponents, request: IChatAgentRequest, history: any[], token: CancellationToken): Promise<IChatAgentResult>;
3946
>
$provideChatSessionProviderOptions(providerHandle: number, token: CancellationToken): Promise<IChatSessionProviderOptions | undefined>;
3947
>
$provideHandleOptionsChange(providerHandle: number, sessionResource: UriComponents, updates: Record<string, string | IChatSessionProviderOptionItem | undefined>, token: CancellationToken): Promise<void>;
3948
>
$forkChatSession(providerHandle: number, sessionResource: UriComponents, request: IChatSessionRequestHistoryItemDto | undefined, token: CancellationToken): Promise<Dto<IChatSessionItem>>;
3949
>
$resolveChatSessionItem(providerHandle: number, sessionResource: UriComponents, token: CancellationToken): Promise<Dto<IChatSessionItem> | undefined>;
3950
>
$provideChatSessionInputState(controllerHandle: number, sessionResource: UriComponents | undefined, token: CancellationToken): Promise<IChatSessionProviderOptionGroup[] | undefined>;
3951
>
}
3952
>
3953
>
export interface GitRefQueryDto {
3954
>
readonly contains?: string;
3955
>
readonly count?: number;
3956
>
readonly pattern?: string | string[];
3957
>
readonly sort?: 'alphabetically' | 'committerdate' | 'creatordate';
3958
>
}
3959
>
3960
>
export enum GitRefTypeDto {
3961
>
Head,
3962
>
RemoteHead,
3963
>
Tag
3964
>
}
3965
>
3966
>
export interface GitRefDto {
3967
>
readonly id: string;
3968
>
readonly name: string;
3969
>
readonly type: GitRefTypeDto;
3970
>
readonly revision: string;
3971
>
}
3972
>
3973
>
export interface GitChangeDto {
3974
>
readonly uri: UriComponents;
3975
>
readonly originalUri: UriComponents | undefined;
3976
>
readonly modifiedUri: UriComponents | undefined;
3977
>
}
3978
>
3979
>
export interface GitDiffChangeDto extends GitChangeDto {
3980
>
readonly insertions: number;
3981
>
readonly deletions: number;
3982
>
}
3983
>
3984
>
export interface GitRemoteDto {
3985
>
readonly name: string;
3986
>
readonly fetchUrl?: string;
3987
>
readonly pushUrl?: string;
3988
>
readonly isReadOnly: boolean;
3989
>
}
3990
>
3991
>
export interface GitRepositoryStateDto {
3992
>
readonly HEAD?: GitBranchDto;
3993
>
readonly remotes: readonly GitRemoteDto[];
3994
>
readonly mergeChanges: readonly GitChangeDto[];
3995
>
readonly indexChanges: readonly GitChangeDto[];
3996
>
readonly workingTreeChanges: readonly GitChangeDto[];
3997
>
readonly untrackedChanges: readonly GitChangeDto[];
3998
>
}
3999
>
4000
>
export interface GitBranchDto {
4001
>
readonly name?: string;
4002
>
readonly commit?: string;
4003
>
readonly type: GitRefTypeDto;
4004
>
readonly remote?: string;
4005
>
readonly upstream?: GitUpstreamRefDto;
4006
>
readonly ahead?: number;
4007
>
readonly behind?: number;
4008
>
}
4009
>
4010
>
export interface GitBaseRefDto {
4011
>
readonly name: string;
4012
>
readonly isProtected: boolean;
4013
>
}
4014
>
4015
>
export interface GitUpstreamRefDto {
4016
>
readonly remote: string;
4017
>
readonly name: string;
4018
>
readonly commit?: string;
4019
>
}
4020
>
4021
>
export interface ExtHostGitExtensionShape {
4022
>
$isGitExtensionAvailable(): Promise<boolean>;
4023
>
$openRepository(root: UriComponents): Promise<{ handle: number; rootUri: UriComponents; state: GitRepositoryStateDto } | undefined>;
4024
>
$getRefs(handle: number, query: GitRefQueryDto, token?: CancellationToken): Promise<GitRefDto[]>;
4025
>
$getRepositoryState(handle: number): Promise<GitRepositoryStateDto | undefined>;
4026
>
$diffBetweenWithStats(handle: number, ref1: string, ref2: string, path?: string): Promise<GitDiffChangeDto[]>;
4027
>
$diffBetweenWithStats2(handle: number, ref: string, path?: string): Promise<GitDiffChangeDto[]>;
4028
>
}
4029
>
4030
>
// --- proxy identifiers
4031
>
4032
>
export const MainContext = {
4033
>
MainThreadAuthentication: createProxyIdentifier<MainThreadAuthenticationShape>('MainThreadAuthentication'),
4034
>
MainThreadBulkEdits: createProxyIdentifier<MainThreadBulkEditsShape>('MainThreadBulkEdits'),
4035
>
MainThreadLanguageModels: createProxyIdentifier<MainThreadLanguageModelsShape>('MainThreadLanguageModels'),
4036
>
MainThreadEmbeddings: createProxyIdentifier<MainThreadEmbeddingsShape>('MainThreadEmbeddings'),
4037
>
MainThreadChatAgents2: createProxyIdentifier<MainThreadChatAgentsShape2>('MainThreadChatAgents2'),
4038
>
MainThreadCodeMapper: createProxyIdentifier<MainThreadCodeMapperShape>('MainThreadCodeMapper'),
4039
>
MainThreadLanguageModelTools: createProxyIdentifier<MainThreadLanguageModelToolsShape>('MainThreadChatSkills'),
4040
>
MainThreadGitExtension: createProxyIdentifier<MainThreadGitExtensionShape>('MainThreadGitExtension'),
4041
>
MainThreadClipboard: createProxyIdentifier<MainThreadClipboardShape>('MainThreadClipboard'),
4042
>
MainThreadCommands: createProxyIdentifier<MainThreadCommandsShape>('MainThreadCommands'),
4043
>
MainThreadComments: createProxyIdentifier<MainThreadCommentsShape>('MainThreadComments'),
4044
>
MainThreadConfiguration: createProxyIdentifier<MainThreadConfigurationShape>('MainThreadConfiguration'),
4045
>
MainThreadConsole: createProxyIdentifier<MainThreadConsoleShape>('MainThreadConsole'),
4046
>
MainThreadDebugService: createProxyIdentifier<MainThreadDebugServiceShape>('MainThreadDebugService'),
4047
>
MainThreadDecorations: createProxyIdentifier<MainThreadDecorationsShape>('MainThreadDecorations'),
4048
>
MainThreadDiagnostics: createProxyIdentifier<MainThreadDiagnosticsShape>('MainThreadDiagnostics'),
4049
>
MainThreadDialogs: createProxyIdentifier<MainThreadDiaglogsShape>('MainThreadDiaglogs'),
4050
>
MainThreadDocuments: createProxyIdentifier<MainThreadDocumentsShape>('MainThreadDocuments'),
4051
>
MainThreadDocumentContentProviders: createProxyIdentifier<MainThreadDocumentContentProvidersShape>('MainThreadDocumentContentProviders'),
4052
>
MainThreadTextEditors: createProxyIdentifier<MainThreadTextEditorsShape>('MainThreadTextEditors'),
4053
>
MainThreadEditorInsets: createProxyIdentifier<MainThreadEditorInsetsShape>('MainThreadEditorInsets'),
4054
>
MainThreadEditorTabs: createProxyIdentifier<MainThreadEditorTabsShape>('MainThreadEditorTabs'),
4055
>
MainThreadErrors: createProxyIdentifier<MainThreadErrorsShape>('MainThreadErrors'),
4056
>
MainThreadTreeViews: createProxyIdentifier<MainThreadTreeViewsShape>('MainThreadTreeViews'),
4057
>
MainThreadDownloadService: createProxyIdentifier<MainThreadDownloadServiceShape>('MainThreadDownloadService'),
4058
>
MainThreadLanguageFeatures: createProxyIdentifier<MainThreadLanguageFeaturesShape>('MainThreadLanguageFeatures'),
4059
>
MainThreadLanguages: createProxyIdentifier<MainThreadLanguagesShape>('MainThreadLanguages'),
4060
>
MainThreadLogger: createProxyIdentifier<MainThreadLoggerShape>('MainThreadLogger'),
4061
>
MainThreadMessageService: createProxyIdentifier<MainThreadMessageServiceShape>('MainThreadMessageService'),
4062
>
MainThreadOutputService: createProxyIdentifier<MainThreadOutputServiceShape>('MainThreadOutputService'),
4063
>
MainThreadProgress: createProxyIdentifier<MainThreadProgressShape>('MainThreadProgress'),
4064
>
MainThreadQuickDiff: createProxyIdentifier<MainThreadQuickDiffShape>('MainThreadQuickDiff'),
4065
>
MainThreadAgentEditorComments: createProxyIdentifier<MainThreadAgentEditorCommentsShape>('MainThreadAgentEditorComments'),
4066
>
MainThreadDocumentDiff: createProxyIdentifier<MainThreadDocumentDiffShape>('MainThreadDocumentDiff'),
4067
>
MainThreadQuickOpen: createProxyIdentifier<MainThreadQuickOpenShape>('MainThreadQuickOpen'),
4068
>
MainThreadStatusBar: createProxyIdentifier<MainThreadStatusBarShape>('MainThreadStatusBar'),
4069
>
MainThreadSecretState: createProxyIdentifier<MainThreadSecretStateShape>('MainThreadSecretState'),
4070
>
MainThreadStorage: createProxyIdentifier<MainThreadStorageShape>('MainThreadStorage'),
4071
>
MainThreadSpeech: createProxyIdentifier<MainThreadSpeechShape>('MainThreadSpeechProvider'),
4072
>
MainThreadTelemetry: createProxyIdentifier<MainThreadTelemetryShape>('MainThreadTelemetry'),
4073
>
MainThreadMeteredConnection: createProxyIdentifier<MainThreadMeteredConnectionShape>('MainThreadMeteredConnection'),
4074
>
MainThreadTerminalService: createProxyIdentifier<MainThreadTerminalServiceShape>('MainThreadTerminalService'),
4075
>
MainThreadTerminalShellIntegration: createProxyIdentifier<MainThreadTerminalShellIntegrationShape>('MainThreadTerminalShellIntegration'),
4076
>
MainThreadWebviews: createProxyIdentifier<MainThreadWebviewsShape>('MainThreadWebviews'),
4077
>
MainThreadWebviewPanels: createProxyIdentifier<MainThreadWebviewPanelsShape>('MainThreadWebviewPanels'),
4078
>
MainThreadWebviewViews: createProxyIdentifier<MainThreadWebviewViewsShape>('MainThreadWebviewViews'),
4079
>
MainThreadCustomEditors: createProxyIdentifier<MainThreadCustomEditorsShape>('MainThreadCustomEditors'),
4080
>
MainThreadUrls: createProxyIdentifier<MainThreadUrlsShape>('MainThreadUrls'),
4081
>
MainThreadUriOpeners: createProxyIdentifier<MainThreadUriOpenersShape>('MainThreadUriOpeners'),
4082
>
MainThreadProfileContentHandlers: createProxyIdentifier<MainThreadProfileContentHandlersShape>('MainThreadProfileContentHandlers'),
4083
>
MainThreadWorkspace: createProxyIdentifier<MainThreadWorkspaceShape>('MainThreadWorkspace'),
4084
>
MainThreadFileSystem: createProxyIdentifier<MainThreadFileSystemShape>('MainThreadFileSystem'),
4085
>
MainThreadFileSystemEventService: createProxyIdentifier<MainThreadFileSystemEventServiceShape>('MainThreadFileSystemEventService'),
4086
>
MainThreadExtensionService: createProxyIdentifier<MainThreadExtensionServiceShape>('MainThreadExtensionService'),
4087
>
MainThreadSCM: createProxyIdentifier<MainThreadSCMShape>('MainThreadSCM'),
4088
>
MainThreadSearch: createProxyIdentifier<MainThreadSearchShape>('MainThreadSearch'),
4089
>
MainThreadShare: createProxyIdentifier<MainThreadShareShape>('MainThreadShare'),
4090
>
MainThreadTask: createProxyIdentifier<MainThreadTaskShape>('MainThreadTask'),
4091
>
MainThreadWindow: createProxyIdentifier<MainThreadWindowShape>('MainThreadWindow'),
4092
>
MainThreadPower: createProxyIdentifier<MainThreadPowerShape>('MainThreadPower'),
4093
>
MainThreadLabelService: createProxyIdentifier<MainThreadLabelServiceShape>('MainThreadLabelService'),
4094
>
MainThreadNotebook: createProxyIdentifier<MainThreadNotebookShape>('MainThreadNotebook'),
4095
>
MainThreadNotebookDocuments: createProxyIdentifier<MainThreadNotebookDocumentsShape>('MainThreadNotebookDocumentsShape'),
4096
>
MainThreadNotebookEditors: createProxyIdentifier<MainThreadNotebookEditorsShape>('MainThreadNotebookEditorsShape'),
4097
>
MainThreadNotebookKernels: createProxyIdentifier<MainThreadNotebookKernelsShape>('MainThreadNotebookKernels'),
4098
>
MainThreadNotebookRenderers: createProxyIdentifier<MainThreadNotebookRenderersShape>('MainThreadNotebookRenderers'),
4099
>
MainThreadInteractive: createProxyIdentifier<MainThreadInteractiveShape>('MainThreadInteractive'),
4100
>
MainThreadTheming: createProxyIdentifier<MainThreadThemingShape>('MainThreadTheming'),
4101
>
MainThreadTunnelService: createProxyIdentifier<MainThreadTunnelServiceShape>('MainThreadTunnelService'),
4102
>
MainThreadManagedSockets: createProxyIdentifier<MainThreadManagedSocketsShape>('MainThreadManagedSockets'),
4103
>
MainThreadBrowserTunnelProxy: createProxyIdentifier<MainThreadBrowserTunnelProxyShape>('MainThreadBrowserTunnelProxy'),
4104
>
MainThreadTimeline: createProxyIdentifier<MainThreadTimelineShape>('MainThreadTimeline'),
4105
>
MainThreadTesting: createProxyIdentifier<MainThreadTestingShape>('MainThreadTesting'),
4106
>
MainThreadLocalization: createProxyIdentifier<MainThreadLocalizationShape>('MainThreadLocalizationShape'),
4107
>
MainThreadMcp: createProxyIdentifier<MainThreadMcpShape>('MainThreadMcpShape'),
4108
>
MainThreadAiRelatedInformation: createProxyIdentifier<MainThreadAiRelatedInformationShape>('MainThreadAiRelatedInformation'),
4109
>
MainThreadAiEmbeddingVector: createProxyIdentifier<MainThreadAiEmbeddingVectorShape>('MainThreadAiEmbeddingVector'),
4110
>
MainThreadChatStatus: createProxyIdentifier<MainThreadChatStatusShape>('MainThreadChatStatus'),
4111
>
MainThreadChatQuota: createProxyIdentifier<MainThreadChatQuotaShape>('MainThreadChatQuota'),
4112
>
MainThreadChatInputNotification: createProxyIdentifier<MainThreadChatInputNotificationShape>('MainThreadChatInputNotification'),
4113
>
MainThreadAiSettingsSearch: createProxyIdentifier<MainThreadAiSettingsSearchShape>('MainThreadAiSettingsSearch'),
4114
>
MainThreadDataChannels: createProxyIdentifier<MainThreadDataChannelsShape>('MainThreadDataChannels'),
4115
>
MainThreadChatSessions: createProxyIdentifier<MainThreadChatSessionsShape>('MainThreadChatSessions'),
4116
>
MainThreadChatOutputRenderer: createProxyIdentifier<MainThreadChatOutputRendererShape>('MainThreadChatOutputRenderer'),
4117
>
MainThreadChatContext: createProxyIdentifier<MainThreadChatContextShape>('MainThreadChatContext'),
4118
>
MainThreadChatDebug: createProxyIdentifier<MainThreadChatDebugShape>('MainThreadChatDebug'),
4119
>
MainThreadBrowsers: createProxyIdentifier<MainThreadBrowsersShape>('MainThreadBrowsers'),
4120
>
};
4121
>
4122
>
export const ExtHostContext = {
4123
>
ExtHostCodeMapper: createProxyIdentifier<ExtHostCodeMapperShape>('ExtHostCodeMapper'),
4124
>
ExtHostCommands: createProxyIdentifier<ExtHostCommandsShape>('ExtHostCommands'),
4125
>
ExtHostConfiguration: createProxyIdentifier<ExtHostConfigurationShape>('ExtHostConfiguration'),
4126
>
ExtHostDiagnostics: createProxyIdentifier<ExtHostDiagnosticsShape>('ExtHostDiagnostics'),
4127
>
ExtHostDebugService: createProxyIdentifier<ExtHostDebugServiceShape>('ExtHostDebugService'),
4128
>
ExtHostDecorations: createProxyIdentifier<ExtHostDecorationsShape>('ExtHostDecorations'),
4129
>
ExtHostDocumentsAndEditors: createProxyIdentifier<ExtHostDocumentsAndEditorsShape>('ExtHostDocumentsAndEditors'),
4130
>
ExtHostDocuments: createProxyIdentifier<ExtHostDocumentsShape>('ExtHostDocuments'),
4131
>
ExtHostDocumentContentProviders: createProxyIdentifier<ExtHostDocumentContentProvidersShape>('ExtHostDocumentContentProviders'),
4132
>
ExtHostDocumentSaveParticipant: createProxyIdentifier<ExtHostDocumentSaveParticipantShape>('ExtHostDocumentSaveParticipant'),
4133
>
ExtHostEditors: createProxyIdentifier<ExtHostEditorsShape>('ExtHostEditors'),
4134
>
ExtHostTreeViews: createProxyIdentifier<ExtHostTreeViewsShape>('ExtHostTreeViews'),
4135
>
ExtHostFileSystem: createProxyIdentifier<ExtHostFileSystemShape>('ExtHostFileSystem'),
4136
>
ExtHostFileSystemInfo: createProxyIdentifier<ExtHostFileSystemInfoShape>('ExtHostFileSystemInfo'),
4137
>
ExtHostFileSystemEventService: createProxyIdentifier<ExtHostFileSystemEventServiceShape>('ExtHostFileSystemEventService'),
4138
>
ExtHostLanguages: createProxyIdentifier<ExtHostLanguagesShape>('ExtHostLanguages'),
4139
>
ExtHostLanguageFeatures: createProxyIdentifier<ExtHostLanguageFeaturesShape>('ExtHostLanguageFeatures'),
4140
>
ExtHostQuickOpen: createProxyIdentifier<ExtHostQuickOpenShape>('ExtHostQuickOpen'),
4141
>
ExtHostQuickDiff: createProxyIdentifier<ExtHostQuickDiffShape>('ExtHostQuickDiff'),
4142
>
ExtHostAgentEditorComments: createProxyIdentifier<ExtHostAgentEditorCommentsShape>('ExtHostAgentEditorComments'),
4143
>
ExtHostStatusBar: createProxyIdentifier<ExtHostStatusBarShape>('ExtHostStatusBar'),
4144
>
ExtHostShare: createProxyIdentifier<ExtHostShareShape>('ExtHostShare'),
4145
>
ExtHostExtensionService: createProxyIdentifier<ExtHostExtensionServiceShape>('ExtHostExtensionService'),
4146
>
ExtHostLogLevelServiceShape: createProxyIdentifier<ExtHostLogLevelServiceShape>('ExtHostLogLevelServiceShape'),
4147
>
ExtHostTerminalService: createProxyIdentifier<ExtHostTerminalServiceShape>('ExtHostTerminalService'),
4148
>
ExtHostTerminalShellIntegration: createProxyIdentifier<ExtHostTerminalShellIntegrationShape>('ExtHostTerminalShellIntegration'),
4149
>
ExtHostSCM: createProxyIdentifier<ExtHostSCMShape>('ExtHostSCM'),
4150
>
ExtHostSearch: createProxyIdentifier<ExtHostSearchShape>('ExtHostSearch'),
4151
>
ExtHostTask: createProxyIdentifier<ExtHostTaskShape>('ExtHostTask'),
4152
>
ExtHostWorkspace: createProxyIdentifier<ExtHostWorkspaceShape>('ExtHostWorkspace'),
4153
>
ExtHostWindow: createProxyIdentifier<ExtHostWindowShape>('ExtHostWindow'),
4154
>
ExtHostPower: createProxyIdentifier<ExtHostPowerShape>('ExtHostPower'),
4155
>
ExtHostWebviews: createProxyIdentifier<ExtHostWebviewsShape>('ExtHostWebviews'),
4156
>
ExtHostWebviewPanels: createProxyIdentifier<ExtHostWebviewPanelsShape>('ExtHostWebviewPanels'),
4157
>
ExtHostCustomEditors: createProxyIdentifier<ExtHostCustomEditorsShape>('ExtHostCustomEditors'),
4158
>
ExtHostWebviewViews: createProxyIdentifier<ExtHostWebviewViewsShape>('ExtHostWebviewViews'),
4159
>
ExtHostEditorInsets: createProxyIdentifier<ExtHostEditorInsetsShape>('ExtHostEditorInsets'),
4160
>
ExtHostEditorTabs: createProxyIdentifier<IExtHostEditorTabsShape>('ExtHostEditorTabs'),
4161
>
ExtHostProgress: createProxyIdentifier<ExtHostProgressShape>('ExtHostProgress'),
4162
>
ExtHostComments: createProxyIdentifier<ExtHostCommentsShape>('ExtHostComments'),
4163
>
ExtHostSecretState: createProxyIdentifier<ExtHostSecretStateShape>('ExtHostSecretState'),
4164
>
ExtHostStorage: createProxyIdentifier<ExtHostStorageShape>('ExtHostStorage'),
4165
>
ExtHostUrls: createProxyIdentifier<ExtHostUrlsShape>('ExtHostUrls'),
4166
>
ExtHostUriOpeners: createProxyIdentifier<ExtHostUriOpenersShape>('ExtHostUriOpeners'),
4167
>
ExtHostChatOutputRenderer: createProxyIdentifier<ExtHostChatOutputRendererShape>('ExtHostChatOutputRenderer'),
4168
>
ExtHostProfileContentHandlers: createProxyIdentifier<ExtHostProfileContentHandlersShape>('ExtHostProfileContentHandlers'),
4169
>
ExtHostOutputService: createProxyIdentifier<ExtHostOutputServiceShape>('ExtHostOutputService'),
4170
>
ExtHostLabelService: createProxyIdentifier<ExtHostLabelServiceShape>('ExtHostLabelService'),
4171
>
ExtHostNotebook: createProxyIdentifier<ExtHostNotebookShape>('ExtHostNotebook'),
4172
>
ExtHostNotebookDocuments: createProxyIdentifier<ExtHostNotebookDocumentsShape>('ExtHostNotebookDocuments'),
4173
>
ExtHostNotebookEditors: createProxyIdentifier<ExtHostNotebookEditorsShape>('ExtHostNotebookEditors'),
4174
>
ExtHostNotebookKernels: createProxyIdentifier<ExtHostNotebookKernelsShape>('ExtHostNotebookKernels'),
4175
>
ExtHostNotebookRenderers: createProxyIdentifier<ExtHostNotebookRenderersShape>('ExtHostNotebookRenderers'),
4176
>
ExtHostNotebookDocumentSaveParticipant: createProxyIdentifier<ExtHostNotebookDocumentSaveParticipantShape>('ExtHostNotebookDocumentSaveParticipant'),
4177
>
ExtHostInteractive: createProxyIdentifier<ExtHostInteractiveShape>('ExtHostInteractive'),
4178
>
ExtHostChatAgents2: createProxyIdentifier<ExtHostChatAgentsShape2>('ExtHostChatAgents'),
4179
>
ExtHostLanguageModelTools: createProxyIdentifier<ExtHostLanguageModelToolsShape>('ExtHostChatSkills'),
4180
>
ExtHostChatProvider: createProxyIdentifier<ExtHostLanguageModelsShape>('ExtHostChatProvider'),
4181
>
ExtHostChatContext: createProxyIdentifier<ExtHostChatContextShape>('ExtHostChatContext'),
4182
>
ExtHostChatDebug: createProxyIdentifier<ExtHostChatDebugShape>('ExtHostChatDebug'),
4183
>
ExtHostSpeech: createProxyIdentifier<ExtHostSpeechShape>('ExtHostSpeech'),
4184
>
ExtHostEmbeddings: createProxyIdentifier<ExtHostEmbeddingsShape>('ExtHostEmbeddings'),
4185
>
ExtHostAiRelatedInformation: createProxyIdentifier<ExtHostAiRelatedInformationShape>('ExtHostAiRelatedInformation'),
4186
>
ExtHostAiEmbeddingVector: createProxyIdentifier<ExtHostAiEmbeddingVectorShape>('ExtHostAiEmbeddingVector'),
4187
>
ExtHostAiSettingsSearch: createProxyIdentifier<ExtHostAiSettingsSearchShape>('ExtHostAiSettingsSearch'),
4188
>
ExtHostTheming: createProxyIdentifier<ExtHostThemingShape>('ExtHostTheming'),
4189
>
ExtHostTunnelService: createProxyIdentifier<ExtHostTunnelServiceShape>('ExtHostTunnelService'),
4190
>
ExtHostManagedSockets: createProxyIdentifier<ExtHostManagedSocketsShape>('ExtHostManagedSockets'),
4191
>
ExtHostBrowserTunnelProxy: createProxyIdentifier<ExtHostBrowserTunnelProxyShape>('ExtHostBrowserTunnelProxy'),
4192
>
ExtHostAuthentication: createProxyIdentifier<ExtHostAuthenticationShape>('ExtHostAuthentication'),
4193
>
ExtHostTimeline: createProxyIdentifier<ExtHostTimelineShape>('ExtHostTimeline'),
4194
>
ExtHostTesting: createProxyIdentifier<ExtHostTestingShape>('ExtHostTesting'),
4195
>
ExtHostTelemetry: createProxyIdentifier<ExtHostTelemetryShape>('ExtHostTelemetry'),
4196
>
ExtHostMeteredConnection: createProxyIdentifier<ExtHostMeteredConnectionShape>('ExtHostMeteredConnection'),
4197
>
ExtHostLocalization: createProxyIdentifier<ExtHostLocalizationShape>('ExtHostLocalization'),
4198
>
ExtHostMcp: createProxyIdentifier<ExtHostMcpShape>('ExtHostMcp'),
4199
>
ExtHostDataChannels: createProxyIdentifier<ExtHostDataChannelsShape>('ExtHostDataChannels'),
4200
>
ExtHostChatSessions: createProxyIdentifier<ExtHostChatSessionsShape>('ExtHostChatSessions'),
4201
>
ExtHostChatQuota: createProxyIdentifier<ExtHostChatQuotaShape>('ExtHostChatQuota'),
4202
>
ExtHostGitExtension: createProxyIdentifier<ExtHostGitExtensionShape>('ExtHostGitExtension'),
4203
>
ExtHostBrowsers: createProxyIdentifier<ExtHostBrowsersShape>('ExtHostBrowsers'),
4204
>
};