@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

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

@@ -1,70 +1,76 @@
 
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { Sequencer, disposableTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
-import { Disposable, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
 import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
 import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { combineAutomationCatalogueStates, serializeAutomationEditableState, isAutomationActiveRunError } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService';
+import { combineAutomationCatalogueStates, AutomationUnavailableError, assertAutomationTargetAuthority, serializeAutomationEditableState } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService';
 import { ISessionsProvidersService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsProvidersService.service';
-import { AutomationService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/browser/automationService';
-import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 import { derived } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/derived';
+import { observableSignalFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableSignalFromEvent';
 
-const MAX_AUTOMATION_TRANSFER_ATTEMPTS = 3;
-const AUTOMATION_MIGRATION_RETRY_DELAY_MS = 30_000;
 let ProviderAutomationService = class ProviderAutomationService extends Disposable {
-    constructor(
-        initialProvidersSettled,
-        sessionsProvidersService,
-        instantiationService,
-        logService
-    ) {
+    constructor(initialProvidersSettled, sessionsProvidersService) {
         super();
         this.sessionsProvidersService = sessionsProvidersService;
-        this.logService = logService;
-        this.migrationSequencer = ( new Sequencer());
-        this.migrationRetry = this._register(( new MutableDisposable()));
-        this.migrationPromise = Promise.resolve();
         this.runsForCache = ( new Map());
-        this.staleRunRecoveryGeneration = 0;
-        this.recoveredStores = ( new Set());
-        this.legacyStore = this._register(instantiationService.createInstance(AutomationService));
+        this.historyState = derived(this, reader => {
+            this.providersChanged.read(reader);
+            return combineAutomationCatalogueStates(
+                this.getStores(reader).map(store => store.historyState?.read(reader) ?? "ready")
+            );
+        });
         this.providersChanged = observableSignalFromEvent(this, sessionsProvidersService.onDidChangeProviders);
         this.catalogueState = derived(this, reader => {
             this.providersChanged.read(reader);
-            const states = this.getStores().map(entry => entry.store.catalogueState.read(reader));
+            const states = this.getStores(reader).map(store => store.catalogueState.read(reader));
             if (!initialProvidersSettled.read(reader)) {
                 states.push("loading");
             }
-            return combineAutomationCatalogueStates(states);
+            return states.length > 0 ? combineAutomationCatalogueStates(states) : "unavailable";
+        });
+        this.unavailableProviders = derived(this, reader => {
+            this.providersChanged.read(reader);
+            return this.sessionsProvidersService.getProviders().filter(
+                provider => provider.automations?.enabled?.read(reader) !== false && provider.automations?.catalogueState.read(reader) === "unavailable"
+            ).map(provider => {
+                const reason = provider.automations?.unavailableReason?.read(reader);
+                const reasonCode = provider.automations?.unavailableReasonCode?.read(reader);
+                return {
+                    id: provider.id,
+                    label: provider.label,
+                    ...(reason !== undefined ? {
+                        unavailableReason: reason
+                    } : {}),
+                    ...(reasonCode !== undefined ? {
+                        unavailableReasonCode: reasonCode
+                    } : {})
+                };
+            });
+        });
+        this.availableProviders = derived(this, reader => {
+            this.providersChanged.read(reader);
+            return this.sessionsProvidersService.getProviders().filter(
+                provider => provider.automations?.enabled?.read(reader) !== false && provider.automations?.canCreateAutomation.read(reader)
+            ).map(provider => ({
+                id: provider.id,
+                label: provider.label
+            }));
         });
         this.automations = derived(this, reader => {
             this.providersChanged.read(reader);
-            return distinctById(
-                this.getStores().flatMap(entry => [...entry.store.automations.read(reader)])
-            ).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+            return this.getStores(reader).flatMap(store => [...store.automations.read(reader)]).sort((a, b) => b.createdAt.localeCompare(a.createdAt));
         });
         this.runs = derived(this, reader => {
             this.providersChanged.read(reader);
-            return distinctById(this.getStores().flatMap(entry => [...entry.store.runs.read(reader)])).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+            return this.getStores(reader).flatMap(store => [...store.runs.read(reader)]).sort((a, b) => b.startedAt.localeCompare(a.startedAt));
         });
-        this._register(sessionsProvidersService.onDidChangeProviders(event => {
-            for (const provider of event.removed) {
-                if (provider.automations) {
-                    this.recoveredStores.delete(provider.automations);
-                }
-            }
-            if (( event.added.some(provider => provider.automations))) {
-                this.queueMigration();
-            }
-        }));
-        this.queueMigration();
     }
     getAutomation(id) {
-        return this.findAutomationStore(id)?.store.getAutomation(id);
+        return this.findAutomationStore(id)?.getAutomation(id);
+    }
+    async getCustomizationChoices(target, existingId, token) {
+        const store = target.providerId ? this.sessionsProvidersService.getProvider(target.providerId)?.automations : undefined;
+        return store?.getCustomizationChoices?.(target, existingId, token);
     }
     runsFor(automationId) {
         let result = this.runsForCache.get(automationId);
@@ -77,417 +83,95 @@ let ProviderAutomationService = class ProviderAutomationService extends Disposab
         }
         return result;
     }
-    createAutomation(options, mutationGuard) {
-        return this.getCreationStore(options).createAutomation(options, mutationGuard);
+    canCreateAutomation(providerId) {
+        const store = providerId ? this.sessionsProvidersService.getProvider(providerId)?.automations : undefined;
+        return store !== undefined && store.enabled?.get() !== false && store.canCreateAutomation.get();
     }
-    async updateAutomation(id, patch) {
-        const source = this.requireAutomationStore(id);
-        let previous = source.getAutomation(id);
-        while (previous) {
-            const targetChanged = this.hasTargetChanged(previous, patch.target);
-            this.assertCanTransferStorage(source, id, patch.target, targetChanged);
-            const result = await source.updateAutomationIfUnchanged(id, patch, previous);
-            if (result.kind === "conflict") {
-                previous = result.current;
-                continue;
-            }
-            await this.retargetAutomationStorageIfNeeded(source, result.automation, previous, targetChanged);
-            return result.automation;
+    async refresh() {
+        await Promise.all(this.getStores().map(store => store.refresh?.()));
+    }
+    getProviderConfiguration(providerId) {
+        const store = providerId ? this.sessionsProvidersService.getProvider(providerId)?.automations : undefined;
+        return store?.enabled?.get() === false ? undefined : store?.configuration;
+    }
+    createAutomation(options, mutationGuard) {
+        const providerId = options.target.providerId;
+        const store = providerId ? this.sessionsProvidersService.getProvider(providerId)?.automations : undefined;
+        if (!store || store.enabled?.get() === false || !store.canCreateAutomation.get()) {
+            throw ( new AutomationUnavailableError(( localize(
+                3822,
+                "Connect to an Agent Host that supports automations before creating one."
+            ))));
         }
-        throw ( new Error(`Automation '${id}' does not exist.`));
+        return store.createAutomation(options, mutationGuard);
+    }
+    updateAutomation(id, patch) {
+        const store = this.requireAutomationStore(id);
+        assertAutomationTargetAuthority(store.getAutomation(id), patch.target);
+        return store.updateAutomation(id, patch);
     }
     async updateAutomationIfUnchanged(id, patch, expected, mutationGuard) {
-        const source = this.requireAutomationStore(id);
-        const previous = source.getAutomation(id);
-        if (!previous) {
-            return {
-                kind: "conflict",
-                current: undefined
-            };
-        }
-        if (serializeAutomationEditableState(previous) !== serializeAutomationEditableState(expected)) {
+        const store = this.requireAutomationStore(id);
+        const current = store.getAutomation(id);
+        if (!current || serializeAutomationEditableState(current) !== serializeAutomationEditableState(expected)) {
             return {
                 kind: "conflict",
-                current: previous
+                current
             };
         }
-        const targetChanged = this.hasTargetChanged(previous, patch.target);
-        this.assertCanTransferStorage(source, id, patch.target, targetChanged);
-        const result = await source.updateAutomationIfUnchanged(id, patch, expected, mutationGuard);
-        if (result.kind === "updated") {
-            await this.retargetAutomationStorageIfNeeded(source, result.automation, previous, targetChanged);
-        }
-        return result;
+        assertAutomationTargetAuthority(current, patch.target);
+        return store.updateAutomationIfUnchanged(id, patch, expected, mutationGuard);
     }
     async deleteAutomation(id, mutationGuard) {
         await this.requireAutomationStore(id).deleteAutomation(id, mutationGuard);
         this.runsForCache.delete(id);
     }
-    recordRunStart(automationId, trigger, leaderWindowId) {
-        return this.requireAutomationStore(automationId).recordRunStart(automationId, trigger, leaderWindowId);
-    }
-    updateRun(runId, patch) {
-        const store = this.findRunStore(runId);
-        return store ? store.updateRun(runId, patch) : Promise.resolve(undefined);
-    }
-    deleteRun(runId) {
-        const store = this.findRunStore(runId);
-        return store ? store.deleteRun(runId) : Promise.resolve();
+    runAutomation(automationId, token) {
+        return this.requireAutomationStore(automationId).runAutomation(automationId, token);
     }
     getActiveRunFor(automationId) {
-        return this.findAutomationStore(automationId)?.store.getActiveRunFor(automationId);
-    }
-    isSchedulingOwnedByHost(automationId) {
-        return this.findAutomationStore(automationId)?.store.isSchedulingOwnedByHost?.(automationId) === true;
+        return this.findAutomationStore(automationId)?.getActiveRunFor(automationId);
     }
     canRunAutomation(automationId) {
-        const entry = this.findAutomationStore(automationId);
-        return entry?.store.canRunAutomation?.(automationId) ?? entry !== undefined;
+        return this.findAutomationStore(automationId)?.canRunAutomation(automationId) === true;
     }
     canUpdateAutomation(automationId) {
-        const entry = this.findAutomationStore(automationId);
-        return entry?.store.canUpdateAutomation?.(automationId) ?? entry !== undefined;
+        return this.findAutomationStore(automationId)?.canUpdateAutomation(automationId) === true;
     }
     canDeleteAutomation(automationId) {
-        const entry = this.findAutomationStore(automationId);
-        return entry?.store.canDeleteAutomation?.(automationId) ?? entry !== undefined;
-    }
-    async markStaleRunsFailed(reason) {
-        await this.migrationPromise;
-        const stores = this.getStores();
-        const results = await Promise.allSettled(stores.map(entry => entry.store.markStaleRunsFailed(reason)));
-        for (let index = 0; index < results.length; index++) {
-            const result = results[index];
-            if (result.status === "rejected") {
-                const providerId = stores[index].providerId ?? "legacy";
-                this.logService.error(
-                    `[ProviderAutomationService] Failed to recover stale Automation runs for '${providerId}'.`,
-                    result.reason
-                );
-            }
-        }
-    }
-    async startStaleRunRecovery(reason) {
-        const generation = ++this.staleRunRecoveryGeneration;
-        this.staleRunRecoveryReason = reason;
-        this.recoveredStores.clear();
-        const stores = this.getStores();
-        this.migrationPromise = this.migrationSequencer.queue(() => this.recoverStores(stores, reason, generation)).catch(error => {
-            this.logService.error(
-                "[ProviderAutomationService] Failed to start stale Automation run recovery.",
-                error
-            );
-        });
-        await this.migrationPromise;
+        return this.findAutomationStore(automationId)?.canDeleteAutomation(automationId) === true;
     }
-    stopStaleRunRecovery() {
-        this.staleRunRecoveryGeneration++;
-        this.staleRunRecoveryReason = undefined;
-        this.recoveredStores.clear();
+    canStopRun(run) {
+        return this.findAutomationStore(run.automationId)?.canStopRun?.(run) === true;
     }
-    waitForMigrationForTesting() {
-        return this.migrationPromise;
-    }
-    getProviderStores() {
-        return this.sessionsProvidersService.getProviders().filter(provider => provider.automations).map(provider => ({
-            providerId: provider.id,
-            store: provider.automations
-        }));
-    }
-    getStores() {
-        return [...this.getProviderStores(), {
-            providerId: undefined,
-            store: this.legacyStore
-        }];
-    }
-    getCreationStore(options) {
-        return this.getTargetStore(options.target.providerId);
-    }
-    getTargetStore(providerId) {
-        if (providerId) {
-            const providerStore = this.sessionsProvidersService.getProvider(providerId)?.automations;
-            if (providerStore) {
-                return providerStore;
-            }
+    async stopRun(run) {
+        const store = this.requireAutomationStore(run.automationId);
+        if (!store.stopRun || !store.canStopRun?.(run)) {
+            throw ( new AutomationUnavailableError(( localize(3823, "This automation run cannot be stopped from VS Code."))));
         }
-        return this.legacyStore;
+        await store.stopRun(run);
     }
-    hasTargetChanged(current, target) {
-        return !!target && serializeAutomationEditableState(current) !== serializeAutomationEditableState({
-            ...current,
-            target
+    getStores(reader) {
+        return this.sessionsProvidersService.getProviders().flatMap(provider => {
+            const store = provider.automations;
+            return store && store.enabled?.read(reader) !== false ? [store] : [];
         });
     }
-    assertCanTransferStorage(source, automationId, target, targetChanged) {
-        if (!targetChanged || !target || source === this.getTargetStore(target.providerId) || !source.getActiveRunFor(automationId)) {
-            return;
-        }
-        throw this.createActiveRunTransferError();
-    }
-    createActiveRunTransferError() {
-        return (new Error(localize(
-            3410,
-            "Wait for the active run to finish before changing this automation's agent."
-        )));
-    }
-    async retargetAutomationStorageIfNeeded(sourceStore, initialAutomation, previousAutomation, targetChanged) {
-        let snapshot = {
-            automation: initialAutomation,
-            runs: sourceStore.runsFor(initialAutomation.id).get()
-        };
-        for (let attempt = 0; attempt < MAX_AUTOMATION_TRANSFER_ATTEMPTS; attempt++) {
-            const destinationStore = this.getTargetStore(snapshot.automation.target.providerId);
-            if (sourceStore === destinationStore) {
-                return;
-            }
-            if (sourceStore.getActiveRunFor(snapshot.automation.id)) {
-                if (!targetChanged) {
-                    return;
-                }
-                await this.restoreSourceAfterBlockedTransfer(sourceStore, initialAutomation, previousAutomation);
-                throw this.createActiveRunTransferError();
-            }
-            try {
-                await destinationStore.upsertAutomationSnapshot(snapshot);
-            } catch (error) {
-                if (!isAutomationActiveRunError(error)) {
-                    throw error;
-                }
-                if (!targetChanged) {
-                    return;
-                }
-                await this.restoreSourceAfterBlockedTransfer(sourceStore, initialAutomation, previousAutomation);
-                throw this.createActiveRunTransferError();
-            }
-            if (destinationStore.preservesImportedRunHistory === false) {
-                return;
-            }
-            const sourceRemoval = await sourceStore.removeAutomationSnapshotIfUnchanged(snapshot);
-            switch (sourceRemoval.kind) {
-            case "removed":
-                await destinationStore.acknowledgeAutomationSnapshotImported?.(snapshot);
-                return;
-            case "missing":
-                await this.rollbackAutomationSnapshotIfUnchanged(destinationStore, snapshot);
-                return;
-            case "conflict":
-                if (!(await this.rollbackAutomationSnapshotIfUnchanged(destinationStore, snapshot))) {
-                    return;
-                }
-                snapshot = sourceRemoval.current;
-                break;
-            }
-        }
-        this.logService.warn(
-            `[ProviderAutomationService] Automation '${snapshot.automation.id}' kept changing while transferring storage ownership; leaving the source copy in place.`
-        );
-    }
-    async restoreSourceAfterBlockedTransfer(sourceStore, expected, previous) {
-        try {
-            const result = await sourceStore.updateAutomationIfUnchanged(expected.id, {
-                name: previous.name,
-                prompt: previous.prompt,
-                schedule: previous.schedule,
-                target: previous.target,
-                ...(previous.sessionTemplate ? {
-                    sessionTemplate: previous.sessionTemplate
-                } : {
-                    modelId: previous.modelId ?? null,
-                    mode: previous.mode ?? null,
-                    permissionLevel: previous.permissionLevel ?? null
-                }),
-                enabled: previous.enabled
-            }, expected);
-            if (result.kind === "conflict") {
-                this.logService.warn(
-                    `[ProviderAutomationService] Automation '${expected.id}' changed while its active run blocked storage transfer; the latest source state was preserved.`
-                );
-            }
-        } catch (error) {
-            this.logService.error(
-                `[ProviderAutomationService] Failed to restore the source state after an active run blocked storage transfer for '${expected.id}'.`,
-                error
-            );
-        }
-    }
     findAutomationStore(id) {
-        return this.getStores().find(entry => !!entry.store.getAutomation(id));
+        return this.getStores().find(store => !!store.getAutomation(id));
     }
     requireAutomationStore(id) {
-        const entry = this.findAutomationStore(id);
-        if (!entry) {
-            throw ( new Error(`Automation '${id}' does not exist.`));
-        }
-        return entry.store;
-    }
-    findRunStore(runId) {
-        return this.getStores().find(entry => ( entry.store.runs.get().some(run => run.id === runId)))?.store;
-    }
-    queueMigration() {
-        this.migrationRetry.clear();
-        const migration = this.migrationSequencer.queue(async () => {
-            const initialRecoveryReason = this.staleRunRecoveryReason;
-            if (initialRecoveryReason) {
-                await this.recoverStores(this.getStores(), initialRecoveryReason, this.staleRunRecoveryGeneration);
-            }
-            await this.migrateLegacyAutomations();
-            await this.completeProviderMigrations();
-            const finalRecoveryReason = this.staleRunRecoveryReason;
-            if (finalRecoveryReason) {
-                await this.recoverStores(this.getStores(), finalRecoveryReason, this.staleRunRecoveryGeneration);
-            }
-        });
-        this.migrationPromise = migration;
-        void migration.then(() => this.migrationRetry.clear(), error => {
-            if (this._store.isDisposed || isCancellationError(error)) {
-                return;
-            }
-            if (isAutomationActiveRunError(error)) {
-                this.logService.info(
-                    `[ProviderAutomationService] Automation migration deferred while a run is active; retrying in ${AUTOMATION_MIGRATION_RETRY_DELAY_MS}ms.`
-                );
-            } else {
-                this.logService.error(
-                    `[ProviderAutomationService] Failed to migrate legacy Automations; retrying in ${AUTOMATION_MIGRATION_RETRY_DELAY_MS}ms.`,
-                    error
-                );
-            }
-            this.migrationRetry.value = disposableTimeout(() => this.queueMigration(), AUTOMATION_MIGRATION_RETRY_DELAY_MS);
-        });
-    }
-    async recoverStores(entries, reason, generation) {
-        for (const entry of entries) {
-            if (generation !== this.staleRunRecoveryGeneration || this.staleRunRecoveryReason !== reason) {
-                return;
-            }
-            if (( this.recoveredStores.has(entry.store))) {
-                continue;
-            }
-            try {
-                await entry.store.markStaleRunsFailed(reason);
-                if (generation === this.staleRunRecoveryGeneration && this.staleRunRecoveryReason === reason) {
-                    this.recoveredStores.add(entry.store);
-                }
-            } catch (error) {
-                const providerId = entry.providerId ?? "legacy";
-                this.logService.error(
-                    `[ProviderAutomationService] Failed to recover stale Automation runs for '${providerId}'.`,
-                    error
-                );
-            }
-        }
-    }
-    async migrateLegacyAutomations() {
-        if (this.legacyStore.canCompleteMigration() === false) {
-            throw ( new Error("Legacy Automation storage cannot be migrated safely by this version."));
-        }
-        const failures = [];
-        for (const automation of [...this.legacyStore.automations.get()]) {
-            try {
-                await this.migrateLegacyAutomation(automation);
-            } catch (error) {
-                if (isCancellationError(error) || this._store.isDisposed) {
-                    throw ( new CancellationError());
-                }
-                if (isAutomationActiveRunError(error)) {
-                    this.logService.info(
-                        `[ProviderAutomationService] Deferred migration for Automation '${automation.id}' while a run is active.`
-                    );
-                } else {
-                    this.logService.error(
-                        `[ProviderAutomationService] Failed to migrate Automation '${automation.id}'.`,
-                        error
-                    );
-                }
-                failures.push(error instanceof Error ? error : ( new Error(String(error))));
-            }
-        }
-        if (failures.length > 0) {
-            throw ( new AggregateError(failures, `Failed to migrate ${failures.length} Automation snapshot(s).`));
-        }
-    }
-    async migrateLegacyAutomation(initialAutomation) {
-        let snapshot = {
-            automation: initialAutomation,
-            runs: this.legacyStore.runsFor(initialAutomation.id).get()
-        };
-        for (let attempt = 0; attempt < MAX_AUTOMATION_TRANSFER_ATTEMPTS; attempt++) {
-            const providerId = snapshot.automation.target.providerId;
-            if (!providerId) {
-                return;
-            }
-            const providerStore = this.sessionsProvidersService.getProvider(providerId)?.automations;
-            if (!providerStore) {
-                return;
-            }
-            const importResult = await providerStore.importAutomationSnapshot(snapshot);
-            if (importResult.kind === "conflict") {
-                this.logService.warn(
-                    `[ProviderAutomationService] Automation '${snapshot.automation.id}' conflicts with the destination provider store; leaving the legacy copy in place.`
-                );
-                return;
-            }
-            this.recoveredStores.delete(providerStore);
-            if (providerStore.preservesImportedRunHistory === false) {
-                return;
-            }
-            const sourceRemoval = await this.legacyStore.removeAutomationSnapshotIfUnchanged(snapshot);
-            switch (sourceRemoval.kind) {
-            case "removed":
-                await providerStore.acknowledgeAutomationSnapshotImported?.(snapshot);
-                return;
-            case "missing":
-                if (importResult.kind === "inserted") {
-                    await this.rollbackAutomationSnapshotIfUnchanged(providerStore, snapshot);
-                }
-                return;
-            case "conflict":
-                if (importResult.kind === "inserted" && !(await this.rollbackAutomationSnapshotIfUnchanged(providerStore, snapshot))) {
-                    return;
-                }
-                snapshot = sourceRemoval.current;
-                break;
-            }
-        }
-        this.logService.warn(
-            `[ProviderAutomationService] Automation '${snapshot.automation.id}' kept changing during legacy migration; leaving it in legacy storage.`
-        );
-    }
-    async completeProviderMigrations() {
-        const stores = [...( new Set(this.getStores().map(entry => entry.store)))];
-        for (const store of stores) {
-            await store.completeMigration?.();
-        }
-    }
-    async rollbackAutomationSnapshotIfUnchanged(store, snapshot) {
-        const result = await store.removeAutomationSnapshotIfUnchanged(snapshot);
-        switch (result.kind) {
-        case "removed":
-            return true;
-        case "conflict":
-            this.logService.warn(
-                `[ProviderAutomationService] Automation '${snapshot.automation.id}' changed in the destination store during rollback; leaving both copies in place.`
-            );
-            return false;
-        case "missing":
-            this.logService.warn(
-                `[ProviderAutomationService] Automation '${snapshot.automation.id}' was deleted from the destination store during rollback; leaving the source copy in place.`
-            );
-            return false;
+        const store = this.findAutomationStore(id);
+        if (!store) {
+            throw ( new AutomationUnavailableError(( localize(
+                3824,
+                "Automation '{0}' is unavailable. Its Agent Host may be disconnected or the automation may have been deleted.",
+                id
+            ))));
         }
+        return store;
     }
 };
-ProviderAutomationService = ( __decorate([( __param(1, ISessionsProvidersService)), ( __param(2, IInstantiationService)), ( __param(3, ILogService))], ProviderAutomationService));
-function distinctById(items) {
-    const result = [];
-    const seen = ( new Set());
-    for (const item of items) {
-        if (!( seen.has(item.id))) {
-            seen.add(item.id);
-            result.push(item);
-        }
-    }
-    return result;
-}
+ProviderAutomationService = ( __decorate([( __param(1, ISessionsProvidersService))], ProviderAutomationService));
 
 export { ProviderAutomationService };