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

package/apps/app-lifeops/src/actions/calendly.d.ts

@@ -1,3 +0,0 @@
-import { type Action } from "@elizaos/core";
-export declare const calendlyAction: Action;
-//# sourceMappingURL=calendly.d.ts.map

package/apps/app-lifeops/src/actions/calendly.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"calendly.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/calendly.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAMZ,MAAM,eAAe,CAAC;AA6GvB,eAAO,MAAM,cAAc,EAAE,MA0R5B,CAAC"}

package/apps/app-lifeops/src/actions/calendly.js

@@ -1,285 +0,0 @@
-import { logger, } from "@elizaos/core";
-import { extractActionParamsViaLlm, hasAdminAccess } from "@elizaos/agent";
-import { CalendlyError, createCalendlySingleUseLink, getCalendlyAvailability, listCalendlyEventTypes, listCalendlyScheduledEvents, readCalendlyCredentialsFromEnv, } from "../lifeops/calendly-client.js";
-const ACTION_NAME = "CALENDLY";
-function coerceString(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function parseSubaction(value) {
-    const s = coerceString(value)?.toLowerCase();
-    if (!s)
-        return null;
-    if (s === "list_event_types" ||
-        s === "availability" ||
-        s === "upcoming_events" ||
-        s === "single_use_link") {
-        return s;
-    }
-    return null;
-}
-function formatEventTypes(types) {
-    if (types.length === 0)
-        return "No Calendly event types found.";
-    const active = types.filter((t) => t.active);
-    const lines = active.map((t) => `- ${t.name} (${t.durationMinutes}m) — ${t.schedulingUrl}\n  uri: ${t.uri}`);
-    return `Calendly event types (${active.length} active):\n${lines.join("\n")}`;
-}
-function formatScheduledEvents(events) {
-    if (events.length === 0)
-        return "No upcoming Calendly events.";
-    const lines = events.map((event) => {
-        const inviteeSummary = event.invitees.length > 0
-            ? event.invitees
-                .map((inv) => inv.name ?? inv.email ?? "(unknown)")
-                .join(", ")
-            : "(no invitees yet)";
-        return `- ${event.name} @ ${event.startTime} → ${event.endTime} [${event.status}] — ${inviteeSummary}`;
-    });
-    return `Calendly scheduled events (${events.length}):\n${lines.join("\n")}`;
-}
-function formatAvailability(days) {
-    if (days.length === 0)
-        return "No available slots in that range.";
-    const lines = days.map((day) => {
-        const times = day.slots.map((s) => s.startTime).join(", ");
-        return `- ${day.date}: ${day.slots.length} slot(s) — ${times}`;
-    });
-    return `Calendly availability:\n${lines.join("\n")}`;
-}
-function failure(text, error, extra = {}) {
-    return {
-        text,
-        success: false,
-        values: { success: false, error, ...extra },
-        data: { actionName: ACTION_NAME, error, ...extra },
-    };
-}
-function success(text, data) {
-    return {
-        text,
-        success: true,
-        values: { success: true },
-        data: { actionName: ACTION_NAME, ...data },
-    };
-}
-export const calendlyAction = {
-    name: ACTION_NAME,
-    similes: [
-        "CALENDLY_LIST_EVENT_TYPES",
-        "CALENDLY_AVAILABILITY",
-        "CALENDLY_UPCOMING",
-        "CALENDLY_BOOKING_LINK",
-        "CALENDLY_ACTION",
-        "CALENDLY_EVENT_TYPES",
-        "CALENDLY_SCHEDULED_EVENTS",
-    ],
-    description: "Work with Calendly specifically (calendly.com / api.calendly.com): " +
-        "list event types, check availability against a Calendly event type URI, " +
-        "list Calendly-scheduled events, generate Calendly single-use booking " +
-        "links. Subactions: list_event_types, availability, upcoming_events, " +
-        "single_use_link. " +
-        "Use this — NOT CALENDAR_ACTION — whenever the user mentions Calendly by " +
-        "name or passes a calendly.com / api.calendly.com URL. CALENDAR_ACTION " +
-        "is for Google Calendar; CALENDLY is its own third-party scheduling " +
-        "product with a separate API, event-type URIs, and booking-link flow.",
-    validate: async (runtime, message) => {
-        if (!readCalendlyCredentialsFromEnv())
-            return false;
-        return hasAdminAccess(runtime, message);
-    },
-    parameters: [
-        {
-            name: "subaction",
-            description: "One of: list_event_types, availability, upcoming_events, single_use_link. Strongly preferred — when omitted, the handler runs an LLM extraction over the conversation to recover it.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "intent",
-            description: "Optional free-form description of the user's intent.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "eventTypeUri",
-            description: "Calendly event type URI. Required for availability and single_use_link.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "startDate",
-            description: "ISO date (YYYY-MM-DD) for range-based queries (availability, upcoming_events).",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "endDate",
-            description: "ISO date (YYYY-MM-DD) for range-based queries.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "timezone",
-            description: "IANA timezone, e.g. America/Los_Angeles.",
-            required: false,
-            schema: { type: "string" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Show me my Calendly event types" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Calendly event types (2 active):\n- 30 Minute Meeting (30m) — https://calendly.com/me/30min\n  uri: https://api.calendly.com/event_types/ABCD",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: {
-                    text: "What's my Calendly availability next week for the 30 min meeting?",
-                },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Calendly availability:\n- 2026-04-20: 4 slot(s) — ...",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Generate a one-time Calendly link for my intro call" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Single-use Calendly booking link: https://calendly.com/d/xxx-yyy-zzz",
-                },
-            },
-        ],
-    ],
-    handler: async (runtime, message, state, options) => {
-        if (!(await hasAdminAccess(runtime, message))) {
-            return failure("Permission denied: only the owner or admin may use Calendly.", "PERMISSION_DENIED");
-        }
-        const credentials = readCalendlyCredentialsFromEnv();
-        if (!credentials) {
-            return failure("Calendly is not configured. Set ELIZA_CALENDLY_TOKEN.", "CALENDLY_NOT_CONFIGURED");
-        }
-        const rawParameters = options?.parameters;
-        const rawParams = ((typeof rawParameters === "object" && rawParameters !== null
-            ? rawParameters
-            : {}) ?? {});
-        const params = (await extractActionParamsViaLlm({
-            runtime,
-            message,
-            state,
-            actionName: "CALENDLY",
-            actionDescription: calendlyAction.description ?? "",
-            paramSchema: calendlyAction.parameters ?? [],
-            existingParams: rawParams,
-            requiredFields: ["subaction"],
-        }));
-        const subaction = parseSubaction(params.subaction);
-        const eventTypeUri = coerceString(params.eventTypeUri);
-        const startDate = coerceString(params.startDate);
-        const endDate = coerceString(params.endDate);
-        if (!subaction) {
-            return failure("Missing or invalid subaction. Use one of: list_event_types, availability, upcoming_events, single_use_link.", "INVALID_SUBACTION");
-        }
-        try {
-            switch (subaction) {
-                case "list_event_types": {
-                    const types = await listCalendlyEventTypes(credentials);
-                    return success(formatEventTypes(types), {
-                        subaction,
-                        eventTypes: types,
-                    });
-                }
-                case "availability": {
-                    if (!eventTypeUri) {
-                        return failure("Missing required parameter: eventTypeUri.", "MISSING_EVENT_TYPE_URI");
-                    }
-                    if (!startDate || !endDate) {
-                        return failure("Missing required parameters: startDate and endDate (YYYY-MM-DD).", "MISSING_DATE_RANGE");
-                    }
-                    const availability = await getCalendlyAvailability(credentials, eventTypeUri, {
-                        startDate,
-                        endDate,
-                        timezone: coerceString(params.timezone),
-                    });
-                    return success(formatAvailability(availability), {
-                        subaction,
-                        availability,
-                    });
-                }
-                case "upcoming_events": {
-                    const startDate = coerceString(params.startDate);
-                    const endDate = coerceString(params.endDate);
-                    const events = await listCalendlyScheduledEvents(credentials, {
-                        minStartTime: startDate
-                            ? `${startDate}T00:00:00Z`
-                            : new Date().toISOString(),
-                        maxStartTime: endDate ? `${endDate}T23:59:59Z` : undefined,
-                        status: "active",
-                        limit: 50,
-                    });
-                    return success(formatScheduledEvents(events), {
-                        subaction,
-                        events,
-                    });
-                }
-                case "single_use_link": {
-                    if (!eventTypeUri) {
-                        return failure("Missing required parameter: eventTypeUri.", "MISSING_EVENT_TYPE_URI");
-                    }
-                    const link = await createCalendlySingleUseLink(credentials, eventTypeUri);
-                    const expiryText = link.expiresAt
-                        ? ` (expires ${link.expiresAt})`
-                        : "";
-                    return success(`Single-use Calendly booking link: ${link.bookingUrl}${expiryText}`, { subaction, link });
-                }
-                default: {
-                    // Exhaustiveness check — if CalendlySubaction gains a new variant,
-                    // TypeScript fails to compile here. If runtime bypasses the type
-                    // system (e.g. `as never`), we still return a structured failure
-                    // instead of falling off the end as undefined.
-                    const _exhaustive = subaction;
-                    void _exhaustive;
-                    return failure(`Unknown Calendly subaction: ${String(subaction)}`, "UNKNOWN_SUBACTION");
-                }
-            }
-        }
-        catch (error) {
-            if (error instanceof CalendlyError) {
-                logger.warn({
-                    boundary: "lifeops",
-                    integration: "calendly",
-                    subaction,
-                    statusCode: error.status,
-                }, `[lifeops] Calendly ${subaction} failed: ${error.message}`);
-                return failure(`Calendly ${subaction} failed: ${error.message}`, "CALENDLY_API_ERROR", { statusCode: error.status });
-            }
-            // Declared return type is Promise<ActionResult>; never throw arbitrary
-            // errors out of the handler. Log and return a structured failure.
-            const message = error instanceof Error ? error.message : String(error);
-            logger.error({
-                boundary: "lifeops",
-                integration: "calendly",
-                subaction,
-                err: error,
-            }, `[lifeops] Calendly ${subaction} unexpected error: ${message}`);
-            return failure(`Calendly ${subaction} failed unexpectedly: ${message}`, "CALENDLY_UNEXPECTED_ERROR");
-        }
-    },
-};

