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

package/apps/app-lifeops/src/lifeops/service-normalize-task.js

@@ -0,0 +1,333 @@
+import { LIFEOPS_BROWSER_ACTION_KINDS, } from "@elizaos/shared/contracts/lifeops";
+import { fail, normalizeEnumValue, normalizeFiniteNumber, normalizeIsoString, normalizeOptionalBoolean, normalizeOptionalMinutes, normalizeOptionalString, normalizePositiveInteger, requireNonEmptyString, } from "./service-normalize.js";
+import { DAY_MINUTES, } from "./service-constants.js";
+import { normalizeOptionalBrowserKind } from "./service-normalize-connector.js";
+function requireRecord(value, field) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        fail(400, `${field} must be an object`);
+    }
+    return { ...value };
+}
+function normalizeOptionalRecord(value, field) {
+    if (value === undefined)
+        return undefined;
+    return requireRecord(value, field);
+}
+export function normalizeBrowserActionInput(value, field) {
+    const input = requireRecord(value, field);
+    const kind = normalizeEnumValue(input.kind, `${field}.kind`, LIFEOPS_BROWSER_ACTION_KINDS);
+    const label = requireNonEmptyString(input.label, `${field}.label`);
+    const browser = normalizeOptionalBrowserKind(input.browser, `${field}.browser`);
+    const windowId = normalizeOptionalString(input.windowId) ?? null;
+    const tabId = normalizeOptionalString(input.tabId) ?? null;
+    const url = normalizeOptionalString(input.url) ?? null;
+    const selector = normalizeOptionalString(input.selector) ?? null;
+    const text = normalizeOptionalString(input.text) ?? null;
+    if ((kind === "open" || kind === "navigate") && !url) {
+        fail(400, `${field}.url is required for ${kind} actions`);
+    }
+    if (kind === "focus_tab" && !tabId) {
+        fail(400, `${field}.tabId is required for focus_tab actions`);
+    }
+    if ((kind === "click" || kind === "type" || kind === "submit") && !selector) {
+        fail(400, `${field}.selector is required for ${kind} actions`);
+    }
+    if (kind === "type" && text === null) {
+        fail(400, `${field}.text is required for type actions`);
+    }
+    return {
+        kind,
+        label,
+        browser,
+        windowId,
+        tabId,
+        url,
+        selector,
+        text,
+        accountAffecting: normalizeOptionalBoolean(input.accountAffecting, `${field}.accountAffecting`) ?? false,
+        requiresConfirmation: normalizeOptionalBoolean(input.requiresConfirmation, `${field}.requiresConfirmation`) ?? false,
+        metadata: normalizeOptionalRecord(input.metadata, `${field}.metadata`) ?? {},
+    };
+}
+export function normalizeWorkflowActionPlan(value) {
+    const input = requireRecord(value, "actionPlan");
+    if (!Array.isArray(input.steps) || input.steps.length === 0) {
+        fail(400, "actionPlan.steps must contain at least one step");
+    }
+    const steps = input.steps.map((candidate, index) => {
+        const step = requireRecord(candidate, `actionPlan.steps[${index}]`);
+        const kind = normalizeEnumValue(step.kind, `actionPlan.steps[${index}].kind`, [
+            "create_task",
+            "relock_website_access",
+            "resolve_website_access_callback",
+            "get_calendar_feed",
+            "get_gmail_triage",
+            "summarize",
+            "browser",
+        ]);
+        const id = normalizeOptionalString(step.id);
+        const resultKey = normalizeOptionalString(step.resultKey);
+        if (kind === "create_task") {
+            return {
+                kind,
+                id,
+                resultKey,
+                request: requireRecord(step.request, `actionPlan.steps[${index}].request`),
+            };
+        }
+        if (kind === "relock_website_access") {
+            return {
+                kind,
+                id,
+                resultKey,
+                request: {
+                    groupKey: requireNonEmptyString(requireRecord(step.request, `actionPlan.steps[${index}].request`)
+                        .groupKey, `actionPlan.steps[${index}].request.groupKey`),
+                },
+            };
+        }
+        if (kind === "resolve_website_access_callback") {
+            return {
+                kind,
+                id,
+                resultKey,
+                request: {
+                    callbackKey: requireNonEmptyString(requireRecord(step.request, `actionPlan.steps[${index}].request`)
+                        .callbackKey, `actionPlan.steps[${index}].request.callbackKey`),
+                },
+            };
+        }
+        if (kind === "get_calendar_feed") {
+            return {
+                kind,
+                id,
+                resultKey,
+                request: normalizeOptionalRecord(step.request, `actionPlan.steps[${index}].request`),
+            };
+        }
+        if (kind === "get_gmail_triage") {
+            return {
+                kind,
+                id,
+                resultKey,
+                request: normalizeOptionalRecord(step.request, `actionPlan.steps[${index}].request`),
+            };
+        }
+        if (kind === "summarize") {
+            return {
+                kind,
+                id,
+                resultKey,
+                sourceKey: normalizeOptionalString(step.sourceKey),
+                prompt: normalizeOptionalString(step.prompt),
+            };
+        }
+        if (!Array.isArray(step.actions) || step.actions.length === 0) {
+            fail(400, `actionPlan.steps[${index}].actions must contain at least one action`);
+        }
+        return {
+            kind,
+            id,
+            resultKey,
+            sessionTitle: requireNonEmptyString(step.sessionTitle, `actionPlan.steps[${index}].sessionTitle`),
+            actions: step.actions.map((action, actionIndex) => normalizeBrowserActionInput(action, `actionPlan.steps[${index}].actions[${actionIndex}]`)),
+        };
+    });
+    return { steps };
+}
+export function normalizeWindowNames(value, field, windowPolicy) {
+    if (!Array.isArray(value) || value.length === 0) {
+        fail(400, `${field} must contain at least one time window`);
+    }
+    const allowedNames = new Set(windowPolicy.windows.map((window) => window.name));
+    const seen = new Set();
+    const windows = [];
+    for (const candidate of value) {
+        const name = requireNonEmptyString(candidate, field);
+        if (!allowedNames.has(name)) {
+            fail(400, `${field} contains unknown window "${name}"`);
+        }
+        if (!seen.has(name)) {
+            seen.add(name);
+            windows.push(name);
+        }
+    }
+    return windows;
+}
+export function normalizeCadence(cadence, windowPolicy) {
+    const visibilityLeadMinutes = normalizeOptionalMinutes(cadence.visibilityLeadMinutes, "cadence.visibilityLeadMinutes");
+    const visibilityLagMinutes = normalizeOptionalMinutes(cadence.visibilityLagMinutes, "cadence.visibilityLagMinutes");
+    const withVisibility = (value) => {
+        const next = { ...value };
+        if (visibilityLeadMinutes !== undefined) {
+            next.visibilityLeadMinutes = visibilityLeadMinutes;
+        }
+        if (visibilityLagMinutes !== undefined) {
+            next.visibilityLagMinutes = visibilityLagMinutes;
+        }
+        return next;
+    };
+    switch (cadence.kind) {
+        case "once":
+            return withVisibility({
+                kind: "once",
+                dueAt: normalizeIsoString(cadence.dueAt, "cadence.dueAt"),
+            });
+        case "daily":
+            return withVisibility({
+                kind: "daily",
+                windows: normalizeWindowNames(cadence.windows, "cadence.windows", windowPolicy),
+            });
+        case "weekly": {
+            if (!Array.isArray(cadence.weekdays) || cadence.weekdays.length === 0) {
+                fail(400, "cadence.weekdays must contain at least one weekday");
+            }
+            const weekdays = [
+                ...new Set(cadence.weekdays.map((weekday) => Math.trunc(normalizeFiniteNumber(weekday, "cadence.weekdays")))),
+            ].sort((left, right) => left - right);
+            if (weekdays.some((weekday) => weekday < 0 || weekday > 6)) {
+                fail(400, "cadence.weekdays must use Sunday=0 through Saturday=6");
+            }
+            return withVisibility({
+                kind: "weekly",
+                weekdays,
+                windows: normalizeWindowNames(cadence.windows, "cadence.windows", windowPolicy),
+            });
+        }
+        case "times_per_day": {
+            if (!Array.isArray(cadence.slots) || cadence.slots.length === 0) {
+                fail(400, "cadence.slots must contain at least one slot");
+            }
+            const seen = new Set();
+            const slots = cadence.slots.map((slot, index) => {
+                const key = requireNonEmptyString(slot.key, `cadence.slots[${index}].key`);
+                if (seen.has(key)) {
+                    fail(400, `cadence.slots contains duplicate key "${key}"`);
+                }
+                seen.add(key);
+                const label = requireNonEmptyString(slot.label, `cadence.slots[${index}].label`);
+                const minuteOfDay = Math.trunc(normalizeFiniteNumber(slot.minuteOfDay, `cadence.slots[${index}].minuteOfDay`));
+                const durationMinutes = Math.trunc(normalizeFiniteNumber(slot.durationMinutes, `cadence.slots[${index}].durationMinutes`));
+                if (minuteOfDay < 0 || minuteOfDay >= DAY_MINUTES) {
+                    fail(400, `cadence.slots[${index}].minuteOfDay must be between 0 and 1439`);
+                }
+                if (durationMinutes <= 0 || durationMinutes > DAY_MINUTES) {
+                    fail(400, `cadence.slots[${index}].durationMinutes must be between 1 and 1440`);
+                }
+                return {
+                    key,
+                    label,
+                    minuteOfDay,
+                    durationMinutes,
+                };
+            });
+            return withVisibility({
+                kind: "times_per_day",
+                slots,
+            });
+        }
+        case "interval": {
+            const everyMinutes = Math.trunc(normalizeFiniteNumber(cadence.everyMinutes, "cadence.everyMinutes"));
+            if (everyMinutes <= 0 || everyMinutes > DAY_MINUTES) {
+                fail(400, "cadence.everyMinutes must be between 1 and 1440");
+            }
+            const windows = normalizeWindowNames(cadence.windows, "cadence.windows", windowPolicy);
+            const normalized = {
+                kind: "interval",
+                everyMinutes,
+                windows,
+            };
+            if (cadence.startMinuteOfDay !== undefined) {
+                const startMinuteOfDay = Math.trunc(normalizeFiniteNumber(cadence.startMinuteOfDay, "cadence.startMinuteOfDay"));
+                if (startMinuteOfDay < 0 || startMinuteOfDay >= DAY_MINUTES) {
+                    fail(400, "cadence.startMinuteOfDay must be between 0 and 1439");
+                }
+                normalized.startMinuteOfDay = startMinuteOfDay;
+            }
+            if (cadence.maxOccurrencesPerDay !== undefined) {
+                const maxOccurrencesPerDay = normalizePositiveInteger(cadence.maxOccurrencesPerDay, "cadence.maxOccurrencesPerDay");
+                if (maxOccurrencesPerDay > Math.ceil(DAY_MINUTES / everyMinutes)) {
+                    fail(400, "cadence.maxOccurrencesPerDay is larger than the interval allows");
+                }
+                normalized.maxOccurrencesPerDay = maxOccurrencesPerDay;
+            }
+            if (cadence.durationMinutes !== undefined) {
+                const durationMinutes = Math.trunc(normalizeFiniteNumber(cadence.durationMinutes, "cadence.durationMinutes"));
+                if (durationMinutes <= 0 || durationMinutes > DAY_MINUTES) {
+                    fail(400, "cadence.durationMinutes must be between 1 and 1440");
+                }
+                normalized.durationMinutes = durationMinutes;
+            }
+            return withVisibility(normalized);
+        }
+        default:
+            fail(400, "cadence.kind is not supported");
+    }
+}
+export function normalizeWebsiteAccessPolicy(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    const record = requireRecord(value, field);
+    const groupKey = requireNonEmptyString(record.groupKey, `${field}.groupKey`);
+    if (!Array.isArray(record.websites) || record.websites.length === 0) {
+        fail(400, `${field}.websites must contain at least one website`);
+    }
+    const seen = new Set();
+    const websites = [];
+    for (const [index, candidate] of record.websites.entries()) {
+        const website = requireNonEmptyString(candidate, `${field}.websites[${index}]`).toLowerCase();
+        if (!seen.has(website)) {
+            seen.add(website);
+            websites.push(website);
+        }
+    }
+    const rawUnlockMode = normalizeOptionalString(record.unlockMode) ?? "fixed_duration";
+    const unlockMode = rawUnlockMode === "until_manual_lock" || rawUnlockMode === "until_callback"
+        ? rawUnlockMode
+        : rawUnlockMode === "fixed_duration"
+            ? rawUnlockMode
+            : fail(400, `${field}.unlockMode must be fixed_duration, until_manual_lock, or until_callback`);
+    const unlockDurationMinutes = unlockMode === "fixed_duration"
+        ? normalizePositiveInteger(record.unlockDurationMinutes, `${field}.unlockDurationMinutes`)
+        : undefined;
+    const callbackKey = unlockMode === "until_callback"
+        ? requireNonEmptyString(record.callbackKey, `${field}.callbackKey`)
+        : (normalizeOptionalString(record.callbackKey) ?? null);
+    const reason = normalizeOptionalString(record.reason) ??
+        "Access is locked until this routine earns another unlock.";
+    return {
+        groupKey,
+        websites,
+        unlockMode,
+        ...(unlockDurationMinutes !== undefined ? { unlockDurationMinutes } : {}),
+        ...(callbackKey ? { callbackKey } : {}),
+        reason,
+    };
+}
+export function normalizeProgressionRule(rule) {
+    if (!rule || rule.kind === "none") {
+        return { kind: "none" };
+    }
+    if (rule.kind !== "linear_increment") {
+        fail(400, "progressionRule.kind is not supported");
+    }
+    const metric = requireNonEmptyString(rule.metric, "progressionRule.metric");
+    const start = normalizeFiniteNumber(rule.start, "progressionRule.start");
+    const step = normalizeFiniteNumber(rule.step, "progressionRule.step");
+    if (step <= 0) {
+        fail(400, "progressionRule.step must be greater than 0");
+    }
+    const normalized = {
+        kind: "linear_increment",
+        metric,
+        start,
+        step,
+    };
+    const unit = normalizeOptionalString(rule.unit);
+    if (unit) {
+        normalized.unit = unit;
+    }
+    return normalized;
+}

