@codingame/monaco-vscode-api 16.1.1 → 17.1.0

package/vscode/src/vs/workbench/contrib/accessibility/browser/accessibleViewActions.js

@@ -40,7 +40,7 @@ class AccessibleViewNextAction extends Action2 {
                 }
             ],
             icon: Codicon.arrowDown,
-            title: ( localize(4180, "Show Next in Accessible View"))
+            title: ( localize(4209, "Show Next in Accessible View"))
         });
     }
     run(accessor) {
@@ -63,7 +63,7 @@ class AccessibleViewNextCodeBlockAction extends Action2 {
                 ...accessibleViewMenu,
                 when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewContainsCodeBlocks)),
             },
-            title: ( localize(4181, "Accessible View: Next Code Block"))
+            title: ( localize(4210, "Accessible View: Next Code Block"))
         });
     }
     run(accessor) {
@@ -86,7 +86,7 @@ class AccessibleViewPreviousCodeBlockAction extends Action2 {
                 ...accessibleViewMenu,
                 when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewContainsCodeBlocks)),
             },
-            title: ( localize(4182, "Accessible View: Previous Code Block"))
+            title: ( localize(4211, "Accessible View: Previous Code Block"))
         });
     }
     run(accessor) {
@@ -111,7 +111,7 @@ class AccessibleViewPreviousAction extends Action2 {
                     when: ( ContextKeyExpr.and(accessibleViewIsShown, accessibleViewSupportsNavigation)),
                 }
             ],
-            title: ( localize(4183, "Show Previous in Accessible View"))
+            title: ( localize(4212, "Show Previous in Accessible View"))
         });
     }
     run(accessor) {
@@ -137,7 +137,7 @@ class AccessibleViewGoToSymbolAction extends Action2 {
                     when: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewGoToSymbolSupported)),
                 }
             ],
-            title: ( localize(4184, "Go To Symbol in Accessible View"))
+            title: ( localize(4213, "Go To Symbol in Accessible View"))
         });
     }
     run(accessor) {
@@ -164,7 +164,7 @@ const AccessibilityHelpAction = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(4185, "Open Accessibility Help")),
+            title: ( localize(4214, "Open Accessibility Help")),
             order: 1
         }],
 })));
@@ -182,7 +182,7 @@ const AccessibleViewAction = registerCommand(( new MultiCommand({
     menuOpts: [{
             menuId: MenuId.CommandPalette,
             group: '',
-            title: ( localize(4186, "Open Accessible View")),
+            title: ( localize(4215, "Open Accessible View")),
             order: 1
         }],
 })));
@@ -204,7 +204,7 @@ class AccessibleViewDisableHintAction extends Action2 {
                     when: ( ContextKeyExpr.and(( ContextKeyExpr.or(accessibleViewIsShown, accessibilityHelpIsShown)), accessibleViewVerbosityEnabled)),
                 }
             ],
-            title: ( localize(4187, "Disable Accessible View Hint"))
+            title: ( localize(4216, "Disable Accessible View Hint"))
         });
     }
     run(accessor) {
@@ -230,7 +230,7 @@ class AccessibilityHelpConfigureKeybindingsAction extends Action2 {
                     when: accessibleViewHasUnassignedKeybindings,
                 }
             ],
-            title: ( localize(4188, "Accessibility Help Configure Unassigned Keybindings"))
+            title: ( localize(4217, "Accessibility Help Configure Unassigned Keybindings"))
         });
     }
     async run(accessor) {
@@ -256,7 +256,7 @@ class AccessibilityHelpConfigureAssignedKeybindingsAction extends Action2 {
                     when: accessibleViewHasAssignedKeybindings,
                 }
             ],
-            title: ( localize(4189, "Accessibility Help Configure Assigned Keybindings"))
+            title: ( localize(4218, "Accessibility Help Configure Assigned Keybindings"))
         });
     }
     async run(accessor) {
@@ -273,7 +273,7 @@ class AccessibilityHelpOpenHelpLinkAction extends Action2 {
                 primary: KeyMod$1.Alt | KeyCode.KeyH,
                 weight: KeybindingWeight.WorkbenchContrib
             },
-            title: ( localize(4190, "Accessibility Help Open Help Link"))
+            title: ( localize(4219, "Accessibility Help Open Help Link"))
         });
     }
     run(accessor) {
@@ -307,7 +307,7 @@ class AccessibleViewAcceptInlineCompletionAction extends Action2 {
                     ))))
                 }
             ],
