@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

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

@@ -1,71 +0,0 @@
-import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { ConfirmedReason, IChatExtensionsContent, IChatSubagentToolInvocationData, IChatTodoListContent, IChatToolInputInvocationData, IChatToolInvocation, IChatToolInvocationSerialized, ToolConfirmKind, type IChatTerminalToolInvocationData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatService/chatService";
-import { IPreparedToolInvocation, IToolConfirmationMessages, IToolData, IToolProgressStep, IToolResult, ToolDataSource } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
-export interface IStreamingToolCallOptions {
-    toolCallId: string;
-    toolId: string;
-    toolData: IToolData;
-    subagentInvocationId?: string;
-    chatRequestId?: string;
-}
-export declare class ChatToolInvocation implements IChatToolInvocation {
-    readonly toolCallId: string;
-    readonly kind: "toolInvocation";
-    invocationMessage: string | IMarkdownString;
-    readonly originMessage: string | IMarkdownString | undefined;
-    pastTenseMessage: string | IMarkdownString | undefined;
-    confirmationMessages: IToolConfirmationMessages | undefined;
-    presentation: IPreparedToolInvocation["presentation"];
-    readonly toolId: string;
-    source: ToolDataSource;
-    readonly subAgentInvocationId: string | undefined;
-    parameters: unknown;
-    generatedTitle?: string;
-    readonly chatRequestId?: string;
-    toolSpecificData?: IChatTerminalToolInvocationData | IChatToolInputInvocationData | IChatExtensionsContent | IChatTodoListContent | IChatSubagentToolInvocationData;
-    private readonly _progress;
-    private readonly _state;
-    private readonly _partialInput;
-    private readonly _streamingMessage;
-    get state(): IObservable<IChatToolInvocation.State>;
-    /**
-     * Create a tool invocation in streaming state.
-     * Use this when the tool call is beginning to stream partial input from the LM.
-     */
-    static createStreaming(options: IStreamingToolCallOptions): ChatToolInvocation;
-    /**
-     * Create a tool invocation already in cancelled state.
-     * Use this when a hook denies tool execution before it even starts.
-     */
-    static createCancelled(options: IStreamingToolCallOptions, parameters: unknown, reason: ToolConfirmKind.Denied | ToolConfirmKind.Skipped, reasonMessage?: string | IMarkdownString): ChatToolInvocation;
-    constructor(preparedInvocation: IPreparedToolInvocation | undefined, toolData: IToolData, toolCallId: string, subAgentInvocationId: string | undefined, parameters: unknown, startOptions?: {
-        startInStreaming?: boolean;
-        startInCancelled?: boolean;
-        cancelReason?: ToolConfirmKind.Denied | ToolConfirmKind.Skipped;
-        cancelReasonMessage?: string | IMarkdownString;
-    }, chatRequestId?: string);
-    /**
-     * Update the partial input observable during streaming.
-     */
-    updatePartialInput(input: unknown): void;
-    /**
-     * Update the streaming message (from handleToolStream).
-     */
-    updateStreamingMessage(message: string | IMarkdownString): void;
-    /**
-     * Cancel a streaming invocation directly (e.g., when preToolUse hook denies).
-     * Only works when in Streaming state.
-     * @returns true if the cancellation was applied, false if not in streaming state
-     */
-    cancelFromStreaming(reason: ToolConfirmKind.Denied | ToolConfirmKind.Skipped, reasonMessage?: string | IMarkdownString): boolean;
-    /**
-     * Transition from streaming state to prepared/executing state.
-     * Called when the full tool call is ready.
-     */
-    transitionFromStreaming(preparedInvocation: IPreparedToolInvocation | undefined, parameters: unknown, autoConfirmed: ConfirmedReason | undefined): void;
-    private _setCompleted;
-    didExecuteTool(result: IToolResult | undefined, final?: boolean): IChatToolInvocation.State;
-    acceptProgress(step: IToolProgressStep): void;
-    toJSON(): IChatToolInvocationSerialized;
-}

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

@@ -1,293 +0,0 @@
-
-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 { 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';
-
-class ChatToolInvocation {
-    get state() {
-        return this._state;
-    }
-    static createStreaming(options) {
-        return ( new ChatToolInvocation(
-            undefined,
-            options.toolData,
-            options.toolCallId,
-            options.subagentInvocationId,
-            undefined,
-            {
-                startInStreaming: true
-            },
-            options.chatRequestId
-        ));
-    }
-    static createCancelled(options, parameters, reason, reasonMessage) {
-        return ( new ChatToolInvocation(
-            undefined,
-            options.toolData,
-            options.toolCallId,
-            options.subagentInvocationId,
-            parameters,
-            {
-                startInCancelled: true,
-                cancelReason: reason,
-                cancelReasonMessage: reasonMessage
-            },
-            options.chatRequestId
-        ));
-    }
-    constructor(
-        preparedInvocation,
-        toolData,
-        toolCallId,
-        subAgentInvocationId,
-        parameters,
-        startOptions = {},
-        chatRequestId
-    ) {
-        this.toolCallId = toolCallId;
-        this.kind = "toolInvocation";
-        this._progress = observableValue(this, {
-            progress: 0
-        });
-        this._partialInput = observableValue(this, undefined);
-        this._streamingMessage = observableValue(this, undefined);
-        let defaultMessage = "";
-        if (startOptions.startInStreaming) {
-            defaultMessage = ( localize(6350, "Using \"{0}\"", toolData.displayName));
-        } else if (startOptions.startInCancelled) {
-            defaultMessage = startOptions.cancelReasonMessage ?? ( localize(6351, "Tool \"{0}\" was denied", toolData.displayName));
-        }
-        this.invocationMessage = preparedInvocation?.invocationMessage ?? defaultMessage;
-        this.pastTenseMessage = preparedInvocation?.pastTenseMessage;
-        this.originMessage = preparedInvocation?.originMessage;
-        this.confirmationMessages = preparedInvocation?.confirmationMessages;
-        this.presentation = preparedInvocation?.presentation;
-        this.toolSpecificData = preparedInvocation?.toolSpecificData;
-        this.toolId = toolData.id;
-        this.source = toolData.source;
-        this.subAgentInvocationId = subAgentInvocationId;
-        this.parameters = parameters;
-        this.chatRequestId = chatRequestId;
-        if (startOptions.startInCancelled) {
-            this._state = observableValue(this, {
-                type: IChatToolInvocation.StateKind.Cancelled,
-                reason: startOptions.cancelReason ?? ToolConfirmKind.Denied,
-                reasonMessage: startOptions.cancelReasonMessage,
-                parameters: this.parameters,
-                confirmationMessages: this.confirmationMessages
-            });
-        } else if (startOptions.startInStreaming) {
-            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,
-                            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);
-    }
-    cancelFromStreaming(reason, reasonMessage) {
-        const currentState = this._state.get();
-        if (currentState.type !== IChatToolInvocation.StateKind.Streaming) {
-            return false;
-        }
-        this._state.set({
-            type: IChatToolInvocation.StateKind.Cancelled,
-            reason: reason,
-            reasonMessage: reasonMessage,
-            parameters: this.parameters,
-            confirmationMessages: this.confirmationMessages
-        }, undefined);
-        return true;
-    }
-    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,
-                parameters: this.parameters,
-                confirmationMessages: this.confirmationMessages
-            }, undefined);
-            return;
-        }
-        this._state.set({
-            type: IChatToolInvocation.StateKind.Completed,
-            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) {
-            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
-                },
-                resultDetails: result?.toolResultDetails,
-                contentForModel: result?.content || [],
-                confirm: reason => this._setCompleted(result, reason),
-                parameters: this.parameters,
-                confirmationMessages: this.confirmationMessages
-            }, undefined);
-        } else {
-            this._setCompleted(result);
-        }
-        return this._state.get();
-    }
-    acceptProgress(step) {
-        const prev = this._progress.get();
-        this._progress.set({
-            progress: step.progress || prev.progress || 0,
-            message: step.message
-        }, undefined);
-    }
-    toJSON() {
-        const waitingForPostApproval = this.state.get().type === IChatToolInvocation.StateKind.WaitingForPostApproval;
-        const details = waitingForPostApproval ? undefined : IChatToolInvocation.resultDetails(this);
-        return {
-            kind: "toolInvocationSerialized",
-            presentation: this.presentation,
-            invocationMessage: this.invocationMessage,
-            pastTenseMessage: this.pastTenseMessage,
-            originMessage: this.originMessage,
-            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,
-            toolSpecificData: this.toolSpecificData,
-            toolCallId: this.toolCallId,
-            toolId: this.toolId,
-            subAgentInvocationId: this.subAgentInvocationId,
-            generatedTitle: this.generatedTitle
-        };
-    }
-}
-
-export { ChatToolInvocation };

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/utils.d.ts

@@ -1,2 +0,0 @@
-import { ILanguageModelChatResponse } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels";
-export declare function getTextResponseFromStream(response: ILanguageModelChatResponse): Promise<string>;

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/monitoring/utils.js

@@ -1,31 +0,0 @@
-
-
-async function getTextResponseFromStream(response) {
-    let responseText = '';
-    const streaming = (async () => {
-        if (!response || !response.stream) {
-            return;
-        }
-        for await (const part of response.stream) {
-            if (Array.isArray(part)) {
-                for (const p of part) {
-                    if (p.type === 'text') {
-                        responseText += p.value;
-                    }
-                }
-            }
-            else if (part.type === 'text') {
-                responseText += part.value;
-            }
-        }
-    })();
-    try {
-        await Promise.all([response.result, streaming]);
-        return responseText;
-    }
-    catch (err) {
-        return 'Error occurred ' + err;
-    }
-}
-
-export { getTextResponseFromStream };