package/apps/app-lifeops/src/lifeops/service-normalize.d.ts

@@ -0,0 +1,27 @@
+import { type IAgentRuntime } from "@elizaos/core";
+import type { LifeOpsContextPolicy, LifeOpsDomain, LifeOpsPrivacyClass, LifeOpsReminderUrgency, LifeOpsSubjectType, LifeOpsVisibilityScope } from "@elizaos/shared/contracts/lifeops";
+export declare function lifeOpsErrorMessage(error: unknown): string;
+export declare function fail(status: number, message: string): never;
+export declare function defaultOwnerEntityId(runtime: IAgentRuntime): string;
+export declare function normalizeLifeOpsDomain(value: unknown, fallback: LifeOpsDomain): LifeOpsDomain;
+export declare function normalizeLifeOpsSubjectType(value: unknown, fallback: LifeOpsSubjectType): LifeOpsSubjectType;
+export declare function normalizeLifeOpsVisibilityScope(value: unknown, fallback: LifeOpsVisibilityScope): LifeOpsVisibilityScope;
+export declare function normalizeLifeOpsContextPolicy(value: unknown, fallback: LifeOpsContextPolicy): LifeOpsContextPolicy;
+export declare function requireAgentId(runtime: IAgentRuntime): string;
+export declare function requireNonEmptyString(value: unknown, field: string): string;
+export declare function normalizeOptionalString(value: unknown): string | undefined;
+export declare function normalizeOptionalBoolean(value: unknown, field: string): boolean | undefined;
+export declare function normalizeIsoString(value: unknown, field: string): string;
+export declare function normalizeOptionalIsoString(value: unknown, field: string): string | undefined;
+export declare function normalizeFiniteNumber(value: unknown, field: string): number;
+export declare function normalizeOptionalMinutes(value: unknown, field: string): number | undefined;
+export declare function normalizePositiveInteger(value: unknown, field: string): number;
+export declare function normalizeOptionalNonNegativeInteger(value: unknown, field: string): number | null;
+export declare function normalizeOptionalFiniteNumber(value: unknown, field: string): number | null;
+export declare function normalizeEnumValue<T extends string>(value: unknown, field: string, allowed: readonly T[], fallback?: T): T;
+export declare function normalizeValidTimeZone(value: unknown, field: string, fallback?: string): string;
+export declare function normalizePriority(value: unknown, current?: number): number;
+export declare function normalizePrivacyClass(value: unknown, field?: string, current?: LifeOpsPrivacyClass): LifeOpsPrivacyClass;
+export declare function normalizePhoneNumber(value: unknown, field: string): string;
+export declare function normalizeReminderUrgency(value: unknown): LifeOpsReminderUrgency;
+//# sourceMappingURL=service-normalize.d.ts.map

