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

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

@@ -0,0 +1,56 @@
+
+
+function aggregateChatUsage(usages) {
+    const models = ( new Map());
+    let inputTokens = 0;
+    let cachedTokens = 0;
+    let outputTokens = 0;
+    let hasUsage = false;
+    let isComplete = true;
+    for (const usage of usages) {
+        if (!usage) {
+            isComplete = false;
+            continue;
+        }
+        const modelTotals = usage.modelTotals?.filter(isValidModelTotal);
+        if (modelTotals?.length) {
+            hasUsage = true;
+            for (const total of modelTotals) {
+                inputTokens += total.inputTokens;
+                cachedTokens += total.cachedTokens;
+                outputTokens += total.outputTokens;
+                const current = models.get(total.model);
+                models.set(total.model, {
+                    model: total.model,
+                    inputTokens: (current?.inputTokens ?? 0) + total.inputTokens,
+                    cachedTokens: (current?.cachedTokens ?? 0) + total.cachedTokens,
+                    outputTokens: (current?.outputTokens ?? 0) + total.outputTokens
+                });
+            }
+            continue;
+        }
+        isComplete = false;
+        if (isTokenCount(usage.promptTokens) && isTokenCount(usage.completionTokens)) {
+            hasUsage = true;
+            inputTokens += usage.promptTokens;
+            outputTokens += usage.completionTokens;
+        }
+    }
+    return hasUsage ? {
+        inputTokens,
+        ...(isComplete ? {
+            cachedTokens
+        } : {}),
+        outputTokens,
+        models: [...( models.values())],
+        isComplete
+    } : undefined;
+}
+function isValidModelTotal(total) {
+    return !!total.model && isTokenCount(total.inputTokens) && isTokenCount(total.cachedTokens) && isTokenCount(total.outputTokens);
+}
+function isTokenCount(value) {
+    return Number.isFinite(value) && value >= 0;
+}
+
+export { aggregateChatUsage };

package/vscode/src/vs/platform/agentHost/common/meta/agentCheckoutOperationMeta.d.ts

@@ -1,18 +0,0 @@
-interface IHasCheckoutOperationMeta {
-    readonly _meta?: Record<string, unknown>;
-}
-export declare enum CheckoutOperationPreAction {
-    Stash = "stash",
-    Commit = "commit"
-}
-/** Creates request metadata for a Checkout changeset operation. */
-export declare function checkoutOperationMeta(treeish: string, preCheckoutAction?: CheckoutOperationPreAction): Record<string, unknown>;
-/** Reads and validates the treeish requested by a Checkout changeset operation. */
-export declare function readCheckoutOperationTreeish(source: IHasCheckoutOperationMeta): string | undefined;
-/** Reads and validates the action requested before a Checkout changeset operation. */
-export declare function readCheckoutOperationPreAction(source: IHasCheckoutOperationMeta): CheckoutOperationPreAction | undefined;
-/** Creates structured error data for a Checkout operation blocked by a dirty working tree. */
-export declare function checkoutOperationDirtyWorkingTreeErrorData(): Record<string, unknown>;
-/** Returns whether error data identifies a Checkout operation blocked by a dirty working tree. */
-export declare function isCheckoutOperationDirtyWorkingTreeErrorData(data: unknown): boolean;
-export {};

package/vscode/src/vs/platform/agentHost/common/meta/agentCheckoutOperationMeta.js

