@elizaos/ui 2.0.0-alpha.358 → 2.0.0-alpha.376

package/apps/app-lifeops/src/actions/life-param-extractor.js

@@ -0,0 +1,431 @@
+/**
+ * LLM planning and structured extraction for LifeOps task creation.
+ *
+ * Performs a second LLM call (TEXT_LARGE) after operation classification
+ * to decide whether the current create_definition request should:
+ * 1. create or preview a LifeOps item now, or
+ * 2. reply/clarify without creating anything yet.
+ *
+ * When creation is appropriate, the same response also extracts structured
+ * fields — title, cadence, priority, time-of-day, etc. — from natural
+ * language so life.ts can stay on an LLM-driven extraction path.
+ */
+import { ModelType, parseJSONObjectFromText } from "@elizaos/core";
+import { recentConversationTexts } from "./life-recent-context.js";
+import { resolveContextWindow } from "./lifeops-extraction-config.js";
+import { normalizeExplicitTimeZoneToken } from "./timezone-normalization.js";
+const VALID_CADENCE_KINDS = new Set([
+    "once",
+    "daily",
+    "weekly",
+    "times_per_day",
+    "interval",
+]);
+const VALID_REQUEST_KINDS = new Set(["alarm", "reminder"]);
+const VALID_CREATE_PLAN_MODES = new Set(["create", "respond"]);
+const ALARM_CONTEXT_RE = /\b(alarm|wake(?:-|\s)?up|wake me up)\b/i;
+const REMINDER_CONTEXT_RE = /\b(remind(?: me)?|reminder|set (?:a )?reminder|create (?:a )?reminder|nudge me|ping me)\b/i;
+const REQUEST_KIND_VALIDATION_WINDOW = 6;
+const DEFAULT_CREATE_PLAN_RESPONSE = "Restate the reminder in one sentence with the task and timing.";
+const EMPTY_TASK_CREATE_PLAN = {
+    mode: "respond",
+    response: DEFAULT_CREATE_PLAN_RESPONSE,
+    requestKind: null,
+    title: null,
+    description: null,
+    cadenceKind: null,
+    windows: null,
+    weekdays: null,
+    timeOfDay: null,
+    timeZone: null,
+    everyMinutes: null,
+    timesPerDay: null,
+    priority: null,
+    durationMinutes: null,
+};
+// ── Prompt ────────────────────────────────────────────
+function buildExtractionPrompt(intent, recentConversation) {
+    return [
+        "Plan the next step for a LifeOps create_definition request.",
+        "Use the full current user request plus recent conversation.",
+        "The user may speak informally, formally, code-switched, or in another language.",
+        "Do not strip acknowledgements, fillers, or language-footer text. Interpret the whole request in context.",
+        "Infer practical reminder windows from natural phrases when needed: wake up or before work -> morning, lunch or after lunch -> afternoon, after work or dinner -> evening, before bed or before sleep -> night.",
+        "Return ONLY a JSON object with these fields (use null for unknown):",
+        "",
+        '- mode: "create" when the request is specific enough to create or preview a LifeOps item now, "respond" when you should reply without creating anything yet',
+        '  Choose mode="create" whenever the user gives a title and cadence, even if they say "preview the plan", "don\'t save yet", "just show it first", or similar — the handler (not you) controls whether it is saved or previewed. Only use mode="respond" when the user hasn\'t specified what to track or when.',
+        "- response: short natural-language reply when mode is respond, otherwise null",
+        '- requestKind: "alarm" when this is explicitly an alarm/wake-up request, "reminder" when it is explicitly a reminder request, otherwise null',
+        "- title: short name for the task (2-5 words)",
+        "- description: brief description if the user provided context",
+        '- cadenceKind: one of "once", "daily", "weekly", "times_per_day", "interval"',
+        '  - "once" — a specific dated and/or timed event that happens a single time (e.g. "april 17 at 8pm", "tomorrow at 9", "set an alarm for 7am")',
+        '  - "daily" — happens every day, typically with one time or window (e.g. "every morning", "every night")',
+        '  - "weekly" — happens on specific weekdays (e.g. "every Sunday", "Mon/Wed/Fri")',
+        '  - "times_per_day" — happens multiple times on the SAME recurring day, with multiple times or windows (e.g. "morning and night", "three times a day")',
+        '  - "interval" — happens every N minutes/hours (e.g. "every 2 hours")',
+        '  If the request names a specific calendar date OR a specific wall-clock time without a recurrence word, pick "once".',
+        '- windows: array of time windows like ["morning", "night", "afternoon", "evening"]',
+        "- weekdays: array of weekday numbers (0=Sun, 1=Mon, ..., 6=Sat) for weekly tasks",
+        '- timeOfDay: specific time in HH:MM 24h format like "15:00" or "08:30" if mentioned',
+        '- timeZone: IANA timezone like "America/Denver" when the user explicitly gives one',
+        '- everyMinutes: interval in minutes for recurring tasks (e.g., 120 for "every 2 hours")',
+        '- timesPerDay: number of times per day if mentioned (e.g., 4 for "four times a day")',
+        "- priority: 1-5 (1=low, 5=critical) based on urgency/importance language",
+        "- durationMinutes: how long the activity takes if mentioned",
+        "",
+        "Examples:",
+        '  "remind me to brush teeth morning and night" -> {"mode":"create","response":null,"requestKind":"reminder","title":"Brush teeth","cadenceKind":"daily","windows":["morning","night"],"description":null,"weekdays":null,"timeOfDay":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "call mom every Sunday at 3pm" -> {"mode":"create","response":null,"requestKind":null,"title":"Call mom","cadenceKind":"weekly","weekdays":[0],"timeOfDay":"15:00","description":null,"windows":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "drink water every 2 hours" -> {"mode":"create","response":null,"requestKind":null,"title":"Drink water","cadenceKind":"interval","everyMinutes":120,"description":null,"windows":null,"weekdays":null,"timeOfDay":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "workout 4 times a week" -> {"mode":"create","response":null,"requestKind":null,"title":"Workout","cadenceKind":"weekly","weekdays":[1,3,5,6],"timesPerDay":null,"description":null,"windows":null,"timeOfDay":null,"everyMinutes":null,"priority":null,"durationMinutes":null}',
+        '  "set an alarm for 7 am" -> {"mode":"create","response":null,"requestKind":"alarm","title":"Alarm","cadenceKind":"once","timeOfDay":"07:00","description":null,"windows":null,"weekdays":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "set a reminder for tomorrow at 9am to call mom" -> {"mode":"create","response":null,"requestKind":"reminder","title":"Call mom","cadenceKind":"once","timeOfDay":"09:00","description":null,"windows":null,"weekdays":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "make sure I brush my teeth when I wake up and before bed" -> {"mode":"create","response":null,"requestKind":"reminder","title":"Brush teeth","cadenceKind":"daily","windows":["morning","night"],"description":null,"weekdays":null,"timeOfDay":null,"timeZone":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "recuérdame cepillarme los dientes por la mañana y por la noche" -> {"mode":"create","response":null,"requestKind":"reminder","title":"Brush teeth","cadenceKind":"daily","windows":["morning","night"],"description":null,"weekdays":null,"timeOfDay":null,"timeZone":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "set a reminder for april 17 at 8pm mountain time to hug my wife" -> {"mode":"create","response":null,"requestKind":"reminder","title":"Hug my wife","cadenceKind":"once","timeOfDay":"20:00","timeZone":"America/Denver","description":null,"windows":null,"weekdays":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":30}',
+        '  "lol yeah. can you help me add a todo for my life?" -> {"mode":"respond","response":"What do you want the todo to be, and when should it happen?","requestKind":null,"title":null,"description":null,"cadenceKind":null,"windows":null,"weekdays":null,"timeOfDay":null,"everyMinutes":null,"timesPerDay":null,"priority":null,"durationMinutes":null}',
+        '  "Please make that into a routine named Evening mobility flow with reminders around 8am and 9pm. Just preview the plan for now and do not save it yet." -> {"mode":"create","response":null,"requestKind":"reminder","title":"Evening mobility flow","cadenceKind":"times_per_day","timesPerDay":2,"windows":["morning","night"],"description":null,"weekdays":null,"timeOfDay":null,"everyMinutes":null,"priority":null,"durationMinutes":null}',
+        "",
+        "Use recent conversation only to resolve short follow-ups. Do not emit requestKind='alarm' or requestKind='reminder' unless the current request or recent conversation explicitly supports it.",
+        "If the user has not actually specified the todo/habit yet, choose mode='respond' and ask a concise clarifying question instead of inventing a task.",
+        "",
+        "Return ONLY valid JSON. No prose.",
+        "",
+        `User request: ${JSON.stringify(intent)}`,
+        `Recent conversation: ${JSON.stringify(recentConversation)}`,
+    ].join("\n");
+}
+// ── Validators ────────────────────────────────────────
+function validateTitle(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function validateRequestKind(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return VALID_REQUEST_KINDS.has(normalized)
+        ? normalized
+        : null;
+}
+function validateCreatePlanMode(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return VALID_CREATE_PLAN_MODES.has(normalized)
+        ? normalized
+        : null;
+}
+function validateResponse(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function validateCadenceKind(value) {
+    if (typeof value !== "string")
+        return null;
+    return VALID_CADENCE_KINDS.has(value)
+        ? value
+        : null;
+}
+function validateWindows(value) {
+    if (!Array.isArray(value))
+        return null;
+    const filtered = value.filter((w) => typeof w === "string" && w.trim().length > 0);
+    return filtered.length > 0 ? filtered : null;
+}
+function validateWeekdays(value) {
+    if (!Array.isArray(value))
+        return null;
+    const filtered = value.filter((d) => typeof d === "number" && Number.isInteger(d) && d >= 0 && d <= 6);
+    return filtered.length > 0 ? filtered : null;
+}
+function validateTimeOfDay(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    // Accept HH:MM format
+    if (/^\d{1,2}:\d{2}$/.test(trimmed))
+        return trimmed;
+    return null;
+}
+function validateTimeZone(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    return normalizeExplicitTimeZoneToken(value);
+}
+function validatePositiveNumber(value) {
+    if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return null;
+    }
+    return value;
+}
+function validatePriority(value) {
+    if (typeof value !== "number" || !Number.isFinite(value))
+        return null;
+    return Math.max(1, Math.min(5, Math.round(value)));
+}
+function validateRequestKindAgainstContext(value, currentText, recentWindow) {
+    if (!value) {
+        return null;
+    }
+    const texts = [currentText, ...recentWindow];
+    const pattern = value === "alarm" ? ALARM_CONTEXT_RE : REMINDER_CONTEXT_RE;
+    return texts.some((text) => pattern.test(text)) ? value : null;
+}
+function buildTaskCreatePlan(args) {
+    const { parsed, intent, recentWindow } = args;
+    const mode = validateCreatePlanMode(parsed.mode);
+    if (!mode) {
+        return null;
+    }
+    return {
+        mode,
+        response: mode === "respond"
+            ? (validateResponse(parsed.response) ?? DEFAULT_CREATE_PLAN_RESPONSE)
+            : null,
+        requestKind: validateRequestKindAgainstContext(validateRequestKind(parsed.requestKind), intent, recentWindow.slice(-REQUEST_KIND_VALIDATION_WINDOW)),
+        title: validateTitle(parsed.title),
+        description: validateTitle(parsed.description),
+        cadenceKind: validateCadenceKind(parsed.cadenceKind),
+        windows: validateWindows(parsed.windows),
+        weekdays: validateWeekdays(parsed.weekdays),
+        timeOfDay: validateTimeOfDay(parsed.timeOfDay),
+        timeZone: validateTimeZone(parsed.timeZone),
+        everyMinutes: validatePositiveNumber(parsed.everyMinutes),
+        timesPerDay: validatePositiveNumber(parsed.timesPerDay),
+        priority: validatePriority(parsed.priority),
+        durationMinutes: validatePositiveNumber(parsed.durationMinutes),
+    };
+}
+function buildRepairPrompt(args) {
+    return [
+        "Your last reply for the LifeOps create-definition planner was invalid.",
+        "Return ONLY valid JSON with these exact fields:",
+        "mode, response, requestKind, title, description, cadenceKind, windows, weekdays, timeOfDay, timeZone, everyMinutes, timesPerDay, priority, durationMinutes",
+        "",
+        'mode must be "create" or "respond".',
+        "If mode is respond, include a short clarifying response.",
+        "If mode is create, response must be null.",
+        "",
+        `User request: ${JSON.stringify(args.intent)}`,
+        `Recent conversation: ${JSON.stringify(args.recentConversation)}`,
+        `Previous invalid output: ${JSON.stringify(args.rawResponse)}`,
+    ].join("\n");
+}
+function buildExtractionFailurePlan() {
+    return {
+        ...EMPTY_TASK_CREATE_PLAN,
+    };
+}
+// ── Extractor ─────────────────────────────────────────
+/**
+ * Call the LLM to plan whether a create_definition request should create
+ * a task draft now or reply first, while also extracting structured
+ * task parameters for the create path.
+ */
+export async function extractTaskCreatePlanWithLlm(args) {
+    const { runtime, intent } = args;
+    if (!intent || intent.trim().length === 0) {
+        return buildExtractionFailurePlan();
+    }
+    const recentWindow = await recentConversationTexts({
+        runtime,
+        message: args.message,
+        state: args.state,
+        limit: Math.max(resolveContextWindow(), REQUEST_KIND_VALIDATION_WINDOW),
+    });
+    if (typeof runtime.useModel !== "function") {
+        return buildExtractionFailurePlan();
+    }
+    const recentConversation = recentWindow
+        .slice(-resolveContextWindow())
+        .join("\n");
+    const prompt = buildExtractionPrompt(intent, recentConversation);
+    try {
+        const result = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
+        const raw = typeof result === "string" ? result : "";
+        const parsed = parseJSONObjectFromText(raw);
+        const parsedPlan = parsed
+            ? buildTaskCreatePlan({
+                parsed,
+                intent,
+                recentWindow,
+            })
+            : null;
+        if (parsedPlan) {
+            return parsedPlan;
+        }
+        const repairResult = await runtime.useModel(ModelType.TEXT_LARGE, {
+            prompt: buildRepairPrompt({
+                intent,
+                recentConversation,
+                rawResponse: raw,
+            }),
+        });
+        const repairedRaw = typeof repairResult === "string" ? repairResult : "";
+        const repairedParsed = parseJSONObjectFromText(repairedRaw);
+        if (!repairedParsed) {
+            return buildExtractionFailurePlan();
+        }
+        return (buildTaskCreatePlan({
+            parsed: repairedParsed,
+            intent,
+            recentWindow,
+        }) ?? buildExtractionFailurePlan());
+    }
+    catch {
+        return buildExtractionFailurePlan();
+    }
+}
+export async function extractTaskParamsWithLlm(args) {
+    const plan = await extractTaskCreatePlanWithLlm(args);
+    const { mode: _mode, response: _response, ...params } = plan;
+    return params;
+}
+// ── Reminder intensity extractor ─────────────────────
+/** Valid LifeOpsReminderIntensity values (mirrors shared/contracts/lifeops). */
+const VALID_REMINDER_INTENSITIES = new Set([
+    "minimal",
+    "normal",
+    "persistent",
+    "high_priority_only",
+]);
+const EMPTY_REMINDER_INTENSITY_PLAN = {
+    intensity: "unknown",
+};
+function parseReminderIntensityPlan(raw) {
+    const normalized = raw.trim().toLowerCase();
+    if (VALID_REMINDER_INTENSITIES.has(normalized)) {
+        return {
+            intensity: normalized,
+        };
+    }
+    const parsed = parseJSONObjectFromText(raw);
+    if (!parsed || typeof parsed.intensity !== "string") {
+        return null;
+    }
+    const parsedIntensity = parsed.intensity.trim().toLowerCase();
+    if (!VALID_REMINDER_INTENSITIES.has(parsedIntensity)) {
+        return null;
+    }
+    return {
+        intensity: parsedIntensity,
+    };
+}
+function buildReminderIntensityRepairPrompt(args) {
+    return [
+        "Your last reply for the LifeOps reminder-intensity extractor was invalid.",
+        'Return ONLY valid JSON like {"intensity":"minimal"}.',
+        'Allowed intensity values: "minimal", "normal", "persistent", "high_priority_only".',
+        "",
+        `User said: ${JSON.stringify(args.intent)}`,
+        `Previous invalid output: ${JSON.stringify(args.rawResponse)}`,
+    ].join("\n");
+}
+/**
+ * Ask a small text model to classify the user's intent into a reminder
+ * intensity value. Returns an explicit "unknown" result when the model is
+ * unavailable or the response is invalid so callers do not need regex
+ * fallbacks.
+ */
+export async function extractReminderIntensityWithLlm(args) {
+    if (typeof args.runtime.useModel !== "function") {
+        return { ...EMPTY_REMINDER_INTENSITY_PLAN };
+    }
+    const prompt = [
+        "The user is requesting a change to their reminder frequency.",
+        "Classify into exactly one of these values:",
+        "- minimal: user wants fewer/less reminders",
+        "- normal: user wants default/standard reminders",
+        "- persistent: user wants more/frequent reminders",
+        "- high_priority_only: user wants to pause or mute most reminders",
+        "",
+        'Return ONLY valid JSON like {"intensity":"minimal"}. No prose.',
+        "",
+        `User said: ${JSON.stringify(args.intent)}`,
+    ].join("\n");
+    try {
+        const result = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+        });
+        const raw = typeof result === "string" ? result : "";
+        const parsed = parseReminderIntensityPlan(raw);
+        if (parsed) {
+            return parsed;
+        }
+        const repairResult = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt: buildReminderIntensityRepairPrompt({
+                intent: args.intent,
+                rawResponse: raw,
+            }),
+        });
+        const repairedRaw = typeof repairResult === "string" ? repairResult : "";
+        return (parseReminderIntensityPlan(repairedRaw) ?? {
+            ...EMPTY_REMINDER_INTENSITY_PLAN,
+        });
+    }
+    catch {
+        return { ...EMPTY_REMINDER_INTENSITY_PLAN };
+    }
+}
+// ── Website unlock mode extractor ────────────────────
+/** Valid unlock modes (mirrors shared/contracts/lifeops). */
+const VALID_UNLOCK_MODES = new Set([
+    "fixed_duration",
+    "until_manual_lock",
+    "until_callback",
+]);
+/**
+ * Ask a small text model to determine the website unlock mode from the
+ * user's intent.  Returns null when the model is unavailable, throws, or
+ * returns an invalid value — callers should fall back to regex.
+ */
+export async function extractUnlockModeWithLlm(args) {
+    if (typeof args.runtime.useModel !== "function")
+        return null;
+    const prompt = [
+        "The user is configuring website blocking. Determine the unlock mode:",
+        "- fixed_duration: unlock for a specific time period (extract durationMinutes)",
+        "- until_manual_lock: unlock until user manually re-locks",
+        "- until_callback: unlock until a specific event/task completes (extract callbackKey as a slug)",
+        "",
+        "Return JSON: { mode, durationMinutes?, callbackKey? }",
+        "Return null if no unlock mode is detectable.",
+        "",
+        `User said: ${JSON.stringify(args.intent)}`,
+    ].join("\n");
+    try {
+        const result = await args.runtime.useModel(ModelType.TEXT_SMALL, {
+            prompt,
+        });
+        const raw = typeof result === "string" ? result : "";
+        const parsed = parseJSONObjectFromText(raw);
+        if (!parsed?.mode)
+            return null;
+        if (!VALID_UNLOCK_MODES.has(parsed.mode))
+            return null;
+        return {
+            mode: parsed.mode,
+            callbackKey: typeof parsed.callbackKey === "string"
+                ? parsed.callbackKey.trim() || undefined
+                : undefined,
+            durationMinutes: typeof parsed.durationMinutes === "number" &&
+                Number.isFinite(parsed.durationMinutes) &&
+                parsed.durationMinutes > 0
+                ? parsed.durationMinutes
+                : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+// Re-export for tests
+export { buildExtractionPrompt };

package/apps/app-lifeops/src/actions/life-recent-context.d.ts

@@ -0,0 +1,9 @@
+import type { IAgentRuntime, Memory, State } from "@elizaos/core";
+export declare function recentConversationTextsFromState(state: State | undefined, limit?: number): string[];
+export declare function recentConversationTexts(args: {
+    runtime: IAgentRuntime;
+    message?: Memory;
+    state: State | undefined;
+    limit?: number;
+}): Promise<string[]>;
+//# sourceMappingURL=life-recent-context.d.ts.map

package/apps/app-lifeops/src/actions/life-recent-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"life-recent-context.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/life-recent-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AAkClE,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,KAAK,GAAG,SAAS,EACxB,KAAK,SAAI,GACR,MAAM,EAAE,CAmBV;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE;IAClD,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,KAAK,GAAG,SAAS,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CA0CpB"}

package/apps/app-lifeops/src/actions/life-recent-context.js

@@ -0,0 +1,78 @@
+import { logger } from "@elizaos/core";
+import { getRecentMessagesData } from "@elizaos/shared";
+// Match any speaker prefix pattern: "word:" or "word word:" at the start of a line.
+// This is language-agnostic — strips any short prefix label followed by a colon,
+// rather than hardcoding specific English role names.
+const STATE_SPEAKER_PREFIX_RE = /^[a-zA-Z\u00C0-\u024F\u0400-\u04FF\u3000-\u9FFF]{1,20}\s*:\s*/;
+function normalizeConversationLine(value) {
+    return value.replace(STATE_SPEAKER_PREFIX_RE, "").trim();
+}
+function splitConversationText(value) {
+    return value
+        .split(/\n+/)
+        .map((line) => normalizeConversationLine(line))
+        .filter((line) => line.length > 0);
+}
+function dedupePreservingOrder(values) {
+    const seen = new Set();
+    const deduped = [];
+    for (const value of values) {
+        if (seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        deduped.push(value);
+    }
+    return deduped;
+}
+export function recentConversationTextsFromState(state, limit = 6) {
+    const collected = [];
+    const pushText = (value) => {
+        if (typeof value === "string" && value.trim().length > 0) {
+            collected.push(...splitConversationText(value));
+        }
+    };
+    pushText(state?.values?.recentMessages);
+    pushText(state?.text);
+    for (const item of getRecentMessagesData(state)) {
+        const content = item?.content;
+        if (content && typeof content === "object") {
+            pushText(content.text);
+        }
+    }
+    return dedupePreservingOrder(collected.slice(-Math.max(1, limit)));
+}
+export async function recentConversationTexts(args) {
+    const limit = Math.max(1, args.limit ?? 6);
+    const stateTexts = recentConversationTextsFromState(args.state, limit);
+    const roomId = typeof args.message?.roomId === "string" ? args.message.roomId : "";
+    if (stateTexts.length >= limit ||
+        !roomId ||
+        typeof args.runtime.getMemories !== "function") {
+        return stateTexts;
+    }
+    try {
+        const memories = await args.runtime.getMemories({
+            roomId,
+            tableName: "messages",
+            limit: limit,
+        });
+        const memoryTexts = Array.isArray(memories)
+            ? memories
+                .map((memory) => typeof memory?.content?.text === "string"
+                ? normalizeConversationLine(memory.content.text)
+                : "")
+                .filter((text) => text.length > 0)
+            : [];
+        return dedupePreservingOrder([...memoryTexts, ...stateTexts].slice(-limit));
+    }
+    catch (error) {
+        logger.warn({
+            boundary: "lifeops",
+            component: "life-recent-context",
+            roomId,
+            detail: error instanceof Error ? error.message : String(error),
+        }, "[life-recent-context] getMemories failed; falling back to state-only context");
+        return stateTexts;
+    }
+}

package/apps/app-lifeops/src/actions/life-update-extractor.d.ts

@@ -0,0 +1,27 @@
+import type { IAgentRuntime } from "@elizaos/core";
+export interface ExtractedUpdateFields {
+    title: string | null;
+    cadenceKind: string | null;
+    windows: string[] | null;
+    weekdays: number[] | null;
+    timeOfDay: string | null;
+    everyMinutes: number | null;
+    priority: number | null;
+    description: string | null;
+}
+/**
+ * When the LLM caller passes an update_definition intent without pre-parsed
+ * structured fields (e.g. "change my workout to 6am"), this function asks
+ * a large text model to extract which fields the user actually wants to change.
+ *
+ * Returns an explicit empty update object when the model is unavailable or the
+ * response is unparseable, so callers do not need heuristic fallbacks.
+ */
+export declare function extractUpdateFieldsWithLlm(args: {
+    runtime: IAgentRuntime;
+    intent: string;
+    currentTitle: string;
+    currentCadenceKind: string;
+    currentWindows: string[];
+}): Promise<ExtractedUpdateFields>;
+//# sourceMappingURL=life-update-extractor.d.ts.map

package/apps/app-lifeops/src/actions/life-update-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"life-update-extractor.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/actions/life-update-extractor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAWnD,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,OAAO,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IACzB,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC1B,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAwJD;;;;;;;GAOG;AACH,wBAAsB,0BAA0B,CAAC,IAAI,EAAE;IACrD,OAAO,EAAE,aAAa,CAAC;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,GAAG,OAAO,CAAC,qBAAqB,CAAC,CA2DjC"}