package/apps/app-lifeops/src/lifeops/service-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-normalize.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-normalize.ts"],"names":[],"mappings":"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"}

package/apps/app-lifeops/src/lifeops/service-normalize.js

@@ -0,0 +1,193 @@
+import { stringToUuid, } from "@elizaos/core";
+import { LIFEOPS_CONTEXT_POLICIES, LIFEOPS_DOMAINS, LIFEOPS_PRIVACY_CLASSES, LIFEOPS_REMINDER_URGENCY_LEVELS, LIFEOPS_SUBJECT_TYPES, LIFEOPS_VISIBILITY_SCOPES, } from "@elizaos/shared/contracts/lifeops";
+import { LifeOpsServiceError } from "./service-types.js";
+import { LIFEOPS_TIME_ZONE_ALIASES } from "./service-constants.js";
+import { isValidTimeZone, resolveDefaultTimeZone } from "./defaults.js";
+export function lifeOpsErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function fail(status, message) {
+    throw new LifeOpsServiceError(status, message);
+}
+export function defaultOwnerEntityId(runtime) {
+    return stringToUuid(`${requireAgentId(runtime)}-admin-entity`);
+}
+export function normalizeLifeOpsDomain(value, fallback) {
+    return normalizeEnumValue(value, "ownership.domain", LIFEOPS_DOMAINS, fallback);
+}
+export function normalizeLifeOpsSubjectType(value, fallback) {
+    return normalizeEnumValue(value, "ownership.subjectType", LIFEOPS_SUBJECT_TYPES, fallback);
+}
+export function normalizeLifeOpsVisibilityScope(value, fallback) {
+    return normalizeEnumValue(value, "ownership.visibilityScope", LIFEOPS_VISIBILITY_SCOPES, fallback);
+}
+export function normalizeLifeOpsContextPolicy(value, fallback) {
+    return normalizeEnumValue(value, "ownership.contextPolicy", LIFEOPS_CONTEXT_POLICIES, fallback);
+}
+export function requireAgentId(runtime) {
+    const agentId = runtime.agentId;
+    if (typeof agentId !== "string" || agentId.trim().length === 0) {
+        fail(500, "agent runtime is missing agentId");
+    }
+    return agentId;
+}
+export function requireNonEmptyString(value, field) {
+    if (typeof value !== "string") {
+        fail(400, `${field} must be a string`);
+    }
+    const normalized = value.trim();
+    if (normalized.length === 0) {
+        fail(400, `${field} is required`);
+    }
+    return normalized;
+}
+export function normalizeOptionalString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const normalized = value.trim();
+    return normalized.length > 0 ? normalized : undefined;
+}
+export function normalizeOptionalBoolean(value, field) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "boolean") {
+        return value;
+    }
+    if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        if (normalized === "true" || normalized === "1") {
+            return true;
+        }
+        if (normalized === "false" || normalized === "0") {
+            return false;
+        }
+    }
+    fail(400, `${field} must be a boolean`);
+}
+export function normalizeIsoString(value, field) {
+    const text = requireNonEmptyString(value, field);
+    const parsed = Date.parse(text);
+    if (!Number.isFinite(parsed)) {
+        fail(400, `${field} must be a valid ISO datetime`);
+    }
+    return new Date(parsed).toISOString();
+}
+export function normalizeOptionalIsoString(value, field) {
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    return normalizeIsoString(value, field);
+}
+export function normalizeFiniteNumber(value, field) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === "string" && value.trim().length > 0) {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    fail(400, `${field} must be a finite number`);
+}
+export function normalizeOptionalMinutes(value, field) {
+    if (value === null || value === undefined || value === "")
+        return undefined;
+    const minutes = Math.trunc(normalizeFiniteNumber(value, field));
+    if (minutes < 0) {
+        fail(400, `${field} must be zero or greater`);
+    }
+    return minutes;
+}
+export function normalizePositiveInteger(value, field) {
+    const number = Math.trunc(normalizeFiniteNumber(value, field));
+    if (number <= 0) {
+        fail(400, `${field} must be greater than zero`);
+    }
+    return number;
+}
+export function normalizeOptionalNonNegativeInteger(value, field) {
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    const number = Math.trunc(normalizeFiniteNumber(value, field));
+    if (number < 0) {
+        fail(400, `${field} must be zero or greater`);
+    }
+    return number;
+}
+export function normalizeOptionalFiniteNumber(value, field) {
+    if (value === null || value === undefined || value === "") {
+        return null;
+    }
+    return normalizeFiniteNumber(value, field);
+}
+export function normalizeEnumValue(value, field, allowed, fallback) {
+    if (fallback !== undefined &&
+        (value === undefined || value === null || value === "")) {
+        return fallback;
+    }
+    const text = requireNonEmptyString(value, field);
+    if (!allowed.includes(text)) {
+        fail(400, `${field} must be one of: ${allowed.join(", ")}`);
+    }
+    return text;
+}
+export function normalizeValidTimeZone(value, field, fallback = resolveDefaultTimeZone()) {
+    if (value === undefined || value === null) {
+        return fallback;
+    }
+    if (typeof value !== "string") {
+        fail(400, `${field} must be a valid IANA time zone`);
+    }
+    const candidate = value.trim();
+    if (candidate.length === 0) {
+        return fallback;
+    }
+    const normalized = LIFEOPS_TIME_ZONE_ALIASES[candidate.toLowerCase()] ?? candidate;
+    if (!isValidTimeZone(normalized)) {
+        fail(400, `${field} must be a valid IANA time zone`);
+    }
+    return normalized;
+}
+export function normalizePriority(value, current = 3) {
+    if (value === undefined)
+        return current;
+    const priority = Math.trunc(normalizeFiniteNumber(value, "priority"));
+    if (priority < 1 || priority > 5) {
+        fail(400, "priority must be between 1 and 5");
+    }
+    return priority;
+}
+export function normalizePrivacyClass(value, field = "privacyClass", current = "private") {
+    if (value === undefined) {
+        return current;
+    }
+    return normalizeEnumValue(value, field, LIFEOPS_PRIVACY_CLASSES);
+}
+export function normalizePhoneNumber(value, field) {
+    const raw = requireNonEmptyString(value, field);
+    const digits = raw.replace(/[^\d+]/g, "");
+    if (digits.startsWith("+")) {
+        const normalized = `+${digits.slice(1).replace(/\D/g, "")}`;
+        if (!/^\+\d{10,15}$/.test(normalized)) {
+            fail(400, `${field} must be a valid E.164 phone number`);
+        }
+        return normalized;
+    }
+    const plainDigits = digits.replace(/\D/g, "");
+    if (/^\d{10}$/.test(plainDigits)) {
+        return `+1${plainDigits}`;
+    }
+    if (/^1\d{10}$/.test(plainDigits)) {
+        return `+${plainDigits}`;
+    }
+    fail(400, `${field} must be a valid phone number`);
+}
+export function normalizeReminderUrgency(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        return "medium";
+    }
+    return normalizeEnumValue(value, "urgency", LIFEOPS_REMINDER_URGENCY_LEVELS);
+}