@@ -1,27 +0,0 @@
-
-import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
-
-const TREEISH_META_KEY = 'treeish';
-const PRE_CHECKOUT_ACTION_META_KEY = 'preCheckoutAction';
-const DIRTY_WORKING_TREE_ERROR_REASON = 'dirtyWorkingTree';
-var CheckoutOperationPreAction;
-(function (CheckoutOperationPreAction) {
-    CheckoutOperationPreAction["Stash"] = "stash";
-    CheckoutOperationPreAction["Commit"] = "commit";
-})(CheckoutOperationPreAction || (CheckoutOperationPreAction = {}));
-function checkoutOperationMeta(treeish, preCheckoutAction) {
-    return {
-        [TREEISH_META_KEY]: treeish,
-        ...(preCheckoutAction
-            ? { [PRE_CHECKOUT_ACTION_META_KEY]: preCheckoutAction }
-            : {}),
-    };
-}
-function hasErrorReason(data) {
-    return typeof data === 'object' && data !== null && hasKey(data, { reason: true });
-}
-function isCheckoutOperationDirtyWorkingTreeErrorData(data) {
-    return hasErrorReason(data) && data.reason === DIRTY_WORKING_TREE_ERROR_REASON;
-}
-
-export { CheckoutOperationPreAction, checkoutOperationMeta, isCheckoutOperationDirtyWorkingTreeErrorData };

package/vscode/src/vs/sessions/browser/parts/singlePaneAuxiliaryBarPart.js

@@ -1,36 +0,0 @@
-
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colorUtils';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/baseColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/chartsColors';
-import { editorBackground } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/editorColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/inputColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/listColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/menuColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/minimapColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/miscColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/quickpickColors';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/colors/searchColors';
-import { AbstractPaneCompositePart } from '@codingame/monaco-vscode-api/vscode/vs/workbench/browser/parts/paneCompositePart';
-import { Parts } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/layout/browser/layoutService';
-import { AuxiliaryBarPart } from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/auxiliaryBarPart';
-
-class SinglePaneAuxiliaryBarPart extends AuxiliaryBarPart {
-    create(parent) {
-        this.options = { ...this.options, hasTitle: false };
-        super.create(parent);
-    }
-    shouldShowCompositeBar() {
-        return false;
-    }
-    getPartBackgroundColor() {
-        return this.getColor(editorBackground) || '';
-    }
-    layout(width, height, top, left) {
-        if (!this.layoutService.isVisible(Parts.AUXILIARYBAR_PART)) {
-            return;
-        }
-        AbstractPaneCompositePart.prototype.layout.call(this, width, height, top, left);
-    }
-}
-
-export { SinglePaneAuxiliaryBarPart };

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

@@ -1,37 +0,0 @@
-import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-export declare const DEFAULT_HEARTBEAT_INTERVAL_MS = 30000;
-export declare const DEFAULT_STALE_AFTER_MS = 90000;
-export interface IAutomationLeaderElectionOptions {
-    readonly heartbeatIntervalMs?: number;
-    readonly staleAfterMs?: number;
-    readonly now?: () => number;
-    readonly instanceId?: string;
-}
-export declare class AutomationLeaderElection extends Disposable {
-    private readonly storageService;
-    private readonly logService;
-    private readonly _isLeader;
-    readonly isLeader: IObservable<boolean>;
-    private readonly _instanceId;
-    private readonly _heartbeatIntervalMs;
-    private readonly _staleAfterMs;
-    private readonly _now;
-    private readonly _timer;
-    constructor(storageService: IStorageService, logService: ILogService, options?: IAutomationLeaderElectionOptions);
-    get instanceId(): string;
-    /** Test-only: drive the evaluation cycle synchronously. */
-    evaluateForTesting(): void;
-    private evaluate;
-    private readLeader;
-    /** Returns true if the write succeeded, false if storage threw. */
-    private writeLeader;
-    private releaseIfLeader;
-}
-export interface IAutomationLeaderElection extends IDisposable {
-    readonly isLeader: IObservable<boolean>;
-    readonly instanceId: string;
-    evaluateForTesting(): void;
-}

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

