@elizaos/agent 2.0.0-alpha.211 → 2.0.0-alpha.213

package/apps/app-lifeops/src/lifeops/service-mixin-workflows.js

@@ -19,7 +19,7 @@ export function withWorkflows(Base) {
                 return null;
             }
             const schedule = workflow.schedule;
-            if (schedule.kind === "manual") {
+            if (schedule.kind === "manual" || schedule.kind === "event") {
                 return null;
             }
             if (schedule.kind === "once") {
@@ -50,29 +50,53 @@ export function withWorkflows(Base) {
             };
         }
         initializeWorkflowSchedulerState(workflow) {
-            const nextDueAt = this.computeWorkflowNextDueAt(workflow);
             const currentState = this.readWorkflowSchedulerState(workflow);
-            const targetState = workflow.triggerType !== "schedule" || workflow.schedule.kind === "manual"
-                ? null
-                : {
-                    managedBy: "task_worker",
-                    nextDueAt,
-                    lastDueAt: null,
-                    lastRunId: null,
-                    lastRunStatus: null,
-                    updatedAt: new Date().toISOString(),
-                };
+            const targetState = this.buildInitialSchedulerState(workflow);
             if ((currentState === null && targetState === null) ||
                 (currentState &&
                     targetState &&
                     currentState.nextDueAt === targetState.nextDueAt &&
                     currentState.lastDueAt === targetState.lastDueAt &&
                     currentState.lastRunId === targetState.lastRunId &&
-                    currentState.lastRunStatus === targetState.lastRunStatus)) {
+                    currentState.lastRunStatus === targetState.lastRunStatus &&
+                    (currentState.lastFiredEventEndAt ?? null) ===
+                        (targetState.lastFiredEventEndAt ?? null) &&
+                    (currentState.lastFiredEventId ?? null) ===
+                        (targetState.lastFiredEventId ?? null))) {
                 return workflow;
             }
             return this.withWorkflowSchedulerState(workflow, targetState);
         }
+        buildInitialSchedulerState(workflow) {
+            if (workflow.triggerType === "manual") {
+                return null;
+            }
+            if (workflow.triggerType === "event") {
+                // Anchor the cursor at workflow creation so we never fire for events
+                // that ended before the workflow existed.
+                return {
+                    managedBy: "task_worker",
+                    nextDueAt: null,
+                    lastDueAt: null,
+                    lastRunId: null,
+                    lastRunStatus: null,
+                    updatedAt: new Date().toISOString(),
+                    lastFiredEventEndAt: workflow.createdAt,
+                    lastFiredEventId: null,
+                };
+            }
+            if (workflow.schedule.kind === "manual") {
+                return null;
+            }
+            return {
+                managedBy: "task_worker",
+                nextDueAt: this.computeWorkflowNextDueAt(workflow),
+                lastDueAt: null,
+                lastRunId: null,
+                lastRunStatus: null,
+                updatedAt: new Date().toISOString(),
+            };
+        }
         async runDueWorkflows(args) {
             const nowMs = Date.parse(args.now);
             const workflows = await this.repository.listWorkflows(this.agentId());
@@ -135,6 +159,112 @@ export function withWorkflows(Base) {
             }
             return runs;
         }
