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

package/apps/app-lifeops/src/lifeops/service-mixin-calendar.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=service-mixin-calendar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"service-mixin-calendar.d.ts","sourceRoot":"","sources":["../../../../../../../apps/app-lifeops/src/lifeops/service-mixin-calendar.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,513 @@
+import { createGoogleCalendarEvent, deleteGoogleCalendarEvent, fetchGoogleCalendarEvent, fetchGoogleCalendarEvents, updateGoogleCalendarEvent, } from "./google-calendar.js";
+import { resolveGoogleExecutionTarget, resolveGoogleGrants, } from "./google-connector-gateway.js";
+import { ensureFreshGoogleAccessToken, } from "./google-oauth.js";
+import { createLifeOpsAuditEvent, createLifeOpsCalendarSyncState, createLifeOpsReminderPlan, } from "./repository.js";
+import { fail, normalizeOptionalString, requireNonEmptyString, } from "./service-normalize.js";
+import { normalizeOptionalConnectorMode, normalizeOptionalConnectorSide, } from "./service-normalize-connector.js";
+import { createCalendarEventId, isCalendarSyncStateFresh, } from "./service-normalize-gmail.js";
+import { buildNextCalendarEventContext, hasGoogleGmailTriageCapability, normalizeCalendarAttendees, normalizeCalendarDateTimeInTimeZone, normalizeCalendarId, normalizeCalendarTimeZone, resolveCalendarEventRange, resolveCalendarWindow, resolveNextCalendarEventWindow, } from "./service-normalize-calendar.js";
+import { findLinkedMailForCalendarEvent, } from "./service-normalize-gmail.js";
+import { DEFAULT_CALENDAR_REMINDER_STEPS, } from "./service-constants.js";
+import { normalizeOptionalBoolean, } from "./service-normalize.js";
+import { LifeOpsServiceError } from "./service-types.js";
+const DEFAULT_GMAIL_TRIAGE_MAX_RESULTS = 12;
+/** @internal */
+export function withCalendar(Base) {
+    class LifeOpsCalendarServiceMixin extends Base {
+        async recordCalendarEventAudit(ownerId, reason, inputs, decision, eventType = "calendar_event_created") {
+            await this.repository.createAuditEvent(createLifeOpsAuditEvent({
+                agentId: this.agentId(),
+                eventType,
+                ownerType: "calendar_event",
+                ownerId,
+                reason,
+                inputs,
+                decision,
+                actor: "user",
+            }));
+        }
+        async syncCalendarReminderPlans(events) {
+            const eventIds = events.map((event) => event.id);
+            const existingPlans = await this.repository.listReminderPlansForOwners(this.agentId(), "calendar_event", eventIds);
+            const plansByOwnerId = new Map(existingPlans.map((plan) => [plan.ownerId, plan]));
+            for (const event of events) {
+                const existing = plansByOwnerId.get(event.id);
+                if (existing) {
+                    const sameSteps = JSON.stringify(existing.steps) ===
+                        JSON.stringify(DEFAULT_CALENDAR_REMINDER_STEPS);
+                    if (sameSteps) {
+                        continue;
+                    }
+                    await this.repository.updateReminderPlan({
+                        ...existing,
+                        steps: DEFAULT_CALENDAR_REMINDER_STEPS.map((step) => ({ ...step })),
+                        updatedAt: new Date().toISOString(),
+                    });
+                    continue;
+                }
+                await this.repository.createReminderPlan(createLifeOpsReminderPlan({
+                    agentId: this.agentId(),
+                    ownerType: "calendar_event",
+                    ownerId: event.id,
+                    steps: DEFAULT_CALENDAR_REMINDER_STEPS.map((step) => ({ ...step })),
+                    mutePolicy: {},
+                    quietHours: {},
+                }));
+            }
+        }
+        async deleteCalendarReminderPlansForEvents(eventIds) {
+            if (eventIds.length === 0) {
+                return;
+            }
+            const plans = await this.repository.listReminderPlansForOwners(this.agentId(), "calendar_event", eventIds);
+            for (const plan of plans) {
+                await this.repository.deleteReminderPlan(this.agentId(), plan.id);
+            }
+        }
+        async syncGoogleCalendarFeed(args) {
+            const grant = await this.requireGoogleCalendarGrant(args.requestUrl, args.requestedMode, args.requestedSide, args.grantId);
+            const syncCalendar = async () => {
+                const syncedAt = new Date().toISOString();
+                const existingEvents = await this.repository.listCalendarEvents(this.agentId(), "google", args.timeMin, args.timeMax, grant.side);
+                const events = resolveGoogleExecutionTarget(grant) === "cloud"
+                    ? (await this.googleManagedClient.getCalendarFeed({
+                        side: grant.side,
+                        grantId: grant.id,
+                        calendarId: args.calendarId,
+                        timeMin: args.timeMin,
+                        timeMax: args.timeMax,
+                        timeZone: args.timeZone,
+                    })).events
+                    : await fetchGoogleCalendarEvents({
+                        accessToken: (await ensureFreshGoogleAccessToken(grant.tokenRef ??
+                            fail(409, "Google Calendar token reference is missing."))).accessToken,
+                        calendarId: args.calendarId,
+                        timeMin: args.timeMin,
+                        timeMax: args.timeMax,
+                        timeZone: args.timeZone,
+                    });
+                const nextEvents = events.map((event) => ({
+                    id: createCalendarEventId(this.agentId(), "google", grant.side, event.calendarId, event.externalId),
+                    agentId: this.agentId(),
+                    provider: "google",
+                    side: grant.side,
+                    ...event,
+                    syncedAt,
+                    updatedAt: syncedAt,
+                }));
+                const nextEventIds = new Set(nextEvents.map((event) => event.id));
+                const removedEventIds = existingEvents
+                    .map((event) => event.id)
+                    .filter((eventId) => !nextEventIds.has(eventId));
+                await this.repository.pruneCalendarEventsInWindow(this.agentId(), "google", args.calendarId, args.timeMin, args.timeMax, events.map((event) => event.externalId), grant.side);
+                await this.deleteCalendarReminderPlansForEvents(removedEventIds);
+                for (const event of nextEvents) {
+                    await this.repository.upsertCalendarEvent(event, grant.side);
+                }
+                await this.syncCalendarReminderPlans(nextEvents);
+                await this.repository.upsertCalendarSyncState(createLifeOpsCalendarSyncState({
+                    agentId: this.agentId(),
+                    provider: "google",
+                    side: grant.side,
+                    calendarId: args.calendarId,
+                    windowStartAt: args.timeMin,
+                    windowEndAt: args.timeMax,
+                    syncedAt,
+                }));
+                await this.clearGoogleGrantAuthFailure(grant);
+                return {
+                    calendarId: args.calendarId,
+                    events: await this.repository.listCalendarEvents(this.agentId(), "google", args.timeMin, args.timeMax, grant.side),
+                    source: "synced",
+                    timeMin: args.timeMin,
+                    timeMax: args.timeMax,
+                    syncedAt,
+                };
+            };
+            return resolveGoogleExecutionTarget(grant) === "cloud"
+                ? this.runManagedGoogleOperation(grant, syncCalendar)
+                : this.withGoogleGrantOperation(grant, syncCalendar);
+        }
+        async getCalendarFeed(requestUrl, request = {}, now = new Date()) {
+            const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+            const side = normalizeOptionalConnectorSide(request.side, "side");
+            const { grantId } = request;
+            const calendarId = normalizeCalendarId(request.calendarId);
+            const timeZone = normalizeCalendarTimeZone(request.timeZone);
+            const { timeMin, timeMax } = resolveCalendarWindow({
+                now,
+                timeZone,
+                requestedTimeMin: request.timeMin,
+                requestedTimeMax: request.timeMax,
+            });
+            const forceSync = normalizeOptionalBoolean(request.forceSync, "forceSync") ?? false;
+            // Multi-account aggregation: when no grantId specified, check if
+            // there are multiple grants and aggregate from all of them.
+            if (!grantId) {
+                const allGrants = (await this.repository.listConnectorGrants(this.agentId())).filter((g) => g.provider === "google");
+                const grants = resolveGoogleGrants({
+                    grants: allGrants,
+                    requestedSide: side,
+                    requestedMode: mode,
+                });
+                if (grants.length > 1) {
+                    return this.aggregateCalendarFeeds(requestUrl, grants, calendarId, timeMin, timeMax, timeZone, forceSync, now);
+                }
+            }
+            const grant = await this.requireGoogleCalendarGrant(requestUrl, mode, side, grantId);
+            const effectiveSide = grant.side;
+            const syncState = await this.repository.getCalendarSyncState(this.agentId(), "google", calendarId, effectiveSide);
+            if (!forceSync &&
+                syncState &&
+                isCalendarSyncStateFresh({
+                    syncedAt: syncState.syncedAt,
+                    timeMin,
+                    timeMax,
+                    windowStartAt: syncState.windowStartAt,
+                    windowEndAt: syncState.windowEndAt,
+                    now,
+                })) {
+                return {
+                    calendarId,
+                    events: await this.repository.listCalendarEvents(this.agentId(), "google", timeMin, timeMax, effectiveSide),
+                    source: "cache",
+                    timeMin,
+                    timeMax,
+                    syncedAt: syncState.syncedAt,
+                };
+            }
+            return this.syncGoogleCalendarFeed({
+                requestUrl,
+                requestedMode: mode,
+                requestedSide: effectiveSide,
+                grantId: grant.id,
+                calendarId,
+                timeMin,
+                timeMax,
+                timeZone,
+            });
+        }
+        async aggregateCalendarFeeds(requestUrl, grants, calendarId, timeMin, timeMax, timeZone, forceSync, now) {
+            const results = await Promise.allSettled(grants.map((grant) => this.getCalendarFeed(requestUrl, {
+                grantId: grant.id,
+                calendarId,
+                timeMin,
+                timeMax,
+                timeZone,
+                forceSync,
+            }, now).then((feed) => ({
+                feed,
+                grant,
+            }))));
+            const allEvents = [];
+            let latestSyncedAt = null;
+            let source = "cache";
+            for (const result of results) {
+                if (result.status === "rejected") {
+                    this.logLifeOpsWarn("calendar_feed_aggregate", `Grant failed: ${result.reason}`, {});
+                    continue;
+                }
+                const { feed, grant } = result.value;
+                if (feed.source === "synced") {
+                    source = "synced";
+                }
+                if (feed.syncedAt &&
+                    (!latestSyncedAt || feed.syncedAt > latestSyncedAt)) {
+                    latestSyncedAt = feed.syncedAt;
+                }
+                for (const event of feed.events) {
+                    allEvents.push({
+                        ...event,
+                        grantId: grant.id,
+                        accountEmail: grant.identityEmail ?? undefined,
+                    });
+                }
+            }
+            allEvents.sort((a, b) => a.startAt.localeCompare(b.startAt));
+            return {
+                calendarId,
+                events: allEvents,
+                source,
+                timeMin,
+                timeMax,
+                syncedAt: latestSyncedAt,
+            };
+        }
+        async createCalendarEvent(requestUrl, request, now = new Date()) {
+            const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+            const side = normalizeOptionalConnectorSide(request.side, "side");
+            const grantId = normalizeOptionalString(request.grantId);
+            const calendarId = normalizeCalendarId(request.calendarId);
+            const title = requireNonEmptyString(request.title, "title");
+            const description = normalizeOptionalString(request.description) ?? "";
+            const location = normalizeOptionalString(request.location) ?? "";
+            const attendees = normalizeCalendarAttendees(request.attendees);
+            const { startAt, endAt, timeZone } = resolveCalendarEventRange(request, now);
+            const grant = await this.requireGoogleCalendarWriteGrant(requestUrl, mode, side, grantId);
+            const createEvent = async () => {
+                const created = resolveGoogleExecutionTarget(grant) === "cloud"
+                    ? (await this.googleManagedClient.createCalendarEvent({
+                        side: grant.side,
+                        grantId: grant.id,
+                        calendarId,
+                        title,
+                        description,
+                        location,
+                        startAt,
+                        endAt,
+                        timeZone,
+                        attendees,
+                    })).event
+                    : await createGoogleCalendarEvent({
+                        accessToken: (await ensureFreshGoogleAccessToken(grant.tokenRef ??
+                            fail(409, "Google Calendar token reference is missing."))).accessToken,
+                        calendarId,
+                        title,
+                        description,
+                        location,
+                        startAt,
+                        endAt,
+                        timeZone,
+                        attendees,
+                    });
+                const syncedAt = new Date().toISOString();
+                const event = {
+                    id: createCalendarEventId(this.agentId(), "google", grant.side, created.calendarId, created.externalId),
+                    agentId: this.agentId(),
+                    provider: "google",
+                    side: grant.side,
+                    ...created,
+                    syncedAt,
+                    updatedAt: syncedAt,
+                };
+                await this.repository.upsertCalendarEvent(event, grant.side);
+                await this.syncCalendarReminderPlans([event]);
+                await this.clearGoogleGrantAuthFailure(grant);
+                await this.recordCalendarEventAudit(event.id, "calendar event created", {
+                    calendarId,
+                    mode: grant.mode,
+                    title,
+                    requestedStartAt: startAt,
+                    requestedEndAt: endAt,
+                }, {
+                    externalId: event.externalId,
+                    htmlLink: event.htmlLink,
+                });
+                return event;
+            };
+            return resolveGoogleExecutionTarget(grant) === "cloud"
+                ? this.runManagedGoogleOperation(grant, createEvent)
+                : this.withGoogleGrantOperation(grant, createEvent);
+        }
+        async updateCalendarEvent(requestUrl, request) {
+            const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+            const side = normalizeOptionalConnectorSide(request.side, "side");
+            const calendarId = normalizeCalendarId(request.calendarId);
+            const externalEventId = requireNonEmptyString(request.eventId, "eventId");
+            const grant = await this.requireGoogleCalendarWriteGrant(requestUrl, mode, side, request.grantId);
+            const updateEvent = async () => {
+                const normalizedAttendees = request.attendees
+                    ? normalizeCalendarAttendees(request.attendees)
+                    : undefined;
+                const materializedUpdated = resolveGoogleExecutionTarget(grant) === "cloud"
+                    ? (await this.googleManagedClient.updateCalendarEvent({
+                        side: grant.side,
+                        grantId: grant.id,
+                        calendarId,
+                        eventId: externalEventId,
+                        title: request.title,
+                        description: request.description,
+                        location: request.location,
+                        startAt: request.startAt,
+                        endAt: request.endAt,
+                        timeZone: request.timeZone,
+                        attendees: normalizedAttendees,
+                    })).event
+                    : await (async () => {
+                        const accessToken = (await ensureFreshGoogleAccessToken(grant.tokenRef ??
+                            fail(409, "Google Calendar token reference is missing."))).accessToken;
+                        // Google's PATCH semantics: if you send `start.dateTime` you must
+                        // also send `end.dateTime`, otherwise the API rejects the call as
+                        // "Bad Request" because the event would have inconsistent bounds.
+                        // When the caller only supplies one bound or omits the timezone,
+                        // load the current event so we can preserve both the existing
+                        // timezone and duration instead of guessing.
+                        const ONE_HOUR_MS = 60 * 60 * 1000;
+                        const needsExistingEventContext = Boolean(request.startAt || request.endAt) &&
+                            (!request.timeZone || !request.startAt || !request.endAt);
+                        const existingEvent = needsExistingEventContext
+                            ? await fetchGoogleCalendarEvent({
+                                accessToken,
+                                calendarId: calendarId ?? undefined,
+                                eventId: externalEventId,
+                            })
+                            : null;
+                        const normalizedTimeZone = normalizeCalendarTimeZone(request.timeZone ?? existingEvent?.timezone ?? undefined);
+                        let normalizedStartAt = normalizeCalendarDateTimeInTimeZone(request.startAt, "startAt", normalizedTimeZone);
+                        let normalizedEndAt = normalizeCalendarDateTimeInTimeZone(request.endAt, "endAt", normalizedTimeZone);
+                        const existingDurationMs = existingEvent &&
+                            Number.isFinite(Date.parse(existingEvent.startAt)) &&
+                            Number.isFinite(Date.parse(existingEvent.endAt))
+                            ? Date.parse(existingEvent.endAt) -
+                                Date.parse(existingEvent.startAt)
+                            : Number.NaN;
+                        const fallbackDurationMs = Number.isFinite(existingDurationMs) && existingDurationMs > 0
+                            ? existingDurationMs
+                            : ONE_HOUR_MS;
+                        if (normalizedStartAt && !normalizedEndAt) {
+                            normalizedEndAt = new Date(new Date(normalizedStartAt).getTime() + fallbackDurationMs).toISOString();
+                        }
+                        else if (normalizedEndAt && !normalizedStartAt) {
+                            normalizedStartAt = new Date(new Date(normalizedEndAt).getTime() - fallbackDurationMs).toISOString();
+                        }
+                        return updateGoogleCalendarEvent({
+                            accessToken,
+                            calendarId: calendarId ?? undefined,
+                            eventId: externalEventId,
+                            title: request.title,
+                            description: request.description,
+                            location: request.location,
+                            startAt: normalizedStartAt,
+                            endAt: normalizedEndAt,
+                            timeZone: normalizedTimeZone,
+                            attendees: normalizedAttendees,
+                        });
+                    })();
+                const syncedAt = new Date().toISOString();
+                const event = {
+                    id: createCalendarEventId(this.agentId(), "google", grant.side, materializedUpdated.calendarId, materializedUpdated.externalId),
+                    agentId: this.agentId(),
+                    provider: "google",
+                    side: grant.side,
+                    ...materializedUpdated,
+                    syncedAt,
+                    updatedAt: syncedAt,
+                };
+                await this.repository.upsertCalendarEvent(event, grant.side);
+                await this.syncCalendarReminderPlans([event]);
+                await this.clearGoogleGrantAuthFailure(grant);
+                await this.recordCalendarEventAudit(event.id, "calendar event updated", {
+                    calendarId: calendarId ?? "primary",
+                    mode: grant.mode,
+                    patched: Object.fromEntries(Object.entries({
+                        title: request.title,
+                        description: request.description,
+                        location: request.location,
+                        startAt: request.startAt,
+                        endAt: request.endAt,
+                        timeZone: request.timeZone,
+                    }).filter(([, value]) => value !== undefined)),
+                }, {
+                    externalId: event.externalId,
+                    htmlLink: event.htmlLink,
+                }, "calendar_event_updated");
+                return event;
+            };
+            return resolveGoogleExecutionTarget(grant) === "cloud"
+                ? this.runManagedGoogleOperation(grant, updateEvent)
+                : this.withGoogleGrantOperation(grant, updateEvent);
+        }
+        async deleteCalendarEvent(requestUrl, request) {
+            const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+            const side = normalizeOptionalConnectorSide(request.side, "side");
+            const calendarId = normalizeCalendarId(request.calendarId);
+            const externalEventId = requireNonEmptyString(request.eventId, "eventId");
+            const grant = await this.requireGoogleCalendarWriteGrant(requestUrl, mode, side, request.grantId);
+            const deleteEvent = async () => {
+                if (resolveGoogleExecutionTarget(grant) === "cloud") {
+                    await this.googleManagedClient.deleteCalendarEvent({
+                        side: grant.side,
+                        grantId: grant.id,
+                        calendarId,
+                        eventId: externalEventId,
+                    });
+                }
+                else {
+                    const accessToken = (await ensureFreshGoogleAccessToken(grant.tokenRef ??
+                        fail(409, "Google Calendar token reference is missing."))).accessToken;
+                    await deleteGoogleCalendarEvent({
+                        accessToken,
+                        calendarId: calendarId ?? undefined,
+                        eventId: externalEventId,
+                    });
+                }
+                // Best-effort: drop the local cached row so subsequent feed reads
+                // don't show a phantom event. Ignore failures here — the source of
+                // truth (Google) has already accepted the delete.
+                try {
+                    await this.repository.deleteCalendarEventByExternalId(this.agentId(), "google", calendarId ?? "primary", externalEventId, grant.side);
+                }
+                catch {
+                    // intentionally swallowed: local cache mirror, not authoritative
+                }
+                await this.clearGoogleGrantAuthFailure(grant);
+                await this.recordCalendarEventAudit(externalEventId, "calendar event deleted", {
+                    calendarId: calendarId ?? "primary",
+                    mode: grant.mode,
+                }, {
+                    externalId: externalEventId,
+                }, "calendar_event_deleted");
+            };
+            return resolveGoogleExecutionTarget(grant) === "cloud"
+                ? this.runManagedGoogleOperation(grant, deleteEvent)
+                : this.withGoogleGrantOperation(grant, deleteEvent);
+        }
+        async getNextCalendarEventContext(requestUrl, request = {}, now = new Date()) {
+            const mode = normalizeOptionalConnectorMode(request.mode, "mode");
+            const timeZone = normalizeCalendarTimeZone(request.timeZone);
+            const feed = await this.getCalendarFeed(requestUrl, {
+                ...request,
+                timeZone,
+                ...resolveNextCalendarEventWindow({
+                    now,
+                    timeZone,
+                    requestedTimeMin: request.timeMin,
+                    requestedTimeMax: request.timeMax,
+                }),
+            }, now);
+            const nextEvent = feed.events.find((event) => Date.parse(event.endAt) > now.getTime()) ??
+                null;
+            if (!nextEvent) {
+                return buildNextCalendarEventContext(null, now);
+            }
+            let linkedMail = [];
+            let linkedMailState = "unavailable";
+            let linkedMailError = null;
+            const status = await this.getGoogleConnectorStatus(requestUrl, mode, nextEvent.side);
+            if (status.connected &&
+                status.grant &&
+                hasGoogleGmailTriageCapability(status.grant)) {
+                const cachedMessages = await this.repository.listGmailMessages(this.agentId(), "google", {
+                    maxResults: DEFAULT_GMAIL_TRIAGE_MAX_RESULTS,
+                }, status.grant.side);
+                linkedMail = findLinkedMailForCalendarEvent(nextEvent, cachedMessages);
+                linkedMailState = "cache";
+                if (linkedMail.length === 0) {
+                    try {
+                        const triage = await this.getGmailTriage(requestUrl, {
+                            mode,
+                            side: status.grant.side,
+                            maxResults: DEFAULT_GMAIL_TRIAGE_MAX_RESULTS,
+                        }, now);
+                        linkedMail = findLinkedMailForCalendarEvent(nextEvent, triage.messages);
+                        linkedMailState = "synced";
+                    }
+                    catch (error) {
+                        if (!(error instanceof LifeOpsServiceError)) {
+                            throw error;
+                        }
+                        this.logLifeOpsWarn("next_calendar_context_linked_mail", error.message, {
+                            provider: "google",
+                            mode: status.mode,
+                            calendarEventId: nextEvent.id,
+                        });
+                        linkedMailState = "error";
+                        linkedMailError = error.message;
+                    }
+                }
+            }
+            return buildNextCalendarEventContext(nextEvent, now, linkedMail, linkedMailState, linkedMailError);
+        }
+    }
+    return LifeOpsCalendarServiceMixin;
+}

package/apps/app-lifeops/src/lifeops/service-mixin-core.d.ts

@@ -0,0 +1,49 @@
+import { type IAgentRuntime } from "@elizaos/core";
+import type { LifeOpsAuditEvent, LifeOpsAuditEventType, LifeOpsBrowserAction, LifeOpsBrowserCompanionStatus, LifeOpsBrowserSettings, LifeOpsConnectorGrant, LifeOpsConnectorMode, LifeOpsOwnership, LifeOpsOwnershipInput, LifeOpsWorkflowDefinition, UpsertLifeOpsBrowserCompanionRequest } from "@elizaos/shared/contracts/lifeops";
+import { computeAdaptiveWindowPolicy } from "./defaults.js";
+import { GoogleManagedClient } from "./google-managed-client.js";
+import { LifeOpsRepository } from "./repository.js";
+import type { LifeOpsServiceOptions } from "./service-types.js";
+/** Constructor type for the mixin pattern. */
+export type Constructor<T = {}> = new (...args: any[]) => T;
+export declare class LifeOpsServiceBase {
+    readonly runtime: IAgentRuntime;
+    readonly repository: LifeOpsRepository;
+    readonly explicitOwnerEntityIdValue: string | null;
+    readonly ownerEntityIdValue: string;
+    readonly googleManagedClient: GoogleManagedClient;
+    ownerRoutingEntityIdPromise: Promise<string | null> | null;
+    /** Cached adaptive window policy derived from the activity profile.
+     *  Recomputed at most every 30 minutes to avoid re-reading task metadata
+     *  on every occurrence refresh. */
+    adaptiveWindowPolicyCache: {
+        policy: ReturnType<typeof computeAdaptiveWindowPolicy>;
+        computedAt: number;
+    } | null;
+    constructor(runtime: IAgentRuntime, options?: LifeOpsServiceOptions);
+    agentId(): string;
+    ownerEntityId(): string;
+    ownerRoutingEntityId(): Promise<string | null>;
+    getBrowserSettingsInternal(): Promise<LifeOpsBrowserSettings>;
+    isBrowserPaused(settings: LifeOpsBrowserSettings): boolean;
+    requireBrowserAvailableForActions(actions: readonly LifeOpsBrowserAction[]): Promise<LifeOpsBrowserSettings>;
+    buildBrowserCompanion(request: UpsertLifeOpsBrowserCompanionRequest, current: LifeOpsBrowserCompanionStatus | null): LifeOpsBrowserCompanionStatus;
+    normalizeOwnership(input: LifeOpsOwnershipInput | undefined, current?: LifeOpsOwnership): LifeOpsOwnership;
+    normalizeChildOwnership(parent: LifeOpsOwnership, input: LifeOpsOwnershipInput | undefined, field?: string): LifeOpsOwnership;
+    logLifeOpsWarn(operation: string, message: string, context?: Record<string, unknown>): void;
+    logLifeOpsError(operation: string, error: unknown, context?: Record<string, unknown>): void;
+    withReminderProcessingLock<T>(operation: () => Promise<T>): Promise<T>;
+    recordAudit(eventType: LifeOpsAuditEventType, ownerType: "definition" | "occurrence" | "goal", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+    recordConnectorAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+    recordChannelPolicyAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+    recordWorkflowAudit(eventType: "workflow_created" | "workflow_updated" | "workflow_run", ownerId: string, actor: "user" | "workflow", reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<LifeOpsAuditEvent>;
+    recordReminderAudit(eventType: "reminder_due" | "reminder_delivered" | "reminder_blocked" | "reminder_escalation_started" | "reminder_escalation_resolved", ownerType: "occurrence" | "calendar_event", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+    recordBrowserAudit(eventType: "browser_session_created" | "browser_session_updated", ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+    recordXPostAudit(ownerId: string, reason: string, inputs: Record<string, unknown>, decision: Record<string, unknown>): Promise<void>;
+    clearGoogleGrantAuthFailure(grant: LifeOpsConnectorGrant): Promise<LifeOpsConnectorGrant>;
+    markGoogleGrantNeedsReauth(grant: LifeOpsConnectorGrant, message: string): Promise<LifeOpsConnectorGrant>;
+    emitAssistantEvent(text: string, source: string, data?: Record<string, unknown>): void;
+    getWorkflowDefinition(workflowId: string): Promise<LifeOpsWorkflowDefinition>;
+    requireXGrant(requestedMode?: LifeOpsConnectorMode): Promise<LifeOpsConnectorGrant>;
+}
+//# sourceMappingURL=service-mixin-core.d.ts.map

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

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