@@ -1,126 +0,0 @@
-
-import { IntervalTimer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
-import { generateUuid } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uuid';
-import { StorageScope, StorageTarget } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage';
-import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
-
-const LEADER_KEY = "chat.automations.leader";
-const DEFAULT_HEARTBEAT_INTERVAL_MS = 30_000;
-const DEFAULT_STALE_AFTER_MS = 90_000;
-class AutomationLeaderElection extends Disposable {
-    constructor(storageService, logService, options = {}) {
-        super();
-        this.storageService = storageService;
-        this.logService = logService;
-        this._timer = this._register(( new IntervalTimer()));
-        this._instanceId = options.instanceId ?? generateUuid();
-        this._heartbeatIntervalMs = options.heartbeatIntervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
-        this._staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
-        this._now = options.now ?? Date.now;
-        this._isLeader = observableValue(this, false);
-        this.isLeader = this._isLeader;
-        this._register(toDisposable(() => this.releaseIfLeader()));
-        this.evaluate();
-        this._timer.cancelAndSet(() => this.evaluate(), this._heartbeatIntervalMs);
-    }
-    get instanceId() {
-        return this._instanceId;
-    }
-    evaluateForTesting() {
-        this.evaluate();
-    }
-    evaluate() {
-        const now = this._now();
-        const current = this.readLeader();
-        const claimable = !current || current.instanceId === this._instanceId || current.instanceId === "" || (now - current.heartbeatAt) > this._staleAfterMs;
-        if (!claimable) {
-            if (this._isLeader.get()) {
-                this.logService.info(
-                    `[AutomationLeaderElection] window ${this._instanceId} stood down for ${current.instanceId}.`
-                );
-            }
-            this._isLeader.set(false, undefined);
-            return;
-        }
-        const nonce = generateUuid();
-        const writeOk = this.writeLeader({
-            instanceId: this._instanceId,
-            heartbeatAt: now,
-            nonce
-        });
-        if (!writeOk) {
-            this._isLeader.set(false, undefined);
-            return;
-        }
-        const verify = this.readLeader();
-        if (verify?.instanceId === this._instanceId && verify.nonce === nonce) {
-            if (!this._isLeader.get()) {
-                this.logService.info(
-                    `[AutomationLeaderElection] window ${this._instanceId} claimed leader slot.`
-                );
-            }
-            this._isLeader.set(true, undefined);
-        } else {
-            if (this._isLeader.get()) {
-                this.logService.info(
-                    `[AutomationLeaderElection] window ${this._instanceId} lost leader race to ${verify?.instanceId ?? "<none>"}.`
-                );
-            }
-            this._isLeader.set(false, undefined);
-        }
-    }
-    readLeader() {
-        let raw;
-        try {
-            raw = this.storageService.get(LEADER_KEY, StorageScope.APPLICATION);
-        } catch (err) {
-            this.logService.warn("[AutomationLeaderElection] storage read failed", err);
-            return undefined;
-        }
-        if (!raw) {
-            return undefined;
-        }
-        try {
-            const parsed = JSON.parse(raw);
-            if (typeof parsed?.instanceId !== "string" || typeof parsed?.heartbeatAt !== "number") {
-                return undefined;
-            }
-            return {
-                instanceId: parsed.instanceId,
-                heartbeatAt: parsed.heartbeatAt,
-                nonce: typeof parsed.nonce === "string" ? parsed.nonce : ""
-            };
-        } catch {
-            return undefined;
-        }
-    }
-    writeLeader(record) {
-        try {
-            this.storageService.store(
-                LEADER_KEY,
-                JSON.stringify(record),
-                StorageScope.APPLICATION,
-                StorageTarget.MACHINE
-            );
-            return true;
-        } catch (err) {
-            this.logService.warn("[AutomationLeaderElection] storage write failed", err);
-            return false;
-        }
-    }
-    releaseIfLeader() {
-        const current = this.readLeader();
-        if (current?.instanceId !== this._instanceId) {
-            return;
-        }
-        this.writeLeader({
-            instanceId: "",
-            heartbeatAt: 0,
-            nonce: ""
-        });
-    }
-}
-
-export { AutomationLeaderElection, DEFAULT_HEARTBEAT_INTERVAL_MS, DEFAULT_STALE_AFTER_MS };

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

@@ -1,59 +0,0 @@
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-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 { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.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 { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
-import { IAutomationLeaderElection } from "./automationLeaderElection.js";
-export declare const DEFAULT_SCHEDULER_TICK_MS = 60000;
-export declare const CRASH_RECOVERY_REASON: string;
-export declare const RUN_TIMEOUT_REASON_PREFIX = "Timed out after";
-export interface IAutomationSchedulerCoreOptions {
-    readonly tickIntervalMs?: number;
-    readonly now?: () => Date;
-    readonly leaderElection?: IAutomationLeaderElection;
-    readonly disableAutoTick?: boolean;
-    readonly isFeatureEnabled?: () => boolean;
-    readonly getRunTimeoutMs?: () => number;
-    readonly onDidChangeTargetAvailability?: Event<void>;
-}
-export declare class AutomationSchedulerCore extends Disposable {
-    private readonly automationService;
-    private readonly runner;
-    private readonly logService;
-    private readonly _leader;
-    private readonly _tickIntervalMs;
-    private readonly _now;
-    private readonly _isFeatureEnabled;
-    private readonly _getRunTimeoutMs;
-    private readonly _timer;
-    private readonly _runCts;
-    private _didStartupForCurrentLeadership;
-    private _pendingRuns;
-    constructor(automationService: IAutomationService, runner: IAutomationRunner, storageService: IStorageService, logService: ILogService, options?: IAutomationSchedulerCoreOptions);
-    /** Test-only: run a single tick and await it. */
-    tickForTesting(): Promise<void>;
-    /** Test-only: await in-flight runs. */
-    waitForPendingRuns(): Promise<void>;
-    private kickoffPendingRuns;
-    private tickOnce;
-    private dispatchDue;
-    private runOneWithTimeout;
-    dispose(): void;
-}
-export declare class AutomationScheduler extends Disposable implements IWorkbenchContribution {
-    private readonly _automationService;
-    private readonly _runner;
-    private readonly _storageService;
-    private readonly _logService;
-    private readonly _configurationService;
-    private readonly _sessionsManagementService;
-    static readonly ID = "workbench.contrib.automationScheduler";
-    private readonly _core;
-    constructor(_automationService: IAutomationService, _runner: IAutomationRunner, _storageService: IStorageService, _logService: ILogService, _configurationService: IConfigurationService, _sessionsManagementService: ISessionsManagementService);
-    private _isEnabled;
-    private _createCore;
-}

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

@@ -1,232 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { IntervalTimer, raceTimeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
-import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
-import { stringHash } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
-import { Disposable, MutableDisposable } 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 { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
-import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-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 { DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES, CHAT_AUTOMATIONS_ENABLED_SETTING, CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
-import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
-import { AutomationLeaderElection } from './automationLeaderElection.js';
-import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
-
-const DEFAULT_SCHEDULER_TICK_MS = 60_000;
-const CRASH_RECOVERY_REASON = ( localize(3364, "Interrupted by app shutdown"));
-class AutomationSchedulerCore extends Disposable {
-    constructor(automationService, runner, storageService, logService, options = {}) {
-        super();
-        this.automationService = automationService;
-        this.runner = runner;
-        this.logService = logService;
-        this._timer = this._register(( new IntervalTimer()));
-        this._runCts = this._register(( new CancellationTokenSource()));
-        this._didStartupForCurrentLeadership = false;
-        this._pendingRuns = Promise.resolve();
-        this._tickIntervalMs = options.tickIntervalMs ?? DEFAULT_SCHEDULER_TICK_MS;
-        this._now = options.now ?? (() => ( new Date()));
-        this._isFeatureEnabled = options.isFeatureEnabled ?? (() => true);
-        this._getRunTimeoutMs = options.getRunTimeoutMs ?? (() => DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES * 60_000);
-        this._leader = options.leaderElection ?? this._register(( new AutomationLeaderElection(storageService, logService)));
-        this._register(autorun(reader => {
-            const isLeader = this._leader.isLeader.read(reader);
-            if (!isLeader) {
-                this._didStartupForCurrentLeadership = false;
-                this.automationService.stopStaleRunRecovery();
-                return;
-            }
-            this.kickoffPendingRuns(() => this.tickOnce(true));
-        }));
-        if (!options.disableAutoTick) {
-            this._timer.cancelAndSet(() => {
-                this.kickoffPendingRuns(() => this.tickOnce(false));
-            }, this._tickIntervalMs);
-        }
-        if (options.onDidChangeTargetAvailability) {
-            this._register(options.onDidChangeTargetAvailability(() => {
-                this.kickoffPendingRuns(() => this.tickOnce(false));
-            }));
-        }
-    }
-    async tickForTesting() {
-        this.kickoffPendingRuns(() => this.tickOnce(false));
-        await this._pendingRuns;
-    }
-    async waitForPendingRuns() {
-        await this._pendingRuns;
-    }
-    kickoffPendingRuns(task) {
-        if (this._store.isDisposed) {
-            return;
-        }
-        this._pendingRuns = this._pendingRuns.then(task).catch(err => {
-            this.logService.error("[AutomationScheduler] tick failed", err);
-        });
-    }
-    async tickOnce(isLeadershipTransition) {
-        if (!this._leader.isLeader.get()) {
-            return;
-        }
-        if (!this._isFeatureEnabled()) {
-            return;
-        }
-        if (!this._didStartupForCurrentLeadership) {
-            this._didStartupForCurrentLeadership = true;
-            await this.automationService.startStaleRunRecovery(CRASH_RECOVERY_REASON);
-            await this.dispatchDue("catch_up");
-            if (isLeadershipTransition) {
-                return;
-            }
-        }
-        await this.dispatchDue("schedule");
-    }
-    async dispatchDue(trigger) {
-        const now = this._now();
-        const due = this.automationService.automations.get().filter(
-            automation => this.automationService.isSchedulingOwnedByHost?.(automation.id) !== true && isDue(automation, now)
-        );
-        if (due.length === 0) {
-            return;
-        }
-        const leaderWindowId = stringHash(this._leader.instanceId, 0);
-        for (const automation of due) {
-            try {
-                await this.runOneWithTimeout(automation, trigger, leaderWindowId);
-            } catch (err) {
-                this.logService.error("[AutomationScheduler] dispatch failed for automation", automation.id, err);
-            }
-        }
-    }
-    async runOneWithTimeout(automation, trigger, leaderWindowId) {
-        const timeoutMs = this._getRunTimeoutMs();
-        const perRunCts = ( new CancellationTokenSource(this._runCts.token));
-        try {
-            if (timeoutMs <= 0) {
-                await this.runner.runOnce(automation, trigger, leaderWindowId, perRunCts.token).whenCompleted;
-                return;
-            }
-            let timedOut = false;
-            await raceTimeout(
-                this.runner.runOnce(automation, trigger, leaderWindowId, perRunCts.token).whenCompleted,
-                timeoutMs,
-                () => {
-                    timedOut = true;
-                }
-            );
-            if (!timedOut) {
-                return;
-            }
-            try {
-                const active = this.automationService.getActiveRunFor(automation.id);
-                if (active) {
-                    const updated = await this.automationService.updateRun(active.id, {
-                        status: "failed",
-                        errorMessage: ( localize(3365, "Timed out after {0} minute(s).", Math.round(timeoutMs / 60_000))),
-                        completedAt: this._now().toISOString()
-                    });
-                    if (updated) {
-                        this.logService.warn(
-                            `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms; marked run ${active.id} failed (previousStatus=${active.status}, session=${updated.sessionResource?.toString() ?? "(none)"}).`
-                        );
-                    } else {
-                        this.logService.warn(
-                            `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms, but active run ${active.id} disappeared before it could be marked failed (previousStatus=${active.status}, session=${active.sessionResource?.toString() ?? "(none)"}).`
-                        );
-                    }
-                } else {
-                    this.logService.warn(
-                        `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms with no active run recorded.`
-                    );
-                }
-            } catch (err) {
-                this.logService.warn(
-                    `[AutomationScheduler] automation ${automation.id} timed out after ${timeoutMs}ms and failed to mark its active run as failed.`,
-                    err
-                );
-            }
-            perRunCts.cancel();
-        } finally {
-            perRunCts.dispose();
-        }
-    }
-    dispose() {
-        this.automationService.stopStaleRunRecovery();
-        this._runCts.cancel();
-        super.dispose();
-    }
-}
-let AutomationScheduler = class AutomationScheduler extends Disposable {
-    static {
-        this.ID = "workbench.contrib.automationScheduler";
-    }
-    constructor(
-        _automationService,
-        _runner,
-        _storageService,
-        _logService,
-        _configurationService,
-        _sessionsManagementService
-    ) {
-        super();
-        this._automationService = _automationService;
-        this._runner = _runner;
-        this._storageService = _storageService;
-        this._logService = _logService;
-        this._configurationService = _configurationService;
-        this._sessionsManagementService = _sessionsManagementService;
-        this._core = this._register(( new MutableDisposable()));
-        if (this._isEnabled()) {
-            this._createCore();
-        }
-        this._register(_configurationService.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(CHAT_AUTOMATIONS_ENABLED_SETTING)) {
-                if (this._isEnabled()) {
-                    this._createCore();
-                } else {
-                    this._core.clear();
-                }
-            }
-        }));
-    }
-    _isEnabled() {
-        return this._configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true;
-    }
-    _createCore() {
-        if (this._core.value) {
-            return;
-        }
-        this._core.value = ( new AutomationSchedulerCore(
-            this._automationService,
-            this._runner,
-            this._storageService,
-            this._logService,
-            {
-                isFeatureEnabled: () => this._isEnabled(),
-                getRunTimeoutMs: () => {
-                    const minutes = this._configurationService.getValue(CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING);
-                    const sane = typeof minutes === "number" && Number.isFinite(minutes) && minutes >= 1 ? minutes : DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES;
-                    return sane * 60_000;
-                },
-                onDidChangeTargetAvailability: this._sessionsManagementService.onDidChangeSessionTypes
-            }
-        ));
-    }
-};
-AutomationScheduler = ( __decorate([( __param(0, IAutomationService)), ( __param(1, IAutomationRunner)), ( __param(2, IStorageService)), ( __param(3, ILogService)), ( __param(4, IConfigurationService)), ( __param(5, ISessionsManagementService))], AutomationScheduler));
-function isDue(automation, now) {
-    if (!automation.enabled || !automation.nextRunAt) {
-        return false;
-    }
-    const next = Date.parse(automation.nextRunAt);
-    if (Number.isNaN(next)) {
-        return false;
-    }
-    return next <= now.getTime();
-}
-
-export { AutomationScheduler, AutomationSchedulerCore, CRASH_RECOVERY_REASON, DEFAULT_SCHEDULER_TICK_MS };

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

@@ -1,13 +0,0 @@
-import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
-import { IAutomationStorageCompareAndSwapResult } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/common/automationStorageService";
-import { IAutomationStorageService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/automations/common/automationStorageService.service";
-/**
- * Uses an IndexedDB transaction so automation writes remain atomic across browser tabs.
- */
-export declare class BrowserAutomationStorageService implements IAutomationStorageService {
-    readonly _serviceBrand: undefined;
-    private readonly storageService;
-    constructor(storageService: IStorageService);
-    read(key: string): Promise<string | undefined>;
-    compareAndSwap(key: string, expectedValue: string | undefined, newValue: string): Promise<IAutomationStorageCompareAndSwapResult>;
-}

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

@@ -1,22 +0,0 @@
-
-import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
-import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
-import { BrowserStorageService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/storage/browser/storageService';
-
-let BrowserAutomationStorageService = class BrowserAutomationStorageService {
-    constructor(storageService) {
-        if (!(storageService instanceof BrowserStorageService)) {
-            throw ( new Error("Browser automation storage requires BrowserStorageService."));
-        }
-        this.storageService = storageService;
-    }
-    async read(key) {
-        return this.storageService.getApplicationStorageValue(key);
-    }
-    async compareAndSwap(key, expectedValue, newValue) {
-        return this.storageService.compareAndSwapApplicationStorage(key, expectedValue, newValue);
-    }
-};
-BrowserAutomationStorageService = ( __decorate([( __param(0, IStorageService))], BrowserAutomationStorageService));
-
-export { BrowserAutomationStorageService };