+        /**
+         * Fires event-triggered workflows for calendar events that have ended since
+         * the workflow's cursor. Uses a (end_at, id) tuple cursor per workflow so
+         * repeated invocations never re-fire for the same event.
+         */
+        async runDueEventWorkflows(args) {
+            const workflows = await this.repository.listWorkflows(this.agentId());
+            const runs = [];
+            for (const workflow of workflows) {
+                if (runs.length >= args.limit) {
+                    break;
+                }
+                if (workflow.status !== "active" ||
+                    workflow.triggerType !== "event" ||
+                    workflow.schedule.kind !== "event") {
+                    continue;
+                }
+                if (workflow.schedule.eventKind !== "calendar.event.ended") {
+                    continue;
+                }
+                let nextWorkflow = workflow;
+                const existingState = this.readWorkflowSchedulerState(nextWorkflow);
+                let schedulerState = existingState ?? {
+                    managedBy: "task_worker",
+                    nextDueAt: null,
+                    lastDueAt: null,
+                    lastRunId: null,
+                    lastRunStatus: null,
+                    updatedAt: new Date().toISOString(),
+                    lastFiredEventEndAt: nextWorkflow.createdAt,
+                    lastFiredEventId: null,
+                };
+                let stateChanged = existingState === null;
+                const remaining = args.limit - runs.length;
+                const candidates = await this.repository.listCalendarEventsEndedAfterCursor({
+                    agentId: this.agentId(),
+                    provider: "google",
+                    side: "owner",
+                    cursorEndAt: schedulerState.lastFiredEventEndAt ?? null,
+                    cursorEventId: schedulerState.lastFiredEventId ?? null,
+                    upToIso: args.now,
+                    limit: Math.max(remaining * 4, 8),
+                });
+                const filters = workflow.schedule.filters?.kind === "calendar.event.ended"
+                    ? workflow.schedule.filters.filters
+                    : undefined;
+                for (const event of candidates) {
+                    if (runs.length >= args.limit) {
+                        break;
+                    }
+                    if (!matchesCalendarEventEndedFilters(event, filters)) {
+                        // Even when skipped we advance the cursor so the workflow never
+                        // re-considers this event on the next tick.
+                        schedulerState = {
+                            ...schedulerState,
+                            lastFiredEventEndAt: event.endAt,
+                            lastFiredEventId: event.id,
+                            updatedAt: new Date().toISOString(),
+                        };
+                        stateChanged = true;
+                        continue;
+                    }
+                    const { run, error } = await this.executeWorkflowDefinition(nextWorkflow, {
+                        startedAt: event.endAt,
+                        confirmBrowserActions: false,
+                        request: {
+                            scheduledExecution: false,
+                            event: {
+                                kind: "calendar.event.ended",
+                                eventId: event.id,
+                                calendarId: event.calendarId,
+                                title: event.title,
+                                startAt: event.startAt,
+                                endAt: event.endAt,
+                                htmlLink: event.htmlLink,
+                            },
+                        },
+                    });
+                    runs.push(run);
+                    await this.emitWorkflowRunNudge(nextWorkflow, run);
+                    schedulerState = {
+                        ...schedulerState,
+                        lastDueAt: event.endAt,
+                        lastRunId: run.id,
+                        lastRunStatus: run.status,
+                        lastFiredEventEndAt: event.endAt,
+                        lastFiredEventId: event.id,
+                        updatedAt: new Date().toISOString(),
+                    };
+                    stateChanged = true;
+                    if (error) {
+                        this.logLifeOpsError("workflow_event_execution", error, {
+                            workflowId: nextWorkflow.id,
+                            workflowRunId: run.id,
+                            eventId: event.id,
+                            eventEndAt: event.endAt,
+                        });
+                    }
+                }
+                if (stateChanged) {
+                    nextWorkflow = this.withWorkflowSchedulerState(nextWorkflow, schedulerState);
+                    await this.repository.updateWorkflow(nextWorkflow);
+                }
+            }
+            return runs;
+        }
         async listWorkflows() {
             const workflows = await this.repository.listWorkflows(this.agentId());
             const records = [];
@@ -409,3 +539,47 @@ export function withWorkflows(Base) {
     }
     return LifeOpsWorkflowsServiceMixin;
 }
