@codingame/monaco-vscode-chat-cloud-service-override 0.0.0-stage → 38.0.7

package/vscode/src/vs/sessions/contrib/providers/copilotChatSessions/browser/cloudAutomationStore.js

@@ -0,0 +1,695 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { RunOnceScheduler } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { isCancellationError, CancellationError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isStringArray } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ChatAIDisabledSettingId } from '@codingame/monaco-vscode-api/vscode/vs/platform/chat/common/chatSettings';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { IDefaultAccountService } from '@codingame/monaco-vscode-api/vscode/vs/platform/defaultAccount/common/defaultAccount.service';
+import { MutationUncertainError, ApiRequestError } from '@codingame/monaco-vscode-api/vscode/vs/platform/github/common/missionControl/missionControlClient';
+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 { getGitHubRepositoryId } from '@codingame/monaco-vscode-api/vscode/vs/platform/github/common/githubUrls';
+import { RepositoryPicker } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/browser/agentSessions/repositoryPicker';
+import { IGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/github/browser/githubService.service';
+import { AutomationUnavailableError, serializeAutomationEditableState, assertAutomationSessionTemplateAuthority } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationService';
+import { CHAT_CLOUD_AUTOMATIONS_ENABLED_SETTING, CHAT_AUTOMATIONS_ENABLED_SETTING } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/automations/automationsEnabled';
+import { IChatEntitlementService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service';
+import { IWorkbenchGitHubService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/github/common/githubService.service';
+import { GITHUB_REMOTE_FILE_SCHEME } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { GitHubCloudAutomationStore } from './githubCloudAutomationStore.js';
+import { observableValue } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableValue';
+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';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+import { transaction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/transaction';
+
+let CloudAutomationStore = class CloudAutomationStore extends Disposable {
+    constructor(
+        providerId,
+        sessionTypeId,
+        resolveRepositoryUri,
+        configurationService,
+        defaultAccountService,
+        entitlementService,
+        instantiationService,
+        logService,
+        gitHubService,
+        workbenchGitHubService
+    ) {
+        super();
+        this.providerId = providerId;
+        this.sessionTypeId = sessionTypeId;
+        this.defaultAccountService = defaultAccountService;
+        this.instantiationService = instantiationService;
+        this.logService = logService;
+        this.gitHubService = gitHubService;
+        this.store = observableValue(this, undefined);
+        this.refreshError = observableValue(this, undefined);
+        this.historyState = observableValue(this, "ready");
+        this.discoveryAttempts = 0;
+        this.historyScheduler = this._register(( new RunOnceScheduler(() => {
+            this.discoveryAttempts = Math.max(0, this.discoveryAttempts - 1);
+            this.refreshHistoryInBackground();
+        }, 15_000)));
+        this.catalogueState = derived(
+            this,
+            reader => this.refreshError.read(reader) ? "error" : this.store.read(reader)?.catalogueState.read(reader) ?? "unavailable"
+        );
+        this.unavailableReason = this.refreshError;
+        this.canCreateAutomation = derived(
+            this,
+            reader => this.enabled.read(reader) && this.catalogueState.read(reader) === "ready" && this.store.read(reader)?.mutationUncertain.read(reader) === false
+        );
+        this.automations = derived(
+            this,
+            reader => (this.store.read(reader)?.entries.read(reader) ?? []).map(entry => this.toAutomation(entry))
+        );
+        this.runs = derived(
+            this,
+            reader => (this.store.read(reader)?.history.read(reader) ?? []).map(entry => this.toRun(entry)).filter(run => run !== undefined)
+        );
+        this.configuration = {
+            sessionTypes: [sessionTypeId],
+            description: ( localize(5027, "Runs even when your computer is off, triggered on a schedule.")),
+            timeZone: "UTC",
+            targetChangeDisabledReason: ( localize(
+                5028,
+                "The repository and provider cannot be changed for an existing cloud automation. Duplicate this automation to use another target."
+            )),
+            tools: derived(this, reader => toToolCatalog(
+                this.store.read(reader)?.toolCatalog.read(reader),
+                !!this.store.read(reader)
+            )),
+            loadTools: () => this.store.get()?.loadTools(),
+            pickWorkspace: token => this.pickWorkspace(token),
+            getWorkspaceTarget: workspace => derived(
+                reader => this.store.read(reader)?.getWorkspaceTarget(workspace).read(reader) ?? {
+                    disabledReason: ( localize(5029, "Cloud automations are unavailable."))
+                }
+            )
+        };
+        const configurationChanged = observableSignalFromEvent(this, configurationService.onDidChangeConfiguration);
+        const sentimentChanged = observableSignalFromEvent(this, entitlementService.onDidChangeSentiment);
+        const accountChanged = observableSignalFromEvent(this, defaultAccountService.onDidChangeDefaultAccount);
+        const clientChanged = observableSignalFromEvent(this, workbenchGitHubService.onDidChangeDefaultClient);
+        this.enabled = derived(this, reader => {
+            configurationChanged.read(reader);
+            sentimentChanged.read(reader);
+            return configurationService.getValue(CHAT_CLOUD_AUTOMATIONS_ENABLED_SETTING) === true && configurationService.getValue(CHAT_AUTOMATIONS_ENABLED_SETTING) === true && configurationService.getValue(ChatAIDisabledSettingId) !== true && !entitlementService.sentiment.hidden;
+        });
+        this._register(autorun(reader => {
+            accountChanged.read(reader);
+            clientChanged.read(reader);
+            this.historyScheduler.cancel();
+            this.discoveryAttempts = 0;
+            this.historyRefresh = undefined;
+            const account = defaultAccountService.currentDefaultAccount;
+            let store;
+            if (this.enabled.read(reader) && account && !account.enterprise) {
+                store = reader.store.add(
+                    instantiationService.createInstance(GitHubCloudAutomationStore, resolveRepositoryUri)
+                );
+            }
+            transaction(tx => {
+                this.store.set(store, tx);
+                this.refreshError.set(undefined, tx);
+                this.historyState.set("ready", tx);
+            });
+            if (store) {
+                void (async () => {
+                    await Promise.resolve();
+                    this.assertCurrentStore(store);
+                    await this.refresh();
+                })().catch(error => {
+                    if (!isCancellationError(error)) {
+                        this.logService.warn("[CloudAutomations] Initial refresh failed", error);
+                    }
+                });
+            }
+        }));
+    }
+    async pickWorkspace(token) {
+        const store = this.requireStore();
+        const resources = ( new DisposableStore());
+        const checkAccount = () => {
+            this.assertCurrentStore(store);
+            if (token.isCancellationRequested) {
+                throw ( new CancellationError());
+            }
+            if (this.gitHubService.enterpriseHost !== undefined) {
+                throw ( new Error(( localize(5030, "Select a private repository on GitHub.com."))));
+            }
+        };
+        try {
+            checkAccount();
+            await this.gitHubService.authenticateForRepositoryAccess(token);
+            checkAccount();
+            const picker = resources.add(this.instantiationService.createInstance(RepositoryPicker));
+            const result = await picker.pickRepository(async (query, requestToken) => {
+                checkAccount();
+                const repositories = await this.gitHubService.getRepositories(getGitHubRepositoryId(query.trim()) ?? query, requestToken);
+                checkAccount();
+                return repositories.filter(repository => repository.isPrivate).map(repository => repository.fullName);
+            }, {
+                allowRepositoryUrl: true,
+                placeholder: ( localize(5031, "Search for a private repository or paste a repository URL..."))
+            }, token);
+            checkAccount();
+            if (!result) {
+                return undefined;
+            }
+            const repository = getGitHubRepositoryId(result.repository ?? result.cloneUrl ?? "");
+            if (!repository) {
+                throw ( new Error(( localize(5030, "Select a private repository on GitHub.com."))));
+            }
+            return ( URI.from({
+                scheme: GITHUB_REMOTE_FILE_SCHEME,
+                authority: "github",
+                path: `/${repository}/HEAD`
+            }));
+        } finally {
+            resources.dispose();
+        }
+    }
+    async refresh() {
+        const store = this.requireStore();
+        try {
+            await store.refresh();
+            if (this.store.get() === store) {
+                this.refreshError.set(undefined, undefined);
+            }
+        } catch (error) {
+            if (this.store.get() === store && !isCancellationError(error)) {
+                this.refreshError.set(error instanceof Error ? error.message : ( localize(5032, "Cloud automations could not be refreshed.")), undefined);
+            }
+            throw error;
+        }
+        this.assertCurrentStore(store);
+        await this.refreshHistory();
+    }
+    refreshHistory() {
+        if (this.historyRefresh) {
+            return this.historyRefresh;
+        }
+        const store = this.requireStore();
+        this.historyScheduler.cancel();
+        this.historyState.set("loading", undefined);
+        this.historyRefresh = (async () => {
+            try {
+                await store.refreshHistory();
+                this.assertCurrentStore(store);
+                this.historyState.set("ready", undefined);
+            } catch (error) {
+                if (this.store.get() === store && !isCancellationError(error)) {
+                    this.historyState.set("error", undefined);
+                }
+                throw error;
+            } finally {
+                if (this.store.get() === store && !this._store.isDisposed) {
+                    this.historyRefresh = undefined;
+                    if (this.historyState.get() === "ready" && (this.discoveryAttempts > 0 || ( this.runs.get().some(run => run.status === "pending" || run.status === "running")))) {
+                        this.historyScheduler.schedule();
+                    }
+                }
+            }
+        })();
+        return this.historyRefresh;
+    }
+    refreshHistoryInBackground() {
+        void this.refreshHistory().catch(error => {
+            if (!isCancellationError(error)) {
+                this.logService.warn("[CloudAutomations] History refresh failed", error);
+            }
+        });
+    }
+    getAutomation(id) {
+        return this.automations.get().find(automation => automation.id === id);
+    }
+    runsFor(id) {
+        return derived(
+            this,
+            reader => this.runs.read(reader).filter(run => run.automationId === id)
+        );
+    }
+    getActiveRunFor(id) {
+        return this.runs.get().filter(
+            run => run.automationId === id && (run.status === "pending" || run.status === "running")
+        ).sort((a, b) => b.startedAt.localeCompare(a.startedAt))[0];
+    }
+    canRunAutomation(id) {
+        return this.canCreateAutomation.get() && this.getAutomation(id) !== undefined;
+    }
+    canUpdateAutomation(id) {
+        return this.canRunAutomation(id) && !this.getAutomation(id)?.readOnlyReason;
+    }
+    canDeleteAutomation(id) {
+        return this.canRunAutomation(id);
+    }
+    async createAutomation(options, guard) {
+        const store = this.requireWritableStore();
+        this.validateTarget(options.target);
+        validateLocalOptions(options);
+        const value = {
+            name: options.name,
+            description: "",
+            prompt: options.prompt,
+            disabled: !(options.enabled ?? true),
+            triggers: cloudAutomationTriggers(options.schedule),
+            ...templateMutation(options.sessionTemplate),
+            ...(options.modelId !== undefined && options.sessionTemplate === undefined ? {
+                model: options.modelId
+            } : {})
+        };
+        const entry = await store.create(options.target.folderUri, value, guard);
+        this.assertCurrentStore(store);
+        return this.toAutomation(entry);
+    }
+    async updateAutomation(id, patch) {
+        const store = this.requireWritableStore();
+        const {
+            entry
+        } = await store.update(this.requireEntry(id), current => this.updateValue(current, id, patch));
+        this.assertCurrentStore(store);
+        if (!entry) {
+            throw ( new AutomationUnavailableError(( localize(
+                5033,
+                "This cloud automation is no longer available. Refresh the catalogue."
+            ))));
+        }
+        return this.toAutomation(entry);
+    }
+    async updateAutomationIfUnchanged(id, patch, expected, guard) {
+        const store = this.requireWritableStore();
+        const entry = this.requireEntry(id);
+        const result = await store.update(entry, current => {
+            const latest = this.toAutomation({
+                repository: entry.repository,
+                definition: current
+            });
+            return serializeAutomationEditableState(latest) === serializeAutomationEditableState(expected) ? this.updateValue(current, id, patch) : undefined;
+        }, guard);
+        this.assertCurrentStore(store);
+        if (!result.entry) {
+            return {
+                kind: "conflict",
+                current: undefined
+            };
+        }
+        const automation = this.toAutomation(result.entry);
+        return result.updated ? {
+            kind: "updated",
+            automation
+        } : {
+            kind: "conflict",
+            current: automation
+        };
+    }
+    async deleteAutomation(id, guard) {
+        await this.requireWritableStore().delete(this.requireEntry(id), guard);
+    }
+    async runAutomation(id, token = CancellationToken.None) {
+        const store = this.requireWritableStore();
+        try {
+            await store.run(this.requireEntry(id), token);
+        } catch (error) {
+            if ((error instanceof MutationUncertainError || error instanceof ApiRequestError && error.outcome === "indeterminate") && this.store.get() === store) {
+                this.discoveryAttempts = 4;
+                this.refreshHistoryInBackground();
+            }
+            throw error;
+        }
+        this.assertCurrentStore(store);
+        this.discoveryAttempts = 4;
+        this.refreshHistoryInBackground();
+        return {
+            kind: "accepted"
+        };
+    }
+    canStopRun(run) {
+        return this.canRunAutomation(run.automationId) && ( this.runs.get().some(
+            current => current.id === run.id && (current.status === "pending" || current.status === "running")
+        ));
+    }
+    async stopRun(run) {
+        const store = this.requireWritableStore();
+        const entry = store.history.get().find(entry => this.toRun(entry)?.id === run.id);
+        if (!entry || !this.canStopRun(run)) {
+            throw ( new AutomationUnavailableError(( localize(5034, "Unable to stop this cloud automation run."))));
+        }
+        await store.stop(entry);
+        this.assertCurrentStore(store);
+        this.discoveryAttempts = 4;
+        this.refreshHistoryInBackground();
+    }
+    updateValue(definition, id, patch) {
+        validateLocalOptions(patch);
+        if (patch.sessionTemplate === null) {
+            throw ( new Error(( localize(5035, "Resetting cloud automation configuration is not supported."))));
+        }
+        const current = this.getAutomation(id);
+        assertAutomationSessionTemplateAuthority(current, patch);
+        if (cloudAutomationSchedule(definition.triggers).interval === "custom") {
+            throw ( new Error(( localize(5036, "This automation uses triggers that cannot be edited in VS Code."))));
+        }
+        if (patch.target) {
+            this.validateTarget(patch.target);
+            if (current.target.kind !== "workspace" || !isEqual(current.target.folderUri, patch.target.folderUri)) {
+                throw ( new Error(( localize(5037, "Duplicate this automation to use another repository."))));
+            }
+        }
+        let triggers = patch.schedule ? cloudAutomationTriggers(patch.schedule) : undefined;
+        if (triggers?.interval && definition.triggers?.interval) {
+            const {
+                types: _types,
+                hour_utc: _hour,
+                minute_utc: _minute,
+                day_of_week: _day,
+                ...otherFields
+            } = definition.triggers.interval;
+            triggers = {
+                interval: {
+                    ...otherFields,
+                    ...triggers.interval
+                }
+            };
+        }
+        return {
+            ...(patch.name !== undefined ? {
+                name: patch.name
+            } : {}),
+            ...(patch.prompt !== undefined ? {
+                prompt: patch.prompt
+            } : {}),
+            ...(patch.enabled !== undefined ? {
+                disabled: !patch.enabled
+            } : {}),
+            ...(triggers !== undefined ? {
+                triggers
+            } : {}),
+            ...(patch.sessionTemplate !== undefined ? templateMutation(patch.sessionTemplate) : {}),
+            ...(patch.modelId !== undefined ? {
+                model: patch.modelId ?? ""
+            } : {})
+        };
+    }
+    validateTarget(target) {
+        if (target.providerId !== this.providerId || target.sessionTypeId !== this.sessionTypeId || target.kind !== "workspace" || target.isolation.kind !== "default") {
+            throw ( new Error(( localize(
+                5038,
+                "Select a GitHub repository with default isolation for this cloud automation."
+            ))));
+        }
+    }
+    requireStore() {
+        const store = this.store.get();
+        if (!store || !this.enabled.get() || this._store.isDisposed) {
+            throw ( new AutomationUnavailableError(( localize(
+                5039,
+                "Sign in to GitHub.com and enable cloud automations before continuing."
+            ))));
+        }
+        return store;
+    }
+    assertCurrentStore(store) {
+        if (this.store.get() !== store || this._store.isDisposed) {
+            throw ( new CancellationError());
+        }
+    }
+    requireWritableStore() {
+        const store = this.requireStore();
+        if (!this.canCreateAutomation.get()) {
+            throw ( new AutomationUnavailableError(( localize(5040, "Refresh cloud automations before submitting another request."))));
+        }
+        return store;
+    }
+    requireEntry(id) {
+        const entry = this.requireStore().entries.get().find(entry => this.toAutomation(entry).id === id);
+        if (!entry) {
+            throw ( new AutomationUnavailableError(( localize(
+                5033,
+                "This cloud automation is no longer available. Refresh the catalogue."
+            ))));
+        }
+        return entry;
+    }
+    toAutomation(entry) {
+        const {
+            definition,
+            repository
+        } = entry;
+        const schedule = cloudAutomationSchedule(definition.triggers);
+        return {
+            id: JSON.stringify([
+                this.providerId,
+                this.defaultAccountService.currentDefaultAccount?.accountName,
+                repository.owner.toLowerCase(),
+                repository.name.toLowerCase(),
+                definition.id
+            ]),
+            name: definition.name,
+            prompt: definition.prompt,
+            schedule,
+            targetDisplay: {
+                label: `${repository.owner}/${repository.name}`,
+                icon: Codicon.cloud
+            },
+            externalResource: ( URI.from({
+                scheme: Schemas.https,
+                authority: "github.com",
+                path: `/${repository.owner}/${repository.name}/agents/automations/${definition.id}`
+            })),
+            target: {
+                kind: "workspace",
+                providerId: this.providerId,
+                sessionTypeId: this.sessionTypeId,
+                isolation: {
+                    kind: "default"
+                },
+                folderUri: ( URI.from({
+                    scheme: GITHUB_REMOTE_FILE_SCHEME,
+                    authority: "github",
+                    path: `/${repository.owner}/${repository.name}/HEAD`
+                }))
+            },
+            sessionTemplate: {
+                ...(definition.model ? {
+                    modelId: definition.model
+                } : {}),
+                config: {
+                    ...(definition.tools ? {
+                        tools: definition.tools
+                    } : {}),
+                    ...(definition.reasoning_effort ? {
+                        reasoningEffort: definition.reasoning_effort
+                    } : {})
+                }
+            },
+            enabled: definition.disabled !== true,
+            createdAt: definition.created_at,
+            updatedAt: definition.updated_at,
+            ...(schedule.interval === "custom" ? {
+                readOnlyReason: ( localize(5041, "This automation uses triggers that cannot be edited in VS Code."))
+            } : {})
+        };
+    }
+    toRun(
+        {
+            entry,
+            task
+        }
+    ) {
+        const status = cloudTaskStatus(task);
+        if (status === undefined) {
+            this.logService.warn(
+                `[CloudAutomations] Skipping run ${task.id} with unsupported state: ${task.state}`
+            );
+            return undefined;
+        }
+        const automationId = this.toAutomation(entry).id;
+        return {
+            id: JSON.stringify([automationId, task.id]),
+            automationId,
+            status,
+            trigger: "external",
+            startedAt: task.created_at,
+            updatedAt: task.updated_at,
+            ...(status === "completed" || status === "failed" ? {
+                completedAt: task.updated_at
+            } : {}),
+            ...(status === "failed" ? {
+                errorMessage: task.status || task.state
+            } : {}),
+            ...(task.state === "waiting_for_user" ? {
+                needsInput: true,
+                statusDescription: ( localize(5042, "Needs input on GitHub"))
+            } : {}),
+            externalResource: ( URI.from({
+                scheme: Schemas.https,
+                authority: "github.com",
+                path: `/${entry.repository.owner}/${entry.repository.name}/tasks/${task.id}`
+            }))
+        };
+    }
+};
+CloudAutomationStore = ( __decorate([( __param(3, IConfigurationService)), ( __param(4, IDefaultAccountService)), ( __param(5, IChatEntitlementService)), ( __param(6, IInstantiationService)), ( __param(7, ILogService)), ( __param(8, IGitHubService)), ( __param(9, IWorkbenchGitHubService))], CloudAutomationStore));
+function toToolCatalog(catalog, available) {
+    if (!available) {
+        return {
+            kind: "error",
+            message: ( localize(5043, "Cloud automations are unavailable."))
+        };
+    }
+    if (catalog?.kind === "error") {
+        return {
+            kind: "error",
+            message: ( localize(5044, "Available tools could not be loaded."))
+        };
+    }
+    if (catalog?.kind !== "ready") {
+        return {
+            kind: "loading"
+        };
+    }
+    return {
+        kind: "ready",
+        groups: catalog.groups.map(group => ({
+            id: group.id,
+            label: group.name || group.title || group.id,
+            tools: group.tools.map(tool => ({
+                id: tool.id,
+                label: tool.name || tool.title || tool.id,
+                description: tool.description || undefined
+            }))
+        }))
+    };
+}
+function validateLocalOptions(options) {
+    if (options.mode !== undefined || options.permissionLevel !== undefined) {
+        throw ( new Error(( localize(5045, "Cloud automations do not support local mode or approval settings."))));
+    }
+    if ((options.name !== undefined && !options.name.trim()) || (options.prompt !== undefined && !options.prompt.trim())) {
+        throw ( new Error(( localize(5046, "An automation name and prompt are required."))));
+    }
+}
+function templateMutation(template) {
+    const tools = template?.config?.tools;
+    const reasoning = template?.config?.reasoningEffort;
+    if (template?.agent || template?.modelConfiguration || ( ( Object.keys(template?.config ?? {})).some(key => key !== "tools" && key !== "reasoningEffort")) || (tools !== undefined && !isStringArray(tools)) || (reasoning !== undefined && typeof reasoning !== "string")) {
+        throw ( new Error(( localize(5047, "This session configuration is not supported by cloud automations."))));
+    }
+    return {
+        model: template?.modelId ?? "",
+        ...(isStringArray(tools) ? {
+            tools
+        } : {}),
+        ...(typeof reasoning === "string" ? {
+            reasoning_effort: reasoning
+        } : {})
+    };
+}
+function cloudAutomationSchedule(triggers) {
+    const base = {
+        scheduleHour: 0,
+        scheduleMinute: 0,
+        scheduleDay: 0,
+        timeZone: "UTC"
+    };
+    if (( Object.keys(triggers ?? {})).length === 0) {
+        return {
+            ...base,
+            interval: "manual"
+        };
+    }
+    const trigger = triggers?.interval;
+    if (( Object.keys(triggers ?? {})).length !== 1 || !trigger || trigger.types?.length !== 1) {
+        return {
+            ...base,
+            interval: "custom"
+        };
+    }
+    const interval = trigger.types[0];
+    if (interval === "hourly") {
+        return {
+            ...base,
+            interval
+        };
+    }
+    const hour = trigger.hour_utc;
+    const minute = trigger.minute_utc ?? 0;
+    const day = trigger.day_of_week ?? 0;
+    if ((interval === "daily" || interval === "weekly") && typeof hour === "number" && Number.isInteger(hour) && hour >= 0 && hour < 24 && typeof minute === "number" && [0, 15, 30, 45].includes(minute) && typeof day === "number" && Number.isInteger(day) && day >= 0 && day < 7) {
+        return {
+            ...base,
+            interval,
+            scheduleHour: hour,
+            scheduleMinute: minute,
+            scheduleDay: day
+        };
+    }
+    return {
+        ...base,
+        interval: "custom"
+    };
+}
+function cloudAutomationTriggers(schedule) {
+    if (schedule.interval === "manual") {
+        return {};
+    }
+    if (schedule.interval === "hourly") {
+        return {
+            interval: {
+                types: ["hourly"]
+            }
+        };
+    }
+    const minute = schedule.scheduleMinute;
+    if (schedule.timeZone !== "UTC" || (schedule.interval !== "daily" && schedule.interval !== "weekly") || !Number.isInteger(schedule.scheduleHour) || schedule.scheduleHour < 0 || schedule.scheduleHour > 23 || (minute !== 0 && minute !== 15 && minute !== 30 && minute !== 45) || !Number.isInteger(schedule.scheduleDay) || schedule.scheduleDay < 0 || schedule.scheduleDay > 6) {
+        throw ( new Error(( localize(
+            5048,
+            "Choose a daily or weekly UTC schedule with minutes 00, 15, 30, or 45."
+        ))));
+    }
+    return {
+        interval: {
+            types: [schedule.interval],
+            hour_utc: schedule.scheduleHour,
+            minute_utc: minute,
+            ...(schedule.interval === "weekly" ? {
+                day_of_week: schedule.scheduleDay
+            } : {})
+        }
+    };
+}
+function cloudTaskStatus(task) {
+    const state = task.state;
+    switch (state) {
+    case "queued":
+        return "pending";
+    case "in_progress":
+    case "running":
+    case "waiting_for_user":
+        return "running";
+    case "completed":
+    case "idle":
+        return "completed";
+    case "failed":
+    case "timed_out":
+    case "cancelled":
+    case "canceled":
+    case "error":
+        return "failed";
+    default:
+        return undefined;
+    }
+}
+
+export { CloudAutomationStore, cloudAutomationSchedule, cloudAutomationTriggers };