@elizaos/ui 2.0.0-alpha.382 → 2.0.0-alpha.385

package/apps/app-lifeops/src/hooks/useTelegramConnector.js

@@ -1,177 +0,0 @@
-import { useCallback, useEffect, useState } from "react";
-import { client } from "@elizaos/app-core";
-function formatError(cause, fallback) {
-    if (cause instanceof Error && cause.message.trim().length > 0) {
-        return cause.message.trim();
-    }
-    return fallback;
-}
-export function useTelegramConnector(options = {}) {
-    const side = options.side ?? "owner";
-    const [status, setStatus] = useState(null);
-    const [loading, setLoading] = useState(true);
-    const [actionPending, setActionPending] = useState(false);
-    const [verifyPending, setVerifyPending] = useState(false);
-    const [error, setError] = useState(null);
-    const [authState, setAuthState] = useState("idle");
-    const [verification, setVerification] = useState(null);
-    const refresh = useCallback(async () => {
-        setLoading(true);
-        try {
-            const nextStatus = await client.getTelegramConnectorStatus(side);
-            setStatus(nextStatus);
-            setAuthState(nextStatus.authState);
-            setError(nextStatus.authError ?? null);
-        }
-        catch (cause) {
-            setError(formatError(cause, "Telegram connector status failed to load."));
-        }
-        finally {
-            setLoading(false);
-        }
-    }, [side]);
-    useEffect(() => {
-        let cancelled = false;
-        void (async () => {
-            setLoading(true);
-            try {
-                const nextStatus = await client.getTelegramConnectorStatus(side);
-                if (cancelled)
-                    return;
-                setStatus(nextStatus);
-                setAuthState(nextStatus.authState);
-                setError(nextStatus.authError ?? null);
-            }
-            catch (cause) {
-                if (cancelled)
-                    return;
-                setError(formatError(cause, "Telegram connector status failed to load."));
-            }
-            finally {
-                if (!cancelled)
-                    setLoading(false);
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-    }, [side]);
-    const startAuth = useCallback(async (phone) => {
-        try {
-            setActionPending(true);
-            setError(null);
-            const result = await client.startTelegramAuth({ phone, side });
-            setAuthState(result.state);
-            if (result.error) {
-                setError(result.error);
-            }
-            void refresh();
-        }
-        catch (cause) {
-            setError(formatError(cause, "Telegram auth failed to start."));
-        }
-        finally {
-            setActionPending(false);
-        }
-    }, [side, refresh]);
-    const submitCode = useCallback(async (code) => {
-        try {
-            setActionPending(true);
-            setError(null);
-            const result = await client.submitTelegramAuth({ code, side });
-            setAuthState(result.state);
-            if (result.error) {
-                setError(result.error);
-            }
-            void refresh();
-        }
-        catch (cause) {
-            setError(formatError(cause, "Telegram code submission failed."));
-        }
-        finally {
-            setActionPending(false);
-        }
-    }, [side, refresh]);
-    const submitPassword = useCallback(async (password) => {
-        try {
-            setActionPending(true);
-            setError(null);
-            const result = await client.submitTelegramAuth({ password, side });
-            setAuthState(result.state);
-            if (result.error) {
-                setError(result.error);
-            }
-            void refresh();
-        }
-        catch (cause) {
-            setError(formatError(cause, "Telegram password submission failed."));
-        }
-        finally {
-            setActionPending(false);
-        }
-    }, [side, refresh]);
-    const cancelAuth = useCallback(async () => {
-        try {
-            setActionPending(true);
-            await client.cancelTelegramAuth({ side, provider: "telegram" });
-            setError(null);
-            setVerification(null);
-            void refresh();
-        }
-        catch (cause) {
-            setError(formatError(cause, "Telegram auth cancellation failed."));
-        }
-        finally {
-            setActionPending(false);
-        }
-    }, [side, refresh]);
-    const disconnect = useCallback(async () => {
-        try {
-            setActionPending(true);
-            const nextStatus = await client.disconnectTelegramConnector({
-                side,
-                provider: "telegram",
-            });
-            setStatus(nextStatus);
-            setAuthState(nextStatus.authState);
-            setError(null);
-            setVerification(null);
-        }
-        catch (cause) {
-            setError(formatError(cause, "Telegram connector disconnect failed."));
-        }
-        finally {
-            setActionPending(false);
-        }
-    }, [side]);
-    const verify = useCallback(async () => {
-        try {
-            setVerifyPending(true);
-            setError(null);
-            const result = await client.verifyTelegramConnector({ side });
-            setVerification(result);
-        }
-        catch (cause) {
-            setError(formatError(cause, "Telegram verification failed."));
-        }
-        finally {
-            setVerifyPending(false);
-        }
-    }, [side]);
-    return {
-        status,
-        loading,
-        actionPending,
-        verifyPending,
-        error,
-        authState,
-        verification,
-        startAuth,
-        submitCode,
-        submitPassword,
-        cancelAuth,
-        disconnect,
-        verify,
-        refresh,
-    };
-}

package/apps/app-lifeops/src/hooks/useWhatsAppConnector.d.ts

@@ -1,8 +0,0 @@
-import type { LifeOpsWhatsAppConnectorStatus } from "@elizaos/shared";
-export declare function useWhatsAppConnector(): {
-    readonly status: LifeOpsWhatsAppConnectorStatus | null;
-    readonly loading: boolean;
-    readonly error: string | null;
-    readonly refresh: () => Promise<void>;
-};
-//# sourceMappingURL=useWhatsAppConnector.d.ts.map

package/apps/app-lifeops/src/hooks/useWhatsAppConnector.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useWhatsAppConnector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useWhatsAppConnector.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,iBAAiB,CAAC;AAUtE,wBAAgB,oBAAoB;;;;;EAiDnC"}

package/apps/app-lifeops/src/hooks/useWhatsAppConnector.js

@@ -1,58 +0,0 @@
-import { client } from "@elizaos/app-core";
-import { useCallback, useEffect, useState } from "react";
-function formatError(cause, fallback) {
-    if (cause instanceof Error && cause.message.trim().length > 0) {
-        return cause.message.trim();
-    }
-    return fallback;
-}
-export function useWhatsAppConnector() {
-    const [status, setStatus] = useState(null);
-    const [loading, setLoading] = useState(true);
-    const [error, setError] = useState(null);
-    const refresh = useCallback(async () => {
-        setLoading(true);
-        try {
-            const nextStatus = await client.getWhatsAppConnectorStatus();
-            setStatus(nextStatus);
-            setError(null);
-        }
-        catch (cause) {
-            setError(formatError(cause, "WhatsApp connector status failed to load."));
-        }
-        finally {
-            setLoading(false);
-        }
-    }, []);
-    useEffect(() => {
-        let cancelled = false;
-        void (async () => {
-            setLoading(true);
-            try {
-                const nextStatus = await client.getWhatsAppConnectorStatus();
-                if (cancelled)
-                    return;
-                setStatus(nextStatus);
-                setError(null);
-            }
-            catch (cause) {
-                if (cancelled)
-                    return;
-                setError(formatError(cause, "WhatsApp connector status failed to load."));
-            }
-            finally {
-                if (!cancelled)
-                    setLoading(false);
-            }
-        })();
-        return () => {
-            cancelled = true;
-        };
-    }, []);
-    return {
-        status,
-        loading,
-        error,
-        refresh,
-    };
-}

package/apps/app-lifeops/src/hooks/useWhatsAppPairing.d.ts

@@ -1,12 +0,0 @@
-type WhatsAppPairingStatus = "idle" | "initializing" | "waiting_for_qr" | "connected" | "disconnected" | "timeout" | "error";
-export declare function useWhatsAppPairing(accountId?: string): {
-    startPairing: () => Promise<void>;
-    stopPairing: () => Promise<void>;
-    disconnect: () => Promise<void>;
-    status: WhatsAppPairingStatus;
-    qrDataUrl: string | null;
-    phoneNumber: string | null;
-    error: string | null;
-};
-export {};
-//# sourceMappingURL=useWhatsAppPairing.d.ts.map

package/apps/app-lifeops/src/hooks/useWhatsAppPairing.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useWhatsAppPairing.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/hooks/useWhatsAppPairing.ts"],"names":[],"mappings":"AAGA,KAAK,qBAAqB,GACtB,MAAM,GACN,cAAc,GACd,gBAAgB,GAChB,WAAW,GACX,cAAc,GACd,SAAS,GACT,OAAO,CAAC;AA6BZ,wBAAgB,kBAAkB,CAAC,SAAS,SAAY;;;;YA1B9C,qBAAqB;eAClB,MAAM,GAAG,IAAI;iBACX,MAAM,GAAG,IAAI;WACnB,MAAM,GAAG,IAAI;EAuKrB"}

package/apps/app-lifeops/src/hooks/useWhatsAppPairing.js

@@ -1,152 +0,0 @@
-import { client } from "@elizaos/app-core/api";
-import { useCallback, useEffect, useState } from "react";
-const WHATSAPP_PAIRING_STATUSES = {
-    idle: true,
-    initializing: true,
-    waiting_for_qr: true,
-    connected: true,
-    disconnected: true,
-    timeout: true,
-    error: true,
-};
-function isWhatsAppPairingStatus(value) {
-    return typeof value === "string" && value in WHATSAPP_PAIRING_STATUSES;
-}
-function formatPairingError(cause) {
-    return cause instanceof Error ? cause.message : String(cause);
-}
-export function useWhatsAppPairing(accountId = "default") {
-    const [state, setState] = useState({
-        status: "idle",
-        qrDataUrl: null,
-        phoneNumber: null,
-        error: null,
-    });
-    useEffect(() => {
-        let cancelled = false;
-        void client
-            .getWhatsAppStatus(accountId)
-            .then((response) => {
-            if (!cancelled && response.authExists) {
-                setState((previous) => ({
-                    ...previous,
-                    status: "connected",
-                    phoneNumber: response.servicePhone,
-                }));
-            }
-        })
-            .catch(() => {
-            if (!cancelled) {
-                setState((previous) => ({
-                    ...previous,
-                    status: "error",
-                    error: "WhatsApp pairing status failed to load.",
-                }));
-            }
-        });
-        return () => {
-            cancelled = true;
-        };
-    }, [accountId]);
-    useEffect(() => {
-        const unbindQr = client.onWsEvent("whatsapp-qr", (data) => {
-            if (data.accountId !== accountId || typeof data.qrDataUrl !== "string") {
-                return;
-            }
-            const qrDataUrl = data.qrDataUrl;
-            setState((previous) => ({
-                ...previous,
-                status: "waiting_for_qr",
-                qrDataUrl,
-                error: null,
-            }));
-        });
-        const unbindStatus = client.onWsEvent("whatsapp-status", (data) => {
-            if (data.accountId !== accountId ||
-                !isWhatsAppPairingStatus(data.status)) {
-                return;
-            }
-            const nextStatus = data.status;
-            setState((previous) => ({
-                ...previous,
-                status: nextStatus,
-                phoneNumber: typeof data.phoneNumber === "string"
-                    ? data.phoneNumber
-                    : previous.phoneNumber,
-                error: typeof data.error === "string" ? data.error : null,
-                qrDataUrl: nextStatus === "connected" ||
-                    nextStatus === "disconnected" ||
-                    nextStatus === "timeout" ||
-                    nextStatus === "error"
-                    ? null
-                    : previous.qrDataUrl,
-            }));
-        });
-        return () => {
-            unbindQr();
-            unbindStatus();
-        };
-    }, [accountId]);
-    const startPairing = useCallback(async () => {
-        setState({
-            status: "initializing",
-            qrDataUrl: null,
-            phoneNumber: null,
-            error: null,
-        });
-        try {
-            const result = await client.startWhatsAppPairing(accountId);
-            if (!result.ok) {
-                setState((previous) => ({
-                    ...previous,
-                    status: "error",
-                    error: result.error ?? "Failed to start pairing.",
-                }));
-            }
-        }
-        catch (cause) {
-            setState((previous) => ({
-                ...previous,
-                status: "error",
-                error: formatPairingError(cause),
-            }));
-        }
-    }, [accountId]);
-    const stopPairing = useCallback(async () => {
-        try {
-            await client.stopWhatsAppPairing(accountId);
-            setState({
-                status: "idle",
-                qrDataUrl: null,
-                phoneNumber: null,
-                error: null,
-            });
-        }
-        catch (cause) {
-            setState((previous) => ({
-                ...previous,
-                status: "error",
-                error: formatPairingError(cause),
-            }));
-        }
-    }, [accountId]);
-    const disconnect = useCallback(async () => {
-        try {
-            await client.disconnectWhatsApp(accountId);
-            setState({
-                status: "idle",
-                qrDataUrl: null,
-                phoneNumber: null,
-                error: null,
-            });
-        }
-        catch (cause) {
-            setState((previous) => ({
-                ...previous,
-                status: "error",
-                error: formatPairingError(cause),
-            }));
-        }
-    }, [accountId]);
-    return { ...state, startPairing, stopPairing, disconnect };
-}

package/apps/app-lifeops/src/inbox/config.d.ts

@@ -1,7 +0,0 @@
-import type { InboxTriageConfig } from "./types.js";
-/**
- * Load inbox triage configuration from the agent config file.
- * Falls back to sensible defaults when not configured.
- */
-export declare function loadInboxTriageConfig(): InboxTriageConfig;
-//# sourceMappingURL=config.d.ts.map

package/apps/app-lifeops/src/inbox/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/inbox/config.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpD;;;GAGG;AACH,wBAAgB,qBAAqB,IAAI,iBAAiB,CAazD"}

package/apps/app-lifeops/src/inbox/config.js

@@ -1,67 +0,0 @@
-import { loadElizaConfig, } from "@elizaos/agent";
-/**
- * Load inbox triage configuration from the agent config file.
- * Falls back to sensible defaults when not configured.
- */
-export function loadInboxTriageConfig() {
-    try {
-        const cfg = loadElizaConfig();
-        const raw = cfg.agents?.defaults?.inboxTriage;
-        if (raw && typeof raw === "object") {
-            return deepMergeConfig(DEFAULT_CONFIG, raw);
-        }
-    }
-    catch {
-        // Config loading failed; use defaults
-    }
-    return { ...DEFAULT_CONFIG };
-}
-/**
- * Deep-merge user overrides onto defaults so nested objects (autoReply,
- * triageRules) keep their default fields when the user only sets a subset.
- */
-function deepMergeConfig(defaults, overrides) {
-    return {
-        ...defaults,
-        ...overrides,
-        autoReply: {
-            ...defaults.autoReply,
-            ...(overrides.autoReply ?? {}),
-        },
-        triageRules: {
-            ...defaults.triageRules,
-            ...(overrides.triageRules ?? {}),
-        },
-    };
-}
-const DEFAULT_CONFIG = {
-    enabled: false,
-    triageCron: "0 * * * *",
-    digestCron: "0 8 * * *",
-    digestTimezone: undefined,
-    channels: [
-        "discord",
-        "telegram",
-        "signal",
-        "imessage",
-        "whatsapp",
-        "gmail",
-        "x_dm",
-    ],
-    prioritySenders: [],
-    priorityChannels: [],
-    autoReply: {
-        enabled: false,
-        confidenceThreshold: 0.85,
-        senderWhitelist: [],
-        channelWhitelist: [],
-        maxAutoRepliesPerHour: 5,
-    },
-    triageRules: {
-        alwaysUrgent: [],
-        alwaysIgnore: [],
-        alwaysNotify: [],
-    },
-    digestDeliveryChannel: "client_chat",
-    retentionDays: 30,
-};

package/apps/app-lifeops/src/inbox/reflection.d.ts

@@ -1,40 +0,0 @@
-import type { IAgentRuntime } from "@elizaos/core";
-/**
- * Before sending a drafted response, run a reflection LLM call to verify
- * the owner actually confirmed the send. This catches ambiguous messages
- * like "sure" (which could be a response to something else) or "wait"
- * that might be misinterpreted as confirmation.
- *
- * Returns true if the reflection confirms the owner intended to send.
- */
-export declare function reflectOnSendConfirmation(runtime: IAgentRuntime, opts: {
-    /** The owner's most recent message. */
-    userMessage: string;
-    /** The drafted response text that would be sent. */
-    draftText: string;
-    /** Where it would be sent. */
-    channelName: string;
-    /** Who it would be sent to. */
-    recipientName: string;
-}): Promise<{
-    confirmed: boolean;
-    reasoning: string;
-}>;
-/**
- * Before auto-sending a reply without explicit owner confirmation, run a
- * reflection check to verify the response is appropriate and safe.
- */
-export declare function reflectOnAutoReply(runtime: IAgentRuntime, opts: {
-    /** The original inbound message. */
-    inboundText: string;
-    /** The proposed auto-reply. */
-    replyText: string;
-    /** Source channel. */
-    source: string;
-    /** Sender name. */
-    senderName: string;
-}): Promise<{
-    approved: boolean;
-    reasoning: string;
-}>;
-//# sourceMappingURL=reflection.d.ts.map

package/apps/app-lifeops/src/inbox/reflection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"reflection.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/inbox/reflection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAcnD;;;;;;;GAOG;AACH,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE;IACJ,uCAAuC;IACvC,WAAW,EAAE,MAAM,CAAC;IACpB,oDAAoD;IACpD,SAAS,EAAE,MAAM,CAAC;IAClB,8BAA8B;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,aAAa,EAAE,MAAM,CAAC;CACvB,GACA,OAAO,CAAC;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CA+CpD;AAMD;;;GAGG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,aAAa,EACtB,IAAI,EAAE;IACJ,oCAAoC;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,mBAAmB;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,GACA,OAAO,CAAC;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAqDnD"}

package/apps/app-lifeops/src/inbox/reflection.js

@@ -1,115 +0,0 @@
-import { logger, ModelType, parseJSONObjectFromText } from "@elizaos/core";
-function parseReflectionObject(raw) {
-    const parsed = parseJSONObjectFromText(raw);
-    return parsed && typeof parsed === "object" ? parsed : null;
-}
-// ---------------------------------------------------------------------------
-// Send confirmation reflection
-// ---------------------------------------------------------------------------
-/**
- * Before sending a drafted response, run a reflection LLM call to verify
- * the owner actually confirmed the send. This catches ambiguous messages
- * like "sure" (which could be a response to something else) or "wait"
- * that might be misinterpreted as confirmation.
- *
- * Returns true if the reflection confirms the owner intended to send.
- */
-export async function reflectOnSendConfirmation(runtime, opts) {
-    const prompt = [
-        "You are a safety check for an inbox response system. Your job is to determine",
-        "whether the user has clearly confirmed they want to send a drafted message.",
-        "",
-        `The pending draft message is: "${opts.draftText}"`,
-        `It would be sent to: ${opts.recipientName} on ${opts.channelName}`,
-        "",
-        `The user's most recent message is: "${opts.userMessage}"`,
-        "",
-        "Determine if the user CLEARLY confirmed they want this message sent.",
-        "Confirmation signals: 'yes', 'send it', 'go ahead', 'looks good, send it', 'confirm'",
-        "Rejection signals: 'no', 'wait', 'hold on', 'change it', 'actually...', 'not yet'",
-        "Ambiguous (treat as NOT confirmed): single words that could mean anything, unrelated responses",
-        "",
-        'Respond with exactly one JSON object: { "confirmed": true/false, "reasoning": "brief explanation" }',
-    ].join("\n");
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_SMALL, { prompt });
-        const raw = typeof result === "string" ? result : "";
-        const parsed = parseReflectionObject(raw);
-        if (parsed) {
-            return {
-                confirmed: parsed.confirmed === true,
-                reasoning: typeof parsed.reasoning === "string"
-                    ? parsed.reasoning
-                    : "No reasoning provided",
-            };
-        }
-        return {
-            confirmed: false,
-            reasoning: `Could not parse reflection: ${raw.slice(0, 100)}`,
-        };
-    }
-    catch (error) {
-        logger.warn("[inbox-reflection] Reflection LLM call failed:", String(error));
-        // On error, default to NOT confirmed (safer)
-        return {
-            confirmed: false,
-            reasoning: "Reflection check failed; defaulting to not confirmed for safety",
-        };
-    }
-}
-// ---------------------------------------------------------------------------
-// Auto-reply safety reflection
-// ---------------------------------------------------------------------------
-/**
- * Before auto-sending a reply without explicit owner confirmation, run a
- * reflection check to verify the response is appropriate and safe.
- */
-export async function reflectOnAutoReply(runtime, opts) {
-    const prompt = [
-        "You are a safety check for an auto-reply system. The system wants to automatically",
-        "send a reply WITHOUT explicit owner confirmation. Your job is to determine if this",
-        "auto-reply is appropriate and safe to send.",
-        "",
-        `Inbound message from ${opts.senderName} on ${opts.source}: "${opts.inboundText}"`,
-        `Proposed auto-reply: "${opts.replyText}"`,
-        "",
-        "Approve the auto-reply ONLY if ALL of these are true:",
-        "1. The reply is factually neutral and unlikely to cause harm",
-        "2. The reply doesn't make promises, commitments, or share sensitive info",
-        "3. The reply is appropriate for the tone and context of the conversation",
-        "4. The reply doesn't reveal private information about the owner",
-        "5. The message is routine (acknowledgement, simple greeting, basic info)",
-        "",
-        "Reject if ANY of these are true:",
-        "- The reply contains opinions, decisions, or commitments",
-        "- The conversation topic is sensitive (financial, legal, personal)",
-        "- The reply could be embarrassing or inappropriate",
-        "- The sender seems upset or the conversation is heated",
-        "",
-        'Respond with exactly one JSON object: { "approved": true/false, "reasoning": "brief explanation" }',
-    ].join("\n");
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_SMALL, { prompt });
-        const raw = typeof result === "string" ? result : "";
-        const parsed = parseReflectionObject(raw);
-        if (parsed) {
-            return {
-                approved: parsed.approved === true,
-                reasoning: typeof parsed.reasoning === "string"
-                    ? parsed.reasoning
-                    : "No reasoning provided",
-            };
-        }
-        return {
-            approved: false,
-            reasoning: `Could not parse reflection: ${raw.slice(0, 100)}`,
-        };
-    }
-    catch (error) {
-        logger.warn("[inbox-reflection] Auto-reply reflection failed:", String(error));
-        return {
-            approved: false,
-            reasoning: "Reflection check failed; blocking auto-reply for safety",
-        };
-    }
-}