package/apps/app-lifeops/src/actions/chat-thread-control.d.ts

@@ -1,3 +0,0 @@
-import type { Action } from "@elizaos/core";
-export declare const chatThreadControlAction: Action;
-//# sourceMappingURL=chat-thread-control.d.ts.map

package/apps/app-lifeops/src/actions/chat-thread-control.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"chat-thread-control.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/chat-thread-control.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAMP,MAAM,eAAe,CAAC;AA2MvB,eAAO,MAAM,uBAAuB,EAAE,MAgIrC,CAAC"}

package/apps/app-lifeops/src/actions/chat-thread-control.js

@@ -1,260 +0,0 @@
-import { ModelType, parseJSONObjectFromText, parseKeyValueXml, } from "@elizaos/core";
-import { recentConversationTexts } from "./life-recent-context.js";
-import { hasLifeOpsAccess, messageText } from "./lifeops-google-helpers.js";
-import { scheduleOnceTriggerTask } from "./scheduled-trigger-task.js";
-function normalizeOperation(value) {
-    if (typeof value !== "string")
-        return null;
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "mute_chat" || normalized === "mute")
-        return "mute_chat";
-    if (normalized === "unmute_chat" ||
-        normalized === "unmute" ||
-        normalized === "restore_chat") {
-        return "unmute_chat";
-    }
-    return null;
-}
-function normalizePlatform(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim().toLowerCase();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function normalizeString(value) {
-    if (typeof value !== "string")
-        return undefined;
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function normalizeDurationMinutes(value) {
-    if (typeof value === "number" && Number.isFinite(value) && value > 0) {
-        return Math.floor(value);
-    }
-    if (typeof value === "string") {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed) && parsed > 0) {
-            return Math.floor(parsed);
-        }
-    }
-    return undefined;
-}
-function normalizeShouldAct(value) {
-    if (typeof value === "boolean")
-        return value;
-    if (typeof value === "string") {
-        const normalized = value.trim().toLowerCase();
-        if (normalized === "true")
-            return true;
-        if (normalized === "false")
-            return false;
-    }
-    return null;
-}
-async function resolveChatThreadPlan(args) {
-    const currentText = messageText(args.message).trim();
-    const recent = await recentConversationTexts({
-        runtime: args.runtime,
-        message: args.message,
-        state: args.state,
-        limit: 8,
-    });
-    const prompt = [
-        "Plan a targeted local chat-thread control action.",
-        "Return ONLY valid JSON with exactly these fields:",
-        "  operation: mute_chat, unmute_chat, or null",
-        "  platform: connector name like telegram or discord",
-        "  chatName: exact chat/channel title when present",
-        "  roomId: explicit room id when the request already supplies one, otherwise null",
-        "  durationMinutes: integer number of minutes when the user asks for a temporary mute, otherwise null",
-        "  shouldAct: boolean",
-        "  response: short follow-up if shouldAct is false or details are missing",
-        "",
-        "Use this action for targeted connector chat mute/unmute, especially when the user names a Telegram or Discord room that is not the current chat.",
-        "Examples:",
-        '  "Mute the crypto signals Telegram group for 24 hours." -> {"operation":"mute_chat","platform":"telegram","chatName":"crypto signals","roomId":null,"durationMinutes":1440,"shouldAct":true,"response":null}',
-        '  "Unmute the Telegram group crypto signals." -> {"operation":"unmute_chat","platform":"telegram","chatName":"crypto signals","roomId":null,"durationMinutes":null,"shouldAct":true,"response":null}',
-        '  "Mute that room." -> {"operation":null,"platform":null,"chatName":null,"roomId":null,"durationMinutes":null,"shouldAct":false,"response":"Which chat should I mute, and on which platform?"}',
-        "",
-        `Current request: ${JSON.stringify(currentText)}`,
-        `Recent conversation: ${JSON.stringify(recent.join("\n"))}`,
-    ].join("\n");
-    try {
-        const raw = await args.runtime.useModel(ModelType.TEXT_SMALL, { prompt });
-        const parsed = parseKeyValueXml(typeof raw === "string" ? raw : "") ?? parseJSONObjectFromText(typeof raw === "string" ? raw : "");
-        if (!parsed) {
-            return { operation: null, shouldAct: null };
-        }
-        return {
-            operation: normalizeOperation(parsed.operation),
-            platform: normalizePlatform(parsed.platform),
-            chatName: normalizeString(parsed.chatName),
-            roomId: normalizeString(parsed.roomId),
-            durationMinutes: normalizeDurationMinutes(parsed.durationMinutes),
-            shouldAct: normalizeShouldAct(parsed.shouldAct),
-            response: normalizeString(parsed.response),
-        };
-    }
-    catch (error) {
-        args.runtime.logger?.warn?.({
-            src: "action:chat-thread-control",
-            error: error instanceof Error ? error.message : String(error),
-        }, "chat thread control planning failed");
-        return { operation: null, shouldAct: null };
-    }
-}
-function roomMatchesTarget(args) {
-    const room = args.room;
-    if (!room)
-        return false;
-    if (normalizePlatform(room.source) !== args.platform) {
-        return false;
-    }
-    if (args.roomId && room.id === args.roomId) {
-        return true;
-    }
-    if (!args.chatName) {
-        return false;
-    }
-    const lookup = args.chatName.trim().toLowerCase();
-    const candidates = [
-        typeof room.name === "string" ? room.name : "",
-        typeof room.channelId === "string" ? room.channelId : "",
-        typeof room.id === "string" ? room.id : "",
-    ]
-        .map((entry) => entry.trim().toLowerCase())
-        .filter((entry) => entry.length > 0);
-    return candidates.some((candidate) => candidate === lookup || candidate.includes(lookup));
-}
-async function resolveTargetRoom(args) {
-    if (args.roomId) {
-        return await args.runtime.getRoom(args.roomId);
-    }
-    const roomIds = (await args.runtime.getRoomsForParticipant?.(args.runtime.agentId)) ?? [];
-    for (const roomId of roomIds) {
-        const room = await args.runtime.getRoom(roomId);
-        if (roomMatchesTarget({
-            room,
-            platform: args.platform,
-            chatName: args.chatName,
-        })) {
-            return room;
-        }
-    }
-    return null;
-}
-export const chatThreadControlAction = {
-    name: "CHAT_THREAD_CONTROL",
-    similes: [
-        "MUTE_TARGET_CHAT",
-        "UNMUTE_TARGET_CHAT",
-        "MUTE_TELEGRAM_CHAT",
-        "UNMUTE_TELEGRAM_CHAT",
-    ],
-    description: "Mute or unmute a specific connector chat that is not necessarily the current room, and optionally schedule an automatic unmute. " +
-        "Use this for requests like 'Mute the crypto signals Telegram group for 24 hours' or 'Unmute that Telegram room now'. " +
-        "Do not use generic MUTE_ROOM or UNMUTE_ROOM when the owner names a different chat or platform.",
-    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
-    handler: async (runtime, message, state, options) => {
-        const runtimeLike = runtime;
-        const params = (options
-            ?.parameters ?? {});
-        const planned = await resolveChatThreadPlan({ runtime, message, state });
-        const operation = normalizeOperation(params.operation) ?? planned.operation;
-        const platform = normalizePlatform(params.platform) ?? planned.platform ?? "telegram";
-        const roomId = normalizeString(params.roomId) ?? planned.roomId;
-        const chatName = normalizeString(params.chatName) ?? planned.chatName;
-        const durationMinutes = normalizeDurationMinutes(params.durationMinutes) ??
-            planned.durationMinutes;
-        if (!operation || planned.shouldAct === false) {
-            return {
-                success: false,
-                text: planned.response ??
-                    "Which chat should I control, and on which platform?",
-                data: {
-                    actionName: "CHAT_THREAD_CONTROL",
-                    needsClarification: true,
-                },
-            };
-        }
-        const room = await resolveTargetRoom({
-            runtime: runtimeLike,
-            platform,
-            roomId,
-            chatName,
-        });
-        if (!room) {
-            return {
-                success: false,
-                text: `I couldn't find that ${platform} chat yet.`,
-                data: {
-                    actionName: "CHAT_THREAD_CONTROL",
-                    operation,
-                    platform,
-                    roomId: roomId ?? null,
-                    chatName: chatName ?? null,
-                    error: "ROOM_NOT_FOUND",
-                },
-            };
-        }
-        if (operation === "unmute_chat") {
-            await runtime.updateParticipantUserState(room.id, runtime.agentId, null);
-            return {
-                success: true,
-                text: `Unmuted ${room.name ?? chatName ?? "that chat"} on ${platform}.`,
-                data: {
-                    actionName: "CHAT_THREAD_CONTROL",
-                    operation,
-                    platform,
-                    roomId: room.id,
-                    roomName: room.name ?? null,
-                    muted: false,
-                },
-            };
-        }
-        await runtime.updateParticipantUserState(room.id, runtime.agentId, "MUTED");
-        let scheduledTaskId;
-        let triggerId;
-        let scheduledAtIso;
-        let duplicateTaskId;
-        if (durationMinutes && durationMinutes > 0) {
-            scheduledAtIso = new Date(Date.now() + durationMinutes * 60_000).toISOString();
-            const schedule = await scheduleOnceTriggerTask({
-                runtime,
-                message,
-                displayName: `Unmute ${platform} chat: ${room.name ?? chatName ?? room.id}`,
-                instructions: [
-                    "Run the queued connector chat unmute.",
-                    `Use CHAT_THREAD_CONTROL to unmute the ${platform} chat.`,
-                    `operation: unmute_chat`,
-                    `platform: ${platform}`,
-                    `roomId: ${room.id}`,
-                    `chatName: ${room.name ?? chatName ?? room.id}`,
-                ].join("\n"),
-                scheduledAtIso,
-                dedupeKey: `chat-thread-control:${platform}:unmute:${room.id}:${scheduledAtIso}`,
-            });
-            scheduledTaskId = schedule.taskId;
-            triggerId = schedule.triggerId;
-            duplicateTaskId = schedule.duplicateTaskId;
-        }
-        return {
-            success: true,
-            text: durationMinutes && scheduledAtIso
-                ? `Muted ${room.name ?? chatName ?? "that chat"} on ${platform} for ${durationMinutes} minutes.`
-                : `Muted ${room.name ?? chatName ?? "that chat"} on ${platform}.`,
-            data: {
-                actionName: "CHAT_THREAD_CONTROL",
-                operation,
-                platform,
-                roomId: room.id,
-                roomName: room.name ?? null,
-                muted: true,
-                durationMinutes: durationMinutes ?? null,
-                scheduledAtIso: scheduledAtIso ?? null,
-                scheduledTaskId: scheduledTaskId ?? duplicateTaskId ?? null,
-                triggerId: triggerId ?? null,
-            },
-        };
-    },
-};

package/apps/app-lifeops/src/actions/checkin.d.ts

@@ -1,8 +0,0 @@
-import type { Action } from "@elizaos/core";
-export declare const runMorningCheckinAction: Action & {
-    suppressPostActionContinuation?: boolean;
-};
-export declare const runNightCheckinAction: Action & {
-    suppressPostActionContinuation?: boolean;
-};
-//# sourceMappingURL=checkin.d.ts.map

package/apps/app-lifeops/src/actions/checkin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"checkin.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/checkin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAqC,MAAM,eAAe,CAAC;AAoF/E,eAAO,MAAM,uBAAuB,EAAE,MAAM,GAAG;IAC7C,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAgF1C,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,MAAM,GAAG;IAC3C,8BAA8B,CAAC,EAAE,OAAO,CAAC;CA+E1C,CAAC"}