@elizaos/ui 2.0.0-alpha.85 → 2.0.0-beta.1

package/dist/components/pages/chat-view-hooks.js

@@ -0,0 +1,531 @@
+import { useDocumentVisibility, useTimeout } from "@elizaos/ui";
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, } from "react";
+import { client } from "../../api/client.js";
+import { ELIZA_CLOUD_STATUS_UPDATED_EVENT, VOICE_CONFIG_UPDATED_EVENT, } from "../../events/index.js";
+import { useVoiceChat } from "../../hooks/useVoiceChat.js";
+import { ttsDebug } from "../../utils/tts-debug.js";
+import { resolveCharacterVoiceConfigFromAppConfig } from "../../voice/character-voice-config.js";
+import { useCompanionSceneStatus } from "../companion/injected.js";
+/* ── Shared constants ──────────────────────────────────────────────── */
+const COMPANION_VISIBLE_MESSAGE_LIMIT = 2;
+const COMPANION_HISTORY_HOLD_MS = 30_000;
+const COMPANION_HISTORY_FADE_MS = 5_000;
+/* ── Helpers ───────────────────────────────────────────────────────── */
+function nowMs() {
+    return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+export function mapUiLanguageToSpeechLocale(uiLanguage) {
+    switch (uiLanguage) {
+        case "zh-CN":
+            return "zh-CN";
+        case "ko":
+            return "ko-KR";
+        case "es":
+            return "es-ES";
+        case "pt":
+            return "pt-BR";
+        case "vi":
+            return "vi-VN";
+        case "tl":
+            return "fil-PH";
+        default:
+            return "en-US";
+    }
+}
+function findLatestAssistantMessage(messages) {
+    return [...messages]
+        .reverse()
+        .find((message) => message.role === "assistant" && message.text.trim());
+}
+const companionSpeechMemoryByConversation = new Map();
+function rememberCompanionSpeech(conversationId, messageId, text) {
+    if (!conversationId)
+        return;
+    companionSpeechMemoryByConversation.set(conversationId, { messageId, text });
+    if (companionSpeechMemoryByConversation.size <= 100)
+        return;
+    const oldestConversationId = companionSpeechMemoryByConversation
+        .keys()
+        .next().value;
+    if (oldestConversationId) {
+        companionSpeechMemoryByConversation.delete(oldestConversationId);
+    }
+}
+function hasCompanionSpeechBeenPlayed(conversationId, messageId, text) {
+    if (!conversationId)
+        return false;
+    const remembered = companionSpeechMemoryByConversation.get(conversationId);
+    return remembered?.messageId === messageId && remembered.text === text;
+}
+export function __resetCompanionSpeechMemoryForTests() {
+    companionSpeechMemoryByConversation.clear();
+}
+/* ── useChatVoiceController ────────────────────────────────────────── */
+/**
+ * Chat assistant TTS pipeline — order matters for cloud-backed voice:
+ * 1. Server exposes Eliza Cloud via `GET /api/cloud/status` (`hasApiKey`, `enabled`, `connected`).
+ * 2. `AppContext.pollCloudCredits` persists React state and dispatches {@link ELIZA_CLOUD_STATUS_UPDATED_EVENT}.
+ * 3. This hook stores `detail.cloudVoiceProxyAvailable` in a ref for same-turn
+ *    `true` before React state commits; `cloudConnected` is `context || ref===true`
+ *    so an early `false` snapshot cannot block TTS after auth loads. Then reloads
+ *    `messages.tts` from `getConfig`.
+ * 4. `useVoiceChat` resolves cloud vs own-key mode and speaks via `/api/tts/cloud`
+ *    only when cloud inference is actually selected, not merely linked.
+ */
+export function useChatVoiceController(options) {
+    const { setTimeout } = useTimeout();
+    const { avatarReady: companionSceneAvatarReady } = useCompanionSceneStatus();
+    const { agentVoiceMuted, chatFirstTokenReceived, chatInput, chatSending, elizaCloudConnected, elizaCloudVoiceProxyAvailable, elizaCloudHasPersistedKey, conversationMessages, activeConversationId, handleChatEdit, handleChatSend, isComposerLocked, isGameModal, setState, uiLanguage, } = options;
+    /** After the first `eliza:cloud-status-updated`, mirrors server `cloudVoiceProxyAvailable` (avoids one-frame lag vs context). */
+    const [cloudVoiceSnapshot, setCloudVoiceSnapshot] = useState(null);
+    const [voiceConfig, setVoiceConfig] = useState(null);
+    /** Bumps after each `getConfig` (or inline VOICE_CONFIG event) settles — game-modal auto-speak waits for this so TTS does not run with a stale/null voice profile and get stuck deduped. */
+    const [voiceBootstrapTick, setVoiceBootstrapTick] = useState(0);
+    const [voiceLatency, setVoiceLatency] = useState(null);
+    const pendingVoiceTurnRef = useRef(null);
+    const suppressedAssistantSpeechIdRef = useRef(null);
+    /** Skips duplicate companion auto-speak when only `voiceBootstrapTick` bumps (config/cloud reload) for the same assistant text. */
+    const companionBootstrapAutoSpeakRef = useRef(null);
+    const initialCompletedAssistantOnGameModalMountRef = useRef(isGameModal && !chatSending
+        ? (() => {
+            const latestAssistant = findLatestAssistantMessage(conversationMessages);
+            if (!latestAssistant)
+                return null;
+            return {
+                messageId: latestAssistant.id,
+                text: latestAssistant.text,
+            };
+        })()
+        : null);
+    const voiceDraftBaseInputRef = useRef("");
+    const prevIsGameModalRef = useRef(isGameModal);
+    const gameModalJustActivatedRef = useRef(false);
+    const loadVoiceConfig = useCallback(async () => {
+        try {
+            const cfg = await client.getConfig();
+            const resolved = resolveCharacterVoiceConfigFromAppConfig({
+                config: cfg,
+                uiLanguage,
+            });
+            setVoiceConfig(resolved.voiceConfig);
+            if (resolved.shouldPersist && resolved.voiceConfig) {
+                void client
+                    .updateConfig({
+                    messages: {
+                        tts: resolved.voiceConfig,
+                    },
+                })
+                    .catch(() => { });
+            }
+        }
+        catch {
+            /* ignore — will use browser TTS fallback */
+            setVoiceConfig(null);
+        }
+        finally {
+            setVoiceBootstrapTick((t) => t + 1);
+        }
+    }, [uiLanguage]);
+    useEffect(() => {
+        void loadVoiceConfig();
+    }, [loadVoiceConfig]);
+    useEffect(() => {
+        if (typeof window === "undefined") {
+            return;
+        }
+        const handler = (event) => {
+            const detail = event.detail;
+            if (detail && typeof detail === "object") {
+                setVoiceConfig(detail);
+                setVoiceBootstrapTick((t) => t + 1);
+                return;
+            }
+            void loadVoiceConfig();
+        };
+        window.addEventListener(VOICE_CONFIG_UPDATED_EVENT, handler);
+        return () => window.removeEventListener(VOICE_CONFIG_UPDATED_EVENT, handler);
+    }, [loadVoiceConfig]);
+    useEffect(() => {
+        if (typeof window === "undefined") {
+            return;
+        }
+        const onCloudStatus = (event) => {
+            const detail = event
+                .detail;
+            if (detail && typeof detail === "object") {
+                ttsDebug("chat:cloud-status-event", {
+                    cloudVoiceProxyAvailable: detail.cloudVoiceProxyAvailable,
+                    connected: detail.connected,
+                    enabled: detail.enabled,
+                    hasPersistedApiKey: detail.hasPersistedApiKey,
+                });
+            }
+            if (detail && typeof detail.cloudVoiceProxyAvailable === "boolean") {
+                setCloudVoiceSnapshot(detail.cloudVoiceProxyAvailable);
+            }
+            void loadVoiceConfig();
+        };
+        window.addEventListener(ELIZA_CLOUD_STATUS_UPDATED_EVENT, onCloudStatus);
+        return () => window.removeEventListener(ELIZA_CLOUD_STATUS_UPDATED_EVENT, onCloudStatus);
+    }, [loadVoiceConfig]);
+    const composeVoiceDraft = useCallback((transcript) => {
+        const base = voiceDraftBaseInputRef.current.trim();
+        const spoken = transcript.trim();
+        if (base && spoken) {
+            return `${base} ${spoken}`;
+        }
+        return base || spoken;
+    }, []);
+    const handleVoiceTranscript = useCallback((text) => {
+        if (isComposerLocked)
+            return;
+        const composedText = composeVoiceDraft(text);
+        if (!composedText)
+            return;
+        const speechEndedAtMs = nowMs();
+        pendingVoiceTurnRef.current = {
+            expiresAtMs: speechEndedAtMs + 15000,
+            speechEndedAtMs,
+        };
+        setVoiceLatency(null);
+        setState("chatInput", composedText);
+        setTimeout(() => void handleChatSend("VOICE_DM"), 50);
+    }, [composeVoiceDraft, handleChatSend, isComposerLocked, setState, setTimeout]);
+    const handleVoiceTranscriptPreview = useCallback((text) => {
+        if (isComposerLocked)
+            return;
+        setState("chatInput", composeVoiceDraft(text));
+    }, [composeVoiceDraft, isComposerLocked, setState]);
+    const handleVoicePlaybackStart = useCallback((event) => {
+        ttsDebug("chat:playback-start", {
+            provider: event.provider,
+            segment: event.segment,
+            cached: event.cached,
+        });
+        const pending = pendingVoiceTurnRef.current;
+        if (!pending)
+            return;
+        if (event.startedAtMs > pending.expiresAtMs) {
+            pendingVoiceTurnRef.current = null;
+            return;
+        }
+        if (pending.voiceStartedAtMs != null)
+            return;
+        pending.voiceStartedAtMs = event.startedAtMs;
+        pending.firstSegmentCached = event.cached;
+        setVoiceLatency((prev) => ({
+            firstSegmentCached: event.cached,
+            speechEndToFirstTokenMs: prev?.speechEndToFirstTokenMs ?? null,
+            speechEndToVoiceStartMs: Math.max(0, Math.round(event.startedAtMs - pending.speechEndedAtMs)),
+        }));
+    }, []);
+    const cloudVoiceAvailable = useMemo(() => {
+        const fromContext = elizaCloudVoiceProxyAvailable;
+        // Ref snapshot can be `false` from an early status poll before the key is
+        // loaded, then never updated if no further event fires. Prefer the
+        // committed `enabled` state; only use the event snapshot to force `true`
+        // when it arrives before the wider app state catches up.
+        return fromContext || cloudVoiceSnapshot === true;
+    }, [cloudVoiceSnapshot, elizaCloudVoiceProxyAvailable]);
+    useEffect(() => {
+        ttsDebug("chat:cloud-voice-available", {
+            cloudVoiceAvailable,
+            elizaCloudConnected,
+            elizaCloudVoiceProxyAvailable,
+            elizaCloudHasPersistedKey,
+            snapshotValue: cloudVoiceSnapshot,
+        });
+    }, [
+        cloudVoiceAvailable,
+        cloudVoiceSnapshot,
+        elizaCloudConnected,
+        elizaCloudVoiceProxyAvailable,
+        elizaCloudHasPersistedKey,
+    ]);
+    const voice = useVoiceChat({
+        cloudConnected: cloudVoiceAvailable,
+        interruptOnSpeech: isGameModal,
+        lang: mapUiLanguageToSpeechLocale(uiLanguage),
+        onPlaybackStart: handleVoicePlaybackStart,
+        onTranscript: handleVoiceTranscript,
+        onTranscriptPreview: handleVoiceTranscriptPreview,
+        voiceConfig,
+    });
+    const { queueAssistantSpeech, speak, startListening, stopListening, stopSpeaking, voiceUnlockedGeneration, } = voice;
+    // After the user gesture unlocks audio, clear progressive TTS dedupe state so
+    // auto-speak can queue the greeting again (ElevenLabs was likely skipped once).
+    const prevVoiceUnlockGenRef = useRef(null);
+    useLayoutEffect(() => {
+        if (prevVoiceUnlockGenRef.current === null) {
+            prevVoiceUnlockGenRef.current = voiceUnlockedGeneration;
+            return;
+        }
+        if (prevVoiceUnlockGenRef.current === voiceUnlockedGeneration)
+            return;
+        prevVoiceUnlockGenRef.current = voiceUnlockedGeneration;
+        stopSpeaking();
+    }, [voiceUnlockedGeneration, stopSpeaking]);
+    const beginVoiceCapture = useCallback((mode = "compose") => {
+        if (isComposerLocked || voice.isListening)
+            return;
+        const latestAssistant = findLatestAssistantMessage(conversationMessages);
+        suppressedAssistantSpeechIdRef.current = latestAssistant?.id ?? null;
+        voiceDraftBaseInputRef.current = chatInput;
+        stopSpeaking();
+        void startListening(mode);
+    }, [
+        chatInput,
+        conversationMessages,
+        isComposerLocked,
+        startListening,
+        stopSpeaking,
+        voice.isListening,
+    ]);
+    const endVoiceCapture = useCallback((captureOptions) => {
+        if (!voice.isListening)
+            return;
+        void stopListening(captureOptions);
+    }, [stopListening, voice.isListening]);
+    const handleSpeakMessage = useCallback((messageId, text) => {
+        if (!text.trim())
+            return;
+        suppressedAssistantSpeechIdRef.current = messageId;
+        rememberCompanionSpeech(activeConversationId, messageId, text);
+        speak(text);
+    }, [activeConversationId, speak]);
+    const handleEditMessage = useCallback(async (messageId, text) => {
+        stopSpeaking();
+        return handleChatEdit(messageId, text);
+    }, [handleChatEdit, stopSpeaking]);
+    // Track when isGameModal transitions from false→true so we can suppress
+    // the stale "latest assistant message" speech that would otherwise replay.
+    // NOTE: Do NOT suppress on the initial mount — only on actual mode switches.
+    const hasSetInitialGameModalRef = useRef(false);
+    useEffect(() => {
+        if (!hasSetInitialGameModalRef.current) {
+            // First render — just record the initial value without suppressing.
+            hasSetInitialGameModalRef.current = true;
+            prevIsGameModalRef.current = isGameModal;
+            return;
+        }
+        if (isGameModal && !prevIsGameModalRef.current) {
+            gameModalJustActivatedRef.current = true;
+        }
+        prevIsGameModalRef.current = isGameModal;
+    }, [isGameModal]);
+    useEffect(() => {
+        if (!isGameModal) {
+            companionBootstrapAutoSpeakRef.current = null;
+        }
+    }, [isGameModal]);
+    useEffect(() => {
+        if (!isGameModal || agentVoiceMuted || voice.isListening)
+            return;
+        if (!companionSceneAvatarReady)
+            return;
+        if (voiceBootstrapTick === 0)
+            return;
+        // Skip the stale replay when the view just became active (mode switch).
+        if (gameModalJustActivatedRef.current) {
+            gameModalJustActivatedRef.current = false;
+            return;
+        }
+        const latestAssistant = findLatestAssistantMessage(conversationMessages);
+        if (!latestAssistant)
+            return;
+        if (suppressedAssistantSpeechIdRef.current === latestAssistant.id)
+            return;
+        const tick = voiceBootstrapTick;
+        const messageId = latestAssistant.id;
+        const text = latestAssistant.text;
+        const ug = voiceUnlockedGeneration;
+        const initialCompletedAssistant = initialCompletedAssistantOnGameModalMountRef.current;
+        if (initialCompletedAssistant &&
+            !chatSending &&
+            initialCompletedAssistant.messageId === messageId &&
+            initialCompletedAssistant.text === text) {
+            initialCompletedAssistantOnGameModalMountRef.current = null;
+            companionBootstrapAutoSpeakRef.current = {
+                tick,
+                messageId,
+                text,
+                unlockGen: ug,
+            };
+            return;
+        }
+        if (initialCompletedAssistant) {
+            initialCompletedAssistantOnGameModalMountRef.current = null;
+        }
+        if (hasCompanionSpeechBeenPlayed(activeConversationId, messageId, text)) {
+            companionBootstrapAutoSpeakRef.current = {
+                tick,
+                messageId,
+                text,
+                unlockGen: ug,
+            };
+            return;
+        }
+        const prev = companionBootstrapAutoSpeakRef.current;
+        if (prev &&
+            prev.messageId === messageId &&
+            prev.text === text &&
+            prev.unlockGen === ug) {
+            if (tick > prev.tick) {
+                // Voice config / cloud status bumped the tick only — do not re-queue the same line.
+                companionBootstrapAutoSpeakRef.current = {
+                    tick,
+                    messageId,
+                    text,
+                    unlockGen: ug,
+                };
+                return;
+            }
+            if (tick === prev.tick) {
+                // Same deps re-run (e.g. React Strict Mode dev double effect) — already queued.
+                return;
+            }
+        }
+        queueAssistantSpeech(messageId, text, !chatSending);
+        rememberCompanionSpeech(activeConversationId, messageId, text);
+        suppressedAssistantSpeechIdRef.current = null;
+        companionBootstrapAutoSpeakRef.current = {
+            tick,
+            messageId,
+            text,
+            unlockGen: ug,
+        };
+    }, [
+        agentVoiceMuted,
+        activeConversationId,
+        chatSending,
+        companionSceneAvatarReady,
+        conversationMessages,
+        isGameModal,
+        queueAssistantSpeech,
+        voice.isListening,
+        voiceBootstrapTick,
+        voiceUnlockedGeneration,
+    ]);
+    useEffect(() => {
+        if (!agentVoiceMuted)
+            return;
+        stopSpeaking();
+    }, [agentVoiceMuted, stopSpeaking]);
+    useEffect(() => {
+        const pending = pendingVoiceTurnRef.current;
+        if (!pending || !chatFirstTokenReceived)
+            return;
+        if (nowMs() > pending.expiresAtMs) {
+            pendingVoiceTurnRef.current = null;
+            return;
+        }
+        if (pending.firstTokenAtMs != null)
+            return;
+        const firstTokenAtMs = nowMs();
+        pending.firstTokenAtMs = firstTokenAtMs;
+        setVoiceLatency((prev) => ({
+            firstSegmentCached: prev?.firstSegmentCached ?? null,
+            speechEndToFirstTokenMs: Math.max(0, Math.round(firstTokenAtMs - pending.speechEndedAtMs)),
+            speechEndToVoiceStartMs: prev?.speechEndToVoiceStartMs ?? null,
+        }));
+    }, [chatFirstTokenReceived]);
+    return {
+        beginVoiceCapture,
+        endVoiceCapture,
+        handleEditMessage,
+        handleSpeakMessage,
+        stopSpeaking,
+        voice,
+        voiceLatency,
+    };
+}
+export function useGameModalMessages(options) {
+    const { activeConversationId, companionMessageCutoffTs, isGameModal, visibleMsgs, } = options;
+    const previousCompanionCutoffTsRef = useRef(companionMessageCutoffTs);
+    const previousGameModalVisibleMsgsRef = useRef([]);
+    const previousActiveConversationIdRef = useRef(activeConversationId);
+    const [companionNowMs, setCompanionNowMs] = useState(() => Date.now());
+    const [companionCarryover, setCompanionCarryover] = useState(null);
+    const docVisible = useDocumentVisibility();
+    const gameModalRecentMsgs = useMemo(() => visibleMsgs.filter((message) => message.timestamp >= companionMessageCutoffTs), [companionMessageCutoffTs, visibleMsgs]);
+    const gameModalContextMsgs = useMemo(() => {
+        if (gameModalRecentMsgs.length > 0) {
+            return gameModalRecentMsgs;
+        }
+        return visibleMsgs.slice(-COMPANION_VISIBLE_MESSAGE_LIMIT);
+    }, [gameModalRecentMsgs, visibleMsgs]);
+    const gameModalVisibleMsgs = useMemo(() => gameModalContextMsgs.slice(-COMPANION_VISIBLE_MESSAGE_LIMIT), [gameModalContextMsgs]);
+    const gameModalCarryoverOpacity = useMemo(() => {
+        if (!companionCarryover)
+            return 0;
+        if (companionNowMs < companionCarryover.fadeStartsAtMs)
+            return 1;
+        const remainingMs = companionCarryover.expiresAtMs - companionNowMs;
+        if (remainingMs <= 0)
+            return 0;
+        return Math.max(0, remainingMs / COMPANION_HISTORY_FADE_MS);
+    }, [companionCarryover, companionNowMs]);
+    useEffect(() => {
+        if (!isGameModal) {
+            previousActiveConversationIdRef.current = activeConversationId;
+            return;
+        }
+        if (previousActiveConversationIdRef.current === activeConversationId) {
+            return;
+        }
+        previousActiveConversationIdRef.current = activeConversationId;
+        previousGameModalVisibleMsgsRef.current = [];
+        previousCompanionCutoffTsRef.current = companionMessageCutoffTs;
+        setCompanionCarryover(null);
+        // NOTE: intentionally no stopSpeaking() here — the auto-speak effect's
+        // queueAssistantSpeech already cancels old speech before queuing new.
+        // Calling stopSpeaking() races with greeting speech and kills it.
+    }, [activeConversationId, companionMessageCutoffTs, isGameModal]);
+    useEffect(() => {
+        if (!isGameModal) {
+            previousCompanionCutoffTsRef.current = companionMessageCutoffTs;
+            return;
+        }
+        const previousCutoffTs = previousCompanionCutoffTsRef.current;
+        if (companionMessageCutoffTs > previousCutoffTs) {
+            const carryoverMessages = previousGameModalVisibleMsgsRef.current.filter((message) => message.timestamp < companionMessageCutoffTs);
+            if (carryoverMessages.length > 0) {
+                const startedAtMs = Date.now();
+                setCompanionCarryover({
+                    expiresAtMs: startedAtMs + COMPANION_HISTORY_HOLD_MS + COMPANION_HISTORY_FADE_MS,
+                    fadeStartsAtMs: startedAtMs + COMPANION_HISTORY_HOLD_MS,
+                    messages: carryoverMessages,
+                });
+            }
+            else {
+                setCompanionCarryover(null);
+            }
+        }
+        previousCompanionCutoffTsRef.current = companionMessageCutoffTs;
+    }, [companionMessageCutoffTs, isGameModal]);
+    useEffect(() => {
+        previousGameModalVisibleMsgsRef.current = gameModalVisibleMsgs;
+    }, [gameModalVisibleMsgs]);
+    useEffect(() => {
+        if (!companionCarryover)
+            return;
+        const tick = () => setCompanionNowMs(Date.now());
+        tick();
+        if (!docVisible)
+            return () => { };
+        const intervalId = window.setInterval(tick, 250);
+        return () => window.clearInterval(intervalId);
+    }, [companionCarryover, docVisible]);
+    useEffect(() => {
+        if (!companionCarryover)
+            return;
+        if (companionNowMs >= companionCarryover.expiresAtMs) {
+            setCompanionCarryover(null);
+        }
+    }, [companionCarryover, companionNowMs]);
+    return {
+        companionCarryover,
+        gameModalCarryoverOpacity,
+        gameModalVisibleMsgs,
+    };
+}

package/dist/components/pages/cloud-dashboard-utils.d.ts

@@ -0,0 +1,91 @@
+import type { CloudBillingCheckoutResponse, CloudBillingSettings, CloudBillingSummary, CloudCompatAgent } from "../../api";
+export declare const ELIZA_CLOUD_INSTANCES_URL = "https://www.elizacloud.ai/dashboard/app";
+/** Marketing / docs site — "Learn more" when not connected (in-app browser on desktop). */
+export declare const ELIZA_CLOUD_WEB_URL = "https://elizacloud.ai";
+export declare const BILLING_PRESET_AMOUNTS: number[];
+export declare const MANAGED_DISCORD_GATEWAY_AGENT_NAME = "Discord Gateway";
+export declare const STATUS_BADGE: Record<string, {
+    i18nKey: string;
+    className: string;
+}>;
+export declare function getCloudAuthToken(): string;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function resolveCloudAccountIdDisplay(userId: string | null, statusReason: string | null, t: (key: string) => string): {
+    mono: boolean;
+    text: string;
+};
+export declare function unwrapBillingData<T extends Record<string, unknown>>(value: T): T;
+export declare function readString(value: unknown): string | undefined;
+export declare function readNumber(value: unknown): number | null;
+export declare function readBoolean(value: unknown): boolean | undefined;
+export interface ManagedDiscordCallbackState {
+    status: "connected" | "error";
+    agentId: string | null;
+    guildId: string | null;
+    guildName: string | null;
+    managed: boolean;
+    message: string | null;
+    restarted: boolean;
+}
+export declare function consumeManagedDiscordCallbackUrl(rawUrl: string): {
+    callback: ManagedDiscordCallbackState | null;
+    cleanedUrl: string | null;
+};
+export declare function buildManagedDiscordSettingsReturnUrl(rawUrl: string): string | null;
+export declare function resolveManagedDiscordAgentChoice(agents: CloudCompatAgent[]): {
+    mode: "none";
+    agent: null;
+    selectedAgentId: null;
+} | {
+    mode: "bootstrap";
+    agent: null;
+    selectedAgentId: null;
+} | {
+    mode: "direct";
+    agent: CloudCompatAgent;
+    selectedAgentId: string;
+} | {
+    mode: "picker";
+    agent: null;
+    selectedAgentId: string;
+};
+export declare function isManagedDiscordGatewayAgent(agent: CloudCompatAgent): boolean;
+export interface ManagedGithubCallbackState {
+    status: "connected" | "error";
+    connectionId: string | null;
+    agentId: string | null;
+    message: string | null;
+}
+export declare function consumeManagedGithubCallbackUrl(rawUrl: string): {
+    callback: ManagedGithubCallbackState | null;
+    cleanedUrl: string | null;
+};
+export declare function normalizeBillingSummary(raw: CloudBillingSummary): CloudBillingSummary;
+export declare function normalizeBillingSettings(raw: CloudBillingSettings): CloudBillingSettings;
+export declare function getBillingAutoTopUp(settings: CloudBillingSettings | null): Record<string, unknown>;
+export declare function getBillingLimits(settings: CloudBillingSettings | null): Record<string, unknown>;
+export declare function resolveCheckoutUrl(response: CloudBillingCheckoutResponse): string | null;
+export interface AutoTopUpFormState {
+    amount: string;
+    dirty: boolean;
+    enabled: boolean;
+    sourceKey: string;
+    threshold: string;
+}
+export type AutoTopUpFormAction = {
+    type: "hydrate";
+    next: AutoTopUpFormState;
+    force?: boolean;
+} | {
+    type: "setAmount";
+    value: string;
+} | {
+    type: "setEnabled";
+    value: boolean;
+} | {
+    type: "setThreshold";
+    value: string;
+};
+export declare function buildAutoTopUpFormState(billingSummary: CloudBillingSummary | null, billingSettings: CloudBillingSettings | null): AutoTopUpFormState;
+export declare function autoTopUpFormReducer(state: AutoTopUpFormState, action: AutoTopUpFormAction): AutoTopUpFormState;
+//# sourceMappingURL=cloud-dashboard-utils.d.ts.map

package/dist/components/pages/cloud-dashboard-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloud-dashboard-utils.d.ts","sourceRoot":"","sources":["../../../../../../src/components/pages/cloud-dashboard-utils.ts"],"names":[],"mappings":"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"}