@codingame/monaco-vscode-workbench-service-override 37.6.1 → 38.0.1

package/vscode/src/vs/sessions/contrib/automations/browser/automationRunner.js

@@ -2,293 +2,182 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { DeferredPromise } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
 import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isCancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 import { INotificationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/notification/common/notification.service';
+import { AutomationUnavailableError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService';
 import { IAutomationService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service';
-import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
-import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
-import { waitForState } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/utils/utilsCancellation';
-import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
 
 let AutomationRunner = class AutomationRunner {
     constructor(
         automationService,
-        sessionsManagementService,
+        sessionsProvidersService,
         logService,
         notificationService
     ) {
         this.automationService = automationService;
-        this.sessionsManagementService = sessionsManagementService;
+        this.sessionsProvidersService = sessionsProvidersService;
         this.logService = logService;
         this.notificationService = notificationService;
     }
-    runOnce(automation, trigger, leaderWindowId, token = CancellationToken.None) {
+    runOnce(automation, token = CancellationToken.None) {
         const dispatched = ( new DeferredPromise());
         return {
             whenDispatched: dispatched.p,
-            whenCompleted: this._runOnce(automation, trigger, leaderWindowId, token, dispatched)
+            whenCompleted: this.run(automation, token, dispatched)
         };
     }
-    async _runOnce(automation, trigger, leaderWindowId, token, dispatched) {
+    async run(automation, token, dispatched) {
         try {
-            await this._runOnceInner(automation, trigger, leaderWindowId, token, dispatched);
-        } catch (err) {
-            this.logService.error(`[AutomationRunner] unexpected error in runOnce for ${automation.id}`, err);
-        } finally {
-            await dispatched.complete({
-                kind: "notStarted",
-                reason: "error"
-            });
-        }
-    }
-    async _runOnceInner(automation, trigger, leaderWindowId, token, dispatched) {
-        let runId;
-        try {
-            if (!this.automationService.getAutomation(automation.id)) {
-                this.logService.trace(`[AutomationRunner] skipping ${automation.id}: automation was deleted.`);
+            if (token.isCancellationRequested) {
                 await dispatched.complete({
                     kind: "notStarted",
-                    reason: "deleted"
+                    reason: "cancelled"
                 });
                 return;
             }
-            const target = automation.target;
-            const isolationMode = target.kind === "workspace" ? target.isolation.kind === "folder" ? "workspace" : target.isolation.kind === "worktree" ? "worktree" : undefined : undefined;
-            const branch = target.kind === "workspace" && target.isolation.kind === "worktree" ? target.isolation.branch : undefined;
-            const automationConfiguration = automation.sessionTemplate ? {
-                sessionTemplate: automation.sessionTemplate
-            } : automation.modelId !== undefined || automation.mode !== undefined || automation.permissionLevel !== undefined ? {
-                modelId: automation.modelId,
-                mode: automation.mode,
-                permissionLevel: automation.permissionLevel
-            } : undefined;
-            const createOptions = target.providerId !== undefined || target.sessionTypeId !== undefined || automationConfiguration !== undefined || isolationMode !== undefined || branch !== undefined ? {
-                providerId: target.providerId,
-                sessionTypeId: target.sessionTypeId,
-                ...(automationConfiguration ? {
-                    sessionTemplate: automation.sessionTemplate,
-                    automationConfiguration
-                } : {}),
-                ...((automation.sessionTemplate?.modelId ?? automation.modelId) ? {
-                    modelId: automation.sessionTemplate?.modelId ?? automation.modelId
-                } : {}),
-                ...(!automation.sessionTemplate && automation.mode ? {
-                    modeId: automation.mode
-                } : {}),
-                ...(!automation.sessionTemplate && automation.permissionLevel ? {
-                    permissionLevel: automation.permissionLevel
-                } : {}),
-                isolationMode,
-                branch
-            } : undefined;
-            const targetAvailable = target.kind === "quickChat" ? this.sessionsManagementService.isQuickChatTargetAvailable(createOptions) : this.sessionsManagementService.isNewSessionTargetAvailable(target.folderUri, createOptions);
-            if (!targetAvailable) {
-                this.logService.trace(
-                    `[AutomationRunner] deferring ${automation.id}: target is not yet advertised.`
-                );
-                if (trigger === "manual") {
-                    this.notificationService.info(( localize(
-                        3360,
-                        "Automation '{0}' cannot start until its agent becomes available.",
-                        automation.name
-                    )));
-                }
+            this.assertProviderAvailable(automation.target.providerId);
+            if (!this.automationService.getAutomation(automation.id)) {
                 await dispatched.complete({
                     kind: "notStarted",
-                    reason: "targetUnavailable"
+                    reason: "deleted"
                 });
                 return;
             }
-            const claim = await this.automationService.recordRunStart(automation.id, trigger, leaderWindowId);
-            if (!claim.claimed) {
-                if (claim.externalDispatch) {
-                    let cancellationForwarded = false;
-                    const forwardCancellation = () => {
-                        if (!cancellationForwarded) {
-                            cancellationForwarded = true;
-                            try {
-                                claim.externalDispatch?.cancel?.();
-                            } catch (error) {
-                                this.logService.error(
-                                    `[AutomationRunner] Failed to forward cancellation for ${automation.id}`,
-                                    error
-                                );
-                            }
-                        }
-                    };
-                    const cancellationListener = claim.externalDispatch.cancel ? token.onCancellationRequested(forwardCancellation) : undefined;
-                    const sessionResource = claim.externalDispatch.sessionResource;
-                    try {
-                        if (sessionResource) {
-                            await dispatched.complete({
-                                kind: "started",
-                                run: claim.run,
-                                sessionResource
-                            });
-                        } else {
-                            await dispatched.complete({
-                                kind: "notStarted",
-                                reason: "error",
-                                run: claim.run
-                            });
-                        }
-                        if (token.isCancellationRequested) {
-                            forwardCancellation();
-                        }
-                        await claim.externalDispatch.whenCompleted;
-                    } finally {
-                        cancellationListener?.dispose();
-                    }
-                    return;
-                }
-                this.logService.trace(`[AutomationRunner] skipping ${automation.id}: active run already exists.`);
+            if (!this.automationService.canRunAutomation(automation.id)) {
+                throw ( new AutomationUnavailableError(( localize(3765, "The automation's Agent Host is not ready to run it."))));
+            }
+            const result = await this.automationService.runAutomation(automation.id, token);
+            if (result.kind === "accepted") {
                 await dispatched.complete({
-                    kind: "alreadyRunning",
-                    activeRun: claim.run
+                    kind: "accepted"
                 });
                 return;
             }
-            runId = claim.run.id;
-            const run = (await this.automationService.updateRun(runId, {
-                status: "running"
-            })) ?? claim.run;
-            this.logService.info(
-                `[AutomationRunner] claimed run ${runId} for automation ${automation.id}: trigger=${trigger}, leaderWindowId=${leaderWindowId}.`
-            );
-            if (token.isCancellationRequested) {
+            if (result.kind === "alreadyRunning") {
                 await dispatched.complete({
-                    kind: "notStarted",
-                    reason: "cancelled",
-                    run
+                    kind: "alreadyRunning",
+                    activeRun: result.run
                 });
-                await this._markCancelled(runId, automation);
                 return;
             }
-            const options = {
-                query: automation.prompt,
-                background: true,
-                title: automation.name?.substring(0, 100)
+            let cancellationForwarded = false;
+            const forwardCancellation = () => {
+                if (!cancellationForwarded) {
+                    cancellationForwarded = true;
+                    try {
+                        result.cancel?.();
+                    } catch (error) {
+                        this.logService.error(
+                            `[AutomationRunner] Failed to forward cancellation for ${automation.id}`,
+                            error
+                        );
+                    }
+                }
             };
-            this.logService.trace(
-                `[AutomationRunner] running ${automation.id}: target=${target.kind}, provider=${createOptions?.providerId ?? "(default)"}, sessionType=${createOptions?.sessionTypeId ?? "(default)"}, model=${automationConfiguration?.modelId ?? "(default)"}, mode=${automationConfiguration?.mode ?? "(default)"}, permissionLevel=${automationConfiguration?.permissionLevel ?? "(default)"}`
-            );
-            this.logService.info(
-                `[AutomationRunner] creating a session for run ${runId} (automation ${automation.id}).`
-            );
-            let session;
-            if (target.kind === "quickChat") {
-                session = await this.sessionsManagementService.createAndSendQuickChatRequest(options, createOptions, token);
-            } else {
-                session = await this.sessionsManagementService.createAndSendNewChatRequest(target.folderUri, options, createOptions, token);
-            }
-            if (session) {
-                const sessionResource = session.resource;
-                let updatedRun;
-                try {
-                    updatedRun = await this.automationService.updateRun(runId, {
-                        sessionResource
+            const cancellationListener = result.cancel ? token.onCancellationRequested(forwardCancellation) : undefined;
+            try {
+                if (result.run.sessionResource) {
+                    await dispatched.complete({
+                        kind: "started",
+                        run: result.run,
+                        sessionResource: result.run.sessionResource
+                    });
+                } else if (token.isCancellationRequested) {
+                    await dispatched.complete({
+                        kind: "notStarted",
+                        reason: "cancelled",
+                        run: result.run
                     });
-                } catch (err) {
-                    this.logService.warn(`[AutomationRunner] session ${( sessionResource.toString())} was created for run ${runId} (automation ${automation.id}), but persisting the session link failed.`, err);
-                    throw err;
-                }
-                if (updatedRun) {
-                    this.logService.info(
-                        `[AutomationRunner] linked run ${runId} for automation ${automation.id} to session ${( sessionResource.toString())}.`
-                    );
                 } else {
-                    this.logService.warn(`[AutomationRunner] session ${( sessionResource.toString())} was created for run ${runId} (automation ${automation.id}), but the run no longer exists and the session link was not persisted.`);
+                    this.notificationService.error(( localize(
+                        3766,
+                        "Automation '{0}' did not start a session: {1}",
+                        automation.name,
+                        result.run.errorMessage ?? ( localize(3767, "The Agent Host ended the run without a session."))
+                    )));
+                    await dispatched.complete({
+                        kind: "notStarted",
+                        reason: "error",
+                        run: result.run
+                    });
                 }
-                const dispatchedRun = updatedRun ?? run;
-                await dispatched.complete({
-                    kind: "started",
-                    run: dispatchedRun,
-                    sessionResource
-                });
-            } else {
-                this.logService.warn(
-                    `[AutomationRunner] session creation returned no session for run ${runId} (automation ${automation.id}): cancelled=${token.isCancellationRequested}.`
-                );
-                await dispatched.complete({
-                    kind: "notStarted",
-                    reason: token.isCancellationRequested ? "cancelled" : "error",
-                    run
-                });
-            }
-            if (token.isCancellationRequested) {
-                await this._markCancelled(runId, automation);
-                return;
-            }
-            const terminalStatus = session ? await waitForState(
-                derived(reader => session.mainChat.read(reader).status.read(reader)),
-                status => status === SessionStatus.Completed || status === SessionStatus.Error,
-                undefined,
-                token
-            ) : SessionStatus.Completed;
-            if (token.isCancellationRequested) {
-                await this._markCancelled(runId, automation);
-                return;
-            }
-            if (terminalStatus === SessionStatus.Error) {
-                throw ( new Error(( localize(3361, "Agent session failed."))));
+                if (token.isCancellationRequested) {
+                    forwardCancellation();
+                }
+                await result.whenCompleted;
+            } finally {
+                cancellationListener?.dispose();
             }
-            await this.automationService.updateRun(runId, {
-                status: "completed",
-                completedAt: ( new Date()).toISOString()
-            });
-        } catch (err) {
-            if (runId && token.isCancellationRequested) {
+        } catch (error) {
+            if (token.isCancellationRequested && isCancellationError(error)) {
                 await dispatched.complete({
                     kind: "notStarted",
                     reason: "cancelled"
                 });
-                await this._markCancelled(runId, automation);
                 return;
             }
-            this.logService.error(`[AutomationRunner] run for ${automation.id} failed`, err);
-            try {
-                const errorMessage = err instanceof Error ? err.message : String(err);
-                this.notificationService.error(( localize(3362, "Automation '{0}' failed: {1}", automation.name, errorMessage)));
-                let failedRun;
-                if (runId) {
-                    failedRun = await this.automationService.updateRun(runId, {
-                        status: "failed",
-                        completedAt: ( new Date()).toISOString(),
-                        errorMessage
-                    });
-                }
-                await dispatched.complete({
-                    kind: "notStarted",
-                    reason: "error",
-                    run: failedRun
-                });
-            } catch (innerErr) {
-                this.logService.error(
-                    `[AutomationRunner] error recording failure for ${automation.id}`,
-                    innerErr
-                );
-            }
+            this.logService.error(`[AutomationRunner] Host run request for ${automation.id} failed`, error);
+            this.notificationService.error(( localize(
+                3768,
+                "Automation '{0}' failed: {1}",
+                automation.name,
+                error instanceof Error ? error.message : String(error)
+            )));
+            await dispatched.complete({
+                kind: "notStarted",
+                reason: error instanceof AutomationUnavailableError ? "targetUnavailable" : "error"
+            });
         }
     }
-    async _markCancelled(runId, automation) {
-        try {
-            if (this.automationService.getActiveRunFor(automation.id)?.id === runId) {
-                await this.automationService.updateRun(runId, {
-                    status: "failed",
-                    completedAt: ( new Date()).toISOString(),
-                    errorMessage: ( localize(3363, "Cancelled"))
-                });
-            }
-        } catch (err) {
-            this.logService.error(
-                `[AutomationRunner] error recording cancellation for ${automation.id}`,
-                err
-            );
+    assertProviderAvailable(providerId) {
+        if (providerId === undefined) {
+            throw ( new AutomationUnavailableError(( localize(
+                3769,
+                "This automation has no Agent Host. Duplicate it and select an Agent Host."
+            ))));
+        }
+        const provider = this.sessionsProvidersService.getProvider(providerId);
+        if (provider === undefined) {
+            throw ( new AutomationUnavailableError(( localize(3770, "Connect to this automation's Agent Host and try again."))));
+        }
+        const store = provider.automations;
+        if (store === undefined) {
+            throw ( new AutomationUnavailableError(( localize(
+                3771,
+                "{0} does not support automations. Use an Agent Host that supports automations.",
+                provider.label
+            ))));
+        }
+        if (store.enabled?.get() === false) {
+            throw ( new AutomationUnavailableError(( localize(3772, "Automations from {0} are disabled.", provider.label))));
+        }
+        switch (store.catalogueState.get()) {
+        case "ready":
+            return;
+        case "loading":
+            throw ( new AutomationUnavailableError(( localize(
+                3773,
+                "Automations from {0} are still loading. Wait for loading to finish, then try again.",
+                provider.label
+            ))));
+        case "error":
+            throw ( new AutomationUnavailableError(( localize(
+                3774,
+                "Automations from {0} could not be loaded. Reconnect to the Agent Host and try again.",
+                provider.label
+            ))));
+        case "unavailable":
+            throw ( new AutomationUnavailableError(store.unavailableReason?.get() ?? ( localize(
+                3775,
+                "{0} is unavailable. Reconnect to the Agent Host and try again.",
+                provider.label
+            ))));
         }
     }
 };
-AutomationRunner = ( __decorate([( __param(0, IAutomationService)), ( __param(1, ISessionsManagementService)), ( __param(2, ILogService)), ( __param(3, INotificationService))], AutomationRunner));
+AutomationRunner = ( __decorate([( __param(0, IAutomationService)), ( __param(1, ISessionsProvidersService)), ( __param(2, ILogService)), ( __param(3, INotificationService))], AutomationRunner));
 
 export { AutomationRunner };

package/vscode/src/vs/sessions/contrib/automations/browser/automationTelemetry.d.ts

@@ -0,0 +1,22 @@
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+export declare function logAutomationViewShown(telemetryService: ITelemetryService): void;
+type AutomationDialogOperation = "create" | "update";
+export declare class AutomationDialogTelemetry {
+    private readonly _telemetryService;
+    private readonly _operation;
+    private readonly _reportedOutcomes;
+    private _completed;
+    constructor(_telemetryService: ITelemetryService, _operation: AutomationDialogOperation);
+    validationFailed(): void;
+    captureFailed(): void;
+    complete(saved: boolean): void;
+    private _report;
+}
+export declare function withAutomationDialogPersistenceTelemetry<T>(telemetryService: ITelemetryService, operation: AutomationDialogOperation, persist: () => Promise<T>): Promise<T>;
+export type AutomationConfigureOutcome = "created" | "updated" | "blocked" | "failed";
+type AutomationConfigureOutcomeEvent = {
+    operation: AutomationDialogOperation | "unknown";
+    outcome: AutomationConfigureOutcome;
+};
+export declare function logAutomationConfigureOutcome(telemetryService: ITelemetryService, operation: AutomationConfigureOutcomeEvent["operation"], outcome: AutomationConfigureOutcome): void;
+export {};

package/vscode/src/vs/sessions/contrib/automations/browser/automationTelemetry.js

@@ -0,0 +1,62 @@
+
+
+function logAutomationViewShown(telemetryService) {
+    telemetryService.publicLog2("automation.viewShown", {
+        surface: "agentsWindow"
+    });
+}
+class AutomationDialogTelemetry {
+    constructor(_telemetryService, _operation) {
+        this._telemetryService = _telemetryService;
+        this._operation = _operation;
+        this._reportedOutcomes = ( new Set());
+        this._completed = false;
+        if (_operation === "create") {
+            this._telemetryService.publicLog2("automation.newInitiated", {
+                surface: "agentsWindow"
+            });
+        }
+    }
+    validationFailed() {
+        this._report("validationFailed");
+    }
+    captureFailed() {
+        this._report("captureFailed");
+    }
+    complete(saved) {
+        if (this._completed) {
+            return;
+        }
+        this._completed = true;
+        this._report(saved ? "saved" : "cancelled");
+    }
+    _report(outcome) {
+        if (( this._reportedOutcomes.has(outcome))) {
+            return;
+        }
+        this._reportedOutcomes.add(outcome);
+        this._telemetryService.publicLog2("automation.dialogOutcome", {
+            operation: this._operation,
+            outcome
+        });
+    }
+}
+async function withAutomationDialogPersistenceTelemetry(telemetryService, operation, persist) {
+    try {
+        return await persist();
+    } catch (error) {
+        telemetryService.publicLog2("automation.dialogOutcome", {
+            operation,
+            outcome: "persistenceFailed"
+        });
+        throw error;
+    }
+}
+function logAutomationConfigureOutcome(telemetryService, operation, outcome) {
+    telemetryService.publicLog2("automation.configureOutcome", {
+        operation,
+        outcome
+    });
+}
+
+export { AutomationDialogTelemetry, logAutomationConfigureOutcome, logAutomationViewShown, withAutomationDialogPersistenceTelemetry };

package/vscode/src/vs/sessions/contrib/automations/browser/automationTools.d.ts

@@ -2,11 +2,13 @@ import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/c
 import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IWorkbenchContribution } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/contributions";
 import { IAutomationRunner } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationRunner.service";
 import { IAutomationService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService.service";
 import { CountTokensCallback, IPreparedToolInvocation, IToolData, IToolImpl, IToolInvocation, IToolInvocationPreparationContext, IToolResult, ToolProgress } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService";
 import { ILanguageModelToolsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service";
+import { ISessionsProvidersService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service";
 import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
 export declare const ListAutomationsToolId = "vscode_listAutomations";
 export declare const ConfigureAutomationToolId = "vscode_configureAutomation";
@@ -15,7 +17,8 @@ export declare const DeleteAutomationToolId = "vscode_deleteAutomation";
 export declare class ListAutomationsTool implements IToolImpl {
     private readonly automationService;
     private readonly configurationService;
-    constructor(automationService: IAutomationService, configurationService: IConfigurationService);
+    private readonly sessionsProvidersService;
+    constructor(automationService: IAutomationService, configurationService: IConfigurationService, sessionsProvidersService: ISessionsProvidersService);
     getToolData(): IToolData;
     prepareToolInvocation(_context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation>;
     invoke(_invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, _token: CancellationToken): Promise<IToolResult>;
@@ -42,10 +45,12 @@ export declare class ConfigureAutomationTool implements IToolImpl {
     private readonly automationService;
     private readonly sessionsManagementService;
     private readonly configurationService;
-    constructor(automationService: IAutomationService, sessionsManagementService: ISessionsManagementService, configurationService: IConfigurationService);
+    private readonly telemetryService;
+    constructor(automationService: IAutomationService, sessionsManagementService: ISessionsManagementService, configurationService: IConfigurationService, telemetryService: ITelemetryService);
     getToolData(): IToolData;
     prepareToolInvocation(context: IToolInvocationPreparationContext, _token: CancellationToken): Promise<IPreparedToolInvocation>;
     invoke(invocation: IToolInvocation, _countTokens: CountTokensCallback, _progress: ToolProgress, token: CancellationToken): Promise<IToolResult>;
+    private completeOperation;
     private applyCreate;
     private applyUpdate;
     private createMutationGuard;