-            title: ( localize(4191, "Accept Inline Completion"))
+            title: ( localize(4220, "Accept Inline Completion"))
         });
     }
     async run(accessor) {

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

@@ -1,9 +1,9 @@
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
-import { IChatResponseViewModel } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { IChatResponseViewModel } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
 import { ChatAgentLocation } from "../common/constants.js";
-import { IChatWidget, type ICodeBlockActionContextProvider, type IQuickChatOpenOptions } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatWidget, type ICodeBlockActionContextProvider, type IQuickChatOpenOptions } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chat";
 export declare const IChatWidgetService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatWidgetService>;
 export interface IChatWidgetService {
     readonly _serviceBrand: undefined;

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

@@ -1,6 +1,6 @@
 import { IDisposable } from "../../../../../base/common/lifecycle.js";
-import { ChatTreeItem, IChatCodeBlockInfo } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chat";
-import { IChatRendererContent } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
+import { ChatTreeItem, IChatCodeBlockInfo } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/browser/chat";
+import { IChatRendererContent } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatViewModel";
 export interface IChatContentPart extends IDisposable {
     domNode: HTMLElement | undefined;
     codeblocksPartId?: string;

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

@@ -1,5 +1,5 @@
 import { IDisposable } from "../../../../../base/common/lifecycle.js";
-import { InlineAnchorWidget } from "@codingame/monaco-vscode-9a6d8b6c-ad4c-5ea3-9558-f43d6dc4c0ad-common/vscode/vs/workbench/contrib/chat/browser/chatInlineAnchorWidget";
+import { InlineAnchorWidget } from "@codingame/monaco-vscode-c465110a-57c0-59d7-a6b2-be0a4db7e517-common/vscode/vs/workbench/contrib/chat/browser/chatInlineAnchorWidget";
 export declare const IChatMarkdownAnchorService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatMarkdownAnchorService>;
 export interface IChatMarkdownAnchorService {
     readonly _serviceBrand: undefined;

package/vscode/src/vs/workbench/contrib/chat/browser/chatEditing/chatEditingEditorContextKeys.js

@@ -9,21 +9,21 @@ import { IInstantiationService } from '../../../../../platform/instantiation/com
 import { EditorResourceAccessor, SideBySideEditor } from '../../../../common/editor.js';
 import { IEditorGroupsService } from '../../../../services/editor/common/editorGroupsService.service.js';
 import { IInlineChatSessionService } from '../../../inlineChat/browser/inlineChatSessionService.service.js';
-import { WorkingSetEntryState } from '../../common/chatEditingService.js';
+import { ModifiedFileEntryState } from '../../common/chatEditingService.js';
 import { IChatEditingService } from '../../common/chatEditingService.service.js';
 import { IChatService } from '../../common/chatService.service.js';
 import { observableFromEvent, constObservable } from '../../../../../base/common/observableInternal/utils.js';
-import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
 import { derived } from '../../../../../base/common/observableInternal/derived.js';
+import { autorun } from '../../../../../base/common/observableInternal/autorun.js';
 
-const ctxIsGlobalEditingSession = ( new RawContextKey('chatEdits.isGlobalEditingSession', undefined, ( localize(4670, "The current editor is part of the global edit session"))));
-const ctxHasEditorModification = ( new RawContextKey('chatEdits.hasEditorModifications', undefined, ( localize(4671, "The current editor contains chat modifications"))));
-const ctxReviewModeEnabled = ( new RawContextKey('chatEdits.isReviewModeEnabled', true, ( localize(4672, "Review mode for chat changes is enabled"))));
+const ctxIsGlobalEditingSession = ( new RawContextKey('chatEdits.isGlobalEditingSession', undefined, ( localize(4734, "The current editor is part of the global edit session"))));
+const ctxHasEditorModification = ( new RawContextKey('chatEdits.hasEditorModifications', undefined, ( localize(4735, "The current editor contains chat modifications"))));
+const ctxReviewModeEnabled = ( new RawContextKey('chatEdits.isReviewModeEnabled', true, ( localize(4736, "Review mode for chat changes is enabled"))));
 const ctxHasRequestInProgress = ( new RawContextKey('chatEdits.isRequestInProgress', false, ( localize(
-    4673,
+    4737,
     "The current editor shows a file from an edit session which is still in progress"
 ))));
-const ctxRequestCount = ( new RawContextKey('chatEdits.requestCount', 0, ( localize(4674, "The number of turns the editing session in this editor has"))));
+const ctxRequestCount = ( new RawContextKey('chatEdits.requestCount', 0, ( localize(4738, "The number of turns the editing session in this editor has"))));
 let ChatEditingEditorContextKeys = class ChatEditingEditorContextKeys {
     static { this.ID = 'chat.edits.editorContextKeys'; }
     constructor(instaService, editorGroupsService) {
@@ -73,17 +73,18 @@ let ContextKeyGroup = class ContextKeyGroup {
                 this._reset();
                 return;
             }
-            const { session, entry, isInlineChat } = tuple;
+            const { session, entry } = tuple;
             const chatModel = chatService.getSession(session.chatSessionId);
-            const isRequestInProgress = chatModel
-                ? observableFromEvent(this, chatModel.onDidChange, () => chatModel.requestInProgress)
+            const lastResponse = chatModel
+                ? observableFromEvent(this, chatModel.onDidChange, () => chatModel.getRequests().at(-1)?.response).read(r)
+                : undefined;
+            const isRequestInProgress = lastResponse
+                ? observableFromEvent(this, lastResponse.onDidChange, () => !lastResponse.isPendingConfirmation && !lastResponse.isComplete)
                 : constObservable(false);
-            this._ctxHasEditorModification.set(isInlineChat || entry?.state.read(r) === WorkingSetEntryState.Modified);
+            this._ctxHasEditorModification.set(entry?.state.read(r) === ModifiedFileEntryState.Modified);
             this._ctxIsGlobalEditingSession.set(session.isGlobalEditingSession);
             this._ctxReviewModeEnabled.set(entry ? entry.reviewMode.read(r) : false);
-            this._ctxHasRequestInProgress.set(Boolean(entry?.isCurrentlyBeingModifiedBy.read(r))
-                || (isInlineChat && isRequestInProgress.read(r))
-            );
+            this._ctxHasRequestInProgress.set(isRequestInProgress.read(r));
             const requestCount = chatModel
                 ? observableFromEvent(this, chatModel.onDidChange, () => chatModel.getRequests().length)
                 : constObservable(0);

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

@@ -0,0 +1,245 @@
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+import { Event } from "../../../../base/common/event.js";
+import { IMarkdownString } from "../../../../base/common/htmlContent.js";
+import { Disposable, IDisposable } from "../../../../base/common/lifecycle.js";
+import { ThemeIcon } from "../../../../base/common/themables.js";
+import { URI } from "../../../../base/common/uri.js";
+import { Command, ProviderResult } from "../../../../editor/common/languages.js";
+import { IContextKeyService } from "../../../../platform/contextkey/common/contextkey.service.js";
+import { ExtensionIdentifier } from "../../../../platform/extensions/common/extensions.js";
+import { ILogService } from "../../../../platform/log/common/log.service.js";
+import { IProductService } from "../../../../platform/product/common/productService.service.js";
+import { IRequestService } from "../../../../platform/request/common/request.service.js";
+import { IStorageService } from "../../../../platform/storage/common/storage.service.js";
+import { IChatAgentService, type IChatAgentNameService } from "./chatAgents.service.js";
+import { IChatAgentEditedFileEvent, IChatProgressHistoryResponseContent, IChatRequestVariableData, ISerializableChatAgentData } from "./chatModel.js";
+import { IRawChatCommandContribution } from "@codingame/monaco-vscode-fab30422-b487-5f4e-8d30-8b4d266e3fcd-common/vscode/vs/workbench/contrib/chat/common/chatParticipantContribTypes";
+import { IChatFollowup, IChatLocationData, IChatProgress, IChatResponseErrorDetails, IChatTaskDto } from "./chatService.js";
+import { ChatAgentLocation, ChatMode } from "./constants.js";
+export interface IChatAgentHistoryEntry {
+    request: IChatAgentRequest;
+    response: ReadonlyArray<IChatProgressHistoryResponseContent | IChatTaskDto>;
+    result: IChatAgentResult;
+}
+export interface IChatAgentData {
+    id: string;
+    name: string;
+    fullName?: string;
+    description?: string;
+    when?: string;
+    extensionId: ExtensionIdentifier;
+    extensionPublisherId: string;
+    publisherDisplayName?: string;
+    extensionDisplayName: string;
+    isDefault?: boolean;
+    isDynamic?: boolean;
+    isCore?: boolean;
+    metadata: IChatAgentMetadata;
+    slashCommands: IChatAgentCommand[];
+    locations: ChatAgentLocation[];
+    modes: ChatMode[];
+    disambiguation: {
+        category: string;
+        description: string;
+        examples: string[];
+    }[];
+}
+export interface IChatWelcomeMessageContent {
+    icon: ThemeIcon;
+    title: string;
+    message: IMarkdownString;
+}
+export interface IChatAgentImplementation {
+    invoke(request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
+    setRequestPaused?(requestId: string, isPaused: boolean): void;
+    provideFollowups?(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
+    provideChatTitle?: (history: IChatAgentHistoryEntry[], token: CancellationToken) => Promise<string | undefined>;
+    provideSampleQuestions?(location: ChatAgentLocation, token: CancellationToken): ProviderResult<IChatFollowup[] | undefined>;
+}
+export interface IChatParticipantDetectionResult {
+    participant: string;
+    command?: string;
+}
+export interface IChatParticipantMetadata {
+    participant: string;
+    command?: string;
+    disambiguation: {
+        category: string;
+        description: string;
+        examples: string[];
+    }[];
+}
+export interface IChatParticipantDetectionProvider {
+    provideParticipantDetection(request: IChatAgentRequest, history: IChatAgentHistoryEntry[], options: {
+        location: ChatAgentLocation;
+        participants: IChatParticipantMetadata[];
+    }, token: CancellationToken): Promise<IChatParticipantDetectionResult | null | undefined>;
+}
+export type IChatAgent = IChatAgentData & IChatAgentImplementation;
+export interface IChatAgentCommand extends IRawChatCommandContribution {
+    followupPlaceholder?: string;
+}
+export interface IChatRequesterInformation {
+    name: string;
+    icon?: URI;
+}
+export interface IChatAgentMetadata {
+    helpTextPrefix?: string | IMarkdownString;
+    helpTextVariablesPrefix?: string | IMarkdownString;
+    helpTextPostfix?: string | IMarkdownString;
+    icon?: URI;
+    iconDark?: URI;
+    themeIcon?: ThemeIcon;
+    sampleRequest?: string;
+    supportIssueReporting?: boolean;
+    followupPlaceholder?: string;
+    isSticky?: boolean;
+    requester?: IChatRequesterInformation;
+    additionalWelcomeMessage?: string | IMarkdownString;
+}
+export interface IChatAgentRequest {
+    sessionId: string;
+    requestId: string;
+    agentId: string;
+    command?: string;
+    message: string;
+    attempt?: number;
+    enableCommandDetection?: boolean;
+    isParticipantDetected?: boolean;
+    variables: IChatRequestVariableData;
+    location: ChatAgentLocation;
+    locationData?: IChatLocationData;
+    acceptedConfirmationData?: any[];
+    rejectedConfirmationData?: any[];
+    userSelectedModelId?: string;
+    userSelectedTools?: string[];
+    userSelectedTools2?: Record<string, boolean>;
+    toolSelectionIsExclusive?: boolean;
+    editedFileEvents?: IChatAgentEditedFileEvent[];
+}
+export interface IChatQuestion {
+    readonly prompt: string;
+    readonly participant?: string;
+    readonly command?: string;
+}
+export interface IChatAgentResultTimings {
+    firstProgress?: number;
+    totalElapsed: number;
+}
+export interface IChatAgentResult {
+    errorDetails?: IChatResponseErrorDetails;
+    timings?: IChatAgentResultTimings;
+    readonly metadata?: {
+        readonly [key: string]: any;
+    };
+    nextQuestion?: IChatQuestion;
+}
+export interface IChatAgentCompletionItem {
+    id: string;
+    name?: string;
+    fullName?: string;
+    icon?: ThemeIcon;
+    value: unknown;
+    command?: Command;
+}
+export declare class ChatAgentService extends Disposable implements IChatAgentService {
+    private readonly contextKeyService;
+    static readonly AGENT_LEADER = "@";
+    _serviceBrand: undefined;
+    private _agents;
+    private readonly _onDidChangeAgents;
+    readonly onDidChangeAgents: Event<IChatAgent | undefined>;
+    private readonly _agentsContextKeys;
+    private readonly _hasDefaultAgent;
+    private readonly _extensionAgentRegistered;
+    private readonly _defaultAgentRegistered;
+    private readonly _editingAgentRegistered;
+    private _hasToolsAgent;
+    private _chatParticipantDetectionProviders;
+    constructor(contextKeyService: IContextKeyService);
+    registerAgent(id: string, data: IChatAgentData): IDisposable;
+    private _updateAgentsContextKeys;
+    private _updateContextKeys;
+    registerAgentImplementation(id: string, agentImpl: IChatAgentImplementation): IDisposable;
+    registerDynamicAgent(data: IChatAgentData, agentImpl: IChatAgentImplementation): IDisposable;
+    private _agentCompletionProviders;
+    registerAgentCompletionProvider(id: string, provider: (query: string, token: CancellationToken) => Promise<IChatAgentCompletionItem[]>): {
+        dispose: () => void;
+    };
+    getAgentCompletionItems(id: string, query: string, token: CancellationToken): Promise<IChatAgentCompletionItem[]>;
+    updateAgent(id: string, updateMetadata: IChatAgentMetadata): void;
+    getDefaultAgent(location: ChatAgentLocation, mode?: ChatMode): IChatAgent | undefined;
+    get hasToolsAgent(): boolean;
+    getContributedDefaultAgent(location: ChatAgentLocation): IChatAgentData | undefined;
+    private _preferExtensionAgent;
+    getAgent(id: string, includeDisabled?: boolean): IChatAgentData | undefined;
+    private _agentIsEnabled;
+    getAgentByFullyQualifiedId(id: string): IChatAgentData | undefined;
+    getAgents(): IChatAgentData[];
+    getActivatedAgents(): IChatAgent[];
+    getAgentsByName(name: string): IChatAgentData[];
+    private _preferExtensionAgents;
+    agentHasDupeName(id: string): boolean;
+    invokeAgent(id: string, request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
+    setRequestPaused(id: string, requestId: string, isPaused: boolean): void;
+    getFollowups(id: string, request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
+    getChatTitle(id: string, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<string | undefined>;
+    registerChatParticipantDetectionProvider(handle: number, provider: IChatParticipantDetectionProvider): IDisposable;
+    hasChatParticipantDetectionProviders(): boolean;
+    detectAgentOrCommand(request: IChatAgentRequest, history: IChatAgentHistoryEntry[], options: {
+        location: ChatAgentLocation;
+    }, token: CancellationToken): Promise<{
+        agent: IChatAgentData;
+        command?: IChatAgentCommand;
+    } | undefined>;
+}
+export declare class MergedChatAgent implements IChatAgent {
+    private readonly data;
+    private readonly impl;
+    constructor(data: IChatAgentData, impl: IChatAgentImplementation);
+    when?: string | undefined;
+    publisherDisplayName?: string | undefined;
+    isDynamic?: boolean | undefined;
+    get id(): string;
+    get name(): string;
+    get fullName(): string;
+    get description(): string;
+    get extensionId(): ExtensionIdentifier;
+    get extensionPublisherId(): string;
+    get extensionPublisherDisplayName(): string | undefined;
+    get extensionDisplayName(): string;
+    get isDefault(): boolean | undefined;
+    get isCore(): boolean | undefined;
+    get metadata(): IChatAgentMetadata;
+    get slashCommands(): IChatAgentCommand[];
+    get locations(): ChatAgentLocation[];
+    get modes(): ChatMode[];
+    get disambiguation(): {
+        category: string;
+        description: string;
+        examples: string[];
+    }[];
+    invoke(request: IChatAgentRequest, progress: (part: IChatProgress) => void, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatAgentResult>;
+    setRequestPaused(requestId: string, isPaused: boolean): void;
+    provideFollowups(request: IChatAgentRequest, result: IChatAgentResult, history: IChatAgentHistoryEntry[], token: CancellationToken): Promise<IChatFollowup[]>;
+    provideSampleQuestions(location: ChatAgentLocation, token: CancellationToken): ProviderResult<IChatFollowup[] | undefined>;
+    toJSON(): IChatAgentData;
+}
+export declare class ChatAgentNameService implements IChatAgentNameService {
+    private readonly requestService;
+    private readonly logService;
+    private readonly storageService;
+    private static readonly StorageKey;
+    _serviceBrand: undefined;
+    private readonly url;
+    private registry;
+    private disposed;
+    constructor(productService: IProductService, requestService: IRequestService, logService: ILogService, storageService: IStorageService);
+    private refresh;
+    private update;
+    getAgentNameRestriction(chatAgentData: IChatAgentData): boolean;
+    private checkAgentNameRestriction;
+    dispose(): void;
+}
+export declare function getFullyQualifiedId(chatAgentData: IChatAgentData): string;
+export declare function reviveSerializedAgent(raw: ISerializableChatAgentData): IChatAgentData;