package/apps/app-lifeops/src/lifeops/service-types.d.ts

@@ -0,0 +1,43 @@
+import type { IAgentRuntime } from "@elizaos/core";
+import type { LifeOpsWorkflowRun } from "@elizaos/shared/contracts/lifeops";
+export type LifeOpsWorkflowSchedulerState = {
+    managedBy: "task_worker";
+    nextDueAt: string | null;
+    lastDueAt: string | null;
+    lastRunId: string | null;
+    lastRunStatus: LifeOpsWorkflowRun["status"] | null;
+    updatedAt: string;
+};
+export type ExecuteWorkflowResult = {
+    run: LifeOpsWorkflowRun;
+    error: unknown | null;
+};
+export type RuntimeMessageTarget = Parameters<IAgentRuntime["sendMessageToTarget"]>[0];
+export type ReminderAttemptLifecycle = "plan" | "escalation";
+export type ReminderActivityProfileSnapshot = {
+    primaryPlatform: string | null;
+    secondaryPlatform: string | null;
+    lastSeenPlatform: string | null;
+    isCurrentlyActive: boolean;
+    /** Epoch ms when owner was last seen active across any platform. */
+    lastSeenAt: number | null;
+};
+export type RuntimeOwnerContactResolution = {
+    sourceOfTruth: "config" | "relationships" | "config+relationships";
+    preferredCommunicationChannel: string | null;
+    platformIdentities: Array<{
+        platform: string;
+        handle: string;
+        status?: string;
+    }>;
+    lastResponseAt: string | null;
+    lastResponseChannel: string | null;
+};
+export type LifeOpsServiceOptions = {
+    ownerEntityId?: string | null;
+};
+export declare class LifeOpsServiceError extends Error {
+    readonly status: number;
+    constructor(status: number, message: string);
+}
+//# sourceMappingURL=service-types.d.ts.map

