@elizaos/agent 2.0.0-alpha.192 → 2.0.0-alpha.196

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

@@ -16,6 +16,157 @@ function getParams(options) {
 function messageText(message) {
     return (message?.content?.text ?? "").toString();
 }
+function normalizedNonEmpty(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeLookup(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+async function resolveRelationshipIdByName(service, rawName) {
+    const needle = normalizeLookup(rawName);
+    if (!needle) {
+        return null;
+    }
+    const relationships = await service.listRelationships({ limit: 200 });
+    const exactMatch = relationships.find((relationship) => normalizeLookup(relationship.name) === needle) ??
+        relationships.find((relationship) => normalizeLookup(relationship.primaryHandle).includes(needle) ||
+            normalizeLookup(relationship.email ?? "").includes(needle));
+    if (exactMatch) {
+        return exactMatch.id;
+    }
+    return (relationships.find((relationship) => normalizeLookup(relationship.name).includes(needle))?.id ?? null);
+}
+async function resolveRelationshipIdFromText(service, rawText) {
+    const haystack = normalizeLookup(rawText);
+    if (!haystack) {
+        return null;
+    }
+    const relationships = await service.listRelationships({ limit: 200 });
+    const fullNameMatch = relationships.find((relationship) => haystack.includes(normalizeLookup(relationship.name)));
+    if (fullNameMatch) {
+        return fullNameMatch.id;
+    }
+    const candidateMatches = new Map();
+    for (const relationship of relationships) {
+        const nameTokens = normalizeLookup(relationship.name)
+            .split(" ")
+            .filter((token) => token.length >= 3);
+        const handleTokens = [
+            normalizeLookup(relationship.primaryHandle).replace(/^@/, ""),
+            normalizeLookup(relationship.email ?? "").split("@")[0] ?? "",
+        ].filter((token) => token.length >= 3);
+        for (const token of [...nameTokens, ...handleTokens]) {
+            const tokenPattern = new RegExp(`\\b${escapeRegExp(token)}\\b`, "i");
+            if (tokenPattern.test(rawText)) {
+                candidateMatches.set(relationship.id, relationship.id);
+                break;
+            }
+        }
+    }
+    if (candidateMatches.size === 1) {
+        return [...candidateMatches.values()][0] ?? null;
+    }
+    return null;
+}
+async function resolveRelationshipId(service, params, body) {
+    const explicitRelationshipId = normalizedNonEmpty(params.relationshipId);
+    if (explicitRelationshipId) {
+        if (UUID_PATTERN.test(explicitRelationshipId)) {
+            return explicitRelationshipId;
+        }
+        const resolvedFromRelationshipId = await resolveRelationshipIdByName(service, explicitRelationshipId);
+        if (resolvedFromRelationshipId) {
+            return resolvedFromRelationshipId;
+        }
+    }
+    const name = normalizedNonEmpty(params.name);
+    if (!name) {
+        for (const candidate of [params.intent, body]) {
+            const normalizedCandidate = normalizedNonEmpty(candidate);
+            const resolvedFromText = normalizedCandidate
+                ? await resolveRelationshipIdFromText(service, normalizedCandidate)
+                : null;
+            if (resolvedFromText) {
+                return resolvedFromText;
+            }
+        }
+        return null;
+    }
+    const resolvedFromName = await resolveRelationshipIdByName(service, name);
+    if (resolvedFromName) {
+        return resolvedFromName;
+    }
+    return resolveRelationshipIdFromText(service, name);
+}
+function normalizeFollowUpDueAt(rawDueAt) {
+    const trimmed = rawDueAt.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const directMs = Date.parse(trimmed);
+    if (Number.isFinite(directMs)) {
+        return new Date(directMs).toISOString();
+    }
+    const normalized = normalizeLookup(trimmed);
+    const base = new Date();
+    const atDefaultFollowUpTime = (date) => {
+        const copy = new Date(date);
+        copy.setHours(9, 0, 0, 0);
+        return copy.toISOString();
+    };
+    if (/\btoday\b/.test(normalized)) {
+        return atDefaultFollowUpTime(base);
+    }
+    if (/\btomorrow\b/.test(normalized)) {
+        const tomorrow = new Date(base);
+        tomorrow.setDate(tomorrow.getDate() + 1);
+        return atDefaultFollowUpTime(tomorrow);
+    }
+    if (/\bnext week\b/.test(normalized) ||
+        /\bin a week\b/.test(normalized) ||
+        /\ba week from now\b/.test(normalized)) {
+        const nextWeek = new Date(base);
+        nextWeek.setDate(nextWeek.getDate() + 7);
+        return atDefaultFollowUpTime(nextWeek);
+    }
+    const weekdayMap = {
+        sunday: 0,
+        monday: 1,
+        tuesday: 2,
+        wednesday: 3,
+        thursday: 4,
+        friday: 5,
+        saturday: 6,
+    };
+    const weekdayMatch = normalized.match(/\b(?:(next)\s+)?(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\b/);
+    if (weekdayMatch) {
+        const qualifier = weekdayMatch[1] ?? "";
+        const weekdayToken = weekdayMatch[2] ?? "";
+        const targetWeekday = weekdayMap[weekdayToken];
+        if (targetWeekday !== undefined) {
+            const currentWeekday = base.getDay();
+            let delta = (targetWeekday - currentWeekday + 7) % 7;
+            if (qualifier === "next") {
+                delta = delta === 0 ? 7 : delta + 7;
+            }
+            else if (delta === 0) {
+                delta = 7;
+            }
+            const resolved = new Date(base);
+            resolved.setDate(resolved.getDate() + delta);
+            return atDefaultFollowUpTime(resolved);
+        }
+    }
+    return null;
+}
 const RELATIONSHIP_SUBACTIONS = [
     "list_contacts",
     "add_contact",
@@ -95,9 +246,10 @@ async function resolveRelationshipPlanWithLlm(args) {
         if (!parsed) {
             return { subaction: null, shouldAct: null };
         }
+        const subaction = normalizeRelationshipSubaction(parsed.subaction);
         return {
-            subaction: normalizeRelationshipSubaction(parsed.subaction),
-            shouldAct: normalizeShouldAct(parsed.shouldAct),
+            subaction,
+            shouldAct: subaction ? true : normalizeShouldAct(parsed.shouldAct),
             response: normalizePlannerResponse(parsed.response),
         };
     }
@@ -125,6 +277,7 @@ export const relationshipAction = {
         "ADD_CONTACT",
     ],
     description: "Manage contacts, relationships, and follow-ups. Subactions: list_contacts, add_contact, log_interaction, add_follow_up, complete_follow_up, follow_up_list, days_since.",
+    suppressPostActionContinuation: true,
     validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
     handler: async (runtime, message, state, options, callback) => {
         if (!(await hasLifeOpsAccess(runtime, message))) {
@@ -216,9 +369,9 @@ export const relationshipAction = {
             };
         }
         if (subaction === "log_interaction") {
-            const relationshipId = params.relationshipId;
+            const relationshipId = await resolveRelationshipId(service, params, body);
             if (!relationshipId) {
-                const text = "I need the contact's relationshipId to log an interaction.";
+                const text = "I need a known contact to log an interaction.";
                 await callback?.({ text });
                 return {
                     text,
@@ -254,11 +407,14 @@ export const relationshipAction = {
             };
         }
         if (subaction === "add_follow_up") {
-            const relationshipId = params.relationshipId;
-            const dueAt = params.dueAt;
+            const relationshipId = await resolveRelationshipId(service, params, body);
+            const dueAtSource = normalizedNonEmpty(params.dueAt) ?? body;
+            const dueAt = dueAtSource ? normalizeFollowUpDueAt(dueAtSource) : null;
             const reason = params.reason ?? params.notes ?? "";
             if (!relationshipId || !dueAt) {
-                const text = "I need a contact relationshipId and a dueAt to schedule a follow-up.";
+                const text = !relationshipId
+                    ? "I need a known contact to schedule a follow-up."
+                    : "I need a due date or time to schedule a follow-up.";
                 await callback?.({ text });
                 return {
                     text,
@@ -318,9 +474,9 @@ export const relationshipAction = {
             };
         }
         if (subaction === "days_since") {
-            const relationshipId = params.relationshipId;
+            const relationshipId = await resolveRelationshipId(service, params, body);
             if (!relationshipId) {
-                const text = "I need a relationshipId to check last contact.";
+                const text = "I need a known contact to check last contact.";
                 await callback?.({ text });
                 return {
                     text,
@@ -361,7 +517,7 @@ export const relationshipAction = {
         },
         {
             name: "name",
-            description: "Contact display name.",
+            description: "Contact display name. When relationshipId is omitted, the handler resolves an existing contact by this name.",
             schema: { type: "string" },
         },
         {
@@ -406,7 +562,7 @@ export const relationshipAction = {
         },
         {
             name: "dueAt",
-            description: "ISO-8601 due time for a follow-up.",
+            description: "Follow-up due time. Accepts natural language like 'tomorrow', 'next week', or 'next Tuesday at 3pm', or an ISO-8601 timestamp.",
             schema: { type: "string" },
         },
         {

package/apps/app-lifeops/src/actions/remote-desktop.js

@@ -37,7 +37,7 @@ export const remoteDesktopAction = {
         "REMOTE_CONTROL",
         "PHONE_REMOTE_ACCESS",
     ],
-    description: "Start or end a secure remote desktop session so you can view/control the computer from your phone. Requires a pairing code. Subactions: start, status, end, list.",
+    description: "Start or end a secure remote desktop session so you can view/control the computer from another device. Requires a pairing code. Use this only for remote-session lifecycle work (start, status, end, list), not for local Finder/Desktop automation, screenshots, browser workflows, or file handling on this machine — those belong to LIFEOPS_COMPUTER_USE.",
     validate: async (runtime, message) => hasOwnerAccess(runtime, message),
     parameters: [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"screen-time.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/screen-time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAkEvB,eAAO,MAAM,gBAAgB,EAAE,MAqN9B,CAAC"}
+{"version":3,"file":"screen-time.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/screen-time.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EACV,MAAM,EAKP,MAAM,eAAe,CAAC;AAmEvB,eAAO,MAAM,gBAAgB,EAAE,MA0N9B,CAAC"}

package/apps/app-lifeops/src/actions/screen-time.js

@@ -5,6 +5,7 @@
  */
 import { LifeOpsService } from "../lifeops/service.js";
 import { hasLifeOpsAccess } from "./lifeops-google-helpers.js";
+import { looksLikeScreenTimeReflection } from "./non-actionable-request.js";
 function getParams(options) {
     const params = options?.parameters;
     return params ?? {};
@@ -49,8 +50,13 @@ function inferSubaction(intent, messageBody) {
 export const screenTimeAction = {
     name: "SCREEN_TIME",
     similes: ["SCREENTIME", "APP_USAGE", "WEBSITE_USAGE", "DWELL_TIME"],
-    description: "Query screen time summaries (per app, per website, daily). Subactions: summary, today, weekly, by_app, by_website.",
-    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    description: "Query screen time summaries (per app, per website, daily). Use this for quantitative usage questions like 'how much screen time have I used today?', 'break down my screen time by app this week', or 'which websites did I spend the most time on?'. Do not use this when the user is only reflecting or venting like 'I spend too much time on my phone' unless they actually ask for the numbers. Subactions: summary, today, weekly, by_app, by_website.",
+    validate: async (runtime, message) => {
+        if (looksLikeScreenTimeReflection(messageText(message))) {
+            return false;
+        }
+        return hasLifeOpsAccess(runtime, message);
+    },
     handler: async (runtime, message, _state, options, callback) => {
         if (!(await hasLifeOpsAccess(runtime, message))) {
             const text = "Screen time data is restricted to the owner.";

package/apps/app-lifeops/src/actions/start-remote-session.js

@@ -21,7 +21,7 @@ function coerceString(value) {
 export const startRemoteSessionAction = {
     name: ACTION_NAME,
     similes: ["OPEN_REMOTE_SESSION", "BEGIN_REMOTE_SESSION", "REMOTE_START"],
-    description: "Open a remote-control session. Requires confirmed: true. If running in local mode (MILADY_REMOTE_LOCAL_MODE=1) no pairing code is needed; otherwise a valid 6-digit pairing code is required.",
+    description: "Open a remote-control session. Requires confirmed: true. If running in local mode (MILADY_REMOTE_LOCAL_MODE=1) no pairing code is needed; otherwise a valid 6-digit pairing code is required. Use this only to start a remote session, not for local screenshots, Finder/Desktop tasks, or browser/file automation on this Mac — those belong to LIFEOPS_COMPUTER_USE.",
     validate: async (runtime, message) => hasOwnerAccess(runtime, message),
     parameters: [
         {

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"subscriptions.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/subscriptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,MAAM,EAOP,MAAM,eAAe,CAAC;AAqQvB,eAAO,MAAM,mBAAmB,EAAE,MAAM,GAAG;IACzC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAuC1C,CAAC"}

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

@@ -0,0 +1,251 @@
+import { hasLifeOpsAccess, INTERNAL_URL } from "./lifeops-google-helpers.js";
+import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
+const ACTION_NAME = "SUBSCRIPTIONS";
+function messageText(message) {
+    return typeof message.content?.text === "string" ? message.content.text : "";
+}
+function mergeParams(message, options) {
+    const params = {
+        ...(options?.parameters ??
+            {}),
+    };
+    if (message.content && typeof message.content === "object") {
+        for (const [key, value] of Object.entries(message.content)) {
+            if (params[key] === undefined) {
+                params[key] = value;
+            }
+        }
+    }
+    return params;
+}
+function normalizeMode(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "audit" ||
+        normalized === "cancel" ||
+        normalized === "status") {
+        return normalized;
+    }
+    return null;
+}
+function parseConfirmed(text, params) {
+    if (typeof params.confirmed === "boolean") {
+        return params.confirmed;
+    }
+    return /\b(go ahead|confirm|yes cancel|do it now|proceed)\b/i.test(text);
+}
+function browserTaskData(result) {
+    const artifacts = Array.isArray(result.cancellation.metadata.artifacts)
+        ? result.cancellation.metadata.artifacts
+        : [];
+    return {
+        status: result.cancellation.status,
+        completed: result.cancellation.status === "completed",
+        needsHuman: [
+            "awaiting_confirmation",
+            "needs_login",
+            "needs_mfa",
+            "needs_user_choice",
+            "retention_offer",
+            "phone_only",
+            "chat_only",
+            "blocked",
+        ].includes(result.cancellation.status),
+        artifactCount: result.cancellation.artifactCount,
+        artifacts,
+    };
+}
+async function runSubscriptionsAction(runtime, message, state, options) {
+    void state;
+    const text = messageText(message);
+    const params = mergeParams(message, options);
+    const service = new LifeOpsService(runtime);
+    const inferred = service.resolveSubscriptionIntent(text);
+    const mode = normalizeMode(params.mode) ?? inferred.mode;
+    if (!mode) {
+        return {
+            success: false,
+            text: "Tell me whether you want a subscription audit, a cancellation, or a status check.",
+            data: { error: "AMBIGUOUS_SUBSCRIPTIONS_REQUEST" },
+        };
+    }
+    const serviceName = params.serviceName ?? inferred.serviceName ?? null;
+    const serviceSlug = params.serviceSlug ?? inferred.serviceSlug ?? null;
+    switch (mode) {
+        case "audit": {
+            const summary = await service.auditSubscriptions(INTERNAL_URL, {
+                queryWindowDays: params.queryWindowDays,
+                serviceQuery: serviceName ?? serviceSlug,
+            });
+            return {
+                success: true,
+                text: service.summarizeSubscriptionAudit(summary),
+                data: {
+                    audit: summary.audit,
+                    candidates: summary.candidates,
+                    report: {
+                        totalCandidates: summary.audit.totalCandidates,
+                        activeCandidates: summary.audit.activeCandidates,
+                        canceledCandidates: summary.audit.canceledCandidates,
+                        uncertainCandidates: summary.audit.uncertainCandidates,
+                    },
+                },
+            };
+        }
+        case "cancel": {
+            const summary = await service.cancelSubscription({
+                candidateId: params.candidateId ?? null,
+                serviceName,
+                serviceSlug,
+                executor: params.executor ?? inferred.executor ?? null,
+                confirmed: parseConfirmed(text, params),
+            });
+            return {
+                success: summary.cancellation.status !== "failed" &&
+                    summary.cancellation.status !== "unsupported_surface",
+                text: service.summarizeSubscriptionCancellation(summary),
+                data: {
+                    cancellation: summary.cancellation,
+                    candidate: summary.candidate,
+                    browserTask: browserTaskData(summary),
+                },
+            };
+        }
+        case "status": {
+            const summary = await service.getSubscriptionCancellationStatus({
+                cancellationId: params.cancellationId ?? null,
+                serviceName,
+                serviceSlug,
+            });
+            if (!summary) {
+                const latestAudit = await service.getLatestSubscriptionAudit();
+                if (latestAudit) {
+                    return {
+                        success: true,
+                        text: service.summarizeSubscriptionAudit(latestAudit),
+                        data: {
+                            audit: latestAudit.audit,
+                            candidates: latestAudit.candidates,
+                        },
+                    };
+                }
+                return {
+                    success: true,
+                    text: "No subscription audit or cancellation state is available yet.",
+                    data: { audit: null, cancellation: null },
+                };
+            }
+            return {
+                success: true,
+                text: service.summarizeSubscriptionCancellation(summary),
+                data: {
+                    cancellation: summary.cancellation,
+                    candidate: summary.candidate,
+                    browserTask: browserTaskData(summary),
+                },
+            };
+        }
+    }
+}
+const examples = [
+    [
+        {
+            name: "{{name1}}",
+            content: { text: "Audit my subscriptions and tell me what I can cancel." },
+        },
+        {
+            name: "{{agentName}}",
+            content: {
+                text: "I'll audit recent subscription signals and summarize what looks active, already canceled, or worth reviewing.",
+                actions: [ACTION_NAME],
+            },
+        },
+    ],
+    [
+        {
+            name: "{{name1}}",
+            content: { text: "Cancel my Google Play subscription." },
+        },
+        {
+            name: "{{agentName}}",
+            content: {
+                text: "I'll open the subscription flow, stop before the irreversible step if confirmation is needed, and then report the outcome.",
+                actions: [ACTION_NAME],
+            },
+        },
+    ],
+    [
+        {
+            name: "{{name1}}",
+            content: { text: "Cancel my Netflix subscription." },
+        },
+        {
+            name: "{{agentName}}",
+            content: {
+                text: "I'll open the subscription flow for Netflix, pause for confirmation if needed, and then report the result.",
+                actions: [ACTION_NAME],
+            },
+        },
+    ],
+    [
+        {
+            name: "{{name1}}",
+            content: { text: "Cancel Hulu in my browser." },
+        },
+        {
+            name: "{{agentName}}",
+            content: {
+                text: "I'll route this through the subscription cancellation flow instead of generic website blocking and tell you what happened.",
+                actions: [ACTION_NAME],
+            },
+        },
+    ],
+    [
+        {
+            name: "{{name1}}",
+            content: { text: "Cancel my App Store subscription on this Mac." },
+        },
+        {
+            name: "{{agentName}}",
+            content: {
+                text: "I'll use the subscription cancellation flow for the App Store and report whether it needs any manual confirmation.",
+                actions: [ACTION_NAME],
+            },
+        },
+    ],
+];
+export const subscriptionsAction = {
+    name: ACTION_NAME,
+    similes: [
+        "SUBSCRIPTION_AUDIT",
+        "SUBSCRIPTION_CANCEL",
+        "UNSUBSCRIBE_SERVICE",
+        "MANAGE_SUBSCRIPTIONS",
+        "CANCEL_NETFLIX",
+        "CANCEL_HULU",
+        "CANCEL_APP_STORE_SUBSCRIPTION",
+        "CANCEL_GOOGLE_PLAY_SUBSCRIPTION",
+    ],
+    description: "Audit recurring subscriptions from LifeOps signals, cancel supported subscriptions through the browser, and report cancellation status with artifacts and human-handoff states. " +
+        "Use this for requests like 'cancel my Netflix subscription', 'cancel Hulu in my browser', 'cancel my Google Play subscription', or 'cancel my App Store subscription on this Mac'.",
+    suppressPostActionContinuation: true,
+    validate: async (runtime, message) => hasLifeOpsAccess(runtime, message),
+    handler: async (runtime, message, state, options) => {
+        try {
+            return await runSubscriptionsAction(runtime, message, state, options);
+        }
+        catch (error) {
+            if (error instanceof LifeOpsServiceError) {
+                return {
+                    success: false,
+                    text: error.message,
+                    data: { status: error.status },
+                };
+            }
+            throw error;
+        }
+    },
+    examples,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"twilio-call.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/twilio-call.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAMZ,MAAM,eAAe,CAAC;AA4BvB,eAAO,MAAM,gBAAgB,EAAE,MAyL9B,CAAC;AA4BF,iBAAS,eAAe,CACtB,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GAAG,SAAS,GAC7D,MAAM,GAAG,IAAI,CAUf;AAED,iBAAS,qBAAqB,CAC5B,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GAAG,SAAS,GAC7D,MAAM,EAAE,CAiBV;AA0BD,eAAO,MAAM,cAAc,EAAE,MAAM,GAAG;IACpC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAgI1C,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,GAAG;IACxC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAsK1C,CAAC;AAGF,eAAO,MAAM,UAAU;;;CAGtB,CAAC"}
+{"version":3,"file":"twilio-call.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/twilio-call.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,MAAM,EAMZ,MAAM,eAAe,CAAC;AA4BvB,eAAO,MAAM,gBAAgB,EAAE,MAiM9B,CAAC;AA4BF,iBAAS,eAAe,CACtB,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GAAG,SAAS,GAC7D,MAAM,GAAG,IAAI,CAUf;AAED,iBAAS,qBAAqB,CAC5B,OAAO,EAAE;IAAE,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAA;CAAE,GAAG,SAAS,GAC7D,MAAM,EAAE,CAiBV;AA0BD,eAAO,MAAM,cAAc,EAAE,MAAM,GAAG;IACpC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CAgI1C,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,GAAG;IACxC,8BAA8B,CAAC,EAAE,OAAO,CAAC;CA2M1C,CAAC;AAGF,eAAO,MAAM,UAAU;;;CAGtB,CAAC"}

package/apps/app-lifeops/src/actions/twilio-call.js

@@ -17,9 +17,17 @@ function coerceBool(value) {
 }
 export const twilioCallAction = {
     name: ACTION_NAME,
-    similes: ["CALL_ME", "PLACE_CALL", "VOICE_CALL", "TWILIO_CALL"],
+    similes: [
+        "CALL_ME",
+        "PLACE_CALL",
+        "VOICE_CALL",
+        "TWILIO_CALL",
+        "CALL_DENTIST",
+        "PHONE_SUPPORT",
+    ],
     description: "Place a voice call via Twilio. Use only for urgent escalations or " +
-        "explicit voice-call requests from the owner. Always drafts first; the " +
+        "explicit voice-call requests from the owner. Use this for real phone " +
+        "calls, not for calendar-only rescheduling or advice. Always drafts first; the " +
         "caller must pass confirmed: true to actually dial.",
     validate: async (runtime, message) => {
         if (!readTwilioCredentialsFromEnv())
@@ -365,6 +373,10 @@ export const callExternalAction = {
         "CALL_THIRD_PARTY",
         "BOOK_BY_PHONE",
         "REBOOK_BY_PHONE",
+        "CALL_DENTIST",
+        "PHONE_CABLE_COMPANY",
+        "CALL_SUPPORT",
+        "RESCHEDULE_APPOINTMENT_BY_PHONE",
     ],
     tags: [
         "always-include",
@@ -372,8 +384,13 @@ export const callExternalAction = {
         "rebook by phone",
         "call vendor",
         "call airline",
+        "call dentist",
+        "call doctor",
+        "phone support",
+        "call cable company",
+        "reschedule appointment",
     ],
-    description: "Place an outbound phone call to a third party via Twilio. Use this for approved booking/reschedule/escalation calls to vendors or counterparties. This action can draft the call, ask which saved contact to use, and then require confirmation before dialing. The recipient must appear in the configured allow-list before the actual call is placed.",
+    description: "Place an outbound phone call to a third party via Twilio. Use this for approved booking, reschedule, outage, support, or escalation calls to vendors or counterparties. Examples: 'call the dentist and reschedule my appointment', 'phone my cable company and ask about the outage', 'call the airline', or 'call the hotel to rebook'. This action can draft the call, ask which saved contact to use, and then require confirmation before dialing. If the user wants a real phone call to a third party, prefer this action over CALENDAR_ACTION, LIFE, or CROSS_CHANNEL_SEND. The recipient must appear in the configured allow-list before the actual call is placed.",
     suppressPostActionContinuation: true,
     validate: async (runtime, message) => {
         return hasOwnerAccess(runtime, message);
@@ -501,6 +518,34 @@ export const callExternalAction = {
                 },
             },
         ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Call the dentist and reschedule my appointment.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "I can draft that call and hold it behind your approval. Tell me which saved contact or phone number to use, and I'll ask for confirmation before dialing.",
+                },
+            },
+        ],
+        [
+            {
+                name: "{{name1}}",
+                content: {
+                    text: "Phone my cable company and ask about the outage.",
+                },
+            },
+            {
+                name: "{{agentName}}",
+                content: {
+                    text: "I can draft the support call. Tell me which saved contact or phone number to use, and I'll ask for confirmation before dialing.",
+                },
+            },
+        ],
     ],
 };
 // Exposed for tests.

package/apps/app-lifeops/src/actions/update-owner-profile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-owner-profile.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/update-owner-profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,eAAe,CAAC;AAmB3E,eAAO,MAAM,wBAAwB,EAAE,MAAM,GAAG;IAC9C,8BAA8B,CAAC,EAAE,OAAO,CAAC;CA2K1C,CAAC"}
+{"version":3,"file":"update-owner-profile.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/update-owner-profile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAiC,MAAM,eAAe,CAAC;AAmB3E,eAAO,MAAM,wBAAwB,EAAE,MAAM,GAAG;IAC9C,8BAA8B,CAAC,EAAE,OAAO,CAAC;CA4K1C,CAAC"}

package/apps/app-lifeops/src/actions/update-owner-profile.js

@@ -21,7 +21,8 @@ export const updateOwnerProfileAction = {
     ],
     description: "Silently persist stable, owner-only LifeOps profile details when the canonical owner clearly states or confirms them. " +
         "Use only for the owner, never for other contacts, and do not ask follow-up questions just to fill these fields. " +
-        "This includes durable travel-booking preferences or a reusable travel-preference checklist when the owner wants those preferences remembered for future bookings.",
+        "This includes durable travel-booking preferences or a reusable travel-preference checklist when the owner wants those preferences remembered for future bookings. " +
+        "Do not use this for todos, goals, reminders, temporary plans, or live task state.",
     descriptionCompressed: "Persist stable owner profile details when stated/confirmed. Owner only.",
     suppressPostActionContinuation: true,
     validate: async (runtime, message) => {

package/apps/app-lifeops/src/actions/website-blocker.d.ts

@@ -1,9 +1,13 @@
 import type { Action } from "@elizaos/core";
-export declare const blockWebsitesAction: Action;
+export declare const blockWebsitesAction: Action & {
+    suppressPostActionContinuation?: boolean;
+};
 export declare const getWebsiteBlockStatusAction: Action;
 export declare const requestWebsiteBlockingPermissionAction: Action;
 export declare const unblockWebsitesAction: Action;
-export declare const selfControlBlockWebsitesAction: Action;
+export declare const selfControlBlockWebsitesAction: Action & {
+    suppressPostActionContinuation?: boolean;
+};
 export declare const selfControlGetStatusAction: Action;
 export declare const selfControlRequestPermissionAction: Action;
 export declare const selfControlUnblockWebsitesAction: Action;