@elizaos/agent 2.0.0-alpha.144 → 2.0.0-alpha.151

package/packages/agent/src/actions/calendar.js

@@ -1,3143 +1 @@
-import { ModelType, parseJSONObjectFromText, parseKeyValueXml, } from "@elizaos/core";
-import { getValidationKeywordTerms, textIncludesKeywordTerm, } from "@elizaos/shared/validation-keywords";
-import { resolveDefaultTimeZone } from "../lifeops/defaults.js";
-import { LifeOpsService, LifeOpsServiceError } from "../lifeops/service.js";
-import { addDaysToLocalDate, buildUtcDateFromLocalParts, getWeekdayForLocalDate, getZonedDateParts, } from "../lifeops/time.js";
-import { collectKeywordTermMatchesForKey, hasContextSignalSyncForKey, } from "./context-signal.js";
-import { renderGroundedActionReply } from "./grounded-action-reply.js";
-import { calendarReadUnavailableMessage, calendarWriteUnavailableMessage, detailArray, detailBoolean, detailNumber, detailString, formatCalendarEventDateTime, formatCalendarFeed, formatNextEventContext, getGoogleCapabilityStatus, hasLifeOpsAccess, INTERNAL_URL, messageText, toActionData, } from "./lifeops-google-helpers.js";
-const MIN_CREATE_EVENT_DURATION_MINUTES = 15;
-const CALENDAR_VALIDATION_CONTEXT_LIMIT = 12;
-const PARAMETER_DOC_NOISE_PATTERN = /\b(?:actions?|params?|parameters?|query\?:string|subaction\?:string|details\?:object|required parameter|supported keys include|may include:|match against titles|structured calendar arguments|structured data when needed|boolean when)\b|\b\w+\?:\w+\b/i;
-const CAL_I18N_OPTS = { includeAllLocales: true };
-const CAL_AFFIRMATIVE_TERMS = getValidationKeywordTerms("contextSignal.affirmative.strong", CAL_I18N_OPTS);
-const CAL_TEMPORAL_FOLLOWUP_TERMS = getValidationKeywordTerms("contextSignal.temporal_followup.strong", CAL_I18N_OPTS);
-const CAL_LIFEOPS_STRONG_TERMS = getValidationKeywordTerms("contextSignal.lifeops.strong", CAL_I18N_OPTS);
-const CAL_CALENDAR_STRONG_TERMS = getValidationKeywordTerms("contextSignal.calendar.strong", CAL_I18N_OPTS);
-const CAL_CALENDAR_WEAK_TERMS = getValidationKeywordTerms("contextSignal.calendar.weak", CAL_I18N_OPTS);
-function textMatchesAnyCal(text, terms) {
-    return terms.some((term) => textIncludesKeywordTerm(text, term));
-}
-const I18N_LOCALES = ["en", "zh-CN", "ko", "es", "pt", "vi", "tl"];
-function buildIntlMonthMap() {
-    const map = {};
-    for (const locale of I18N_LOCALES) {
-        for (let month = 0; month < 12; month++) {
-            const date = new Date(2024, month, 15);
-            for (const style of ["long", "short"]) {
-                const name = new Intl.DateTimeFormat(locale, { month: style })
-                    .format(date)
-                    .toLowerCase()
-                    .replace(/\.$/, "");
-                if (name.length > 0)
-                    map[name] = month + 1;
-            }
-        }
-    }
-    return map;
-}
-function buildIntlWeekdayMap() {
-    const map = {};
-    for (const locale of I18N_LOCALES) {
-        for (let dow = 0; dow < 7; dow++) {
-            const date = new Date(2024, 0, 7 + dow);
-            for (const style of ["long", "short"]) {
-                const name = new Intl.DateTimeFormat(locale, { weekday: style })
-                    .format(date)
-                    .toLowerCase()
-                    .replace(/\.$/, "");
-                if (name.length > 0)
-                    map[name] = dow;
-            }
-        }
-    }
-    return map;
-}
-const MONTH_MAP = buildIntlMonthMap();
-const WEEKDAY_MAP = buildIntlWeekdayMap();
-const MONTH_NAMES_SORTED = Object.keys(MONTH_MAP).sort((a, b) => b.length - a.length);
-const MONTH_NAME_PATTERN = new RegExp(`\\b(${MONTH_NAMES_SORTED.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\.?\\s+(\\d{1,2})(?:st|nd|rd|th)?(?:,?\\s+(\\d{4}))?\\b`, "i");
-const WEEKDAY_NAMES_SORTED = Object.keys(WEEKDAY_MAP).sort((a, b) => b.length - a.length);
-const WEEKDAY_NAME_PATTERN = new RegExp(`\\b(?:(this|next)\\s+)?(${WEEKDAY_NAMES_SORTED.map((n) => n.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|")})\\b`, "i");
-const CALENDAR_DETAIL_ALIASES = {
-    calendarId: ["calendarid", "calendar_id"],
-    timeMin: ["timemin", "time_min"],
-    timeMax: ["timemax", "time_max"],
-    timeZone: ["timezone", "time_zone"],
-    forceSync: ["forcesync", "force_sync"],
-    windowDays: ["windowdays", "window_days"],
-    startAt: ["startat", "start_at"],
-    endAt: ["endat", "end_at"],
-    durationMinutes: ["durationminutes", "duration_minutes"],
-    windowPreset: ["windowpreset", "window_preset"],
-    eventId: [
-        "eventid",
-        "event_id",
-        "externaleventid",
-        "external_event_id",
-        "googleeventid",
-        "google_event_id",
-    ],
-    newTitle: ["newtitle", "new_title", "renameto", "rename_to"],
-    description: ["desc", "summary", "body"],
-    location: ["place", "venue"],
-};
-function normalizeCalendarSubaction(value) {
-    if (typeof value !== "string") {
-        return null;
-    }
-    const normalized = value.trim().toLowerCase();
-    switch (normalized) {
-        case "feed":
-        case "next_event":
-        case "search_events":
-        case "create_event":
-        case "update_event":
-        case "delete_event":
-        case "trip_window":
-            return normalized;
-        default:
-            return null;
-    }
-}
-function normalizeShouldAct(value) {
-    if (typeof value === "boolean") {
-        return value;
-    }
-    if (typeof value === "string") {
-        const normalized = value.trim().toLowerCase();
-        if (normalized === "true") {
-            return true;
-        }
-        if (normalized === "false") {
-            return false;
-        }
-    }
-    return null;
-}
-function normalizePlannerResponse(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const trimmed = value.trim();
-    return trimmed.length > 0 ? trimmed : undefined;
-}
-function buildCalendarReplyOnlyFallback(subaction) {
-    switch (subaction) {
-        case "create_event":
-            return "What event do you want to add, and when should it happen?";
-        case "search_events":
-        case "trip_window":
-            return "What calendar event or trip do you want me to look up?";
-        case "next_event":
-        case "feed":
-            return "Do you want today's schedule, your next event, or a specific event?";
-        case "update_event":
-            return "Which calendar event do you want to change, and what should change?";
-        case "delete_event":
-            return "Which calendar event do you want to delete?";
-        default:
-            return "What do you want to do on your calendar — check your schedule, find an event, or create one?";
-    }
-}
-function looksLikeLifeReminderRequestForCalendarAction(text) {
-    const normalized = normalizeText(text);
-    if (!normalized) {
-        return false;
-    }
-    if (collectKeywordTermMatchesForKey([normalized], "calendar", {
-        includeAllLocales: true,
-    }).size > 0) {
-        return false;
-    }
-    return textMatchesAnyCal(normalized, CAL_LIFEOPS_STRONG_TERMS);
-}
-function buildCalendarServiceErrorFallback(error, intent) {
-    const normalized = normalizeText(error.message);
-    if (normalized.includes("utc 'z' suffix") ||
-        normalized.includes("local datetime without 'z'")) {
-        return `I couldn't pin down the event time from "${intent}". Tell me the date and time again in plain language, like "Friday at 8 pm Pacific."`;
-    }
-    if (normalized.includes("startat is required") ||
-        normalized.includes("windowpreset is not provided")) {
-        return "I still need the time for that event. Tell me when it should happen.";
-    }
-    if (normalized.includes("endat must be later than startat")) {
-        return "That end time lands before the start. Give me the date and time again and I'll fix it.";
-    }
-    if (error.status === 429 || normalized.includes("rate limit")) {
-        return "Calendar is rate-limited right now. Try again in a bit.";
-    }
-    return "I couldn't finish that calendar change yet. Tell me the event and timing again, and I'll try it a different way.";
-}
-function buildCalendarEventDisambiguationFallback(args) {
-    const previewLines = args.candidates.slice(0, 3).map((candidate) => {
-        const when = formatCalendarEventDateTime(candidate, {
-            includeTimeZoneName: true,
-        });
-        return `- ${candidate.title} (${when})`;
-    });
-    const intro = args.titleHint
-        ? `I found multiple events matching "${args.titleHint}".`
-        : "I found multiple matching calendar events.";
-    const suffix = args.candidates.length > 3
-        ? ` There are ${args.candidates.length} matches total.`
-        : "";
-    return [
-        intro,
-        ...previewLines,
-        `Tell me which one to ${args.action} by giving the title and date/time.${suffix}`,
-    ].join("\n");
-}
-function shouldDeleteAllMatchingCalendarEvents(args) {
-    const normalizedIntent = normalizeText(args.intent);
-    const normalizedTitleHint = normalizeText(args.titleHint ?? "");
-    const titleStartsWithQuantifier = /^(all|both|every|each)\b/.test(normalizedTitleHint);
-    if (/\b(?:remove|delete|cancel|kill|drop)\b\s+(?:the\s+)?(?:duplicates?|copies)\b/.test(normalizedIntent)) {
-        return true;
-    }
-    const quantifierMatch = normalizedIntent.match(/\b(?:remove|delete|cancel|kill|drop)\b\s+(both|all|every|each)\b/);
-    if (!quantifierMatch) {
-        return false;
-    }
-    if (titleStartsWithQuantifier) {
-        return false;
-    }
-    const quantifier = quantifierMatch[1];
-    if (quantifier === "both" && args.candidateCount !== 2) {
-        return false;
-    }
-    const trailingIntent = normalizedIntent.slice((quantifierMatch.index ?? 0) + quantifierMatch[0].length);
-    return /\b(?:matching|events?|meetings?|appointments?|invites?|entries|duplicates?|copies)\b/.test(trailingIntent);
-}
-async function renderCalendarActionReply(args) {
-    const { runtime, message, state, intent, scenario, fallback, context } = args;
-    return renderGroundedActionReply({
-        runtime,
-        message,
-        state,
-        intent,
-        domain: "calendar",
-        scenario,
-        fallback,
-        context,
-        preferCharacterVoice: true,
-        additionalRules: [
-            "Mirror the user's phrasing for dates, times, ranges, and scheduling language when possible.",
-            "Prefer phrases like tomorrow morning, next week, later, earlier, free, busy, or the user's own wording over robotic calendar language.",
-            "Never surface raw ISO timestamps unless the user used raw ISO timestamps.",
-            "Preserve all concrete event facts from the context and canonical fallback.",
-            "If this is reply-only or a clarification, do not pretend you already changed the calendar.",
-        ],
-    });
-}
-function normalizeText(value) {
-    return value.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function normalizeLookupKey(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]/g, "");
-}
-function hasCalendarTextSignal(text) {
-    if (!text.trim()) {
-        return false;
-    }
-    if (collectKeywordTermMatchesForKey([text], "calendar", {
-        includeAllLocales: true,
-        strength: "strong",
-    }).size > 0) {
-        return true;
-    }
-    return (collectKeywordTermMatchesForKey([text], "calendar", {
-        includeAllLocales: true,
-        strength: "weak",
-    }).size >= 2);
-}
-function wordCount(value) {
-    const normalized = normalizeText(value);
-    if (!normalized) {
-        return 0;
-    }
-    return normalized.split(" ").filter(Boolean).length;
-}
-function tokenize(value) {
-    return normalizeText(value)
-        .split(" ")
-        .filter((token) => token.length >= 2);
-}
-function tokenVariants(token) {
-    const normalized = token.trim().toLowerCase();
-    if (!normalized) {
-        return [];
-    }
-    const variants = new Set([normalized]);
-    if (normalized.endsWith("ies") && normalized.length > 3) {
-        variants.add(`${normalized.slice(0, -3)}y`);
-    }
-    if (normalized.endsWith("es") && normalized.length > 4) {
-        variants.add(normalized.slice(0, -2));
-    }
-    if (normalized.endsWith("s") &&
-        !normalized.endsWith("ss") &&
-        normalized.length > 3) {
-        variants.add(normalized.slice(0, -1));
-    }
-    return [...variants];
-}
-function tokenizeForSearch(value) {
-    return [...new Set(tokenize(value).flatMap((token) => tokenVariants(token)))];
-}
-function normalizeCalendarSearchQueryValue(value) {
-    if (!value) {
-        return undefined;
-    }
-    if (PARAMETER_DOC_NOISE_PATTERN.test(value)) {
-        return undefined;
-    }
-    const cleaned = normalizeText(value)
-        .replace(/\b(?:actions?|params?|parameters?)\b[:;]*/g, "")
-        .replace(/\b\w+\?:\w+(?:\s+\[[^\]]+\])?\s*-\s*/g, " ")
-        .replace(/\b(?:search|find|look(?:ing)? for|show me|check)\s+(?:my\s+)?(?:calendar|schedule)\s+for\b/g, "")
-        .replace(/\b(?:search|find|look(?:ing)? for|show me|check)\b/g, "")
-        .replace(/\b(?:on|in) my calendar\b/g, "")
-        .replace(/\b(?:today|tomorrow|tonight|this week(?:end)?|next week(?:end)?|week after(?: next)?|this month|next month|this year|next year)\b/g, "")
-        .replace(/\b(?:scheduled|coming up|happening|for me)\b/g, "")
-        .replace(/\b(?:events?|appointments?|meetings?)\b$/g, "")
-        .replace(/\bsupported keys include\b.*$/g, "")
-        .replace(/\bmatch against titles\b.*$/g, "")
-        .replace(/\bstructured calendar arguments\b.*$/g, "")
-        .replace(/[;:,]+/g, " ")
-        .replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, "")
-        .trim();
-    if (!cleaned ||
-        ["calendar", "schedule", "event", "events"].includes(cleaned) ||
-        textMatchesAnyCal(cleaned, CAL_TEMPORAL_FOLLOWUP_TERMS) ||
-        PARAMETER_DOC_NOISE_PATTERN.test(cleaned)) {
-        return undefined;
-    }
-    return cleaned;
-}
-function dedupeCalendarQueries(queries) {
-    const normalized = queries
-        .map((query) => normalizeCalendarSearchQueryValue(query))
-        .filter((query) => Boolean(query));
-    return [...new Set(normalized)];
-}
-function normalizeCalendarDetails(details) {
-    if (!details) {
-        return undefined;
-    }
-    const normalized = { ...details };
-    const aliasMap = new Map();
-    for (const [canonical, aliases] of Object.entries(CALENDAR_DETAIL_ALIASES)) {
-        aliasMap.set(normalizeLookupKey(canonical), canonical);
-        for (const alias of aliases) {
-            aliasMap.set(normalizeLookupKey(alias), canonical);
-        }
-    }
-    for (const [key, value] of Object.entries(details)) {
-        const canonical = aliasMap.get(normalizeLookupKey(key));
-        if (!canonical) {
-            continue;
-        }
-        if (normalized[canonical] === undefined) {
-            normalized[canonical] = value;
-        }
-    }
-    return normalized;
-}
-function parseStateLine(line) {
-    const trimmed = line.trim();
-    const timestampedMatch = trimmed.match(/^\d{1,2}:\d{2}\s+\([^)]+\)\s+\[[^\]]+\]\s+(\S+)\s*:\s*(.*)/);
-    if (timestampedMatch) {
-        return {
-            role: timestampedMatch[1].toLowerCase(),
-            text: timestampedMatch[2].trim(),
-        };
-    }
-    const simpleMatch = trimmed.match(/^(user|assistant|system|owner|admin|\S+)\s*:\s*(.*)/i);
-    if (simpleMatch) {
-        return {
-            role: simpleMatch[1].toLowerCase(),
-            text: simpleMatch[2].trim(),
-        };
-    }
-    return { role: "", text: trimmed };
-}
-const SYSTEM_ROLE_NAMES = new Set(["assistant", "system"]);
-function splitStateTextCandidates(value) {
-    return value
-        .split(/\n+/)
-        .map((line) => parseStateLine(line).text)
-        .filter((text) => text.length > 0);
-}
-function userIntentsFromState(state) {
-    if (!state || typeof state !== "object") {
-        return [];
-    }
-    const stateRecord = state;
-    const values = stateRecord.values && typeof stateRecord.values === "object"
-        ? stateRecord.values
-        : undefined;
-    const raw = typeof values?.recentMessages === "string"
-        ? values.recentMessages
-        : typeof stateRecord.text === "string"
-            ? stateRecord.text
-            : "";
-    if (!raw) {
-        return [];
-    }
-    const agentName = typeof values?.agentName === "string" ? values.agentName.toLowerCase() : "";
-    const excludedRoles = new Set(SYSTEM_ROLE_NAMES);
-    if (agentName) {
-        excludedRoles.add(agentName);
-    }
-    return raw
-        .split(/\n+/)
-        .filter((line) => {
-        const { role } = parseStateLine(line);
-        return role.length > 0 && !excludedRoles.has(role);
-    })
-        .map((line) => parseStateLine(line).text)
-        .filter((text) => text.length > 0);
-}
-function planningConversationLines(state) {
-    if (!state || typeof state !== "object") {
-        return [];
-    }
-    const stateRecord = state;
-    const values = stateRecord.values && typeof stateRecord.values === "object"
-        ? stateRecord.values
-        : undefined;
-    const raw = typeof values?.recentMessages === "string"
-        ? values.recentMessages
-        : typeof stateRecord.text === "string"
-            ? stateRecord.text
-            : "";
-    if (!raw) {
-        return [];
-    }
-    return raw
-        .split(/\n+/)
-        .map((line) => parseStateLine(line))
-        .filter((line) => line.role.length > 0 && line.text.length > 0)
-        .map((line) => `${line.role}: ${line.text}`);
-}
-function hasCalendarContextSignal(message, state) {
-    return hasContextSignalSyncForKey(message, state, "calendar", {
-        contextLimit: CALENDAR_VALIDATION_CONTEXT_LIMIT,
-    });
-}
-function stateTextCandidates(state) {
-    if (!state || typeof state !== "object") {
-        return [];
-    }
-    const stateRecord = state;
-    const values = stateRecord.values && typeof stateRecord.values === "object"
-        ? stateRecord.values
-        : undefined;
-    const candidates = [];
-    const pushText = (value) => {
-        if (typeof value === "string" && value.trim().length > 0) {
-            candidates.push(...splitStateTextCandidates(value));
-        }
-    };
-    pushText(values?.recentMessages);
-    pushText(stateRecord.text);
-    const recentMessagesData = stateRecord.recentMessagesData ?? stateRecord.recentMessages;
-    if (Array.isArray(recentMessagesData)) {
-        for (const item of recentMessagesData) {
-            if (!item || typeof item !== "object") {
-                continue;
-            }
-            const content = item.content;
-            if (!content || typeof content !== "object") {
-                continue;
-            }
-            pushText(content.text);
-        }
-    }
-    return [...new Set(candidates)];
-}
-function scoreIntentCandidate(value) {
-    const normalized = normalizeText(value);
-    if (!normalized) {
-        return Number.NEGATIVE_INFINITY;
-    }
-    let score = Math.min(normalized.length, 160) / 16;
-    if (textMatchesAnyCal(normalized, CAL_AFFIRMATIVE_TERMS)) {
-        score -= 200;
-    }
-    if (PARAMETER_DOC_NOISE_PATTERN.test(normalized)) {
-        score -= 500;
-    }
-    if (hasCalendarTextSignal(value)) {
-        score += 10;
-    }
-    if (textMatchesAnyCal(normalized, CAL_CALENDAR_STRONG_TERMS)) {
-        score += 14;
-    }
-    if (textMatchesAnyCal(normalized, CAL_CALENDAR_WEAK_TERMS)) {
-        score += 10;
-    }
-    if (textMatchesAnyCal(normalized, CAL_CALENDAR_STRONG_TERMS)) {
-        score += 8;
-    }
-    return score;
-}
-function looksLikeNarrativeCalendarQuery(value) {
-    const normalized = normalizeText(value);
-    if (!normalized) {
-        return false;
-    }
-    return (/\b(?:tell me if|let me know if|whether|can you|could you|would you|do i have|are there|what(?:'s| is) on|what(?: event| events)? do i have|when do i|try to find)\b/.test(normalized) &&
-        /\b(?:calendar|schedule|event|events|flight|flights|travel|trip|appointment|meeting|hotel|stay|return)\b/.test(normalized));
-}
-function looksLikeLiteralRequestEcho(query, intent) {
-    const normalizedQuery = normalizeText(query);
-    const normalizedIntent = normalizeText(intent);
-    const questionLike = /[?¿]/.test(query);
-    if (!normalizedQuery || !normalizedIntent) {
-        return false;
-    }
-    if (normalizedQuery === normalizedIntent) {
-        return (questionLike ||
-            wordCount(normalizedQuery) >= 10 ||
-            normalizedQuery.length >= 80);
-    }
-    return ((normalizedQuery.includes(normalizedIntent) ||
-        normalizedIntent.includes(normalizedQuery)) &&
-        (questionLike || normalizedQuery.length >= 96));
-}
-function resolveCalendarIntent(paramsIntent, message, state) {
-    const normalizeFollowUpConstraint = (value) => {
-        const cleaned = value
-            .trim()
-            .replace(/^(?:yes|yeah|yep|yup|ok|okay|sure|please|please do|do it|go ahead|sounds good)\b[\s,.-]*/i, "")
-            .replace(/^(?:and\s+|also\s+)/i, "")
-            .replace(/^(?:what about|how about|and the|also the|or the|only the|just the)\s+/i, "")
-            .trim();
-        if (/^(?:try\s+(?:it|again|that)|retry|do\s+(?:it\s+)?again|one\s+more\s+time|proceed|go for it)$/i.test(cleaned)) {
-            return "";
-        }
-        return cleaned;
-    };
-    const currentMessageText = messageText(message).trim();
-    const normalizedCurrentMessage = normalizeText(currentMessageText);
-    const currentMessageHasCalendarSignal = hasCalendarTextSignal(currentMessageText);
-    const isRefinement = /^(?:what about|how about|and the|also the|or the|only the|just the)\b/i.test(normalizedCurrentMessage);
-    if (currentMessageText && currentMessageHasCalendarSignal && !isRefinement) {
-        return currentMessageText;
-    }
-    if (currentMessageText &&
-        (textMatchesAnyCal(normalizedCurrentMessage, CAL_AFFIRMATIVE_TERMS) ||
-            textMatchesAnyCal(normalizedCurrentMessage, CAL_TEMPORAL_FOLLOWUP_TERMS) ||
-            isRefinement ||
-            hasCalendarContextSignal(message, state))) {
-        const followUpCandidates = userIntentsFromState(state).filter((candidate) => hasCalendarTextSignal(candidate) &&
-            normalizeText(candidate) !== normalizedCurrentMessage);
-        const recentRelevantIntent = followUpCandidates.length > 0
-            ? followUpCandidates.reduce((best, current) => scoreIntentCandidate(current) >= scoreIntentCandidate(best)
-                ? current
-                : best)
-            : undefined;
-        if (recentRelevantIntent) {
-            const followUpConstraint = normalizeFollowUpConstraint(currentMessageText);
-            return followUpConstraint
-                ? `${recentRelevantIntent} ${followUpConstraint}`.trim()
-                : recentRelevantIntent;
-        }
-    }
-    const candidates = [
-        {
-            text: paramsIntent?.trim(),
-            source: "params",
-        },
-        {
-            text: messageText(message).trim(),
-            source: "message",
-        },
-        ...stateTextCandidates(state).map((text) => ({
-            text,
-            source: "state",
-        })),
-    ].filter((candidate) => Boolean(candidate.text && candidate.text.trim().length > 0));
-    if (candidates.length === 0) {
-        return "";
-    }
-    return [...candidates]
-        .sort((left, right) => {
-        const leftBonus = left.source === "message" && hasCalendarTextSignal(left.text) ? 20 : 0;
-        const rightBonus = right.source === "message" && hasCalendarTextSignal(right.text)
-            ? 20
-            : 0;
-        return (scoreIntentCandidate(right.text) +
-            rightBonus -
-            (scoreIntentCandidate(left.text) + leftBonus));
-    })
-        .map((candidate) => candidate.text)[0];
-}
-function inferCalendarSubaction(intent, details, query) {
-    // Delete intent is checked first because phrases like "delete the duplicate
-    // event" otherwise get swept up by the search_events branch via "duplicate"
-    // → "look for". Only the verb decides the subaction here.
-    if (/\b(delete|remove|cancel|drop|get rid of|trash|kill)\b.*\b(event|meeting|appointment|calendar|reminder|invite)\b/.test(intent) ||
-        /\b(uncancel|unbook|unschedule)\b/.test(intent)) {
-        return "delete_event";
-    }
-    // Update intent — same eager-match treatment so "rename", "move", "reschedule"
-    // don't get pulled into search_events.
-    if (/\b(rename|reschedule|move|push|change|update|edit|modify)\b.*\b(event|meeting|appointment|calendar|invite)\b/.test(intent)) {
-        return "update_event";
-    }
-    if (query ||
-        detailString(details, "query") ||
-        /\b(find|search|look for|matching|related to|flight|flights|fly|travel|trip|return)\b/.test(intent)) {
-        return "search_events";
-    }
-    if (detailString(details, "startAt") ||
-        detailNumber(details, "durationMinutes") ||
-        /\b(create|add|book)\b/.test(intent) ||
-        /\bschedule\s+(?:a|an|this|that|the)?\s*(?:calendar\s+)?(?:meeting|event|appointment|call)\b/.test(intent) ||
-        /\bput\b.*\b(calendar|meeting|event)\b/.test(intent) ||
-        /\bmake an event\b/.test(intent)) {
-        return "create_event";
-    }
-    if (/\b(next|upcoming|soon|about to|coming up)\b/.test(intent) &&
-        /\b(event|meeting|appointment|call|calendar item|thing)\b/.test(intent)) {
-        return "next_event";
-    }
-    return "feed";
-}
-function shouldTrustExplicitCalendarSubaction(subaction, params, details) {
-    if (!subaction) {
-        return false;
-    }
-    switch (subaction) {
-        case "create_event":
-            return Boolean(params.title ||
-                detailString(details, "title") ||
-                detailString(details, "startAt") ||
-                detailString(details, "windowPreset") ||
-                detailNumber(details, "durationMinutes"));
-        case "update_event":
-            return Boolean(detailString(details, "eventId") ||
-                detailString(details, "title") ||
-                detailString(details, "newTitle") ||
-                detailString(details, "startAt") ||
-                detailString(details, "endAt"));
-        case "delete_event":
-            return Boolean(detailString(details, "eventId") ||
-                params.title ||
-                detailString(details, "title"));
-        case "search_events":
-            return Boolean(params.query ||
-                detailString(details, "query") ||
-                (params.queries?.length ?? 0) > 0 ||
-                (detailArray(details, "queries")?.length ?? 0) > 0);
-        default:
-            return false;
-    }
-}
-function cleanTripLocation(value) {
-    const cleaned = value
-        .trim()
-        .replace(/\b(?:today|tomorrow|tonight|this week(?:end)?|next week(?:end)?|this month|next month|for me|coming up|upcoming|on my calendar|on the calendar|on my schedule|on the schedule)\b.*$/i, "")
-        .replace(/^[^a-z0-9]+|[^a-z0-9]+$/gi, "")
-        .trim();
-    return cleaned.length > 0 ? cleaned : undefined;
-}
-function inferTripWindowIntent(intent) {
-    const patterns = [
-        /\bwhile\s+(?:i(?:'m| am)|im)\s+in\s+(.+?)(?=$|[?.!,])/i,
-        /\bwhen\s+(?:i(?:'m| am)|im)\s+in\s+(.+?)(?=$|[?.!,])/i,
-        /\bduring\s+(?:my\s+)?(?:trip|stay|visit)\s+(?:to|in)\s+(.+?)(?=$|[?.!,])/i,
-        /\bonce\s+(?:i(?:'m| am)|im)\s+in\s+(.+?)(?=$|[?.!,])/i,
-    ];
-    for (const pattern of patterns) {
-        const match = intent.match(pattern);
-        const location = cleanTripLocation(match?.[1] ?? "");
-        if (location) {
-            return { location };
-        }
-    }
-    return null;
-}
-function parseExplicitLocalDate(value, timeZone) {
-    const normalized = normalizeText(value);
-    const localToday = getZonedDateParts(new Date(), timeZone);
-    const isoMatch = normalized.match(/\b(\d{4})-(\d{1,2})-(\d{1,2})\b/);
-    if (isoMatch) {
-        return {
-            year: Number(isoMatch[1]),
-            month: Number(isoMatch[2]),
-            day: Number(isoMatch[3]),
-        };
-    }
-    const monthNameMatch = normalized.match(MONTH_NAME_PATTERN);
-    if (monthNameMatch) {
-        return {
-            year: monthNameMatch[3] ? Number(monthNameMatch[3]) : localToday.year,
-            month: MONTH_MAP[normalizeLookupKey(monthNameMatch[1])],
-            day: Number(monthNameMatch[2]),
-        };
-    }
-    const numericMatch = normalized.match(/\b(\d{1,2})[/-](\d{1,2})(?:[/-](\d{2,4}))?\b/);
-    if (numericMatch) {
-        const yearRaw = numericMatch[3];
-        const parsedYear = yearRaw === undefined
-            ? localToday.year
-            : yearRaw.length === 2
-                ? 2000 + Number(yearRaw)
-                : Number(yearRaw);
-        return {
-            year: parsedYear,
-            month: Number(numericMatch[1]),
-            day: Number(numericMatch[2]),
-        };
-    }
-    const weekdayMatch = normalized.match(WEEKDAY_NAME_PATTERN);
-    if (weekdayMatch) {
-        const qualifier = normalizeLookupKey(weekdayMatch[1] ?? "");
-        const weekdayKey = normalizeLookupKey(weekdayMatch[2] ?? "");
-        const targetWeekday = WEEKDAY_MAP[weekdayKey];
-        if (targetWeekday !== undefined) {
-            const currentWeekday = new Date(Date.UTC(localToday.year, Math.max(0, localToday.month - 1), localToday.day, 12, 0, 0)).getUTCDay();
-            let delta = (targetWeekday - currentWeekday + 7) % 7;
-            if (qualifier === "next") {
-                delta = delta === 0 ? 7 : delta + 7;
-            }
-            return addDaysToLocalDate({
-                year: localToday.year,
-                month: localToday.month,
-                day: localToday.day,
-            }, delta);
-        }
-    }
-    return null;
-}
-function resolveCalendarTimeZone(details) {
-    return detailString(details, "timeZone") ?? resolveDefaultTimeZone();
-}
-function getLocalTodayDate(timeZone) {
-    const localNow = getZonedDateParts(new Date(), timeZone);
-    return {
-        year: localNow.year,
-        month: localNow.month,
-        day: localNow.day,
-    };
-}
-function addMonthsToLocalDate(dateOnly, monthDelta) {
-    const utcDate = new Date(Date.UTC(dateOnly.year, dateOnly.month - 1 + monthDelta, dateOnly.day, 12, 0, 0));
-    return {
-        year: utcDate.getUTCFullYear(),
-        month: utcDate.getUTCMonth() + 1,
-        day: utcDate.getUTCDate(),
-    };
-}
-function buildLocalDateRange(timeZone, startDate, endDateExclusive, options) {
-    return {
-        timeMin: buildUtcDateFromLocalParts(timeZone, {
-            year: startDate.year,
-            month: startDate.month,
-            day: startDate.day,
-            hour: options?.startHour ?? 0,
-            minute: options?.startMinute ?? 0,
-            second: 0,
-        }).toISOString(),
-        timeMax: buildUtcDateFromLocalParts(timeZone, {
-            year: endDateExclusive.year,
-            month: endDateExclusive.month,
-            day: endDateExclusive.day,
-            hour: options?.endHour ?? 0,
-            minute: options?.endMinute ?? 0,
-            second: 0,
-        }).toISOString(),
-    };
-}
-function buildLocalDayRange(timeZone, startOffsetDays, endOffsetDaysExclusive) {
-    const localToday = getLocalTodayDate(timeZone);
-    return buildLocalDateRange(timeZone, addDaysToLocalDate(localToday, startOffsetDays), addDaysToLocalDate(localToday, endOffsetDaysExclusive));
-}
-function compareLocalDates(left, right) {
-    if (left.year !== right.year) {
-        return left.year - right.year;
-    }
-    if (left.month !== right.month) {
-        return left.month - right.month;
-    }
-    return left.day - right.day;
-}
-function resolveCreateEventCalendarTimeZone(details, feed, fallbackTimeZone) {
-    const explicitTimeZone = detailString(details, "timeZone");
-    if (explicitTimeZone) {
-        return explicitTimeZone;
-    }
-    const counts = new Map();
-    for (const event of feed?.events ?? []) {
-        const eventTimeZone = typeof event.timezone === "string" ? event.timezone.trim() : "";
-        if (!eventTimeZone) {
-            continue;
-        }
-        counts.set(eventTimeZone, (counts.get(eventTimeZone) ?? 0) + 1);
-    }
-    let winner = fallbackTimeZone;
-    let winnerCount = 0;
-    for (const [timeZone, count] of counts.entries()) {
-        if (count > winnerCount) {
-            winner = timeZone;
-            winnerCount = count;
-        }
-    }
-    return winner;
-}
-function formatCreateEventCalendarContext(context) {
-    if (!context) {
-        return "(calendar context unavailable)";
-    }
-    const lines = [
-        `Calendar timezone: ${context.calendarTimeZone}`,
-        `Context window: ${context.feed.timeMin} to ${context.feed.timeMax}`,
-    ];
-    if (context.feed.events.length === 0) {
-        lines.push("(no upcoming events in the next 2 weeks)");
-        return lines.join("\n");
-    }
-    const visibleEvents = context.feed.events.slice(0, 40);
-    for (const event of visibleEvents) {
-        const when = event.isAllDay
-            ? formatCalendarMoment(event)
-            : formatCalendarEventDateTime(event, {
-                includeTimeZoneName: true,
-                includeYear: true,
-            });
-        lines.push(`- ${when} — ${event.title}${event.location ? ` @ ${event.location}` : ""}`);
-    }
-    if (context.feed.events.length > visibleEvents.length) {
-        lines.push(`... ${context.feed.events.length - visibleEvents.length} more upcoming events omitted`);
-    }
-    return lines.join("\n");
-}
-function isPersonalCreateEvent(intent, title) {
-    return /\b(hug|wife|husband|partner|girlfriend|boyfriend|family|mom|dad|date|dinner|lunch|coffee|check in|check-in|call|text|birthday|anniversary|pick up|pickup|drop off|drop-off)\b/i.test(`${intent} ${title}`);
-}
-function resolveSuggestedCreateEventDurationMinutes(intent, title) {
-    if (isShortPreparationEvent(intent, title)) {
-        return MIN_CREATE_EVENT_DURATION_MINUTES;
-    }
-    return isPersonalCreateEvent(intent, title) ? 15 : 60;
-}
-function roundUpToStep(value, step) {
-    return Math.ceil(value / step) * step;
-}
-function overlapsBusyWindow(startMinute, durationMinutes, busyWindows) {
-    const endMinute = startMinute + durationMinutes;
-    return busyWindows.some((window) => startMinute < window.endMinute && endMinute > window.startMinute);
-}
-function busyWindowsForLocalDate(events, targetDate, timeZone) {
-    const windows = [];
-    for (const event of events) {
-        if (event.isAllDay) {
-            continue;
-        }
-        const start = getZonedDateParts(new Date(event.startAt), timeZone);
-        const end = getZonedDateParts(new Date(event.endAt), timeZone);
-        const startDate = { year: start.year, month: start.month, day: start.day };
-        const endDate = { year: end.year, month: end.month, day: end.day };
-        if (compareLocalDates(endDate, targetDate) < 0 ||
-            compareLocalDates(startDate, targetDate) > 0) {
-            continue;
-        }
-        const startMinute = compareLocalDates(startDate, targetDate) < 0
-            ? 0
-            : start.hour * 60 + start.minute;
-        const endMinute = compareLocalDates(endDate, targetDate) > 0
-            ? 24 * 60
-            : Math.max(startMinute + 1, end.hour * 60 + end.minute);
-        windows.push({ startMinute, endMinute });
-    }
-    return windows.sort((left, right) => left.startMinute - right.startMinute);
-}
-function resolvePreferredCreateEventMinutes(intent, title, targetDate) {
-    const weekday = getWeekdayForLocalDate(targetDate);
-    if (isPersonalCreateEvent(intent, title)) {
-        return [19 * 60, 20 * 60, 18 * 60 + 30, 17 * 60 + 30];
-    }
-    if (/\b(dentist|doctor|therapy|appointment|meeting|interview|review|sync)\b/i.test(`${intent} ${title}`)) {
-        return [9 * 60, 10 * 60, 11 * 60, 14 * 60, 15 * 60];
-    }
-    return weekday === 0 || weekday === 6
-        ? [10 * 60, 13 * 60, 18 * 60]
-        : [9 * 60, 11 * 60, 14 * 60, 16 * 60, 19 * 60];
-}
-function chooseSuggestedCreateEventMinute(args) {
-    for (const minute of args.preferredMinutes) {
-        if (!overlapsBusyWindow(minute, args.durationMinutes, args.busyWindows)) {
-            return minute;
-        }
-    }
-    const latestEnd = Math.max(0, ...args.busyWindows.map((window) => window.endMinute));
-    const afterLastEvent = roundUpToStep(latestEnd + 15, 15);
-    if (afterLastEvent + args.durationMinutes <= 22 * 60 &&
-        !overlapsBusyWindow(afterLastEvent, args.durationMinutes, args.busyWindows)) {
-        return afterLastEvent;
-    }
-    for (let minute = 8 * 60; minute <= 21 * 60; minute += 30) {
-        if (!overlapsBusyWindow(minute, args.durationMinutes, args.busyWindows)) {
-            return minute;
-        }
-    }
-    return null;
-}
-function suggestCreateEventStartAt(args) {
-    if (!args.calendarContext) {
-        return null;
-    }
-    const targetDate = parseExplicitLocalDate(args.currentMessage, args.calendarContext.calendarTimeZone) ??
-        parseExplicitLocalDate(args.intent, args.calendarContext.calendarTimeZone);
-    if (!targetDate) {
-        return null;
-    }
-    const durationMinutes = resolveSuggestedCreateEventDurationMinutes(args.intent, args.title);
-    const busyWindows = busyWindowsForLocalDate(args.calendarContext.feed.events, targetDate, args.calendarContext.calendarTimeZone);
-    const startMinute = chooseSuggestedCreateEventMinute({
-        busyWindows,
-        preferredMinutes: resolvePreferredCreateEventMinutes(args.intent, args.title, targetDate),
-        durationMinutes,
-    });
-    if (startMinute === null) {
-        return null;
-    }
-    return {
-        startAt: buildUtcDateFromLocalParts(args.calendarContext.calendarTimeZone, {
-            year: targetDate.year,
-            month: targetDate.month,
-            day: targetDate.day,
-            hour: Math.floor(startMinute / 60),
-            minute: startMinute % 60,
-            second: 0,
-        }).toISOString(),
-        timeZone: args.calendarContext.calendarTimeZone,
-    };
-}
-async function loadCreateEventCalendarContext(service, details, hasCalendarRead) {
-    if (!hasCalendarRead) {
-        return null;
-    }
-    const requestTimeZone = resolveCalendarTimeZone(details);
-    const feed = await service.getCalendarFeed(INTERNAL_URL, {
-        mode: detailString(details, "mode"),
-        side: detailString(details, "side"),
-        calendarId: detailString(details, "calendarId"),
-        timeZone: requestTimeZone,
-        forceSync: detailBoolean(details, "forceSync"),
-        ...buildLocalDayRange(requestTimeZone, 0, 14),
-    });
-    if (!feed || !Array.isArray(feed.events)) {
-        return null;
-    }
-    return {
-        calendarTimeZone: resolveCreateEventCalendarTimeZone(details, feed, requestTimeZone),
-        feed,
-    };
-}
-function normalizeIsoDateTime(value) {
-    if (typeof value !== "string" || value.trim().length === 0) {
-        return undefined;
-    }
-    const parsed = Date.parse(value.trim());
-    return Number.isFinite(parsed) ? new Date(parsed).toISOString() : undefined;
-}
-function normalizeWindowLabel(value) {
-    if (typeof value !== "string") {
-        return undefined;
-    }
-    const cleaned = value.trim();
-    return cleaned.length > 0 && cleaned.length <= 80 ? cleaned : undefined;
-}
-function resolveCalendarLlmWindow(llmPlan) {
-    const timeMin = normalizeIsoDateTime(llmPlan?.timeMin);
-    const timeMax = normalizeIsoDateTime(llmPlan?.timeMax);
-    if (!timeMin || !timeMax) {
-        return null;
-    }
-    const minMs = Date.parse(timeMin);
-    const maxMs = Date.parse(timeMax);
-    const spanMs = maxMs - minMs;
-    if (!Number.isFinite(spanMs) ||
-        spanMs <= 0 ||
-        spanMs > 370 * 24 * 60 * 60 * 1000) {
-        return null;
-    }
-    return {
-        timeMin,
-        timeMax,
-        label: normalizeWindowLabel(llmPlan?.windowLabel) ?? "for the requested window",
-    };
-}
-function resolveWeekendWindow(timeZone, modifier) {
-    const localToday = getLocalTodayDate(timeZone);
-    const currentWeekday = getWeekdayForLocalDate(localToday);
-    let startOffsetDays = (6 - currentWeekday + 7) % 7;
-    let endOffsetFromToday = startOffsetDays + 2;
-    if (modifier === "this" && (currentWeekday === 6 || currentWeekday === 0)) {
-        startOffsetDays = 0;
-        endOffsetFromToday = currentWeekday === 6 ? 2 : 1;
-    }
-    if (modifier === "next") {
-        startOffsetDays += 7;
-        endOffsetFromToday += 7;
-    }
-    const startDay = addDaysToLocalDate(localToday, startOffsetDays);
-    const endDay = addDaysToLocalDate(localToday, endOffsetFromToday);
-    return buildLocalDateRange(timeZone, startDay, endDay);
-}
-function resolveMonthWindow(timeZone, modifier) {
-    const localToday = getLocalTodayDate(timeZone);
-    if (modifier === "this") {
-        const endOfWindow = addMonthsToLocalDate({
-            year: localToday.year,
-            month: localToday.month,
-            day: 1,
-        }, 1);
-        return buildLocalDateRange(timeZone, localToday, endOfWindow);
-    }
-    const startOfNextMonth = addMonthsToLocalDate({
-        year: localToday.year,
-        month: localToday.month,
-        day: 1,
-    }, 1);
-    const startOfFollowingMonth = addMonthsToLocalDate(startOfNextMonth, 1);
-    return buildLocalDateRange(timeZone, startOfNextMonth, startOfFollowingMonth);
-}
-function resolveTonightWindow(timeZone) {
-    const localNow = getZonedDateParts(new Date(), timeZone);
-    const startHour = Math.max(localNow.hour, 17);
-    const startMinute = localNow.hour >= 17 ? localNow.minute : 0;
-    const startDay = {
-        year: localNow.year,
-        month: localNow.month,
-        day: localNow.day,
-    };
-    const endDay = addDaysToLocalDate(startDay, 1);
-    return buildLocalDateRange(timeZone, startDay, endDay, {
-        startHour,
-        startMinute,
-    });
-}
-// Wide window used by update_event / delete_event lookups when the user
-// gave no time hint. Reaches 1 year back and 5 years forward — far enough
-// to find a future birthday or a recent past meeting without scanning the
-// entire account.
-function buildWideLookupRange(timeZone) {
-    return buildLocalDayRange(timeZone, -365, 365 * 5);
-}
-function resolveCalendarWindow(intent, details, forSearch, llmPlan) {
-    const timeMin = detailString(details, "timeMin");
-    const timeMax = detailString(details, "timeMax");
-    const calendarId = detailString(details, "calendarId");
-    const timeZone = resolveCalendarTimeZone(details);
-    const forceSync = detailBoolean(details, "forceSync");
-    if (timeMin || timeMax) {
-        return {
-            request: {
-                calendarId,
-                timeMin: timeMin ?? undefined,
-                timeMax: timeMax ?? undefined,
-                timeZone,
-                forceSync,
-            },
-            label: detailString(details, "label") ?? "for the requested window",
-        };
-    }
-    const llmWindow = resolveCalendarLlmWindow(llmPlan);
-    if (llmWindow) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                timeMin: llmWindow.timeMin,
-                timeMax: llmWindow.timeMax,
-            },
-            label: llmWindow.label,
-        };
-    }
-    const normalizedIntent = normalizeText(intent);
-    const explicitDate = parseExplicitLocalDate(normalizedIntent, timeZone);
-    if (explicitDate) {
-        const nextDate = addDaysToLocalDate(explicitDate, 1);
-        const explicitDateLabel = (normalizedIntent.match(/(?:on|for)\s+(.+)$/i)?.[1] ?? normalizedIntent)
-            .replace(/^(?:on|for)\s+/i, "")
-            .trim();
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                timeMin: buildUtcDateFromLocalParts(timeZone, {
-                    year: explicitDate.year,
-                    month: explicitDate.month,
-                    day: explicitDate.day,
-                    hour: 0,
-                    minute: 0,
-                    second: 0,
-                }).toISOString(),
-                timeMax: buildUtcDateFromLocalParts(timeZone, {
-                    year: nextDate.year,
-                    month: nextDate.month,
-                    day: nextDate.day,
-                    hour: 0,
-                    minute: 0,
-                    second: 0,
-                }).toISOString(),
-            },
-            label: `on ${explicitDateLabel}`,
-        };
-    }
-    if (/\btonight\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...resolveTonightWindow(timeZone),
-            },
-            label: "tonight",
-        };
-    }
-    if (/\bnext week\b/.test(normalizedIntent) &&
-        /\b(?:week after next|the week after)\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...buildLocalDayRange(timeZone, 7, 21),
-            },
-            label: "next week or the week after",
-        };
-    }
-    if (/\btomorrow\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...buildLocalDayRange(timeZone, 1, 2),
-            },
-            label: "tomorrow",
-        };
-    }
-    if (/\bnext weekend\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...resolveWeekendWindow(timeZone, "next"),
-            },
-            label: "next weekend",
-        };
-    }
-    if (/\b(?:this weekend|weekend)\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...resolveWeekendWindow(timeZone, "this"),
-            },
-            label: "this weekend",
-        };
-    }
-    if (/\b(?:week after next|the week after)\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...buildLocalDayRange(timeZone, 14, 21),
-            },
-            label: "the week after next",
-        };
-    }
-    if (/\bnext week\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...buildLocalDayRange(timeZone, 7, 14),
-            },
-            label: "next week",
-        };
-    }
-    if (/\b(this week|week)\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...buildLocalDayRange(timeZone, 0, 7),
-            },
-            label: "this week",
-        };
-    }
-    if (/\bnext month\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...resolveMonthWindow(timeZone, "next"),
-            },
-            label: "next month",
-        };
-    }
-    if (/\bthis month\b/.test(normalizedIntent)) {
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...resolveMonthWindow(timeZone, "this"),
-            },
-            label: "this month",
-        };
-    }
-    const windowDays = detailNumber(details, "windowDays");
-    if (forSearch) {
-        const days = windowDays && windowDays > 0 ? Math.min(windowDays, 90) : 30;
-        return {
-            request: {
-                calendarId,
-                timeZone,
-                forceSync,
-                ...buildLocalDayRange(timeZone, 0, days),
-            },
-            label: `across the next ${days} days`,
-        };
-    }
-    return {
-        request: {
-            calendarId,
-            timeZone,
-            forceSync,
-            ...buildLocalDayRange(timeZone, 0, 1),
-        },
-        label: "today",
-    };
-}
-function resolveTripWindowRequest(details, llmPlan) {
-    const timeMin = detailString(details, "timeMin");
-    const timeMax = detailString(details, "timeMax");
-    const calendarId = detailString(details, "calendarId");
-    const timeZone = resolveCalendarTimeZone(details);
-    const forceSync = detailBoolean(details, "forceSync");
-    if (timeMin || timeMax) {
-        return {
-            calendarId,
-            timeMin: timeMin ?? undefined,
-            timeMax: timeMax ?? undefined,
-            timeZone,
-            forceSync,
-        };
-    }
-    const llmWindow = resolveCalendarLlmWindow(llmPlan);
-    if (llmWindow) {
-        return {
-            calendarId,
-            timeZone,
-            forceSync,
-            timeMin: llmWindow.timeMin,
-            timeMax: llmWindow.timeMax,
-        };
-    }
-    const windowDays = detailNumber(details, "windowDays");
-    const days = windowDays && windowDays > 0 ? Math.min(windowDays, 120) : 60;
-    return {
-        calendarId,
-        timeZone,
-        forceSync,
-        ...buildLocalDayRange(timeZone, 0, days),
-    };
-}
-function inferCalendarSearchQuery(intent) {
-    const normalizedIntent = normalizeText(intent);
-    if (/\b(flight|flights|fly|flying|travel|trip)\b/.test(normalizedIntent)) {
-        const locationMatch = normalizedIntent.match(/\b(?:from|to)\s+(.+?)(?=\b(?:today|tomorrow|tonight|this week(?:end)?|next week(?:end)?|week after(?: next)?|this month|next month|this year|next year|or|and|please|idk|i dk|i don't know)\b|[?.!,]|$)/i);
-        const parts = ["flight"];
-        if (/\b(return|back|home)\b/.test(normalizedIntent)) {
-            parts.push("return");
-        }
-        const location = normalizeCalendarSearchQueryValue(locationMatch?.[1] ?? "");
-        if (location) {
-            parts.push(location);
-        }
-        return normalizeCalendarSearchQueryValue(parts.join(" ")) ?? "flight";
-    }
-    const dateMatch = normalizedIntent.match(/\b(?:on|for)\s+((?:jan(?:uary)?|feb(?:ruary)?|mar(?:ch)?|apr(?:il)?|may|jun(?:e)?|jul(?:y)?|aug(?:ust)?|sep(?:t(?:ember)?)?|oct(?:ober)?|nov(?:ember)?|dec(?:ember)?)\.?\s+\d{1,2}(?:st|nd|rd|th)?(?:,?\s+\d{4})?|\d{1,2}[/-]\d{1,2}(?:[/-]\d{2,4})?|\d{4}-\d{1,2}-\d{1,2})\b/i);
-    const normalizedDate = normalizeCalendarSearchQueryValue(dateMatch?.[1]);
-    if (normalizedDate) {
-        return normalizedDate;
-    }
-    const patterns = [
-        /^(?:please\s+)?(?:find|search(?: for)?|look(?:ing)? for|show me)\s+(.+)$/i,
-        /^(?:please\s+)?(?:do i have|are there)\s+(?:any\s+)?(.+?)(?:\?|$)/i,
-        /^(?:please\s+)?(?:check|look|see)\s+(?:my\s+)?calendar\s+for\s+(.+?)(?:\?|$)/i,
-        /^what\s+(?:event|events)\s+do\s+i\s+have\s+(?:on|for)\s+(.+?)(?:\?|$)/i,
-        /^(?:please\s+)?any\s+(.+?)(?:\?|$)/i,
-    ];
-    for (const pattern of patterns) {
-        const match = normalizedIntent.match(pattern);
-        const value = normalizeCalendarSearchQueryValue(match?.[1] ?? "");
-        if (value) {
-            return value;
-        }
-    }
-    return undefined;
-}
-function inferCalendarSearchQueries(intent) {
-    const normalizedIntent = normalizeText(intent);
-    const queries = new Set();
-    const push = (value) => {
-        const normalized = normalizeCalendarSearchQueryValue(value);
-        if (normalized) {
-            queries.add(normalized);
-        }
-    };
-    push(inferCalendarSearchQuery(intent));
-    if (/\b(return|back|home)\b/.test(normalizedIntent)) {
-        const locationMatch = normalizedIntent.match(/\b(?:from|to)\s+(.+?)(?=\b(?:today|tomorrow|tonight|this week(?:end)?|next week(?:end)?|week after(?: next)?|this month|next month|this year|next year|or|and|please|idk|i dk|i don't know)\b|[?.!,]|$)/i);
-        const location = normalizeCalendarSearchQueryValue(locationMatch?.[1] ?? "");
-        push(`return flight${location ? ` ${location}` : ""}`);
-        if (location) {
-            push(`flight back ${location}`);
-            push(`${location} return flight`);
-        }
-    }
-    return [...queries];
-}
-function sanitizeCalendarQuery(query, intent) {
-    if (!query) {
-        return undefined;
-    }
-    const raw = normalizeText(query);
-    if (PARAMETER_DOC_NOISE_PATTERN.test(raw) ||
-        raw.includes("supported keys include") ||
-        raw.includes("match against titles") ||
-        raw.includes("structured calendar arguments")) {
-        return undefined;
-    }
-    const cleaned = normalizeCalendarSearchQueryValue(query);
-    if (!cleaned ||
-        PARAMETER_DOC_NOISE_PATTERN.test(cleaned) ||
-        textMatchesAnyCal(cleaned, CAL_TEMPORAL_FOLLOWUP_TERMS) ||
-        looksLikeLiteralRequestEcho(cleaned, intent) ||
-        cleaned.length > 160) {
-        return undefined;
-    }
-    const inferred = inferCalendarSearchQuery(intent);
-    if (inferred &&
-        looksLikeNarrativeCalendarQuery(cleaned) &&
-        normalizeText(inferred) !== normalizeText(cleaned)) {
-        return undefined;
-    }
-    return cleaned;
-}
-function scoreCalendarQueryCandidate(query, intent) {
-    const normalized = normalizeText(query);
-    if (!normalized) {
-        return Number.NEGATIVE_INFINITY;
-    }
-    let score = 0;
-    if (PARAMETER_DOC_NOISE_PATTERN.test(normalized)) {
-        score -= 500;
-    }
-    if (looksLikeNarrativeCalendarQuery(normalized)) {
-        score -= 120;
-    }
-    if (looksLikeLiteralRequestEcho(query, intent)) {
-        score -= 120;
-    }
-    if (textMatchesAnyCal(normalized, CAL_TEMPORAL_FOLLOWUP_TERMS)) {
-        score -= 120;
-    }
-    const tokens = tokenizeForSearch(normalized);
-    if (tokens.length <= 4) {
-        score += 12;
-    }
-    else if (tokens.length >= 8) {
-        score -= 15;
-    }
-    const inferredQueries = inferCalendarSearchQueries(intent).map((value) => normalizeText(value));
-    if (inferredQueries.includes(normalized)) {
-        score += 60;
-    }
-    for (const inferredQuery of inferredQueries) {
-        if (!inferredQuery) {
-            continue;
-        }
-        if (normalized.includes(inferredQuery) ||
-            inferredQuery.includes(normalized)) {
-            score += 18;
-        }
-        const inferredTokens = new Set(tokenizeForSearch(inferredQuery));
-        score += tokens.filter((token) => inferredTokens.has(token)).length * 8;
-    }
-    if (/\b(flight|flights|travel|trip|return|back|home)\b/.test(normalizeText(intent)) &&
-        /\b(flight|flights|travel|trip|return|back|home)\b/.test(normalized)) {
-        score += 12;
-    }
-    return score;
-}
-function eventDateSearchTerms(event) {
-    const formatter = (options) => new Intl.DateTimeFormat("en-US", {
-        timeZone: event.timezone || undefined,
-        ...options,
-    }).format(new Date(event.startAt));
-    const monthLong = normalizeText(formatter({ month: "long" }).replace(/\./g, ""));
-    const monthShort = normalizeText(formatter({ month: "short" }).replace(/\./g, ""));
-    const weekdayLong = normalizeText(formatter({ weekday: "long" }));
-    const weekdayShort = normalizeText(formatter({ weekday: "short" }));
-    const day = formatter({ day: "numeric" });
-    const dayPadded = day.padStart(2, "0");
-    const monthNumeric = formatter({ month: "numeric" });
-    const monthPadded = monthNumeric.padStart(2, "0");
-    const year = formatter({ year: "numeric" });
-    return new Set([
-        `${monthLong} ${day}`,
-        `${monthLong} ${day} ${year}`,
-        `${monthShort} ${day}`,
-        `${monthShort} ${day} ${year}`,
-        `${weekdayLong} ${monthLong} ${day}`,
-        `${weekdayShort} ${monthShort} ${day}`,
-        `${monthNumeric}/${day}`,
-        `${monthNumeric}/${dayPadded}`,
-        `${monthPadded}/${day}`,
-        `${monthPadded}/${dayPadded}`,
-        `${year}-${monthPadded}-${dayPadded}`,
-        weekdayLong,
-        weekdayShort,
-    ].map((term) => normalizeText(term)));
-}
-async function extractCalendarSearchQueriesWithLlm(runtime, message, state, intent, timeZone) {
-    return (await extractCalendarPlanWithLlm(runtime, message, state, intent, timeZone)).queries;
-}
-export async function extractCalendarPlanWithLlm(runtime, message, state, intent, timeZone = resolveDefaultTimeZone()) {
-    const recentConversation = formatCreateEventRecentConversation(state);
-    const currentMessage = messageText(message).trim();
-    const now = new Date();
-    const nowIso = now.toISOString();
-    const localNow = new Intl.DateTimeFormat("en-US", {
-        timeZone,
-        dateStyle: "full",
-        timeStyle: "long",
-    }).format(now);
-    const prompt = [
-        "Plan the calendar action for this request.",
-        "The user may speak in any language.",
-        "Use the current request plus recent conversation context.",
-        "If the current request is vague or a follow-up, recover the subject from recent conversation and apply the new constraint from the current request.",
-        "You are allowed to decide that the assistant should reply naturally without acting yet.",
-        "Set shouldAct=false when the user is vague, only acknowledging, brainstorming, or asking for calendar help without enough specifics to safely act.",
-        "When shouldAct=false, provide a short natural response that asks only for what is missing.",
-        "",
-        "Return a JSON object with exactly these fields:",
-        "  subaction: one of the allowed subactions below, or null when this should be reply-only/no-op",
-        "  shouldAct: boolean",
-        "  response: short natural-language reply when shouldAct is false, otherwise empty or null",
-        "  queries: array or ||-delimited string of up to 3 search queries",
-        "  title: optional event title",
-        "  tripLocation: optional trip location",
-        "  timeMin: optional ISO 8601 datetime",
-        "  timeMax: optional ISO 8601 datetime",
-        "  windowLabel: optional natural-language window label",
-        "",
-        "Subactions and when to use each:",
-        "  feed — view today's, tomorrow's, or this week's schedule (e.g. 'what's on my calendar', 'what do I have today', 'this week's agenda')",
-        "  next_event — check the next upcoming event only (e.g. 'what's my next meeting', 'when is my next appointment')",
-        "  search_events — find events by title, attendee, location, or date range (e.g. 'find my flight', 'when is the dentist', 'meetings with John')",
-        "  create_event — schedule a new event (e.g. 'schedule a meeting tomorrow at 3pm', 'add lunch with Sarah on Friday')",
-        "  update_event — rename, reschedule, move, or edit an existing event (e.g. 'rename my meeting to standup', 'reschedule the dentist to Friday', 'move the call to 3pm')",
-        "  delete_event — remove or cancel an existing event (e.g. 'delete the team meeting', 'cancel my appointment', 'remove the duplicate event')",
-        "  trip_window — query what's happening during a trip or stay in a specific place (e.g. 'what's happening while I'm in Denver', 'my Tokyo itinerary')",
-        "",
-        "For feed, search_events, or trip_window, infer an exact timeMin/timeMax window when the request names or implies a date or date range.",
-        "timeMin and timeMax must be ISO 8601 datetimes that the API can use directly.",
-        "windowLabel should be a short natural-language label like on monday, this weekend, next month, or tonight.",
-        "For search_events or trip_window, extract up to 3 short search queries.",
-        "Preserve names, places, and keywords in their original language or script when useful.",
-        "Convert time constraints into concise searchable dates or windows even if the user phrases them in another language.",
-        "Focus on people, places, flights, itinerary, appointments, and explicit dates.",
-        "If the request is about a date, include a date query like april 12 or 2026-04-12.",
-        "If the request asks what is happening while the user is in a place, use trip_window and include tripLocation.",
-        "",
-        "Examples:",
-        '  "what\'s on my calendar tomorrow" → {"subaction":"feed","shouldAct":true,"response":null}',
-        '  "schedule a meeting with Alex at 3pm" → {"subaction":"create_event","shouldAct":true,"response":null,"title":"Meeting with Alex"}',
-        '  "find my return flight" → {"subaction":"search_events","shouldAct":true,"response":null,"queries":["return flight"]}',
-        '  "what do I have while I\'m in Tokyo" → {"subaction":"trip_window","shouldAct":true,"response":null,"queries":["tokyo"],"tripLocation":"Tokyo"}',
-        '  "rename my meeting to standup" → {"subaction":"update_event","shouldAct":true,"response":null,"queries":["meeting"],"title":"standup"}',
-        '  "delete the team meeting tomorrow" → {"subaction":"delete_event","shouldAct":true,"response":null,"queries":["team meeting"]}',
-        '  "can you help me with my calendar?" → {"subaction":null,"shouldAct":false,"response":"What do you want to do on your calendar — check your schedule, find an event, or create one?","queries":[]}',
-        "",
-        "The user may speak any language. Detect the calendar intent regardless of language.",
-        "When the user asks about what is happening in a specific location or during a trip, detect this as trip_window and extract the location, regardless of language.",
-        "",
-        "Return ONLY valid JSON. No prose. No markdown. No XML. No <think>.",
-        "",
-        `Current timezone: ${timeZone}`,
-        `Current local datetime: ${localNow}`,
-        `Current ISO datetime: ${nowIso}`,
-        "",
-        "<current_request>",
-        currentMessage,
-        "</current_request>",
-        "<resolved_intent>",
-        intent,
-        "</resolved_intent>",
-        "<recent_conversation>",
-        recentConversation,
-        "</recent_conversation>",
-    ].join("\n");
-    let rawResponse = "";
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_LARGE, {
-            prompt,
-        });
-        rawResponse = typeof result === "string" ? result : "";
-    }
-    catch (error) {
-        runtime.logger?.warn?.({
-            src: "action:calendar",
-            error: error instanceof Error ? error.message : String(error),
-        }, "Calendar action planning model call failed");
-        return {
-            subaction: null,
-            queries: [],
-            shouldAct: null,
-        };
-    }
-    const parsed = parseKeyValueXml(rawResponse) ??
-        parseJSONObjectFromText(rawResponse);
-    if (!parsed) {
-        return {
-            subaction: null,
-            queries: [],
-            shouldAct: null,
-        };
-    }
-    const tripLocation = typeof parsed.tripLocation === "string" &&
-        parsed.tripLocation.trim().length > 0
-        ? parsed.tripLocation.trim()
-        : undefined;
-    // Extract queries from multiple possible shapes:
-    // - TOON string: "flight || dentist" (split on ||)
-    // - TOON single: "return flight" (no delimiter)
-    // - JSON array: ["flight", "dentist"]
-    // - Numbered fallbacks: query1, query2, query3
-    const rawQueries = [];
-    if (typeof parsed.queries === "string" && parsed.queries.trim().length > 0) {
-        for (const q of parsed.queries.split(/\s*\|\|\s*/)) {
-            if (q.trim().length > 0)
-                rawQueries.push(q.trim());
-        }
-    }
-    else if (Array.isArray(parsed.queries)) {
-        for (const value of parsed.queries) {
-            if (typeof value === "string")
-                rawQueries.push(value);
-        }
-    }
-    if (typeof parsed.query === "string")
-        rawQueries.push(parsed.query);
-    if (typeof parsed.query1 === "string")
-        rawQueries.push(parsed.query1);
-    if (typeof parsed.query2 === "string")
-        rawQueries.push(parsed.query2);
-    if (typeof parsed.query3 === "string")
-        rawQueries.push(parsed.query3);
-    if (tripLocation)
-        rawQueries.push(tripLocation);
-    return {
-        subaction: normalizeCalendarSubaction(parsed.subaction),
-        queries: dedupeCalendarQueries(rawQueries),
-        response: normalizePlannerResponse(parsed.response),
-        shouldAct: normalizeShouldAct(parsed.shouldAct),
-        title: typeof parsed.title === "string" && parsed.title.trim().length > 0
-            ? parsed.title.trim()
-            : undefined,
-        tripLocation,
-        timeMin: normalizeIsoDateTime(parsed.timeMin),
-        timeMax: normalizeIsoDateTime(parsed.timeMax),
-        windowLabel: normalizeWindowLabel(parsed.windowLabel ?? parsed.label),
-    };
-}
-async function resolveCalendarSearchQueries(runtime, message, state, explicitQueries, intent, llmPlan, timeZone) {
-    const providedQueries = dedupeCalendarQueries(explicitQueries.map((query) => sanitizeCalendarQuery(query, intent)));
-    const heuristicQueries = inferCalendarSearchQueries(intent);
-    const llmQueries = llmPlan && llmPlan.queries.length > 0
-        ? llmPlan.queries
-        : await extractCalendarSearchQueriesWithLlm(runtime, message, state, intent, timeZone);
-    const stateQueries = userIntentsFromState(state)
-        .reverse()
-        .flatMap((candidate) => inferCalendarSearchQueries(candidate));
-    const candidates = dedupeCalendarQueries([
-        ...providedQueries,
-        ...llmQueries,
-        ...heuristicQueries,
-        ...stateQueries,
-    ].map((query) => sanitizeCalendarQuery(query, intent)));
-    return [...candidates].sort((left, right) => scoreCalendarQueryCandidate(right, intent) -
-        scoreCalendarQueryCandidate(left, intent));
-}
-function inferCreateEventTitle(intent) {
-    const patterns = [
-        /\b(?:create|add|schedule|book|put)\s+(?:a|an|the)?\s*(.+?)(?=\b(?:for|on|at|tomorrow|today|tonight|next|this|from)\b|[?.!,]|$)/i,
-        /\b(?:meeting|appointment|call|event)\s+(?:with|for)\s+(.+?)(?=\b(?:for|on|at|tomorrow|today|tonight|next|this|from)\b|[?.!,]|$)/i,
-    ];
-    for (const pattern of patterns) {
-        const match = intent.match(pattern);
-        const value = match?.[1]?.trim();
-        if (value && !/^(calendar|event|meeting|appointment|call)$/i.test(value)) {
-            return value.replace(/\s+/g, " ").trim();
-        }
-    }
-    return undefined;
-}
-function isShortPreparationEvent(intent, title) {
-    return /\b(get ready|ready for|prep|prepare|packing|pack|leave for|head to|airport|flight|reminder|remind me)\b/i.test(`${intent} ${title}`);
-}
-function resolveCreateEventDurationMinutes(args) {
-    const { explicitDuration, extractedDuration, intent, title, hasExplicitEndAt, hasExplicitWindowPreset, hasExplicitStartAt, } = args;
-    if (typeof explicitDuration === "number" &&
-        Number.isFinite(explicitDuration)) {
-        return explicitDuration > 0 ? explicitDuration : undefined;
-    }
-    if (typeof extractedDuration === "number" &&
-        Number.isFinite(extractedDuration)) {
-        if (extractedDuration > 0) {
-            return extractedDuration;
-        }
-        if (isShortPreparationEvent(intent, title) &&
-            (hasExplicitStartAt || hasExplicitWindowPreset)) {
-            return MIN_CREATE_EVENT_DURATION_MINUTES;
-        }
-        return undefined;
-    }
-    if (!hasExplicitEndAt &&
-        isShortPreparationEvent(intent, title) &&
-        (hasExplicitStartAt || hasExplicitWindowPreset)) {
-        return MIN_CREATE_EVENT_DURATION_MINUTES;
-    }
-    return undefined;
-}
-function parseCreateEventDurationValue(value) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-        return value;
-    }
-    if (typeof value === "string") {
-        const parsed = Number(value);
-        return Number.isFinite(parsed) ? parsed : undefined;
-    }
-    return undefined;
-}
-function pickCreateEventStringField(args, key) {
-    const explicit = detailString(args.details, key);
-    const extracted = detailString(args.extractedDetails, key);
-    const fallback = args.fallbackRequest &&
-        typeof args.fallbackRequest[key] === "string"
-        ? args.fallbackRequest[key]
-        : undefined;
-    return args.preferExtractedDetails
-        ? (extracted ?? explicit ?? fallback)
-        : (explicit ?? extracted ?? fallback);
-}
-function buildCreateEventRequest(args) {
-    const extractedTitle = detailString(args.extractedDetails, "title");
-    const title = args.preferExtractedDetails
-        ? (extractedTitle ??
-            args.explicitTitle ??
-            args.fallbackRequest?.title ??
-            args.inferredTitle)
-        : (args.explicitTitle ??
-            extractedTitle ??
-            args.fallbackRequest?.title ??
-            args.inferredTitle);
-    const explicitStartAt = detailString(args.details, "startAt");
-    const explicitEndAt = detailString(args.details, "endAt");
-    const explicitWindowPreset = detailString(args.details, "windowPreset");
-    const extractedStartAt = detailString(args.extractedDetails, "startAt");
-    const extractedEndAt = detailString(args.extractedDetails, "endAt");
-    const extractedWindowPreset = detailString(args.extractedDetails, "windowPreset");
-    let resolvedStartAt;
-    let resolvedWindowPreset;
-    if (args.preferExtractedDetails && extractedStartAt) {
-        resolvedStartAt = extractedStartAt;
-        resolvedWindowPreset = undefined;
-    }
-    else if (args.preferExtractedDetails && extractedWindowPreset) {
-        resolvedStartAt = undefined;
-        resolvedWindowPreset = extractedWindowPreset;
-    }
-    else {
-        resolvedStartAt =
-            explicitStartAt ?? extractedStartAt ?? args.fallbackRequest?.startAt;
-        resolvedWindowPreset = resolvedStartAt
-            ? undefined
-            : (explicitWindowPreset ??
-                extractedWindowPreset ??
-                args.fallbackRequest?.windowPreset);
-    }
-    const rawEndAt = args.preferExtractedDetails &&
-        (extractedStartAt || extractedWindowPreset) &&
-        !extractedEndAt
-        ? undefined
-        : args.preferExtractedDetails
-            ? (extractedEndAt ?? explicitEndAt ?? args.fallbackRequest?.endAt)
-            : (explicitEndAt ?? extractedEndAt ?? args.fallbackRequest?.endAt);
-    const explicitDuration = detailNumber(args.details, "durationMinutes");
-    const extractedDuration = parseCreateEventDurationValue(args.extractedDetails.durationMinutes);
-    const fallbackDuration = args.fallbackRequest?.durationMinutes;
-    const durationMinutes = resolveCreateEventDurationMinutes({
-        explicitDuration: explicitDuration,
-        extractedDuration,
-        intent: args.intent,
-        title: title ?? args.fallbackRequest?.title ?? "",
-        hasExplicitEndAt: Boolean(rawEndAt),
-        hasExplicitWindowPreset: Boolean(resolvedWindowPreset),
-        hasExplicitStartAt: Boolean(resolvedStartAt),
-    });
-    const resolvedDurationMinutes = explicitDuration !== undefined || extractedDuration !== undefined
-        ? durationMinutes
-        : fallbackDuration;
-    return {
-        title,
-        resolvedStartAt,
-        resolvedWindowPreset,
-        request: {
-            mode: detailString(args.details, "mode") ?? args.fallbackRequest?.mode,
-            side: (detailString(args.details, "side") ?? args.fallbackRequest?.side),
-            calendarId: detailString(args.details, "calendarId") ??
-                args.fallbackRequest?.calendarId,
-            title: title ?? "",
-            description: pickCreateEventStringField(args, "description") ??
-                args.fallbackRequest?.description,
-            location: pickCreateEventStringField(args, "location") ??
-                args.fallbackRequest?.location,
-            startAt: resolvedStartAt,
-            endAt: rawEndAt ?? args.fallbackRequest?.endAt,
-            timeZone: pickCreateEventStringField(args, "timeZone") ??
-                args.fallbackRequest?.timeZone,
-            durationMinutes: resolvedDurationMinutes,
-            windowPreset: resolvedWindowPreset,
-            attendees: normalizeCalendarAttendees(args.details) ??
-                args.fallbackRequest?.attendees,
-        },
-    };
-}
-function createEventRequestFingerprint(request) {
-    return JSON.stringify({
-        title: request.title,
-        description: request.description ?? null,
-        location: request.location ?? null,
-        startAt: request.startAt ?? null,
-        endAt: request.endAt ?? null,
-        timeZone: request.timeZone ?? null,
-        durationMinutes: request.durationMinutes ?? null,
-        windowPreset: request.windowPreset ?? null,
-        calendarId: request.calendarId ?? null,
-        side: request.side ?? null,
-        mode: request.mode ?? null,
-    });
-}
-function formatCreateEventRecentConversation(state) {
-    const conversation = planningConversationLines(state).join("\n").trim();
-    return conversation.length > 0 ? conversation : "(none)";
-}
-function parseCreateEventExtractionResponse(rawResponse) {
-    const parsed = parseKeyValueXml(rawResponse);
-    return parsed && typeof parsed === "object" ? parsed : {};
-}
-function formatUpdateEventTargetContext(event) {
-    if (!event) {
-        return "(unknown)";
-    }
-    const attendees = event.attendees
-        .map((attendee) => attendee.displayName ?? attendee.email ?? "")
-        .filter((value) => value.length > 0)
-        .join(", ");
-    return [
-        `title: ${event.title}`,
-        `startAt: ${event.startAt}`,
-        `endAt: ${event.endAt}`,
-        `timeZone: ${event.timezone ?? ""}`,
-        `formattedStart: ${formatCalendarEventDateTime(event, {
-            includeTimeZoneName: true,
-        })}`,
-        `location: ${event.location ?? ""}`,
-        `description: ${event.description ?? ""}`,
-        `attendees: ${attendees}`,
-    ].join("\n");
-}
-function shouldRetryCreateEventExtraction(error) {
-    const normalized = normalizeText(error.message);
-    if (error.status === 401 || error.status === 403) {
-        return false;
-    }
-    if (/\b(?:not connected|needs re-authentication|unauthorized|forbidden|permission|scope|grant)\b/.test(normalized)) {
-        return false;
-    }
-    return (error.status === 400 ||
-        error.status === 409 ||
-        /\b(?:startat|endat|duration|windowpreset|date|time|timezone|datetime|later than|invalid|bad request|parse|format)\b/.test(normalized));
-}
-async function inferCreateEventDetails(runtime, message, state, intent, calendarContext, fallbackTimeZone = resolveDefaultTimeZone()) {
-    const recentConversation = formatCreateEventRecentConversation(state);
-    const currentMessage = messageText(message).trim();
-    // Anchor the LLM in the present so relative phrases ("tomorrow", "next
-    // friday", "april 15") and explicit-but-yearless dates resolve to the
-    // correct ISO datetime instead of guessing or returning empty.
-    const now = new Date();
-    const nowIso = now.toISOString();
-    const timeZone = fallbackTimeZone;
-    const calendarTimeZone = calendarContext?.calendarTimeZone ?? fallbackTimeZone;
-    const nowReadable = new Intl.DateTimeFormat("en-US", {
-        timeZone,
-        dateStyle: "full",
-        timeStyle: "long",
-    }).format(now);
-    const prompt = [
-        "Extract calendar event creation fields from the request.",
-        "The user may speak in any language.",
-        "Use the full recent conversation below, not just the latest message.",
-        "Treat the latest user request as authoritative, but recover missing event subject, date, or location from earlier turns when needed.",
-        "If the current request is a follow-up, recover the event subject from recent conversation and apply new timing or location constraints from the current request.",
-        "Use the calendar context below to ground any timing guess.",
-        "Preserve names and places in their original language or script when useful.",
-        "Return XML only. No prose. Leave fields empty when unknown.",
-        "If a start time or window is implied but duration is not explicit, infer a reasonable positive duration.",
-        "For short prep or reminder blocks, use at least 15 minutes instead of 0.",
-        "When the user gives a concrete day or date without an exact time-of-day, use the calendar context to infer a plausible open startAt in the calendar timezone. Avoid obvious overlaps with nearby events. If the calendar context is unavailable or the timing is ambiguous, leave startAt empty.",
-        "Only use windowPreset for explicit 'tomorrow morning|afternoon|evening' phrasing — never as a fallback for arbitrary dates.",
-        "",
-        "<response>",
-        "  <title>event title</title>",
-        "  <description>optional description</description>",
-        "  <location>optional location</location>",
-        "  <startAt>ISO datetime if explicit or resolvable from a date phrase</startAt>",
-        "  <endAt>ISO datetime if explicit</endAt>",
-        "  <durationMinutes>number if implied</durationMinutes>",
-        "  <windowPreset>tomorrow_morning|tomorrow_afternoon|tomorrow_evening</windowPreset>",
-        "  <timeZone>IANA timezone if stated</timeZone>",
-        "</response>",
-        "",
-        `Current timezone: ${timeZone}`,
-        `Calendar timezone for scheduling: ${calendarTimeZone}`,
-        `Current local datetime: ${nowReadable}`,
-        `Current ISO datetime: ${nowIso}`,
-        "",
-        "<current_request>",
-        currentMessage,
-        "</current_request>",
-        "<resolved_intent>",
-        intent,
-        "</resolved_intent>",
-        "<recent_conversation>",
-        recentConversation,
-        "</recent_conversation>",
-        "<calendar_context>",
-        formatCreateEventCalendarContext(calendarContext),
-        "</calendar_context>",
-    ].join("\n");
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-        const rawResponse = typeof result === "string" ? result : "";
-        return parseCreateEventExtractionResponse(rawResponse);
-    }
-    catch (error) {
-        runtime.logger?.warn?.({
-            src: "action:calendar",
-            error: error instanceof Error ? error.message : String(error),
-        }, "Calendar create-event extraction model call failed");
-        return {};
-    }
-}
-async function inferUpdateEventDetails(runtime, message, state, intent, targetEvent, fallbackTimeZone = targetEvent?.timezone ?? resolveDefaultTimeZone()) {
-    const recentConversation = formatCreateEventRecentConversation(state);
-    const currentMessage = messageText(message).trim();
-    const now = new Date();
-    const nowIso = now.toISOString();
-    const timeZone = fallbackTimeZone;
-    const nowReadable = new Intl.DateTimeFormat("en-US", {
-        timeZone,
-        dateStyle: "full",
-        timeStyle: "long",
-    }).format(now);
-    const prompt = [
-        "Extract calendar event update fields from the request.",
-        "The user may speak in any language.",
-        "Use the full recent conversation below, not just the latest message.",
-        "The current event below is the source of truth for unchanged fields.",
-        "Only return fields the user is actually changing. Leave fields empty when unchanged or unknown.",
-        "If the user asks to move or reschedule the event, compute absolute ISO datetimes for the updated startAt and endAt using the current event as context.",
-        "If the user gives a relative shift like later, earlier, push back, or move forward, apply it to the current event timing.",
-        "Unless the user explicitly changes the timezone, preserve the current event timezone.",
-        "If the user only renames the event, leave startAt, endAt, location, description, and timeZone empty.",
-        "Return XML only. No prose.",
-        "",
-        "<response>",
-        "  <title>new event title if changed</title>",
-        "  <description>updated description if changed</description>",
-        "  <location>updated location if changed</location>",
-        "  <startAt>updated ISO datetime if changed</startAt>",
-        "  <endAt>updated ISO datetime if changed</endAt>",
-        "  <timeZone>IANA timezone if changed or needed to interpret the update</timeZone>",
-        "</response>",
-        "",
-        `Current timezone: ${timeZone}`,
-        `Current local datetime: ${nowReadable}`,
-        `Current ISO datetime: ${nowIso}`,
-        "",
-        "<current_request>",
-        currentMessage,
-        "</current_request>",
-        "<resolved_intent>",
-        intent,
-        "</resolved_intent>",
-        "<recent_conversation>",
-        recentConversation,
-        "</recent_conversation>",
-        "<current_event>",
-        formatUpdateEventTargetContext(targetEvent),
-        "</current_event>",
-    ].join("\n");
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-        const rawResponse = typeof result === "string" ? result : "";
-        return parseCreateEventExtractionResponse(rawResponse);
-    }
-    catch (error) {
-        runtime.logger?.warn?.({
-            src: "action:calendar",
-            error: error instanceof Error ? error.message : String(error),
-        }, "Calendar update-event extraction model call failed");
-        return {};
-    }
-}
-async function repairCreateEventDetails(runtime, message, state, intent, calendarContext, failedRequest, previousExtraction, error, fallbackTimeZone = resolveDefaultTimeZone()) {
-    const recentConversation = formatCreateEventRecentConversation(state);
-    const currentMessage = messageText(message).trim();
-    const now = new Date();
-    const timeZone = fallbackTimeZone;
-    const calendarTimeZone = calendarContext?.calendarTimeZone ?? fallbackTimeZone;
-    const nowIso = now.toISOString();
-    const nowReadable = new Intl.DateTimeFormat("en-US", {
-        timeZone,
-        dateStyle: "full",
-        timeStyle: "long",
-    }).format(now);
-    const prompt = [
-        "Extract calendar event creation fields from the request.",
-        "The previous create attempt failed. Repair the extraction so the next create attempt succeeds.",
-        "Use the full recent conversation below, not just the latest message.",
-        "The latest user request is authoritative, but preserve the existing event subject, people, and places unless the user changed them.",
-        "Use the calendar context below to ground any timing repair.",
-        "Use the exact failure reason to correct only the broken fields.",
-        "Return XML only. No prose. Leave fields empty when unchanged or unknown.",
-        "",
-        "<response>",
-        "  <title>event title</title>",
-        "  <description>optional description</description>",
-        "  <location>optional location</location>",
-        "  <startAt>ISO datetime if explicit or resolvable from a date phrase</startAt>",
-        "  <endAt>ISO datetime if explicit</endAt>",
-        "  <durationMinutes>number if implied</durationMinutes>",
-        "  <windowPreset>tomorrow_morning|tomorrow_afternoon|tomorrow_evening</windowPreset>",
-        "  <timeZone>IANA timezone if stated</timeZone>",
-        "</response>",
-        "",
-        `Current timezone: ${timeZone}`,
-        `Calendar timezone for scheduling: ${calendarTimeZone}`,
-        `Current local datetime: ${nowReadable}`,
-        `Current ISO datetime: ${nowIso}`,
-        `Create failure: ${error.message}`,
-        `Previous extraction: ${JSON.stringify(previousExtraction)}`,
-        `Previous create request: ${JSON.stringify(failedRequest)}`,
-        "",
-        "<current_request>",
-        currentMessage,
-        "</current_request>",
-        "<resolved_intent>",
-        intent,
-        "</resolved_intent>",
-        "<recent_conversation>",
-        recentConversation,
-        "</recent_conversation>",
-        "<calendar_context>",
-        formatCreateEventCalendarContext(calendarContext),
-        "</calendar_context>",
-    ].join("\n");
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-        const rawResponse = typeof result === "string" ? result : "";
-        return parseCreateEventExtractionResponse(rawResponse);
-    }
-    catch (repairError) {
-        runtime.logger?.warn?.({
-            src: "action:calendar",
-            error: repairError instanceof Error
-                ? repairError.message
-                : String(repairError),
-        }, "Calendar create-event repair model call failed");
-        return {};
-    }
-}
-function scoreCalendarEvent(event, query) {
-    const normalizedQuery = normalizeText(query);
-    const title = normalizeText(event.title);
-    const description = normalizeText(event.description);
-    const location = normalizeText(event.location);
-    const attendees = event.attendees
-        .flatMap((attendee) => [attendee.displayName ?? "", attendee.email ?? ""])
-        .map((value) => normalizeText(value))
-        .filter((value) => value.length > 0);
-    let score = 0;
-    const queryVariants = [
-        ...new Set([normalizedQuery, ...tokenVariants(normalizedQuery)]),
-    ];
-    if (queryVariants.some((variant) => title === variant)) {
-        score += 100;
-    }
-    else if (queryVariants.some((variant) => variant.length > 0 && title.includes(variant))) {
-        score += 75;
-    }
-    if (queryVariants.some((variant) => variant.length > 0 && description.includes(variant))) {
-        score += 35;
-    }
-    if (queryVariants.some((variant) => variant.length > 0 && location.includes(variant))) {
-        score += 30;
-    }
-    if (attendees.some((value) => queryVariants.some((variant) => variant.length > 0 && value.includes(variant)))) {
-        score += 25;
-    }
-    const queryTokens = tokenizeForSearch(normalizedQuery);
-    if (queryTokens.length > 0) {
-        const titleTokens = new Set(tokenizeForSearch(title));
-        const descriptionTokens = new Set(tokenizeForSearch(description));
-        const locationTokens = new Set(tokenizeForSearch(location));
-        const attendeeTokens = attendees.flatMap((value) => tokenizeForSearch(value));
-        const attendeeTokenSet = new Set(attendeeTokens);
-        score += queryTokens.filter((token) => titleTokens.has(token)).length * 12;
-        score +=
-            queryTokens.filter((token) => descriptionTokens.has(token)).length * 8;
-        score +=
-            queryTokens.filter((token) => locationTokens.has(token)).length * 14;
-        score +=
-            queryTokens.filter((token) => attendeeTokenSet.has(token)).length * 8;
-    }
-    if (/\b(return|back|home)\b/.test(normalizedQuery)) {
-        if (/\b(return|back|home)\b/.test(`${title} ${description}`)) {
-            score += 24;
-        }
-        else if (/\b(flight|travel|trip)\b/.test(`${title} ${description} ${location}`)) {
-            score -= 36;
-        }
-    }
-    const dateTerms = eventDateSearchTerms(event);
-    if ([...dateTerms].some((term) => term === normalizedQuery ||
-        normalizedQuery.includes(term) ||
-        term.includes(normalizedQuery))) {
-        score += 90;
-    }
-    const dateTokens = new Set([...dateTerms].flatMap((term) => tokenizeForSearch(term)));
-    score += queryTokens.filter((token) => dateTokens.has(token)).length * 10;
-    return score;
-}
-function shouldGroundCalendarSearchWithLlm(query, rankedEvents) {
-    const strongestScore = rankedEvents[0]?.score ?? 0;
-    if (strongestScore <= 0) {
-        return false;
-    }
-    if (strongestScore >= 72) {
-        return false;
-    }
-    return wordCount(query) >= 2 || rankedEvents.length > 1;
-}
-function normalizeCalendarMatchIdsFromValue(value, allowedIds) {
-    const rawIds = [];
-    if (typeof value === "string") {
-        for (const token of value.split(/\s*\|\|\s*|\s*,\s*|\s+/)) {
-            if (token.trim().length > 0) {
-                rawIds.push(token.trim());
-            }
-        }
-    }
-    else if (Array.isArray(value)) {
-        for (const item of value) {
-            if (typeof item === "string" && item.trim().length > 0) {
-                rawIds.push(item.trim());
-            }
-        }
-    }
-    return [...new Set(rawIds.filter((id) => allowedIds.has(id)))];
-}
-function extractCalendarGroundedMatchIds(rawResponse, allowedIds) {
-    const parsed = parseKeyValueXml(rawResponse) ??
-        parseJSONObjectFromText(rawResponse);
-    if (!parsed) {
-        return null;
-    }
-    const possibleKeys = [
-        "matchIds",
-        "matches",
-        "ids",
-        "matchId",
-        "matchId1",
-        "matchId2",
-        "matchId3",
-    ];
-    const sawExplicitMatchField = possibleKeys.some((key) => key in parsed);
-    if (!sawExplicitMatchField) {
-        return null;
-    }
-    const ids = possibleKeys.flatMap((key) => normalizeCalendarMatchIdsFromValue(parsed[key], allowedIds));
-    return [...new Set(ids)];
-}
-function formatCalendarCandidateForGrounding(candidate) {
-    const attendees = candidate.event.attendees
-        .map((attendee) => attendee.displayName ?? attendee.email ?? "")
-        .filter((value) => value.length > 0)
-        .join(", ");
-    return [
-        `id: ${candidate.event.id}`,
-        `score: ${candidate.score}`,
-        `title: ${candidate.event.title}`,
-        `startAt: ${candidate.event.startAt}`,
-        `location: ${candidate.event.location ?? ""}`,
-        `description: ${(candidate.event.description ?? "").slice(0, 240)}`,
-        `attendees: ${attendees}`,
-    ].join("\n");
-}
-async function groundCalendarSearchMatchesWithLlm(runtime, state, intent, queries, candidates) {
-    if (candidates.length === 0) {
-        return [];
-    }
-    const recentConversation = formatCreateEventRecentConversation(state);
-    const allowedIds = new Set(candidates.map((candidate) => candidate.event.id));
-    const prompt = [
-        "Decide which candidate calendar events directly match the user's request.",
-        "Be strict.",
-        "Return NO matches when the candidate only shares a generic time window or vague travel context.",
-        "If the request names a person, company, topic, or event name, only match candidates that explicitly mention that subject in the title, description, location, or attendees.",
-        "Flights only count when the request is actually about flights/travel, or the flight text explicitly mentions the named subject.",
-        "Return TOON only. No prose. No <think>.",
-        "Use || to separate multiple ids.",
-        "",
-        "Example:",
-        "matchIds: evt_1 || evt_2",
-        "reason:",
-        "",
-        "<resolved_intent>",
-        intent,
-        "</resolved_intent>",
-        "<search_queries>",
-        queries.join(" || "),
-        "</search_queries>",
-        "<recent_conversation>",
-        recentConversation,
-        "</recent_conversation>",
-        "",
-        "Candidates:",
-        ...candidates.map((candidate, index) => `candidate ${index + 1}\n${formatCalendarCandidateForGrounding(candidate)}`),
-    ].join("\n");
-    try {
-        const result = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-        const rawResponse = typeof result === "string" ? result : "";
-        return extractCalendarGroundedMatchIds(rawResponse, allowedIds);
-    }
-    catch (error) {
-        runtime.logger?.warn?.({
-            src: "action:calendar",
-            error: error instanceof Error ? error.message : String(error),
-        }, "Calendar search grounding model call failed");
-        return null;
-    }
-}
-function isTravelEvent(event) {
-    return /\b(flight|fly|travel|trip|hotel|stay|lodging|airbnb|check[- ]?in|check[- ]?out|return|home)\b/i.test(`${event.title} ${event.description} ${event.location}`);
-}
-function eventStartMs(event) {
-    return Date.parse(event.startAt);
-}
-function eventEndMs(event) {
-    const parsed = Date.parse(event.endAt);
-    if (Number.isFinite(parsed)) {
-        return parsed;
-    }
-    return eventStartMs(event);
-}
-function resolveTripWindowEvents(events, location) {
-    const anchors = events
-        .map((event) => ({
-        event,
-        score: scoreCalendarEvent(event, location) + (isTravelEvent(event) ? 12 : 0),
-    }))
-        .filter((candidate) => candidate.score > 0)
-        .sort((left, right) => eventStartMs(left.event) - eventStartMs(right.event));
-    if (anchors.length === 0) {
-        return null;
-    }
-    const windowStart = Math.min(...anchors.map((candidate) => eventStartMs(candidate.event)));
-    const windowEnd = Math.max(...anchors.map((candidate) => eventEndMs(candidate.event)));
-    return events
-        .filter((event) => eventEndMs(event) >= windowStart && eventStartMs(event) <= windowEnd)
-        .sort((left, right) => eventStartMs(left) - eventStartMs(right));
-}
-function formatCalendarMoment(event) {
-    if (event.isAllDay) {
-        return new Intl.DateTimeFormat("en-US", {
-            timeZone: event.timezone || undefined,
-            month: "short",
-            day: "numeric",
-        }).format(new Date(event.startAt));
-    }
-    return formatCalendarEventDateTime(event);
-}
-function formatTripWindowResults(events, location) {
-    if (events.length === 0) {
-        return `I couldn't find any upcoming calendar events while you're in ${location}.`;
-    }
-    const lines = [`Here's what's on your calendar while you're in ${location}:`];
-    for (const event of events.slice(0, 12)) {
-        lines.push(`- ${formatCalendarMoment(event)}: **${event.title}**`);
-    }
-    return lines.join("\n");
-}
-function formatCalendarSearchResults(events, query, label, intent) {
-    if (events.length === 0) {
-        return `No calendar events matched "${query}" ${label}.`;
-    }
-    if (events.length === 1) {
-        const event = events[0];
-        const normalizedIntent = normalizeText(intent);
-        const matchingSubject = /\b(flight|flights|fly|travel|trip|return|back|home)\b/.test(`${normalizedIntent} ${query}`)
-            ? "flight"
-            : "calendar event";
-        return `Your matching ${matchingSubject} is **${event.title}** (${formatCalendarMoment(event)}).`;
-    }
-    const lines = [
-        `Found ${events.length} calendar event${events.length === 1 ? "" : "s"} for "${query}" ${label}:`,
-    ];
-    for (const event of events.slice(0, 8)) {
-        const when = event.isAllDay
-            ? "all day"
-            : formatCalendarEventDateTime(event);
-        lines.push(`- **${event.title}** (${when})`);
-        if (event.location) {
-            lines.push(`  Location: ${event.location}`);
-        }
-        if (event.description) {
-            lines.push(`  ${event.description.slice(0, 120)}`);
-        }
-    }
-    return lines.join("\n");
-}
-function normalizeCalendarAttendees(details) {
-    const attendees = detailArray(details, "attendees");
-    if (!attendees) {
-        return undefined;
-    }
-    const mapped = attendees.map((attendee) => {
-        if (typeof attendee === "string" && attendee.trim().length > 0) {
-            return {
-                email: attendee.trim(),
-            };
-        }
-        if (!attendee ||
-            typeof attendee !== "object" ||
-            Array.isArray(attendee)) {
-            return null;
-        }
-        const record = attendee;
-        const email = typeof record.email === "string" && record.email.trim().length > 0
-            ? record.email.trim()
-            : null;
-        if (!email) {
-            return null;
-        }
-        return {
-            email,
-            displayName: typeof record.displayName === "string" &&
-                record.displayName.trim().length > 0
-                ? record.displayName.trim()
-                : undefined,
-            optional: typeof record.optional === "boolean" ? record.optional : undefined,
-        };
-    });
-    const normalized = mapped.filter((attendee) => attendee !== null);
-    return normalized.length > 0 ? normalized : undefined;
-}
-export const calendarAction = {
-    name: "CALENDAR_ACTION",
-    similes: [
-        "CALENDAR",
-        "CHECK_CALENDAR",
-        "SCHEDULE_EVENT",
-        "CREATE_CALENDAR_EVENT",
-        "SEARCH_CALENDAR",
-        "NEXT_MEETING",
-        "ITINERARY",
-        "TRAVEL_SCHEDULE",
-        "CHECK_SCHEDULE",
-    ],
-    description: "Interact with Google Calendar through LifeOps. " +
-        "USE this action for: viewing today's or this week's schedule; checking the next upcoming event; " +
-        "searching events by title, attendee, location, or date range; creating new calendar events; " +
-        "querying travel itineraries, flights, hotel stays, and trip windows. " +
-        "DO NOT use this action for email inbox work, drafting or sending emails — use GMAIL_ACTION instead. " +
-        "DO NOT use this action for personal habits, goals, routines, or reminders — use LIFE instead. " +
-        "This action provides the final grounded reply; do not pair it with a speculative REPLY action.",
-    suppressPostActionContinuation: true,
-    validate: async (runtime, message, state) => {
-        if (!(await hasLifeOpsAccess(runtime, message))) {
-            return false;
-        }
-        return hasCalendarContextSignal(message, state);
-    },
-    handler: async (runtime, message, state, options, callback) => {
-        if (!(await hasLifeOpsAccess(runtime, message))) {
-            const text = "Calendar actions are restricted to the owner, explicitly granted users, and the agent.";
-            await callback?.({ text });
-            return {
-                success: false,
-                text,
-            };
-        }
-        const rawParams = options?.parameters;
-        const params = rawParams ?? {};
-        const intent = resolveCalendarIntent(params.intent, message, state);
-        const details = normalizeCalendarDetails(params.details);
-        const planningTimeZone = resolveCalendarTimeZone(details);
-        const llmPlan = await extractCalendarPlanWithLlm(runtime, message, state, intent, planningTimeZone);
-        const heuristicQuery = inferCalendarSearchQuery(intent);
-        const inferredQuery = sanitizeCalendarQuery(params.query ?? detailString(details, "query"), intent);
-        const inferredQueries = dedupeCalendarQueries([
-            inferredQuery,
-            ...llmPlan.queries,
-            ...(params.queries ?? []),
-            ...(detailArray(details, "queries")?.map((value) => typeof value === "string" ? value : undefined) ?? []),
-        ]);
-        const explicitTitle = (typeof params.title === "string" && params.title.trim().length > 0
-            ? params.title.trim()
-            : undefined) ??
-            detailString(details, "title") ??
-            llmPlan.title;
-        const inferredTitle = explicitTitle ?? llmPlan.title ?? inferCreateEventTitle(intent);
-        const tripWindowIntent = llmPlan.tripLocation && llmPlan.tripLocation.trim().length > 0
-            ? { location: llmPlan.tripLocation.trim() }
-            : inferTripWindowIntent(intent);
-        const explicitSubaction = params.subaction;
-        const preferExplicitSubaction = shouldTrustExplicitCalendarSubaction(explicitSubaction, params, details);
-        const hasExplicitCalendarExecutionInput = Boolean(params.subaction ||
-            params.title ||
-            params.query ||
-            (params.queries?.length ?? 0) > 0 ||
-            detailString(details, "query") ||
-            (detailArray(details, "queries")?.length ?? 0) > 0 ||
-            detailString(details, "eventId") ||
-            detailString(details, "startAt") ||
-            detailString(details, "endAt") ||
-            detailString(details, "location") ||
-            detailString(details, "windowPreset") ||
-            detailNumber(details, "windowDays"));
-        const forcedSubaction = (() => {
-            const text = normalizeText(messageText(message));
-            if (/\b(?:rename|change|move|reschedule|push back)\b[^.?!]+\bto\b/.test(text) ||
-                /\b(rename|reschedule|update|edit|modify|change|move)\b.*\b(event|meeting|appointment|calendar|invite)\b/.test(text)) {
-                return "update_event";
-            }
-            if (/\b(delete|remove|cancel|drop|get rid of|trash|kill)\b.*\b(event|meeting|appointment|calendar|invite)\b/.test(text) ||
-                /\b(delete|remove|cancel)\b.+\b(today|tomorrow|tonight|this week|next week)\b/.test(text)) {
-                return "delete_event";
-            }
-            if (/\b(create|add|book|schedule|make|put)\b[^.?!]*\b(event|meeting|appointment|invite|calendar)\b/.test(text)) {
-                return "create_event";
-            }
-            if (/\b(show|list|tell|give|read)\b[^.?!]*\b(all|every|everything|entire|full|whole)\b[^.?!]*\b(event|events|calendar|schedule|meeting|meetings|appointment|appointments|entry|entries|agenda)\b/.test(text) ||
-                /\b(all|every|everything)\b\s+(?:my\s+)?(?:calendar|events?|meetings?|appointments?)\b/.test(text)) {
-                return "feed";
-            }
-            return null;
-        })();
-        let subaction;
-        if (tripWindowIntent) {
-            subaction = "trip_window";
-        }
-        else if (forcedSubaction) {
-            subaction = forcedSubaction;
-        }
-        else if (llmPlan.subaction && !preferExplicitSubaction) {
-            subaction = llmPlan.subaction;
-        }
-        else if (params.subaction) {
-            subaction = params.subaction;
-        }
-        else {
-            runtime.logger?.warn?.({ src: "action:calendar", intent }, "Calendar LLM plan returned no subaction; falling back to regex inference");
-            subaction = inferCalendarSubaction(normalizeText(intent), details, inferredQuery ?? heuristicQuery);
-        }
-        runtime.logger?.debug?.({
-            src: "action:calendar",
-            subaction,
-            forcedSubaction,
-            rawMessage: messageText(message).slice(0, 200),
-            resolvedIntent: intent.slice(0, 200),
-            params: {
-                subaction: params.subaction,
-                title: params.title,
-                intent: params.intent?.slice(0, 200),
-            },
-            detailKeys: details ? Object.keys(details) : [],
-        }, "calendar action dispatch");
-        const service = new LifeOpsService(runtime);
-        const respond = async (payload) => {
-            await callback?.({
-                text: payload.text,
-                source: "action",
-                action: "CALENDAR_ACTION",
-            });
-            return payload;
-        };
-        const renderReply = (scenario, fallback, context) => renderCalendarActionReply({
-            runtime,
-            message,
-            state,
-            intent,
-            scenario,
-            fallback,
-            context,
-        });
-        if (!hasExplicitCalendarExecutionInput &&
-            !forcedSubaction &&
-            !tripWindowIntent &&
-            looksLikeLifeReminderRequestForCalendarAction(messageText(message))) {
-            const fallback = "That sounds like a reminder or todo rather than a calendar event. Tell me the reminder and when it should happen.";
-            return respond({
-                success: true,
-                text: await renderReply("out_of_domain", fallback, {
-                    requestedDomain: "lifeops",
-                }),
-                data: {
-                    noop: true,
-                    suggestedSubaction: null,
-                },
-            });
-        }
-        if (llmPlan.shouldAct === false &&
-            !hasExplicitCalendarExecutionInput &&
-            !forcedSubaction &&
-            !tripWindowIntent) {
-            const fallback = llmPlan.response ?? buildCalendarReplyOnlyFallback(llmPlan.subaction);
-            return respond({
-                success: true,
-                text: await renderReply("reply_only", fallback, {
-                    llmPlan,
-                    suggestedSubaction: llmPlan.subaction,
-                }),
-                data: {
-                    noop: true,
-                    ...(llmPlan.subaction
-                        ? { suggestedSubaction: llmPlan.subaction }
-                        : {}),
-                },
-            });
-        }
-        try {
-            const google = await getGoogleCapabilityStatus(service);
-            if (subaction === "next_event") {
-                if (!google.hasCalendarRead) {
-                    return respond({
-                        success: false,
-                        text: calendarReadUnavailableMessage(google),
-                    });
-                }
-                const context = await service.getNextCalendarEventContext(INTERNAL_URL, {
-                    calendarId: detailString(details, "calendarId"),
-                    timeZone: resolveCalendarTimeZone(details),
-                });
-                const fallback = formatNextEventContext(context);
-                return respond({
-                    success: true,
-                    text: await renderReply("next_event", fallback, {
-                        event: context,
-                    }),
-                    data: toActionData(context),
-                });
-            }
-            if (subaction === "create_event") {
-                if (!google.hasCalendarWrite) {
-                    return respond({
-                        success: false,
-                        text: calendarWriteUnavailableMessage(google),
-                    });
-                }
-                let calendarContext = null;
-                try {
-                    calendarContext = await loadCreateEventCalendarContext(service, details, google.hasCalendarRead);
-                }
-                catch (error) {
-                    runtime.logger?.warn?.({
-                        src: "action:calendar",
-                        error: error instanceof Error ? error.message : String(error),
-                    }, "Calendar create-event context fetch failed");
-                }
-                const extractedDetails = await inferCreateEventDetails(runtime, message, state, intent, calendarContext, planningTimeZone);
-                const { title, resolvedStartAt, resolvedWindowPreset, request } = buildCreateEventRequest({
-                    details,
-                    extractedDetails,
-                    explicitTitle,
-                    inferredTitle,
-                    intent,
-                });
-                if (!title) {
-                    return respond({
-                        success: false,
-                        text: await renderReply("clarify_create_event_title", "What event do you want to add?", {
-                            missing: ["title"],
-                        }),
-                    });
-                }
-                // The LifeOps service throws a raw 400 when neither startAt nor a
-                // window preset is supplied. Catch that case here so the user gets a
-                // useful prompt instead of "startAt is required when windowPreset is
-                // not provided" — and so the failure path doesn't re-trigger the
-                // action via post-action continuation.
-                if (!resolvedStartAt && !resolvedWindowPreset) {
-                    const suggestedStartAt = title
-                        ? suggestCreateEventStartAt({
-                            currentMessage: messageText(message).trim(),
-                            intent,
-                            title,
-                            calendarContext,
-                        })
-                        : null;
-                    const fallback = suggestedStartAt
-                        ? `i can tentatively put "${title}" on ${formatCalendarEventDateTime({
-                            startAt: suggestedStartAt.startAt,
-                            timezone: suggestedStartAt.timeZone,
-                        }, { includeTimeZoneName: true })}. if you want a different time, tell me what works better.`
-                        : `i need a time for "${title}" in ${calendarContext?.calendarTimeZone ??
-                            resolveCalendarTimeZone(details)}. try "tomorrow morning", "tomorrow afternoon", "tomorrow evening", or give me a specific date and time.`;
-                    return respond({
-                        success: false,
-                        text: await renderReply("clarify_create_event_time", fallback, {
-                            title,
-                            suggestedStartAt,
-                            calendarTimeZone: calendarContext?.calendarTimeZone ??
-                                resolveCalendarTimeZone(details),
-                        }),
-                    });
-                }
-                let requestToCreate = request;
-                let event;
-                try {
-                    event = await service.createCalendarEvent(INTERNAL_URL, requestToCreate);
-                }
-                catch (error) {
-                    if (error instanceof LifeOpsServiceError &&
-                        shouldRetryCreateEventExtraction(error)) {
-                        const repairedDetails = await repairCreateEventDetails(runtime, message, state, intent, calendarContext, requestToCreate, extractedDetails, error, planningTimeZone);
-                        const repaired = buildCreateEventRequest({
-                            details,
-                            extractedDetails: repairedDetails,
-                            explicitTitle,
-                            inferredTitle,
-                            intent,
-                            fallbackRequest: requestToCreate,
-                            preferExtractedDetails: true,
-                        });
-                        if (repaired.title &&
-                            (repaired.resolvedStartAt || repaired.resolvedWindowPreset) &&
-                            createEventRequestFingerprint(repaired.request) !==
-                                createEventRequestFingerprint(requestToCreate)) {
-                            runtime.logger?.info?.({
-                                src: "action:calendar",
-                                error: error.message,
-                                priorRequest: requestToCreate,
-                                repairedRequest: repaired.request,
-                            }, "Retrying calendar create-event after repair extraction");
-                            requestToCreate = repaired.request;
-                            event = await service.createCalendarEvent(INTERNAL_URL, requestToCreate);
-                        }
-                        else {
-                            throw error;
-                        }
-                    }
-                    else {
-                        throw error;
-                    }
-                }
-                const fallback = `Created calendar event "${event.title}" for ${formatCalendarEventDateTime(event, {
-                    includeTimeZoneName: true,
-                })}.`;
-                return respond({
-                    success: true,
-                    text: await renderReply("created_event", fallback, {
-                        event,
-                        request: requestToCreate,
-                    }),
-                    data: toActionData(event),
-                });
-            }
-            if (subaction === "update_event") {
-                if (!google.hasCalendarWrite) {
-                    return respond({
-                        success: false,
-                        text: calendarWriteUnavailableMessage(google),
-                    });
-                }
-                // Parse "rename X to Y" / "change X to Y" patterns directly from
-                // the user message. The chat LLM tends to put only the NEW title in
-                // params.title, but we need the OLD title to find the event we're
-                // patching. Pull both halves from the literal phrase if it's there.
-                // We try the raw message first because resolveCalendarIntent may
-                // have replaced the user's text with the LLM's rewritten version,
-                // which often drops "rename" entirely.
-                const rawMessageText = messageText(message);
-                const renamePattern = /\b(?:rename|change|update|edit)\b\s+["“]?([^"”]+?)["”]?\s+(?:to|into|as)\s+["“]?([^"”]+?)["”]?(?:[.!?]|$)/i;
-                const renameMatch = rawMessageText.match(renamePattern) ?? intent.match(renamePattern);
-                const oldTitleFromIntent = renameMatch?.[1]?.trim();
-                const newTitleFromIntent = renameMatch?.[2]?.trim();
-                const explicitEventId = detailString(details, "eventId");
-                let resolvedEventId = explicitEventId;
-                let resolvedCalendarId = detailString(details, "calendarId");
-                let targetEvent = null;
-                // Same lookup-by-title fallback as delete_event so the user can say
-                // "rename my dentist appointment to dentist follow-up" without first
-                // copying an opaque google id.
-                if (!resolvedEventId) {
-                    // Use a wide lookup window — events can be far in the future
-                    // (e.g. a birthday in 2027). The default narrow window would
-                    // miss anything beyond the current day.
-                    // forceSync: true is critical here — without it the feed query
-                    // returns the local cache (life_calendar_events), which may not
-                    // contain far-future events that have never been synced before
-                    // (or any events at all if the cache was wiped). Forcing the
-                    // sync makes the bot pull a fresh window from Google so the
-                    // title-based lookup actually has events to filter against.
-                    const wideLookup = buildWideLookupRange(resolveCalendarTimeZone(details));
-                    const feed = await service.getCalendarFeed(INTERNAL_URL, {
-                        mode: detailString(details, "mode"),
-                        side: detailString(details, "side"),
-                        calendarId: detailString(details, "calendarId"),
-                        timeZone: resolveCalendarTimeZone(details),
-                        forceSync: true,
-                        ...wideLookup,
-                    });
-                    // Prefer the OLD title parsed from "rename X to Y" — explicit
-                    // title from the chat LLM almost always carries the NEW name.
-                    const titleHint = oldTitleFromIntent ?? explicitTitle ?? inferredTitle;
-                    const candidates = titleHint
-                        ? feed.events.filter((e) => normalizeText(e.title).includes(normalizeText(titleHint)))
-                        : feed.events;
-                    if (candidates.length === 0) {
-                        const fallback = titleHint
-                            ? `i couldn't find an event matching "${titleHint}" in that window.`
-                            : "i couldn't find any events to update in that window. give me a title or a date.";
-                        return respond({
-                            success: false,
-                            text: await renderReply("update_event_not_found", fallback, {
-                                titleHint,
-                            }),
-                        });
-                    }
-                    if (candidates.length > 1) {
-                        const fallback = buildCalendarEventDisambiguationFallback({
-                            action: "update",
-                            candidates,
-                            titleHint,
-                        });
-                        return respond({
-                            success: false,
-                            text: await renderReply("clarify_update_event_target", fallback, {
-                                candidateCount: candidates.length,
-                                titleHint,
-                                candidates,
-                            }),
-                        });
-                    }
-                    targetEvent = candidates[0];
-                    resolvedEventId = targetEvent.externalId;
-                    resolvedCalendarId = targetEvent.calendarId;
-                }
-                const newTitle = newTitleFromIntent ??
-                    detailString(details, "newTitle") ??
-                    explicitTitle;
-                // Reuse the same LLM extractor that create_event uses to pull
-                // startAt / endAt / location / description out of the user's intent
-                // text. The chat LLM rarely populates `details.startAt` directly for
-                // an update — it just rewrites the intent and lets the action figure
-                // out the time. Without this we'd PATCH with no fields and the
-                // event wouldn't actually move.
-                //
-                // CRITICAL: only run the extractor when the user actually mentioned
-                // a time. For pure rename intents like "rename X to Y" the LLM will
-                // happily hallucinate a startAt from the year in the new title
-                // ("rename my party 2027 to ..." → startAt 2027-01-01), and a
-                // PATCH with start.dateTime but no matching end.dateTime triggers
-                // Google's "Bad Request" rejection. Detect time keywords in the
-                // raw message before invoking the extractor.
-                const explicitStartAtForUpdate = detailString(details, "startAt");
-                const explicitEndAtForUpdate = detailString(details, "endAt");
-                const rawForUpdate = normalizeText(messageText(message));
-                const hasTimeAnchor = /\b(at|on|by|from|until)\s+\d/.test(rawForUpdate) ||
-                    /\b(today|tomorrow|tonight|monday|tuesday|wednesday|thursday|friday|saturday|sunday|january|february|march|april|may|june|july|august|september|october|november|december)\b/.test(rawForUpdate) ||
-                    /\b\d{1,2}(?::\d{2})?\s*(?:am|pm)\b/.test(rawForUpdate) ||
-                    /\b\d{1,2}\/\d{1,2}(?:\/\d{2,4})?\b/.test(rawForUpdate);
-                const hasRelativeShiftCue = /\b(?:later|earlier|push back|push it back|bring forward|move forward|move back|delay|postpone|advance)\b/.test(rawForUpdate);
-                const needsTimeExtraction = (hasTimeAnchor || hasRelativeShiftCue) &&
-                    !(explicitStartAtForUpdate ||
-                        explicitEndAtForUpdate ||
-                        detailNumber(details, "durationMinutes"));
-                const shouldInferUpdateDetails = Boolean(targetEvent) &&
-                    (needsTimeExtraction ||
-                        /\b(?:rename|change|move|reschedule|update|edit|location|description|notes)\b/.test(rawForUpdate));
-                const extractedForUpdate = shouldInferUpdateDetails
-                    ? await inferUpdateEventDetails(runtime, message, state, intent, targetEvent, targetEvent?.timezone ?? planningTimeZone)
-                    : needsTimeExtraction
-                        ? await inferCreateEventDetails(runtime, message, state, intent, null, targetEvent?.timezone ?? planningTimeZone)
-                        : {};
-                const extractedStartAt = typeof extractedForUpdate.startAt === "string"
-                    ? extractedForUpdate.startAt.trim()
-                    : undefined;
-                const extractedEndAt = typeof extractedForUpdate.endAt === "string"
-                    ? extractedForUpdate.endAt.trim()
-                    : undefined;
-                const extractedLocation = typeof extractedForUpdate.location === "string"
-                    ? extractedForUpdate.location.trim()
-                    : undefined;
-                const extractedDescription = typeof extractedForUpdate.description === "string"
-                    ? extractedForUpdate.description.trim()
-                    : undefined;
-                const extractedTimeZoneForUpdate = typeof extractedForUpdate.timeZone === "string"
-                    ? extractedForUpdate.timeZone.trim()
-                    : undefined;
-                const event = await service.updateCalendarEvent(INTERNAL_URL, {
-                    mode: detailString(details, "mode"),
-                    side: detailString(details, "side"),
-                    calendarId: resolvedCalendarId,
-                    eventId: resolvedEventId ?? "",
-                    title: newTitle,
-                    description: detailString(details, "description") ?? extractedDescription,
-                    location: detailString(details, "location") ?? extractedLocation,
-                    startAt: explicitStartAtForUpdate ?? extractedStartAt,
-                    endAt: explicitEndAtForUpdate ?? extractedEndAt,
-                    timeZone: detailString(details, "timeZone") ??
-                        extractedTimeZoneForUpdate ??
-                        targetEvent?.timezone ??
-                        undefined,
-                });
-                const fallback = `updated "${event.title}" — ${formatCalendarEventDateTime(event, {
-                    includeTimeZoneName: true,
-                })}.`;
-                return respond({
-                    success: true,
-                    text: await renderReply("updated_event", fallback, {
-                        event,
-                        targetEvent,
-                    }),
-                    data: toActionData(event),
-                });
-            }
-            if (subaction === "delete_event") {
-                if (!google.hasCalendarWrite) {
-                    return respond({
-                        success: false,
-                        text: calendarWriteUnavailableMessage(google),
-                    });
-                }
-                const explicitEventId = detailString(details, "eventId");
-                const calendarIdForDelete = detailString(details, "calendarId");
-                // The LLM may not know the event id directly. Fall back to a feed
-                // lookup so phrases like "delete the duplicate test event tomorrow"
-                // can resolve to a concrete event without forcing the user to copy
-                // an opaque google id from the bot's previous reply.
-                const resolvedEventId = explicitEventId;
-                let resolvedEventTitle;
-                const resolvedCalendarId = calendarIdForDelete;
-                if (!resolvedEventId) {
-                    // For delete-by-title we honor an explicit time window if the
-                    // user gave one ("delete the test event tomorrow"); otherwise we
-                    // search wide so far-future events are still findable.
-                    // forceSync: true ensures the lookup actually queries Google
-                    // instead of returning a stale (or empty) local cache.
-                    const hasExplicitWindow = /\b(today|tomorrow|tonight|this week|next week|the week after|this weekend|next weekend|weekend|this month|next month|monday|tuesday|wednesday|thursday|friday|saturday|sunday)\b/i.test(intent);
-                    const feedRequest = hasExplicitWindow
-                        ? resolveCalendarWindow(intent, details, false, llmPlan).request
-                        : {
-                            calendarId: detailString(details, "calendarId"),
-                            timeZone: resolveCalendarTimeZone(details),
-                            ...buildWideLookupRange(resolveCalendarTimeZone(details)),
-                        };
-                    const feed = await service.getCalendarFeed(INTERNAL_URL, {
-                        mode: detailString(details, "mode"),
-                        side: detailString(details, "side"),
-                        forceSync: true,
-                        ...feedRequest,
-                    });
-                    const titleHint = explicitTitle ?? inferredTitle;
-                    const candidates = titleHint
-                        ? feed.events.filter((e) => normalizeText(e.title).includes(normalizeText(titleHint)))
-                        : feed.events;
-                    if (candidates.length === 0) {
-                        const fallback = titleHint
-                            ? `i couldn't find an event matching "${titleHint}" in that window.`
-                            : "i couldn't find any events to delete in that window. give me a title or a date.";
-                        return respond({
-                            success: false,
-                            text: await renderReply("delete_event_not_found", fallback, {
-                                titleHint,
-                            }),
-                        });
-                    }
-                    // Detect "delete all / delete both / delete N" phrasing — when the
-                    // user explicitly opts in to multi-delete, sweep every match.
-                    const deleteAllMatch = shouldDeleteAllMatchingCalendarEvents({
-                        intent,
-                        titleHint,
-                        candidateCount: candidates.length,
-                    });
-                    if (candidates.length > 1 && !deleteAllMatch) {
-                        const fallback = buildCalendarEventDisambiguationFallback({
-                            action: "delete",
-                            candidates,
-                            titleHint,
-                        });
-                        return respond({
-                            success: false,
-                            text: await renderReply("clarify_delete_event_target", fallback, {
-                                candidateCount: candidates.length,
-                                titleHint,
-                                candidates,
-                            }),
-                        });
-                    }
-                    const targets = deleteAllMatch ? candidates : [candidates[0]];
-                    const deleteResults = [];
-                    for (const target of targets) {
-                        try {
-                            await service.deleteCalendarEvent(INTERNAL_URL, {
-                                mode: detailString(details, "mode"),
-                                side: detailString(details, "side"),
-                                calendarId: target.calendarId,
-                                eventId: target.externalId,
-                            });
-                            deleteResults.push({ title: target.title, ok: true });
-                        }
-                        catch (err) {
-                            deleteResults.push({
-                                title: target.title,
-                                ok: false,
-                                error: err instanceof Error ? err.message : String(err),
-                            });
-                        }
-                    }
-                    const okCount = deleteResults.filter((r) => r.ok).length;
-                    const failCount = deleteResults.length - okCount;
-                    const publicDeleteResults = deleteResults.map((result) => ({
-                        title: result.title,
-                        ok: result.ok,
-                    }));
-                    const summary = failCount === 0
-                        ? targets.length === 1
-                            ? `deleted "${deleteResults[0].title}".`
-                            : `deleted ${okCount} matching events.`
-                        : okCount === 0
-                            ? `I couldn't delete those ${deleteResults.length} matching events. Try again in a bit or tell me which one to remove.`
-                            : `Deleted ${okCount} matching event${okCount === 1 ? "" : "s"}, but ${failCount} failed. Tell me which one to remove if you want me to retry individually.`;
-                    return respond({
-                        success: failCount === 0,
-                        text: await renderReply("deleted_event", summary, {
-                            deleteResults: publicDeleteResults,
-                            okCount,
-                            failCount,
-                        }),
-                    });
-                }
-                // Path: explicit eventId was given, no feed lookup needed
-                if (!resolvedEventId) {
-                    return respond({
-                        success: false,
-                        text: await renderReply("clarify_delete_event_target", "i need an event id or a title + date to delete an event.", {
-                            missing: ["event target"],
-                        }),
-                    });
-                }
-                await service.deleteCalendarEvent(INTERNAL_URL, {
-                    mode: detailString(details, "mode"),
-                    side: detailString(details, "side"),
-                    calendarId: resolvedCalendarId,
-                    eventId: resolvedEventId,
-                });
-                const fallback = resolvedEventTitle
-                    ? `deleted "${resolvedEventTitle}".`
-                    : "deleted that calendar event.";
-                return respond({
-                    success: true,
-                    text: await renderReply("deleted_event", fallback, {
-                        eventTitle: resolvedEventTitle,
-                    }),
-                });
-            }
-            if (!google.hasCalendarRead) {
-                return respond({
-                    success: false,
-                    text: calendarReadUnavailableMessage(google),
-                });
-            }
-            if (subaction === "trip_window" && tripWindowIntent) {
-                const feed = await service.getCalendarFeed(INTERNAL_URL, {
-                    mode: detailString(details, "mode"),
-                    side: detailString(details, "side"),
-                    ...resolveTripWindowRequest(details, llmPlan),
-                });
-                const itineraryEvents = resolveTripWindowEvents(feed.events, tripWindowIntent.location);
-                if (!itineraryEvents || itineraryEvents.length === 0) {
-                    const fallback = `I couldn't find a clear trip window for ${tripWindowIntent.location} in your upcoming calendar.`;
-                    return respond({
-                        success: true,
-                        text: await renderReply("trip_window_not_found", fallback, {
-                            location: tripWindowIntent.location,
-                        }),
-                        data: toActionData({
-                            ...feed,
-                            location: tripWindowIntent.location,
-                            events: [],
-                        }),
-                    });
-                }
-                const fallback = formatTripWindowResults(itineraryEvents, tripWindowIntent.location);
-                return respond({
-                    success: true,
-                    text: await renderReply("trip_window_results", fallback, {
-                        location: tripWindowIntent.location,
-                        events: itineraryEvents,
-                    }),
-                    data: toActionData({
-                        ...feed,
-                        location: tripWindowIntent.location,
-                        events: itineraryEvents,
-                    }),
-                });
-            }
-            // When the user explicitly asks for "all events" / "everything" / a
-            // multi-year span, broaden the lookup window past the default
-            // "today only" feed window. resolveCalendarWindow's default is too
-            // narrow for these queries — without this branch, "show all my
-            // events" returns "no events today" even when the calendar has
-            // dozens of upcoming items. We apply this regardless of whether the
-            // chat LLM picked feed or search_events because both subactions go
-            // through this code path.
-            const rawMessageNorm = normalizeText(messageText(message));
-            const wantsWideWindow = /\b(all|every|everything|entire|full|whole)\b[^.?!]*\b(event|events|calendar|schedule|meeting|meetings|appointment|appointments|entry|entries|agenda)\b/.test(rawMessageNorm) ||
-                /\b(next|past|last)\s+\d+\s*(year|years|month|months|weeks?)\b/.test(rawMessageNorm) ||
-                /\b(today\s+(?:until|through|to)\s+next\s+(?:year|month))\b/.test(rawMessageNorm) ||
-                /\bevery\s+calendar\s+entry\b/.test(rawMessageNorm);
-            const baseResolved = resolveCalendarWindow(intent, details, subaction === "search_events" || wantsWideWindow, llmPlan);
-            const request = wantsWideWindow
-                ? {
-                    ...baseResolved.request,
-                    ...buildWideLookupRange(resolveCalendarTimeZone(details)),
-                }
-                : baseResolved.request;
-            const label = wantsWideWindow
-                ? "across the full window"
-                : baseResolved.label;
-            const feed = await service.getCalendarFeed(INTERNAL_URL, {
-                mode: detailString(details, "mode"),
-                side: detailString(details, "side"),
-                forceSync: wantsWideWindow,
-                ...request,
-            });
-            if (subaction === "search_events") {
-                const searchQueries = await resolveCalendarSearchQueries(runtime, message, state, [...inferredQueries], intent, llmPlan, planningTimeZone);
-                const query = searchQueries[0];
-                if (!query || searchQueries.length === 0) {
-                    return respond({
-                        success: false,
-                        text: await renderReply("clarify_calendar_search", "I couldn't infer what to look for in your calendar yet. Try naming a person, place, trip, or date.", {
-                            missing: ["search target"],
-                        }),
-                    });
-                }
-                const rankedEvents = feed.events
-                    .map((event) => {
-                    const matchedQueries = [];
-                    let score = 0;
-                    for (const candidateQuery of searchQueries) {
-                        const queryScore = scoreCalendarEvent(event, candidateQuery);
-                        if (queryScore > 0) {
-                            matchedQueries.push(candidateQuery);
-                            score += queryScore;
-                        }
-                    }
-                    if (matchedQueries.length > 1) {
-                        score += (matchedQueries.length - 1) * 12;
-                    }
-                    return { event, score, matchedQueries };
-                })
-                    .filter((candidate) => candidate.score > 0 && candidate.matchedQueries.length > 0)
-                    .sort((left, right) => {
-                    if (right.score !== left.score) {
-                        return right.score - left.score;
-                    }
-                    return (Date.parse(left.event.startAt) - Date.parse(right.event.startAt));
-                });
-                const strongestScore = rankedEvents[0]?.score ?? 0;
-                const strongestThreshold = strongestScore >= 30 ? Math.max(16, strongestScore - 12) : 1;
-                let filteredEvents = rankedEvents
-                    .filter((candidate) => candidate.score >= strongestThreshold)
-                    .map((candidate) => candidate.event);
-                if (shouldGroundCalendarSearchWithLlm(query, rankedEvents)) {
-                    const groundedIds = await groundCalendarSearchMatchesWithLlm(runtime, state, intent, searchQueries, rankedEvents.slice(0, 6));
-                    if (groundedIds) {
-                        const groundedIdSet = new Set(groundedIds);
-                        filteredEvents = rankedEvents
-                            .filter((candidate) => groundedIdSet.has(candidate.event.id))
-                            .map((candidate) => candidate.event);
-                    }
-                }
-                const fallback = formatCalendarSearchResults(filteredEvents, query, label, intent);
-                return respond({
-                    success: true,
-                    text: await renderReply("search_results", fallback, {
-                        query,
-                        queries: searchQueries,
-                        events: filteredEvents,
-                        label,
-                    }),
-                    data: toActionData({
-                        ...feed,
-                        query,
-                        queries: searchQueries,
-                        events: filteredEvents,
-                    }),
-                });
-            }
-            const fallback = formatCalendarFeed(feed, label);
-            return respond({
-                success: true,
-                text: await renderReply("feed_results", fallback, {
-                    label,
-                    events: feed.events,
-                }),
-                data: toActionData(feed),
-            });
-        }
-        catch (error) {
-            if (error instanceof LifeOpsServiceError) {
-                const fallback = buildCalendarServiceErrorFallback(error, intent);
-                return respond({
-                    success: false,
-                    text: await renderReply("service_error", fallback, {
-                        status: error.status,
-                        subaction,
-                    }),
-                });
-            }
-            throw error;
-        }
-    },
-    parameters: [
-        {
-            name: "subaction",
-            description: "Calendar operation. Use search_events for flights, itinerary, travel, appointments, or keyword lookup; feed for agenda/schedule reads; next_event for the next upcoming event; create_event only when creating a new event.",
-            required: false,
-            schema: {
-                type: "string",
-                enum: [
-                    "feed",
-                    "next_event",
-                    "search_events",
-                    "create_event",
-                    "update_event",
-                    "delete_event",
-                    "trip_window",
-                ],
-            },
-        },
-        {
-            name: "intent",
-            description: 'Natural language calendar request, especially schedule or itinerary questions. Examples: "what is on my calendar today", "do i have any flights this week", "when do i fly back from denver", "create a meeting tomorrow at 3pm".',
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "title",
-            description: "Event title when creating an event. Optional for read/search actions.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "query",
-            description: "Short search phrase for search_events, such as flight, dentist, Denver, or return flight.",
-            required: false,
-            schema: { type: "string" },
-        },
-        {
-            name: "queries",
-            description: "Optional array of search phrases for search_events. The action will combine and dedupe them.",
-            required: false,
-            schema: {
-                type: "array",
-                items: { type: "string" },
-            },
-        },
-        {
-            name: "details",
-            description: "Optional structured calendar fields such as time bounds, timezone, calendar id, create-event timing, location, and attendees.",
-            required: false,
-            schema: { type: "object" },
-        },
-    ],
-    examples: [
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "What's on my calendar today?" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "Events today:\n- **Team sync** (10:00 AM – 10:30 AM)",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "What is my next meeting?" },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: "**Next event: Product review** (2:00 PM – 3:00 PM) — in 45 min",
-                },
-            },
-        ],
-        [
-            {
-                name: "{{name1}}",
-                content: { text: "Create a dentist appointment for tomorrow at 3pm." },
-            },
-            {
-                name: "{{agentName}}",
-                content: {
-                    text: 'Created calendar event "Dentist appointment" for tomorrow at 3:00 PM.',
-                },
-            },
-        ],
-    ],
-};
+export * from "@elizaos/app-lifeops/actions/calendar";