package/apps/app-lifeops/src/lifeops/service-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-types.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAClD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAA;AAE3E,MAAM,MAAM,6BAA6B,GAAG;IAC1C,SAAS,EAAE,aAAa,CAAA;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,aAAa,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAA;IAClD,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,GAAG,EAAE,kBAAkB,CAAA;IACvB,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,aAAa,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;AACtF,MAAM,MAAM,wBAAwB,GAAG,MAAM,GAAG,YAAY,CAAA;AAC5D,MAAM,MAAM,+BAA+B,GAAG;IAC5C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAA;IAChC,gBAAgB,EAAE,MAAM,GAAG,IAAI,CAAA;IAC/B,iBAAiB,EAAE,OAAO,CAAA;IAC1B,oEAAoE;IACpE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,6BAA6B,GAAG;IAC1C,aAAa,EAAE,QAAQ,GAAG,eAAe,GAAG,sBAAsB,CAAA;IAClE,6BAA6B,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5C,kBAAkB,EAAE,KAAK,CAAC;QACxB,QAAQ,EAAE,MAAM,CAAA;QAChB,MAAM,EAAE,MAAM,CAAA;QACd,MAAM,CAAC,EAAE,MAAM,CAAA;KAChB,CAAC,CAAA;IACF,cAAc,EAAE,MAAM,GAAG,IAAI,CAAA;IAC7B,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B,CAAA;AAED,qBAAa,mBAAoB,SAAQ,KAAK;aAE1B,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM,EAC9B,OAAO,EAAE,MAAM;CAKlB"}

package/apps/app-lifeops/src/lifeops/service-types.js

@@ -0,0 +1,8 @@
+export class LifeOpsServiceError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = "LifeOpsServiceError";
+    }
+}