+export function matchesCalendarEventEndedFilters(event, filters) {
+    if (!filters) {
+        return true;
+    }
+    if (filters.calendarIds && filters.calendarIds.length > 0) {
+        if (!filters.calendarIds.includes(event.calendarId)) {
+            return false;
+        }
+    }
+    if (filters.titleIncludesAny && filters.titleIncludesAny.length > 0) {
+        const title = (event.title ?? "").toLowerCase();
+        const matched = filters.titleIncludesAny.some((needle) => title.includes(needle.toLowerCase()));
+        if (!matched) {
+            return false;
+        }
+    }
+    if (typeof filters.minDurationMinutes === "number") {
+        const startMs = Date.parse(event.startAt);
+        const endMs = Date.parse(event.endAt);
+        if (Number.isFinite(startMs) && Number.isFinite(endMs)) {
+            const minutes = (endMs - startMs) / 60_000;
+            if (minutes < filters.minDurationMinutes) {
+                return false;
+            }
+        }
+    }
+    if (filters.attendeeEmailIncludesAny &&
+        filters.attendeeEmailIncludesAny.length > 0) {
+        const attendees = Array.isArray(event.attendees) ? event.attendees : [];
+        const matched = attendees.some((attendee) => {
+            const email = typeof attendee === "object" && attendee !== null
+                ? String(attendee.email ?? "").toLowerCase()
+                : "";
+            if (!email) {
+                return false;
+            }
+            return filters.attendeeEmailIncludesAny.some((needle) => email.includes(needle.toLowerCase()));
+        });
+        if (!matched) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"service-normalize-connector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-normalize-connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,6BAA6B,EAC7B,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EAGvB,mBAAmB,EACnB,+BAA+B,EAC/B,uBAAuB,EACvB,0BAA0B,EAC1B,mCAAmC,EACpC,MAAM,mCAAmC,CAAC;AA8E3C,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,oBAAoB,GAAG,SAAS,CAKlC;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,oBAAoB,GAAG,SAAS,CAKlC;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,GACb,uBAAuB,EAAE,GAAG,SAAS,CAsBvC;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,uBAAuB,EAAE,CAE3B;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,GACb,0BAA0B,CAM5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,0BAA0B,GACtC,uBAAuB,CA0CzB;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,+BAAoE,GAC5E,+BAA+B,CAqCjC;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,kBAAkB,GAAG,IAAI,CAM3B;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,6BAAgE,GACxE,6BAA6B,CA+B/B;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAYrE;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAgCR;AAED,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CASV;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAS3E;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,mCAAmC,EAC5C,OAAO,EAAE,sBAAsB,GAC9B,sBAAsB,CAsExB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,mBAAmB,CAgErB;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmDzB"}
+{"version":3,"file":"service-normalize-connector.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-normalize-connector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,6BAA6B,EAC7B,sBAAsB,EACtB,oBAAoB,EACpB,oBAAoB,EACpB,uBAAuB,EAGvB,mBAAmB,EACnB,+BAA+B,EAC/B,uBAAuB,EACvB,0BAA0B,EAC1B,mCAAmC,EACpC,MAAM,mCAAmC,CAAC;AA+E3C,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,oBAAoB,GAAG,SAAS,CAKlC;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,oBAAoB,GAAG,SAAS,CAKlC;AAED,wBAAgB,gCAAgC,CAC9C,KAAK,EAAE,OAAO,GACb,uBAAuB,EAAE,GAAG,SAAS,CAsBvC;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,uBAAuB,EAAE,CAE3B;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,GACb,0BAA0B,CAM5B;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,OAAO,EACd,WAAW,EAAE,0BAA0B,GACtC,uBAAuB,CA6CzB;AA8ED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,+BAAoE,GAC5E,+BAA+B,CAqCjC;AAED,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,kBAAkB,GAAG,IAAI,CAM3B;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,OAAO,EACd,OAAO,GAAE,6BAAgE,GACxE,6BAA6B,CA+B/B;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAYrE;AAED,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAgCR;AAED,wBAAgB,mCAAmC,CACjD,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,EAAE,CASV;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAS3E;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,mCAAmC,EAC5C,OAAO,EAAE,sBAAsB,GAC9B,sBAAsB,CAsExB;AAED,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,GACf,mBAAmB,CAgErB;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,EACd,KAAK,EAAE,MAAM,GACZ,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAmDzB"}

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

@@ -1,4 +1,4 @@
-import { LIFEOPS_BROWSER_KINDS, LIFEOPS_BROWSER_SITE_ACCESS_MODES, LIFEOPS_BROWSER_TRACKING_MODES, LIFEOPS_CONNECTOR_MODES, LIFEOPS_CONNECTOR_SIDES, LIFEOPS_GOOGLE_CAPABILITIES, LIFEOPS_REMINDER_CHANNELS, LIFEOPS_TIME_WINDOW_NAMES, LIFEOPS_WORKFLOW_TRIGGER_TYPES, } from "@elizaos/shared/contracts/lifeops";
+import { LIFEOPS_BROWSER_KINDS, LIFEOPS_BROWSER_SITE_ACCESS_MODES, LIFEOPS_BROWSER_TRACKING_MODES, LIFEOPS_CONNECTOR_MODES, LIFEOPS_CONNECTOR_SIDES, LIFEOPS_EVENT_KINDS, LIFEOPS_GOOGLE_CAPABILITIES, LIFEOPS_REMINDER_CHANNELS, LIFEOPS_TIME_WINDOW_NAMES, LIFEOPS_WORKFLOW_TRIGGER_TYPES, } from "@elizaos/shared/contracts/lifeops";
 import { parseCronExpression } from "@elizaos/agent/triggers/scheduling";
 import { LifeOpsServiceError } from "./service-types.js";
 import { fail, normalizeEnumValue, normalizeFiniteNumber, normalizeIsoString, normalizeOptionalBoolean, normalizeOptionalIsoString, normalizeOptionalString, normalizePositiveInteger, normalizeValidTimeZone, requireNonEmptyString, } from "./service-normalize.js";
@@ -80,6 +80,9 @@ export function normalizeWorkflowSchedule(value, triggerType) {
         return { kind: "manual" };
     }
     const schedule = requireRecord(value, "schedule");
+    if (triggerType === "event") {
+        return normalizeEventTrigger(schedule);
+    }
     const kind = normalizeEnumValue(schedule.kind, "schedule.kind", [
         "once",
         "interval",
@@ -109,6 +112,54 @@ export function normalizeWorkflowSchedule(value, triggerType) {
         timezone: normalizeValidTimeZone(schedule.timezone, "schedule.timezone"),
     };
 }
+function normalizeEventTrigger(schedule) {
+    const kind = normalizeEnumValue(schedule.kind, "schedule.kind", [
+        "event",
+    ]);
+    const eventKind = normalizeEnumValue(schedule.eventKind, "schedule.eventKind", LIFEOPS_EVENT_KINDS);
+    const rawFilters = schedule.filters;
+    if (rawFilters === undefined || rawFilters === null) {
+        return { kind, eventKind };
+    }
+    const filtersRecord = requireRecord(rawFilters, "schedule.filters");
+    if (eventKind === "calendar.event.ended") {
+        return {
+            kind,
+            eventKind,
+            filters: {
+                kind: "calendar.event.ended",
+                filters: normalizeCalendarEventEndedFilters(filtersRecord),
+            },
+        };
+    }
+    return { kind, eventKind };
+}
+function normalizeCalendarEventEndedFilters(input) {
+    const filters = {};
+    if (input.calendarIds !== undefined) {
+        filters.calendarIds = normalizeStringArray(input.calendarIds, "schedule.filters.calendarIds");
+    }
+    if (input.titleIncludesAny !== undefined) {
+        filters.titleIncludesAny = normalizeStringArray(input.titleIncludesAny, "schedule.filters.titleIncludesAny");
+    }
+    if (input.minDurationMinutes !== undefined) {
+        filters.minDurationMinutes = normalizePositiveInteger(input.minDurationMinutes, "schedule.filters.minDurationMinutes");
+    }
+    if (input.attendeeEmailIncludesAny !== undefined) {
+        filters.attendeeEmailIncludesAny = normalizeStringArray(input.attendeeEmailIncludesAny, "schedule.filters.attendeeEmailIncludesAny");
+    }
+    return filters;
+}
+function normalizeStringArray(value, field) {
+    if (!Array.isArray(value)) {
+        fail(400, `${field} must be an array of strings`);
+    }
+    const out = [];
+    for (const entry of value) {
+        out.push(requireNonEmptyString(entry, `${field}[]`));
+    }
+    return out;
+}
 export function normalizeWorkflowPermissionPolicy(value, current = DEFAULT_WORKFLOW_PERMISSION_POLICY) {
     if (value === undefined) {
         return { ...current };

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

@@ -7,6 +7,14 @@ export type LifeOpsWorkflowSchedulerState = {
     lastRunId: string | null;
     lastRunStatus: LifeOpsWorkflowRun["status"] | null;
     updatedAt: string;
+    /**
+     * Tuple cursor for event-triggered workflows. Processing is ordered by
+     * (end_at ASC, id ASC); after each fire we advance to the (end_at, id) of
+     * the last-fired event so we never re-fire for an event we already ran.
+     * Null for non-event workflows.
+     */
+    lastFiredEventEndAt?: string | null;
+    lastFiredEventId?: string | null;
 };
 export type ExecuteWorkflowResult = {
     run: LifeOpsWorkflowRun;

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

@@ -1 +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"}
+{"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;IACjB;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CACjC,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.d.ts

@@ -825,10 +825,15 @@ declare const LifeOpsServiceComposedBase_base: {
         computeWorkflowNextDueAt(workflow: import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowDefinition, cursorIso?: string | null): string | null;
         withWorkflowSchedulerState(workflow: import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowDefinition, state: import("./service-types.js").LifeOpsWorkflowSchedulerState | null): import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowDefinition;
         initializeWorkflowSchedulerState(workflow: import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowDefinition): import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowDefinition;
+        buildInitialSchedulerState(workflow: import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowDefinition): import("./service-types.js").LifeOpsWorkflowSchedulerState | null;
         runDueWorkflows(args: {
             now: string;
             limit: number;
         }): Promise<import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowRun[]>;
+        runDueEventWorkflows(args: {
+            now: string;
+            limit: number;
+        }): Promise<import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowRun[]>;
         listWorkflows(): Promise<import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowRecord[]>;
         getWorkflow(workflowId: string): Promise<import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowRecord>;
         createWorkflow(request: import("@elizaos/shared/contracts/lifeops.js").CreateLifeOpsWorkflowRequest): Promise<import("@elizaos/shared/contracts/lifeops.js").LifeOpsWorkflowRecord>;

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

@@ -1 +1 @@
-{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEA6EokpC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;0BAA55iC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AArDtvG;;;;;;;GAOG;AACH,qBAAa,0BAA2B,SAAQ,+BA0C/C;CAAG;AAEJ,qBAAa,cAAe,SAAQ,0BAA0B;CAAG"}
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iEA6EokpC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;0BAA55iC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AArDtvG;;;;;;;GAOG;AACH,qBAAa,0BAA2B,SAAQ,+BA0C/C;CAAG;AAEJ,qBAAa,cAAe,SAAQ,0BAA0B;CAAG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elizaos/agent",
-  "version": "2.0.0-alpha.211",
+  "version": "2.0.0-alpha.213",
   "description": "Standalone elizaOS-based agent and backend server package.",
   "type": "module",
   "license": "MIT",
@@ -462,14 +462,14 @@
     "@elizaos/app-steward": "^0.0.0",
     "@elizaos/app-task-coordinator": "^0.0.0",
     "@elizaos/app-training": "^0.0.1",
-    "@elizaos/core": "^2.0.0-alpha.211",
+    "@elizaos/core": "^2.0.0-alpha.213",
     "@elizaos/plugin-agent-orchestrator": "^0.6.2-alpha.0",
     "@elizaos/plugin-ollama": "^2.0.0-alpha.14",
     "@elizaos/plugin-pdf": "^2.0.0-alpha.18",
     "@elizaos/plugin-solana": "1.2.6",
     "@elizaos/plugin-sql": "^2.0.0-alpha.19",
-    "@elizaos/shared": "^2.0.0-alpha.211",
-    "@elizaos/skills": "^2.0.0-alpha.211",
+    "@elizaos/shared": "^2.0.0-alpha.213",
+    "@elizaos/skills": "^2.0.0-alpha.213",
     "@hapi/boom": "^10.0.1",
     "@noble/curves": "^2.0.1",
     "@whiskeysockets/baileys": "7.0.0-rc.9",

package/packages/agent/src/runtime/eliza.js

@@ -355,10 +355,10 @@ export function configureLocalEmbeddingPlugin(_plugin, config) {
     const currentSharedLargeModel = process.env.OPENAI_LARGE_MODEL ?? process.env.LARGE_MODEL;
     setEnvIfMissing("GROQ_SMALL_MODEL", currentSharedSmallModel && !isLikelyOpenAiTextModel(currentSharedSmallModel)
         ? currentSharedSmallModel
-        : "llama-3.1-8b-instant");
+        : "openai/gpt-oss-20b");
     setEnvIfMissing("GROQ_LARGE_MODEL", currentSharedLargeModel && !isLikelyOpenAiTextModel(currentSharedLargeModel)
         ? currentSharedLargeModel
-        : "qwen/qwen3-32b");
+        : "openai/gpt-oss-120b");
     logger.info(`[eliza] Configured local embedding env: ${process.env.LOCAL_EMBEDDING_MODEL} (repo: ${process.env.LOCAL_EMBEDDING_MODEL_REPO ?? "auto"}, dims: ${process.env.LOCAL_EMBEDDING_DIMENSIONS ?? "auto"}, ctx: ${process.env.LOCAL_EMBEDDING_CONTEXT_SIZE ?? "auto"}, GPU: ${process.env.LOCAL_EMBEDDING_GPU_LAYERS}, mmap: ${process.env.LOCAL_EMBEDDING_USE_MMAP})`);
 }
 // ---------------------------------------------------------------------------

package/packages/shared/src/contracts/lifeops.d.ts

@@ -14,8 +14,32 @@ export declare const LIFEOPS_WORKFLOW_STATUSES: readonly ["active", "paused", "a
 export type LifeOpsWorkflowStatus = (typeof LIFEOPS_WORKFLOW_STATUSES)[number];
 export declare const LIFEOPS_WORKFLOW_RUN_STATUSES: readonly ["queued", "running", "success", "failed", "cancelled"];
 export type LifeOpsWorkflowRunStatus = (typeof LIFEOPS_WORKFLOW_RUN_STATUSES)[number];
-export declare const LIFEOPS_WORKFLOW_TRIGGER_TYPES: readonly ["manual", "schedule"];
+export declare const LIFEOPS_WORKFLOW_TRIGGER_TYPES: readonly ["manual", "schedule", "event"];
 export type LifeOpsWorkflowTriggerType = (typeof LIFEOPS_WORKFLOW_TRIGGER_TYPES)[number];
+/**
+ * Registry of event kinds that can fire a LifeOps workflow.
+ *
+ * Each entry is a stable identifier ("namespace.subject.verb") emitted by a
+ * detector inside the engine. Adding a new entry means adding a detector that
+ * publishes matching occurrences to `runDueEventWorkflows`, and — optionally —
+ * a filter shape under {@link LifeOpsEventFilters}.
+ */
+export declare const LIFEOPS_EVENT_KINDS: readonly ["calendar.event.ended"];
+export type LifeOpsEventKind = (typeof LIFEOPS_EVENT_KINDS)[number];
+export interface LifeOpsCalendarEventEndedFilters {
+    /** Only fire for events on these calendar ids (e.g. "primary"). */
+    calendarIds?: string[];
+    /** Only fire when event title matches one of these case-insensitive substrings. */
+    titleIncludesAny?: string[];
+    /** Only fire when the event lasted at least this many minutes. */
+    minDurationMinutes?: number;
+    /** Only fire when one attendee email contains one of these substrings. */
+    attendeeEmailIncludesAny?: string[];
+}
+export type LifeOpsEventFilters = {
+    kind: "calendar.event.ended";
+    filters?: LifeOpsCalendarEventEndedFilters;
+};
 export declare const LIFEOPS_NEGOTIATION_STATES: readonly ["initiated", "proposals_sent", "awaiting_response", "confirmed", "cancelled"];
 export type LifeOpsNegotiationState = (typeof LIFEOPS_NEGOTIATION_STATES)[number];
 export declare const LIFEOPS_PROPOSAL_STATUSES: readonly ["pending", "accepted", "declined", "expired"];
@@ -332,6 +356,10 @@ export type LifeOpsWorkflowSchedule = {
     kind: "cron";
     cronExpression: string;
     timezone: string;
+} | {
+    kind: "event";
+    eventKind: LifeOpsEventKind;
+    filters?: LifeOpsEventFilters;
 };
 export interface LifeOpsWorkflowPermissionPolicy {
     allowBrowserActions: boolean;