@codingame/monaco-vscode-chat-service-override 21.6.0 → 22.0.0

package/vscode/src/vs/workbench/contrib/terminalContrib/chatAgentTools/browser/tools/task/taskHelpers.js

@@ -14,21 +14,29 @@ function toolResultDetailsFromResponse(terminalResults) {
         return [key, item];
     }) ?? []))).values()));
 }
-function toolResultMessageFromResponse(result, taskLabel, toolResultDetails, terminalResults) {
+function toolResultMessageFromResponse(result, taskLabel, toolResultDetails, terminalResults, getOutputTool) {
     let resultSummary = '';
     if (result?.exitCode) {
-        resultSummary = ( localize(11509, 'Task `{0}` failed with exit code {1}.', taskLabel, result.exitCode));
+        resultSummary = ( localize(11612, 'Task `{0}` failed with exit code {1}.', taskLabel, result.exitCode));
     }
     else {
         resultSummary += `\`${taskLabel}\` task `;
         const problemCount = toolResultDetails.length;
-        resultSummary += terminalResults.every(r => r.state === OutputMonitorState.Idle)
-            ? (problemCount
-                ? `finished with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
-                : 'finished')
-            : (problemCount
-                ? `started and will continue to run in the background with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
-                : 'started and will continue to run in the background');
+        if (getOutputTool) {
+            return problemCount ? ( new MarkdownString(
+                `Got output for ${resultSummary} with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
+            )) : ( new MarkdownString(`Got output for ${resultSummary}`));
+        }
+        else {
+            const problemCount = toolResultDetails.length;
+            resultSummary += terminalResults.every(r => r.state === OutputMonitorState.Idle)
+                ? (problemCount
+                    ? `finished with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
+                    : 'finished')
+                : (problemCount
+                    ? `started and will continue to run in the background with \`${problemCount}\` problem${problemCount === 1 ? '' : 's'}`
+                    : 'started and will continue to run in the background');
+        }
     }
     return ( new MarkdownString(resultSummary));
 }

package/vscode/src/vs/base/common/decorators/cancelPreviousCalls.d.ts

@@ -1,84 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-/**
- * Helper type that represents a function that has an optional {@linkcode CancellationToken}
- * argument argument at the end of the arguments list.
- *
- * @typeparam `TFunction` - Type of the function arguments list of which will be extended
- * 							with an optional {@linkcode CancellationToken} argument.
- */
-type TWithOptionalCancellationToken<TFunction extends Function> = TFunction extends (...args: infer TArgs) => infer TReturn ? (...args: [
-    ...TArgs,
-    cancellatioNToken?: CancellationToken
-]) => TReturn : never;
-/**
- * Decorator that provides a mechanism to cancel previous calls of the decorated method
- * by providing a `cancellation token` as the last argument of the method, which gets
- * cancelled immediately on subsequent call of the decorated method.
- *
- * Therefore to use this decorator, the two conditions must be met:
- *
- * - the decorated method must have an *optional* {@linkcode CancellationToken} argument at
- * 	 the end of the arguments list
- * - the object that the decorated method belongs to must implement the {@linkcode Disposable};
- *   this requirement comes from the internal implementation of the decorator that
- *   creates new resources that need to be eventually disposed by someone
- *
- * @typeparam `TObject` - Object type that the decorated method belongs to.
- * @typeparam `TArgs` - Argument list of the decorated method.
- * @typeparam `TReturn` - Return value type of the decorated method.
- *
- * ### Examples
- *
- * ```typescript
- * // let's say we have a class that implements the `Disposable` interface that we want
- * // to use the decorator on
- * class Example extends Disposable {
- * 		async doSomethingAsync(arg1: number, arg2: string): Promise<void> {
- * 			// do something async..
- * 			await new Promise(resolve => setTimeout(resolve, 1000));
- * 		}
- * }
- * ```
- *
- * ```typescript
- * // to do that we need to add the `CancellationToken` argument to the end of args list
- * class Example extends Disposable {
- * 		@cancelPreviousCalls
- * 		async doSomethingAsync(arg1: number, arg2: string, cancellationToken?: CancellationToken): Promise<void> {
- * 			console.log(`call with args ${arg1} and ${arg2} initiated`);
- *
- * 			// the decorator will create the cancellation token automatically
- * 			assertDefined(
- * 				cancellationToken,
- * 				`The method must now have the `CancellationToken` passed to it.`,
- * 			);
- *
- * 			cancellationToken.onCancellationRequested(() => {
- * 				console.log(`call with args ${arg1} and ${arg2} was cancelled`);
- * 			});
- *
- * 			// do something async..
- * 			await new Promise(resolve => setTimeout(resolve, 1000));
- *
- * 			// check cancellation token state after the async operations
- * 			console.log(
- * 				`call with args ${arg1} and ${arg2} completed, canceled?: ${cancellationToken.isCancellationRequested}`,
- * 			);
- * 		}
- * }
- *
- * const example = new Example();
- * // call the decorate method first time
- * example.doSomethingAsync(1, 'foo');
- * // wait for 500ms which is less than 1000ms of the async operation in the first call
- * await new Promise(resolve => setTimeout(resolve, 500));
- * // calling the decorate method second time cancels the token passed to the first call
- * example.doSomethingAsync(2, 'bar');
- * ```
- */
-export declare function cancelPreviousCalls<TObject extends Disposable, TArgs extends unknown[], TReturn extends unknown>(_proto: TObject, methodName: string, descriptor: TypedPropertyDescriptor<TWithOptionalCancellationToken<(...args: TArgs) => TReturn>>): TypedPropertyDescriptor<(...args: [
-    ...TArgs,
-    cancellatioNToken?: CancellationToken | undefined
-]) => TReturn>;
-export {};

package/vscode/src/vs/base/common/decorators/cancelPreviousCalls.js

@@ -1,42 +0,0 @@
-
-import { assertDefined } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-import { DisposableMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import { CancellationToken, CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-
-function cancelPreviousCalls(_proto, methodName, descriptor) {
-    const originalMethod = descriptor.value;
-    assertDefined(originalMethod, `Method '${methodName}' is not defined.`);
-    const objectRecords = ( new WeakMap());
-    descriptor.value = function (...args) {
-        let record = objectRecords.get(this);
-        if (!record) {
-            record = ( new DisposableMap());
-            objectRecords.set(this, record);
-            this._register({
-                dispose: () => {
-                    objectRecords.get(this)?.dispose();
-                    objectRecords.delete(this);
-                },
-            });
-        }
-        record.get(methodName)?.dispose(true);
-        const lastArgument = (args.length > 0)
-            ? args[args.length - 1]
-            : undefined;
-        const token = CancellationToken.isCancellationToken(lastArgument)
-            ? lastArgument
-            : undefined;
-        const cancellationSource = ( new CancellationTokenSource(token));
-        record.set(methodName, cancellationSource);
-        if (CancellationToken.isCancellationToken(lastArgument)) {
-            args[args.length - 1] = cancellationSource.token;
-        }
-        else {
-            args.push(cancellationSource.token);
-        }
-        return originalMethod.call(this, ...args);
-    };
-    return descriptor;
-}
-
-export { cancelPreviousCalls };

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

@@ -1,94 +0,0 @@
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-/**
- * Base prompt parsing error class.
- */
-declare abstract class ParseError extends Error {
-    /**
-     * Error type name.
-     */
-    abstract readonly errorType: string;
-    constructor(message?: string, options?: ErrorOptions);
-    /**
-     * Check if provided object is of the same type as this error.
-     */
-    sameTypeAs(other: unknown): other is typeof this;
-    /**
-     * Check if provided object is equal to this error.
-     */
-    equal(other: unknown): boolean;
-}
-/**
- * Base resolve error class used when file reference resolution fails.
- */
-export declare abstract class ResolveError extends ParseError {
-    readonly uri: URI;
-    abstract errorType: string;
-    constructor(uri: URI, message?: string, options?: ErrorOptions);
-}
-/**
- * A generic error for failing to resolve prompt contents stream.
- */
-export declare class FailedToResolveContentsStream extends ResolveError {
-    readonly originalError: unknown;
-    errorType: string;
-    constructor(uri: URI, originalError: unknown, message?: string);
-}
-/**
- * Error that reflects the case when attempt to open target file fails.
- */
-export declare class OpenFailed extends FailedToResolveContentsStream {
-    errorType: string;
-    constructor(uri: URI, originalError: unknown);
-}
-/**
- * Error that reflects the case when attempt resolve nested file
- * references failes due to a recursive reference, e.g.,
- *
- * ```markdown
- * // a.md
- * #file:b.md
- * ```
- *
- * ```markdown
- * // b.md
- * #file:a.md
- * ```
- */
-export declare class RecursiveReference extends ResolveError {
-    readonly recursivePath: readonly string[];
-    errorType: string;
-    /**
-     * Cached default string representation of the recursive path.
-     */
-    private defaultPathStringCache;
-    constructor(uri: URI, recursivePath: readonly string[]);
-    get message(): string;
-    /**
-     * Returns a string representation of the recursive path.
-     */
-    getRecursivePathString(filename: "basename" | "fullpath", pathJoinCharacter?: string): string;
-    /**
-     * Check if provided object is of the same type as this
-     * error, contains the same recursive path and URI.
-     */
-    equal(other: unknown): other is this;
-    /**
-     * Returns a string representation of the error object.
-     */
-    toString(): string;
-}
-/**
- * Error for the case when a resource URI doesn't point to a prompt file.
- */
-export declare class NotPromptFile extends ResolveError {
-    errorType: string;
-    constructor(uri: URI, message?: string);
-}
-/**
- * Error for the case when a resource URI points to a folder.
- */
-export declare class FolderReference extends NotPromptFile {
-    errorType: string;
-    constructor(uri: URI, message?: string);
-}
-export {};

package/vscode/src/vs/workbench/contrib/chat/common/promptFileReferenceErrors.js

@@ -1,107 +0,0 @@
-
-import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/path';
-import { assert, assertNever } from '@codingame/monaco-vscode-api/vscode/vs/base/common/assert';
-
-class ParseError extends Error {
-    constructor(message, options) {
-        super(message, options);
-    }
-    sameTypeAs(other) {
-        if (other === null || other === undefined) {
-            return false;
-        }
-        return other instanceof this.constructor;
-    }
-    equal(other) {
-        return this.sameTypeAs(other);
-    }
-}
-class ResolveError extends ParseError {
-    constructor(uri, message, options) {
-        super(message, options);
-        this.uri = uri;
-    }
-}
-class FailedToResolveContentsStream extends ResolveError {
-    constructor(uri, originalError, message = `Failed to resolve prompt contents stream for '${( uri.toString())}': ${originalError}.`) {
-        super(uri, message);
-        this.originalError = originalError;
-        this.errorType = 'FailedToResolveContentsStream';
-    }
-}
-class OpenFailed extends FailedToResolveContentsStream {
-    constructor(uri, originalError) {
-        super(uri, originalError, `Failed to open '${uri.fsPath}': ${originalError}.`);
-        this.errorType = 'OpenError';
-    }
-}
-const DEFAULT_RECURSIVE_PATH_JOIN_CHAR = ' -> ';
-class RecursiveReference extends ResolveError {
-    constructor(uri, recursivePath) {
-        assert(recursivePath.length >= 2, `Recursive path must contain at least two paths, got '${recursivePath.length}'.`);
-        super(uri, 'Recursive references found.');
-        this.recursivePath = recursivePath;
-        this.errorType = 'RecursiveReferenceError';
-    }
-    get message() {
-        return `${super.message} ${this.getRecursivePathString('fullpath')}`;
-    }
-    getRecursivePathString(filename, pathJoinCharacter = DEFAULT_RECURSIVE_PATH_JOIN_CHAR) {
-        const isDefault = (filename === 'fullpath') &&
-            (pathJoinCharacter === DEFAULT_RECURSIVE_PATH_JOIN_CHAR);
-        if (isDefault && (this.defaultPathStringCache !== undefined)) {
-            return this.defaultPathStringCache;
-        }
-        const result = ( this.recursivePath
-            .map((path) => {
-            if (filename === 'fullpath') {
-                return `'${path}'`;
-            }
-            if (filename === 'basename') {
-                return `'${basename(path)}'`;
-            }
-            assertNever(filename, `Unknown filename format '${filename}'.`);
-        }))
-            .join(pathJoinCharacter);
-        if (isDefault) {
-            this.defaultPathStringCache = result;
-        }
-        return result;
-    }
-    equal(other) {
-        if (!this.sameTypeAs(other)) {
-            return false;
-        }
-        if (( this.uri.toString()) !== ( other.uri.toString())) {
-            return false;
-        }
-        if (this.recursivePath.length !== other.recursivePath.length) {
-            return false;
-        }
-        const myRecursivePath = this.getRecursivePathString('fullpath');
-        const theirRecursivePath = other.getRecursivePathString('fullpath');
-        if (myRecursivePath.length !== theirRecursivePath.length) {
-            return false;
-        }
-        return myRecursivePath === theirRecursivePath;
-    }
-    toString() {
-        return `"${this.message}"(${this.uri})`;
-    }
-}
-class NotPromptFile extends ResolveError {
-    constructor(uri, message = '') {
-        const suffix = message ? `: ${message}` : '';
-        super(uri, `Resource at ${uri.path} is not a prompt file${suffix}`);
-        this.errorType = 'NotPromptFileError';
-    }
-}
-class FolderReference extends NotPromptFile {
-    constructor(uri, message = '') {
-        const suffix = message ? `: ${message}` : '';
-        super(uri, `Entity at '${uri.path}' is a folder${suffix}`);
-        this.errorType = 'FolderReferenceError';
-    }
-}
-
-export { FailedToResolveContentsStream, FolderReference, NotPromptFile, OpenFailed, RecursiveReference, ResolveError };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/asyncDecoder.d.ts

@@ -1,27 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { BaseDecoder } from "./baseDecoder.js";
-/**
- * Asynchronous iterator wrapper for a decoder.
- */
-export declare class AsyncDecoder<T extends NonNullable<unknown>, K extends NonNullable<unknown> = NonNullable<unknown>> extends Disposable {
-    private readonly decoder;
-    private readonly messages;
-    /**
-     * A transient promise that is resolved when a new event
-     * is received. Used in the situation when there is no new
-     * data available and decoder stream did not finish yet,
-     * hence we need to wait until new event is received.
-     */
-    private resolveOnNewEvent?;
-    /**
-     * @param decoder The decoder instance to wrap.
-     *
-     * Note! Assumes ownership of the `decoder` object, hence will `dispose`
-     * 		 it when the decoder stream is ended.
-     */
-    constructor(decoder: BaseDecoder<T, K>);
-    /**
-     * Async iterator implementation.
-     */
-    [Symbol.asyncIterator](): AsyncIterator<T | null>;
-}

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/asyncDecoder.js

@@ -1,45 +0,0 @@
-
-import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-
-class AsyncDecoder extends Disposable {
-    constructor(decoder) {
-        super();
-        this.decoder = decoder;
-        this.messages = [];
-        this._register(decoder);
-    }
-    async *[Symbol.asyncIterator]() {
-        const callback = (data) => {
-            if (data !== undefined) {
-                this.messages.push(data);
-            }
-            else {
-                this.decoder.removeListener('data', callback);
-                this.decoder.removeListener('end', callback);
-            }
-            if (this.resolveOnNewEvent) {
-                this.resolveOnNewEvent();
-                delete this.resolveOnNewEvent;
-            }
-        };
-        this.decoder.on('end', callback);
-        this.decoder.on('data', callback);
-        this.decoder.start();
-        while (true) {
-            const maybeMessage = this.messages.shift();
-            if (maybeMessage !== undefined) {
-                yield maybeMessage;
-                continue;
-            }
-            if (this.decoder.ended) {
-                this.dispose();
-                return null;
-            }
-            await ( new Promise((resolve) => {
-                this.resolveOnNewEvent = resolve;
-            }));
-        }
-    }
-}
-
-export { AsyncDecoder };

package/vscode/src/vs/workbench/contrib/chat/common/promptSyntax/codecs/base/baseDecoder.d.ts

@@ -1,137 +0,0 @@
-import { Emitter } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { ReadableStream } from "@codingame/monaco-vscode-api/vscode/vs/base/common/stream";
-import { ObservableDisposable } from "../../utils/observableDisposable.js";
-/**
- * Event names of {@link ReadableStream} stream.
- */
-export type TStreamListenerNames = "data" | "error" | "end";
-/**
- * Base decoder class that can be used to convert stream messages data type
- * from one type to another. For instance, a stream of binary data can be
- * "decoded" into a stream of well defined objects.
- * Intended to be a part of "codec" implementation rather than used directly.
- */
-export declare abstract class BaseDecoder<T extends NonNullable<unknown>, K extends NonNullable<unknown> = NonNullable<unknown>> extends ObservableDisposable implements ReadableStream<T> {
-    protected readonly stream: ReadableStream<K>;
-    /**
-     * Private attribute to track if the stream has ended.
-     */
-    private _ended;
-    protected readonly _onData: Emitter<T>;
-    private readonly _onEnd;
-    private readonly _onError;
-    /**
-     * A store of currently registered event listeners.
-     */
-    private readonly _listeners;
-    /**
-     * This method is called when a new incoming data
-     * is received from the input stream.
-     */
-    protected abstract onStreamData(data: K): void;
-    /**
-     * @param stream The input stream to decode.
-     */
-    constructor(stream: ReadableStream<K>);
-    /**
-     * Private attribute to track if the stream has started.
-     */
-    private started;
-    /**
-     * Promise that resolves when the stream has ended, either by
-     * receiving the `end` event or by a disposal, but not when
-     * the `error` event is received alone.
-     * The promise is true if the stream has ended, and false
-     * if the stream has been disposed without ending.
-     */
-    private settledPromise;
-    /**
-     * Promise that resolves when the stream has ended, either by
-     * receiving the `end` event or by a disposal, but not when
-     * the `error` event is received alone.
-     * The promise is true if the stream has ended, and false
-     * if the stream has been disposed without ending.
-     *
-     * @throws If the stream was not yet started to prevent this
-     * 		   promise to block the consumer calls indefinitely.
-     */
-    get settled(): Promise<boolean>;
-    /**
-     * Start receiving data from the stream.
-     * @throws if the decoder stream has already ended.
-     */
-    start(): this;
-    /**
-     * Check if the decoder has been ended hence has
-     * no more data to produce.
-     */
-    get ended(): boolean;
-    /**
-     * Automatically catch and dispatch errors thrown inside `onStreamData`.
-     */
-    private tryOnStreamData;
-    on(event: "data", callback: (data: T) => void): void;
-    on(event: "error", callback: (err: Error) => void): void;
-    on(event: "end", callback: () => void): void;
-    /**
-     * Add listener for the `data` event.
-     * @throws if the decoder stream has already ended.
-     */
-    onData(callback: (data: T) => void): void;
-    /**
-     * Add listener for the `error` event.
-     * @throws if the decoder stream has already ended.
-     */
-    onError(callback: (error: Error) => void): void;
-    /**
-     * Add listener for the `end` event.
-     * @throws if the decoder stream has already ended.
-     */
-    onEnd(callback: () => void): void;
-    /**
-     * Pauses the stream.
-     */
-    pause(): void;
-    /**
-     * Resumes the stream if it has been paused.
-     * @throws if the decoder stream has already ended.
-     */
-    resume(): void;
-    /**
-     * Destroys(disposes) the stream.
-     */
-    destroy(): void;
-    /**
-     * Removes a previously-registered event listener for a specified event.
-     *
-     * Note!
-     *  - the callback function must be the same as the one that was used when
-     * 	  registering the event listener as it is used as an identifier to
-     *    remove the listener
-     *  - this method is idempotent and results in no-op if the listener is
-     *    not found, therefore passing incorrect `callback` function may
-     *    result in silent unexpected behavior
-     */
-    removeListener(eventName: TStreamListenerNames, callback: Function): void;
-    /**
-     * This method is called when the input stream ends.
-     */
-    protected onStreamEnd(): void;
-    /**
-     * This method is called when the input stream emits an error.
-     * We re-emit the error here by default, but subclasses can
-     * override this method to handle the error differently.
-     */
-    private onStreamError;
-    /**
-     * Consume all messages from the stream, blocking until the stream finishes.
-     * @throws if the decoder stream has already ended.
-     */
-    consumeAll(): Promise<T[]>;
-    /**
-     * Async iterator interface for the decoder.
-     * @throws if the decoder stream has already ended.
-     */
-    [Symbol.asyncIterator](): AsyncIterator<T | null>;
-    dispose(): void;
-}