@codingame/monaco-vscode-chat-service-override 25.1.2 → 26.0.0

package/vscode/src/vs/workbench/contrib/chat/common/model/chatProgressTypes/chatToolInvocation.js

@@ -2,7 +2,7 @@
 import { encodeBase64 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { ToolConfirmKind, IChatToolInvocation } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { IChatToolInvocation, ToolConfirmKind } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
 import { isToolResultOutputDetails } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
 import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
 
@@ -10,13 +10,35 @@ class ChatToolInvocation {
     get state() {
         return this._state;
     }
-    constructor(preparedInvocation, toolData, toolCallId, fromSubAgent, parameters) {
+    static createStreaming(options) {
+        return ( new ChatToolInvocation(
+            undefined,
+            options.toolData,
+            options.toolCallId,
+            options.subagentInvocationId,
+            undefined,
+            true,
+            options.chatRequestId
+        ));
+    }
+    constructor(
+        preparedInvocation,
+        toolData,
+        toolCallId,
+        subAgentInvocationId,
+        parameters,
+        isStreaming = false,
+        chatRequestId
+    ) {
         this.toolCallId = toolCallId;
-        this.kind = 'toolInvocation';
-        this._progress = observableValue(this, { progress: 0 });
-        const defaultMessage = ( localize(5965, "Using {0}", `"${toolData.displayName}"`));
-        const invocationMessage = preparedInvocation?.invocationMessage ?? defaultMessage;
-        this.invocationMessage = invocationMessage;
+        this.kind = "toolInvocation";
+        this._progress = observableValue(this, {
+            progress: 0
+        });
+        this._partialInput = observableValue(this, undefined);
+        this._streamingMessage = observableValue(this, undefined);
+        const defaultStreamingMessage = isStreaming ? ( localize(6252, "Using \"{0}\"", toolData.displayName)) : "";
+        this.invocationMessage = preparedInvocation?.invocationMessage ?? defaultStreamingMessage;
         this.pastTenseMessage = preparedInvocation?.pastTenseMessage;
         this.originMessage = preparedInvocation?.originMessage;
         this.confirmationMessages = preparedInvocation?.confirmationMessages;
@@ -24,55 +46,165 @@ class ChatToolInvocation {
         this.toolSpecificData = preparedInvocation?.toolSpecificData;
         this.toolId = toolData.id;
         this.source = toolData.source;
-        this.fromSubAgent = fromSubAgent;
+        this.subAgentInvocationId = subAgentInvocationId;
         this.parameters = parameters;
-        if (!this.confirmationMessages?.title) {
-            this._state = observableValue(this, { type: IChatToolInvocation.StateKind.Executing, confirmed: { type: ToolConfirmKind.ConfirmationNotNeeded, reason: this.confirmationMessages?.confirmationNotNeededReason }, progress: this._progress });
-        }
-        else {
+        this.chatRequestId = chatRequestId;
+        if (isStreaming) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Streaming,
+                partialInput: this._partialInput,
+                streamingMessage: this._streamingMessage
+            });
+        } else if (!this.confirmationMessages?.title) {
+            this._state = observableValue(this, {
+                type: IChatToolInvocation.StateKind.Executing,
+                confirmed: {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: this.confirmationMessages?.confirmationNotNeededReason
+                },
+                progress: this._progress,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            });
+        } else {
             this._state = observableValue(this, {
                 type: IChatToolInvocation.StateKind.WaitingForConfirmation,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages,
                 confirm: reason => {
                     if (reason.type === ToolConfirmKind.Denied || reason.type === ToolConfirmKind.Skipped) {
-                        this._state.set({ type: IChatToolInvocation.StateKind.Cancelled, reason: reason.type }, undefined);
-                    }
-                    else {
-                        this._state.set({ type: IChatToolInvocation.StateKind.Executing, confirmed: reason, progress: this._progress }, undefined);
+                        this._state.set({
+                            type: IChatToolInvocation.StateKind.Cancelled,
+                            reason: reason.type,
+                            parameters: this.parameters,
+                            confirmationMessages: this.confirmationMessages
+                        }, undefined);
+                    } else {
+                        this._state.set({
+                            type: IChatToolInvocation.StateKind.Executing,
+                            confirmed: reason,
+                            progress: this._progress,
+                            parameters: this.parameters,
+                            confirmationMessages: this.confirmationMessages
+                        }, undefined);
                     }
                 }
             });
         }
     }
+    updatePartialInput(input) {
+        if (this._state.get().type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        this._partialInput.set(input, undefined);
+    }
+    updateStreamingMessage(message) {
+        const state = this._state.get();
+        if (state.type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        this._streamingMessage.set(message, undefined);
+    }
+    transitionFromStreaming(preparedInvocation, parameters, autoConfirmed) {
+        const currentState = this._state.get();
+        if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
+            return;
+        }
+        const lastStreamingMessage = this._streamingMessage.get();
+        if (lastStreamingMessage && !preparedInvocation?.invocationMessage) {
+            this.invocationMessage = lastStreamingMessage;
+        }
+        this.parameters = parameters;
+        if (preparedInvocation) {
+            if (preparedInvocation.invocationMessage) {
+                this.invocationMessage = preparedInvocation.invocationMessage;
+            }
+            this.pastTenseMessage = preparedInvocation.pastTenseMessage;
+            this.confirmationMessages = preparedInvocation.confirmationMessages;
+            this.presentation = preparedInvocation.presentation;
+            this.toolSpecificData = preparedInvocation.toolSpecificData;
+        }
+        const confirm = reason => {
+            if (reason.type === ToolConfirmKind.Denied || reason.type === ToolConfirmKind.Skipped) {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.Cancelled,
+                    reason: reason.type,
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            } else {
+                this._state.set({
+                    type: IChatToolInvocation.StateKind.Executing,
+                    confirmed: reason,
+                    progress: this._progress,
+                    parameters: this.parameters,
+                    confirmationMessages: this.confirmationMessages
+                }, undefined);
+            }
+        };
+        if (autoConfirmed) {
+            confirm(autoConfirmed);
+        } else if (!this.confirmationMessages?.title) {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.Executing,
+                confirmed: {
+                    type: ToolConfirmKind.ConfirmationNotNeeded,
+                    reason: this.confirmationMessages?.confirmationNotNeededReason
+                },
+                progress: this._progress,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            }, undefined);
+        } else {
+            this._state.set({
+                type: IChatToolInvocation.StateKind.WaitingForConfirmation,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages,
+                confirm
+            }, undefined);
+        }
+    }
     _setCompleted(result, postConfirmed) {
         if (postConfirmed && (postConfirmed.type === ToolConfirmKind.Denied || postConfirmed.type === ToolConfirmKind.Skipped)) {
-            this._state.set({ type: IChatToolInvocation.StateKind.Cancelled, reason: postConfirmed.type }, undefined);
+            this._state.set({
+                type: IChatToolInvocation.StateKind.Cancelled,
+                reason: postConfirmed.type,
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
+            }, undefined);
             return;
         }
         this._state.set({
             type: IChatToolInvocation.StateKind.Completed,
-            confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || { type: ToolConfirmKind.ConfirmationNotNeeded },
+            confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || {
+                type: ToolConfirmKind.ConfirmationNotNeeded
+            },
             resultDetails: result?.toolResultDetails,
             postConfirmed,
             contentForModel: result?.content || [],
+            parameters: this.parameters,
+            confirmationMessages: this.confirmationMessages
         }, undefined);
     }
     didExecuteTool(result, final) {
         if (result?.toolResultMessage) {
             this.pastTenseMessage = result.toolResultMessage;
-        }
-        else if (this._progress.get().message) {
+        } else if (this._progress.get().message) {
             this.pastTenseMessage = this._progress.get().message;
         }
         if (this.confirmationMessages?.confirmResults && !result?.toolResultError && result?.confirmResults !== false && !final) {
             this._state.set({
                 type: IChatToolInvocation.StateKind.WaitingForPostApproval,
-                confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || { type: ToolConfirmKind.ConfirmationNotNeeded },
+                confirmed: IChatToolInvocation.executionConfirmedOrDenied(this) || {
+                    type: ToolConfirmKind.ConfirmationNotNeeded
+                },
                 resultDetails: result?.toolResultDetails,
                 contentForModel: result?.content || [],
                 confirm: reason => this._setCompleted(result, reason),
+                parameters: this.parameters,
+                confirmationMessages: this.confirmationMessages
             }, undefined);
-        }
-        else {
+        } else {
             this._setCompleted(result);
         }
         return this._state.get();
@@ -81,29 +213,35 @@ class ChatToolInvocation {
         const prev = this._progress.get();
         this._progress.set({
             progress: step.progress || prev.progress || 0,
-            message: step.message,
+            message: step.message
         }, undefined);
     }
     toJSON() {
         const waitingForPostApproval = this.state.get().type === IChatToolInvocation.StateKind.WaitingForPostApproval;
         const details = waitingForPostApproval ? undefined : IChatToolInvocation.resultDetails(this);
         return {
-            kind: 'toolInvocationSerialized',
+            kind: "toolInvocationSerialized",
             presentation: this.presentation,
             invocationMessage: this.invocationMessage,
             pastTenseMessage: this.pastTenseMessage,
             originMessage: this.originMessage,
-            isConfirmed: waitingForPostApproval ? { type: ToolConfirmKind.Skipped } : IChatToolInvocation.executionConfirmedOrDenied(this),
+            isConfirmed: waitingForPostApproval ? {
+                type: ToolConfirmKind.Skipped
+            } : IChatToolInvocation.executionConfirmedOrDenied(this),
             isComplete: true,
             source: this.source,
-            resultDetails: isToolResultOutputDetails(details)
-                ? { output: { type: 'data', mimeType: details.output.mimeType, base64Data: encodeBase64(details.output.value) } }
-                : details,
+            resultDetails: isToolResultOutputDetails(details) ? {
+                output: {
+                    type: "data",
+                    mimeType: details.output.mimeType,
+                    base64Data: encodeBase64(details.output.value)
+                }
+            } : details,
             toolSpecificData: this.toolSpecificData,
             toolCallId: this.toolCallId,
             toolId: this.toolId,
-            fromSubAgent: this.fromSubAgent,
-            generatedTitle: this.generatedTitle,
+            subAgentInvocationId: this.subAgentInvocationId,
+            generatedTitle: this.generatedTitle
         };
     }
 }

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

@@ -0,0 +1,6 @@
+import { IChatDataSerializerLog, IChatModel, ISerializableChatData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
+import * as Adapt from "./objectMutationLog.js";
+export declare const storageSchema: Adapt.TransformObject<IChatModel, import("@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel").ISerializableChatData3>;
+export declare class ChatSessionOperationLog extends Adapt.ObjectMutationLog<IChatModel, ISerializableChatData> implements IChatDataSerializerLog {
+    constructor();
+}

package/vscode/src/vs/workbench/contrib/chat/common/model/chatSessionOperationLog.js

@@ -0,0 +1,141 @@
+
+import { assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
+import { isMarkdownString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
+import { equals } from '@codingame/monaco-vscode-api/vscode/vs/base/common/objects';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { ResponseModelState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService';
+import { ModifiedFileEntryState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService';
+import { v, object, t, array, value, key, ObjectMutationLog } from './objectMutationLog.js';
+
+const toJson = obj => {
+    const cast = obj;
+    return (cast && typeof cast.toJSON === "function" ? cast.toJSON() : obj);
+};
+const responsePartSchema = v(
+    obj => obj.kind === "markdownContent" ? obj.content : toJson(obj),
+    (a, b) => {
+        if (isMarkdownString(a) && isMarkdownString(b)) {
+            return a.value === b.value;
+        }
+        if (hasKey(a, {
+            kind: true
+        }) && hasKey(b, {
+            kind: true
+        })) {
+            if (a.kind !== b.kind) {
+                return false;
+            }
+            switch (a.kind) {
+            case "markdownContent":
+                return a.content === b.content;
+            case "toolInvocationSerialized":
+            case "elicitationSerialized":
+            case "progressTaskSerialized":
+            case "textEditGroup":
+            case "multiDiffData":
+            case "mcpServersStarting":
+                return equals(a, b);
+            case "clearToPreviousToolInvocation":
+            case "codeblockUri":
+            case "command":
+            case "confirmation":
+            case "extensions":
+            case "inlineReference":
+            case "markdownVuln":
+            case "notebookEditGroup":
+            case "progressMessage":
+            case "pullRequest":
+            case "questionCarousel":
+            case "thinking":
+            case "undoStop":
+            case "warning":
+            case "treeData":
+            case "workspaceEdit":
+                return a.kind === b.kind;
+            default:
+                {
+                    assertNever();
+                }
+            }
+        }
+        return false;
+    }
+);
+const urisEqual = (a, b) => {
+    return isEqual(( URI.from(a)), ( URI.from(b)));
+};
+const messageSchema = object({
+    text: v(m => m.text),
+    parts: v(
+        m => m.parts,
+        (a, b) => a.length === b.length && a.every((part, i) => part.text === b[i].text)
+    )
+});
+const agentEditedFileEventSchema = object({
+    uri: v(e => e.uri, urisEqual),
+    eventKind: v(e => e.eventKind)
+});
+const chatVariableSchema = object({
+    variables: t(v => v.variables, array(value((a, b) => a.name === b.name)))
+});
+const requestSchema = object({
+    requestId: t(m => m.id, key()),
+    timestamp: v(m => m.timestamp),
+    confirmation: v(m => m.confirmation),
+    message: t(m => m.message, messageSchema),
+    shouldBeRemovedOnSend: v(m => m.shouldBeRemovedOnSend, equals),
+    agent: v(m => m.response?.agent, (a, b) => a?.id === b?.id),
+    modelId: v(m => m.modelId),
+    editedFileEvents: t(m => m.editedFileEvents, array(agentEditedFileEventSchema)),
+    variableData: t(m => m.variableData, chatVariableSchema),
+    isHidden: v(() => undefined),
+    isCanceled: v(() => undefined),
+    response: t(m => m.response?.entireResponse.value, array(responsePartSchema)),
+    responseId: v(m => m.response?.id),
+    result: v(m => m.response?.result, equals),
+    responseMarkdownInfo: v(m => m.response?.codeBlockInfos?.map(info => ({
+        suggestionId: info.suggestionId
+    })), equals),
+    followups: v(m => m.response?.followups, equals),
+    modelState: v(m => m.response?.stateT, equals),
+    vote: v(m => m.response?.vote),
+    voteDownReason: v(m => m.response?.voteDownReason),
+    slashCommand: t(m => m.response?.slashCommand, value((a, b) => a?.name === b?.name)),
+    usedContext: v(m => m.response?.usedContext, equals),
+    contentReferences: v(m => m.response?.contentReferences, equals),
+    codeCitations: v(m => m.response?.codeCitations, equals),
+    timeSpentWaiting: v(m => m.response?.timestamp)
+}, {
+    sealed: o => o.modelState?.value === ResponseModelState.Cancelled || o.modelState?.value === ResponseModelState.Failed || o.modelState?.value === ResponseModelState.Complete
+});
+const inputStateSchema = object({
+    attachments: v(i => i.attachments, equals),
+    mode: v(i => i.mode, (a, b) => a.id === b.id),
+    selectedModel: v(i => i.selectedModel, (a, b) => a?.identifier === b?.identifier),
+    inputText: v(i => i.inputText),
+    selections: v(i => i.selections, equals),
+    contrib: v(i => i.contrib, equals)
+});
+const storageSchema = object({
+    version: v(() => 3),
+    creationDate: v(m => m.timestamp),
+    customTitle: v(m => m.hasCustomTitle ? m.title : undefined),
+    initialLocation: v(m => m.initialLocation),
+    inputState: t(m => m.inputModel.toJSON(), inputStateSchema),
+    responderUsername: v(m => m.responderUsername),
+    sessionId: v(m => m.sessionId),
+    requests: t(m => m.getRequests(), array(requestSchema)),
+    hasPendingEdits: v(
+        m => m.editingSession?.entries.get().some(e => e.state.get() === ModifiedFileEntryState.Modified)
+    ),
+    repoData: v(m => m.repoData, equals)
+});
+class ChatSessionOperationLog extends ObjectMutationLog {
+    constructor() {
+        super(storageSchema, 1024);
+    }
+}
+
+export { ChatSessionOperationLog, storageSchema };

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

@@ -1,5 +1,6 @@
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { IEnvironmentService } from "@codingame/monaco-vscode-api/vscode/vs/platform/environment/common/environment.service";
 import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
@@ -8,9 +9,9 @@ import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platfo
 import { IUserDataProfilesService } from "@codingame/monaco-vscode-api/vscode/vs/platform/userDataProfile/common/userDataProfile.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { ILifecycleService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
-import { ChatModel, ISerializableChatData, ISerializableChatsData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 import { IChatSessionStats, IChatSessionTiming, ResponseModelState } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
 import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ChatModel, ISerializableChatData, ISerializableChatsData, ISerializedChatDataReference } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
 export declare class ChatSessionStore extends Disposable {
     private readonly fileService;
     private readonly environmentService;
@@ -20,20 +21,21 @@ export declare class ChatSessionStore extends Disposable {
     private readonly storageService;
     private readonly lifecycleService;
     private readonly userDataProfilesService;
+    private readonly configurationService;
     private readonly storageRoot;
     private readonly previousEmptyWindowStorageRoot;
     private readonly transferredSessionStorageRoot;
     private readonly storeQueue;
     private storeTask;
     private shuttingDown;
-    constructor(fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService, workspaceContextService: IWorkspaceContextService, telemetryService: ITelemetryService, storageService: IStorageService, lifecycleService: ILifecycleService, userDataProfilesService: IUserDataProfilesService);
+    constructor(fileService: IFileService, environmentService: IEnvironmentService, logService: ILogService, workspaceContextService: IWorkspaceContextService, telemetryService: ITelemetryService, storageService: IStorageService, lifecycleService: ILifecycleService, userDataProfilesService: IUserDataProfilesService, configurationService: IConfigurationService);
     storeSessions(sessions: ChatModel[]): Promise<void>;
     storeSessionsMetadataOnly(sessions: ChatModel[]): Promise<void>;
     storeTransferSession(transferData: IChatTransfer, session: ChatModel): Promise<void>;
     private getTransferredSessionIndex;
     private static readonly TRANSFER_EXPIRATION_MS;
     getTransferredSessionData(): URI | undefined;
-    readTransferredSession(sessionResource: URI): Promise<ISerializableChatData | undefined>;
+    readTransferredSession(sessionResource: URI): Promise<ISerializedChatDataReference | undefined>;
     private cleanupTransferredSession;
     private writeSession;
     private writeSessionMetadataOnly;
@@ -55,7 +57,7 @@ export declare class ChatSessionStore extends Disposable {
     logIndex(): void;
     migrateDataIfNeeded(getInitialData: () => ISerializableChatsData | undefined): Promise<void>;
     private migrate;
-    readSession(sessionId: string): Promise<ISerializableChatData | undefined>;
+    readSession(sessionId: string): Promise<ISerializedChatDataReference | undefined>;
     private readSessionFromLocation;
     private readSessionFromPreviousLocation;
     private getStorageLocation;