@elizaos/plugin-personal-assistant 2.0.3-beta.6 → 2.0.3-beta.7

package/dist/actions/lib/scheduling-handler.js

@@ -0,0 +1,868 @@
+import {
+  recentConversationTexts as collectRecentConversationTexts,
+  ModelType,
+  parseJsonModelRecord,
+  resolveOptimizedPromptForRuntime,
+  runWithTrajectoryContext
+} from "@elizaos/core";
+import { hasLifeOpsAccess, INTERNAL_URL } from "../../lifeops/access.js";
+import { SCHEDULE_PLAN_INSTRUCTIONS } from "../../lifeops/optimized-prompt-instructions.js";
+import {
+  normalizeLifeOpsMeetingPreferencesPatch,
+  readLifeOpsMeetingPreferences,
+  updateLifeOpsMeetingPreferences
+} from "../../lifeops/owner-profile.js";
+import { inferTimeZoneFromLocationText } from "../../lifeops/time/timezone.js";
+import { getZonedDateParts } from "../../lifeops/time.js";
+import {
+  messageText as getMessageText,
+  renderLifeOpsActionReply
+} from "../../lifeops/voice/grounded-reply.js";
+import { SCHEDULE_PLAN_INSTRUCTIONS as SCHEDULE_PLAN_INSTRUCTIONS2 } from "../../lifeops/optimized-prompt-instructions.js";
+const MS_PER_MINUTE = 6e4;
+const MAX_DAYS_LOOKAHEAD = 60;
+const DEFAULT_DAYS_LOOKAHEAD = 7;
+const DEFAULT_SLOTS_COUNT = 3;
+const SLOT_STEP_MINUTES = 15;
+async function loadLifeOpsServiceModule() {
+  return import("../../lifeops/service.js");
+}
+function parseTimeOfDayToMinutes(value) {
+  const [h, m] = value.split(":");
+  return Number(h) * 60 + Number(m);
+}
+function formatLocalForDisplay(iso, timeZone) {
+  const date = new Date(iso);
+  return new Intl.DateTimeFormat("en-US", {
+    weekday: "short",
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+    timeZone
+  }).format(date);
+}
+function dayOfWeekInTz(date, timeZone) {
+  const parts = getZonedDateParts(date, timeZone);
+  return new Date(
+    Date.UTC(parts.year, Math.max(0, parts.month - 1), parts.day, 12, 0, 0)
+  ).getUTCDay();
+}
+function buildBusyIntervals(events, travelBufferMinutes) {
+  const bufferMs = travelBufferMinutes * MS_PER_MINUTE;
+  const intervals = events.filter((e) => e.status !== "cancelled").map((e) => ({
+    start: Date.parse(e.startAt) - bufferMs,
+    end: Date.parse(e.endAt) + bufferMs
+  })).filter((i) => Number.isFinite(i.start) && Number.isFinite(i.end)).sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const interval of intervals) {
+    const last = merged[merged.length - 1];
+    if (last && interval.start <= last.end) {
+      last.end = Math.max(last.end, interval.end);
+    } else {
+      merged.push({ ...interval });
+    }
+  }
+  return merged;
+}
+function overlapsBusy(slotStart, slotEnd, busy) {
+  for (const interval of busy) {
+    if (slotStart < interval.end && slotEnd > interval.start) return true;
+  }
+  return false;
+}
+function getZonedMinuteOfDay(date, timeZone) {
+  const parts = getZonedDateParts(date, timeZone);
+  return parts.hour * 60 + parts.minute;
+}
+function overlapsBlackout(slotStart, slotEnd, timeZone, blackouts) {
+  if (blackouts.length === 0) return false;
+  const slotStartMin = getZonedMinuteOfDay(slotStart, timeZone);
+  const slotEndMin = getZonedMinuteOfDay(slotEnd, timeZone);
+  const dow = dayOfWeekInTz(slotStart, timeZone);
+  for (const window of blackouts) {
+    if (window.daysOfWeek && window.daysOfWeek.length > 0) {
+      if (!window.daysOfWeek.includes(dow)) continue;
+    }
+    const bStart = parseTimeOfDayToMinutes(window.startLocal);
+    const bEnd = parseTimeOfDayToMinutes(window.endLocal);
+    if (slotStartMin < bEnd && slotEndMin > bStart) return true;
+  }
+  return false;
+}
+function endOfLocalDayMs(date, timeZone) {
+  const parts = getZonedDateParts(date, timeZone);
+  const remainingMinutes = 24 * 60 - (parts.hour * 60 + parts.minute);
+  return date.getTime() + remainingMinutes * MS_PER_MINUTE;
+}
+function computeProposedSlots(args) {
+  const {
+    now,
+    windowStart,
+    windowEnd,
+    durationMinutes,
+    slotCount,
+    preferences,
+    events
+  } = args;
+  const tz = preferences.timeZone;
+  const busy = buildBusyIntervals(events, preferences.travelBufferMinutes);
+  const preferredStart = parseTimeOfDayToMinutes(
+    preferences.preferredStartLocal
+  );
+  const preferredEnd = parseTimeOfDayToMinutes(preferences.preferredEndLocal);
+  const results = [];
+  const seenDays = /* @__PURE__ */ new Set();
+  const step = SLOT_STEP_MINUTES * MS_PER_MINUTE;
+  const cursor = Math.ceil(Math.max(windowStart.getTime(), now.getTime()) / step) * step;
+  const endMs = windowEnd.getTime();
+  const durationMs = durationMinutes * MS_PER_MINUTE;
+  for (let pass = 0; pass < 2 && results.length < slotCount; pass++) {
+    const onePerDay = pass === 0;
+    let t = cursor;
+    while (t + durationMs <= endMs && results.length < slotCount) {
+      const slotStart = new Date(t);
+      const slotEnd = new Date(t + durationMs);
+      const slotStartMin = getZonedMinuteOfDay(slotStart, tz);
+      const slotEndMin = getZonedMinuteOfDay(slotEnd, tz);
+      const parts = getZonedDateParts(slotStart, tz);
+      const endParts = getZonedDateParts(slotEnd, tz);
+      const sameLocalDay = parts.year === endParts.year && parts.month === endParts.month && parts.day === endParts.day;
+      const withinPreferred = sameLocalDay && slotStartMin >= preferredStart && slotEndMin <= preferredEnd;
+      if (withinPreferred && !overlapsBusy(slotStart.getTime(), slotEnd.getTime(), busy) && !overlapsBlackout(slotStart, slotEnd, tz, preferences.blackoutWindows)) {
+        const dayKey = `${parts.year}-${parts.month}-${parts.day}`;
+        if (!onePerDay || !seenDays.has(dayKey)) {
+          seenDays.add(dayKey);
+          results.push({
+            startAt: slotStart.toISOString(),
+            endAt: slotEnd.toISOString(),
+            durationMinutes,
+            localStart: formatLocalForDisplay(slotStart.toISOString(), tz),
+            localEnd: formatLocalForDisplay(slotEnd.toISOString(), tz),
+            timeZone: tz
+          });
+          if (onePerDay) {
+            t = endOfLocalDayMs(slotStart, tz);
+            continue;
+          }
+        }
+      }
+      t += step;
+    }
+  }
+  return results;
+}
+function formatSlotsText(slots) {
+  if (slots.length === 0) {
+    return "I couldn't find any open slots matching your preferences in that window.";
+  }
+  const lines = slots.map(
+    (slot, idx) => `${idx + 1}. ${slot.localStart} \u2013 ${slot.localEnd} (${slot.durationMinutes} min)`
+  );
+  return `Here ${slots.length === 1 ? "is an available option" : `are ${slots.length} options`} you can offer:
+${lines.join("\n")}`;
+}
+function cleanBundledCounterparty(value) {
+  return value.slice(0, 1024).replace(/^(?:with|for|and|also|maybe|please)\s{1,32}/iu, "").replace(/\s{1,32}(?:at|if|while|during|thanks|please)\b.{0,1024}$/iu, "").replace(/[.?!,;:]+$/u, "").trim();
+}
+function extractBundledMeetingCounterparties(messageText) {
+  const trimmed = messageText.trim().slice(0, 4096);
+  if (trimmed.length === 0) {
+    return [];
+  }
+  const patterns = [
+    /\bschedule\s{1,32}(.{1,2048}?)(?:\s{1,32}at\s{1,32}the\s{1,32}same\s{1,32}time\b|\s{1,32}same\s{1,32}day\b|\s{1,32}if\s{1,32}possible\b|[.?!]|$)/iu,
+    /\bbundle\s{1,32}(.{1,2048}?)(?:\s{1,32}together\b|\s{1,32}on\s{1,32}the\s{1,32}same\s{1,32}day\b|\s{1,32}if\s{1,32}possible\b|[.?!]|$)/iu,
+    /\bmeetings?\s{1,32}with\s{1,32}(.{1,2048}?)(?:\s{1,32}on\s{1,32}the\s{1,32}same\s{1,32}day\b|\s{1,32}at\s{1,32}the\s{1,32}same\s{1,32}time\b|\s{1,32}if\s{1,32}possible\b|[.?!]|$)/iu
+  ];
+  for (const pattern of patterns) {
+    const match = pattern.exec(trimmed);
+    const raw = match?.[1]?.trim();
+    if (!raw) {
+      continue;
+    }
+    const counterparties = raw.slice(0, 2048).split(/\s{0,32}(?:,|&|\band\b)\s{0,32}/iu).map(cleanBundledCounterparty).filter((value) => value.length > 0);
+    if (counterparties.length >= 2) {
+      return counterparties.slice(0, 4);
+    }
+  }
+  return [];
+}
+function formatCounterpartyList(counterparties) {
+  if (counterparties.length === 0) {
+    return "those meetings";
+  }
+  if (counterparties.length === 1) {
+    return counterparties[0] ?? "that meeting";
+  }
+  if (counterparties.length === 2) {
+    return `${counterparties[0]} and ${counterparties[1]}`;
+  }
+  return `${counterparties.slice(0, -1).join(", ")}, and ${counterparties[counterparties.length - 1]}`;
+}
+function deriveBundleLocationLabel(messageText) {
+  const lowered = messageText.toLowerCase();
+  const inMatch = /\b(?:in|while i(?:'| a)?m in|while im in)\s+([a-z][a-z\s._-]{1,40}?)(?:\s+(?:for|with|so|and)\b|[,.!?]|$)/iu.exec(
+    lowered
+  );
+  const candidate = inMatch?.[1]?.replace(/[_]+/g, " ").trim();
+  if (!candidate) {
+    return null;
+  }
+  return candidate.split(/\s+/u).map(
+    (part) => part.length > 0 ? `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}` : part
+  ).join(" ");
+}
+function formatProposedSlotsReply(args) {
+  const counterparties = args.context?.counterparties ?? [];
+  const locationLabel = args.context?.bundleLocationLabel?.trim();
+  const targetLabel = formatCounterpartyList(counterparties);
+  const windowLabel = locationLabel ? `${locationLabel}-time` : args.context?.timeZone;
+  if (counterparties.length >= 2) {
+    if (args.slots.length === 0) {
+      return `I couldn't find ${windowLabel} slots that keep ${targetLabel} in the same window. If you want, I can widen the search or split them across nearby times.`;
+    }
+    const lines = args.slots.map(
+      (slot, idx) => `${idx + 1}. ${slot.localStart} \u2013 ${slot.localEnd} (${slot.durationMinutes} min)`
+    );
+    return `Here ${args.slots.length === 1 ? "is 1" : `are ${args.slots.length}`} ${windowLabel} option${args.slots.length === 1 ? "" : "s"} that keep ${targetLabel} in the same window:
+${lines.join("\n")}`;
+  }
+  return formatSlotsText(args.slots);
+}
+function parseOptionalIso(value) {
+  if (typeof value !== "string") return null;
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function getParams(options) {
+  const params = options?.parameters;
+  return params ?? {};
+}
+async function denyIfNoAccess(runtime, message) {
+  return !await hasLifeOpsAccess(runtime, message);
+}
+function makeSchedulingRespond(args) {
+  const intent = getMessageText(args.message).trim();
+  return async (payload) => {
+    const text = await renderLifeOpsActionReply({
+      runtime: args.runtime,
+      message: args.message,
+      state: args.state,
+      intent,
+      scenario: payload.scenario,
+      fallback: payload.fallback,
+      context: payload.context
+    });
+    await args.callback?.({
+      text,
+      source: "action",
+      action: args.actionName
+    });
+    return {
+      text,
+      success: payload.success,
+      ...payload.values ? { values: payload.values } : {},
+      ...payload.data ? { data: payload.data } : {}
+    };
+  };
+}
+async function runProposeMeetingTimesHandler(runtime, message, state, options, callback) {
+  const respond = makeSchedulingRespond({
+    runtime,
+    message,
+    state,
+    callback,
+    actionName: "PROPOSE_MEETING_TIMES"
+  });
+  if (await denyIfNoAccess(runtime, message)) {
+    return respond({
+      success: false,
+      scenario: "scheduling_access_denied",
+      fallback: "Scheduling actions are restricted to the owner and authorized users.",
+      data: { error: "PERMISSION_DENIED" }
+    });
+  }
+  const params = getParams(options);
+  const preferences = await readLifeOpsMeetingPreferences(runtime);
+  const messageBody = typeof message.content.text === "string" ? message.content.text : "";
+  const inferredTimeZone = (typeof params.timeZone === "string" && params.timeZone.trim().length > 0 ? params.timeZone.trim() : null) ?? inferTimeZoneFromLocationText(messageBody);
+  const effectivePreferences = inferredTimeZone ? { ...preferences, timeZone: inferredTimeZone } : preferences;
+  const counterparties = Array.isArray(params.counterparties) && params.counterparties.length > 0 ? params.counterparties : extractBundledMeetingCounterparties(messageBody);
+  const bundleLocationLabel = deriveBundleLocationLabel(messageBody);
+  const durationMinutes = typeof params.durationMinutes === "number" && params.durationMinutes >= 5 && params.durationMinutes <= 480 ? Math.floor(params.durationMinutes) : effectivePreferences.defaultDurationMinutes;
+  const slotCount = typeof params.slotCount === "number" && params.slotCount >= 1 && params.slotCount <= 10 ? Math.floor(params.slotCount) : DEFAULT_SLOTS_COUNT;
+  const daysAhead = typeof params.daysAhead === "number" && params.daysAhead >= 1 && params.daysAhead <= MAX_DAYS_LOOKAHEAD ? Math.floor(params.daysAhead) : DEFAULT_DAYS_LOOKAHEAD;
+  const now = /* @__PURE__ */ new Date();
+  const explicitStart = parseOptionalIso(params.windowStart);
+  const explicitEnd = parseOptionalIso(params.windowEnd);
+  const windowStart = explicitStart ?? now;
+  const windowEnd = explicitEnd ?? new Date(windowStart.getTime() + daysAhead * 24 * 60 * 6e4);
+  const { LifeOpsService, LifeOpsServiceError } = await loadLifeOpsServiceModule();
+  const service = new LifeOpsService(runtime);
+  let events = [];
+  try {
+    const feed = await service.getCalendarFeed(INTERNAL_URL, {
+      includeHiddenCalendars: true,
+      timeMin: windowStart.toISOString(),
+      timeMax: windowEnd.toISOString(),
+      timeZone: effectivePreferences.timeZone
+    });
+    events = feed.events;
+  } catch (error) {
+    if (error instanceof LifeOpsServiceError) {
+      const fallback2 = error.status === 403 ? "I can't propose times yet because calendar access is not available. Grant Apple Calendar access or connect Google Calendar and try again." : `I couldn't read your calendar (${error.message}).`;
+      return respond({
+        success: false,
+        scenario: "scheduling_calendar_unavailable",
+        fallback: fallback2,
+        context: { status: error.status, detail: error.message },
+        data: {
+          error: "CALENDAR_UNAVAILABLE",
+          status: error.status,
+          detail: error.message
+        }
+      });
+    }
+    throw error;
+  }
+  const slots = computeProposedSlots({
+    now,
+    windowStart,
+    windowEnd,
+    durationMinutes,
+    slotCount,
+    preferences: effectivePreferences,
+    events
+  });
+  const fallback = formatProposedSlotsReply({
+    slots,
+    context: {
+      counterparties,
+      bundleLocationLabel,
+      timeZone: effectivePreferences.timeZone
+    }
+  });
+  return respond({
+    success: true,
+    scenario: "scheduling_proposed_slots",
+    fallback,
+    context: {
+      slotCount: slots.length,
+      durationMinutes,
+      timeZone: effectivePreferences.timeZone,
+      counterparties,
+      bundleLocationLabel
+    },
+    data: {
+      slots,
+      durationMinutes,
+      windowStart: windowStart.toISOString(),
+      windowEnd: windowEnd.toISOString(),
+      timeZone: effectivePreferences.timeZone,
+      preferences: effectivePreferences,
+      counterparties,
+      bundleLocationLabel
+    }
+  });
+}
+async function runCheckAvailabilityHandler(runtime, message, state, options, callback) {
+  const respond = makeSchedulingRespond({
+    runtime,
+    message,
+    state,
+    callback,
+    actionName: "CHECK_AVAILABILITY"
+  });
+  if (await denyIfNoAccess(runtime, message)) {
+    return respond({
+      success: false,
+      scenario: "scheduling_access_denied",
+      fallback: "Scheduling actions are restricted to the owner and authorized users.",
+      data: { error: "PERMISSION_DENIED" }
+    });
+  }
+  const params = getParams(options);
+  const windowStart = parseOptionalIso(params.startAt);
+  const windowEnd = parseOptionalIso(params.endAt);
+  if (!windowStart || !windowEnd || windowEnd <= windowStart) {
+    return respond({
+      success: false,
+      scenario: "scheduling_invalid_window",
+      fallback: "I need a valid ISO start and end time to check availability (end must be after start).",
+      data: { error: "INVALID_WINDOW" }
+    });
+  }
+  const preferences = await readLifeOpsMeetingPreferences(runtime);
+  const { LifeOpsService, LifeOpsServiceError } = await loadLifeOpsServiceModule();
+  const service = new LifeOpsService(runtime);
+  let events = [];
+  try {
+    const feed = await service.getCalendarFeed(INTERNAL_URL, {
+      includeHiddenCalendars: true,
+      timeMin: windowStart.toISOString(),
+      timeMax: windowEnd.toISOString(),
+      timeZone: preferences.timeZone
+    });
+    events = feed.events;
+  } catch (error) {
+    if (error instanceof LifeOpsServiceError) {
+      const fallback2 = error.status === 403 ? "I can't check availability because calendar access is not available. Grant Apple Calendar access or connect Google Calendar." : `I couldn't read your calendar (${error.message}).`;
+      return respond({
+        success: false,
+        scenario: "scheduling_calendar_unavailable",
+        fallback: fallback2,
+        context: { status: error.status, detail: error.message },
+        data: {
+          error: "CALENDAR_UNAVAILABLE",
+          status: error.status,
+          detail: error.message
+        }
+      });
+    }
+    throw error;
+  }
+  const windowStartMs = windowStart.getTime();
+  const windowEndMs = windowEnd.getTime();
+  const conflicts = events.filter((event) => {
+    const s = Date.parse(event.startAt);
+    const e = Date.parse(event.endAt);
+    return s < windowEndMs && e > windowStartMs;
+  });
+  const isFree = conflicts.length === 0;
+  const fallback = isFree ? `You're free from ${formatLocalForDisplay(windowStart.toISOString(), preferences.timeZone)} to ${formatLocalForDisplay(windowEnd.toISOString(), preferences.timeZone)}.` : `You have ${conflicts.length} conflict${conflicts.length === 1 ? "" : "s"} in that window: ${conflicts.map((c) => c.title || "Untitled").join(", ")}.`;
+  return respond({
+    success: true,
+    scenario: isFree ? "scheduling_window_free" : "scheduling_window_busy",
+    fallback,
+    context: {
+      isFree,
+      conflictCount: conflicts.length,
+      timeZone: preferences.timeZone
+    },
+    data: {
+      isFree,
+      windowStart: windowStart.toISOString(),
+      windowEnd: windowEnd.toISOString(),
+      conflicts: conflicts.map((c) => ({
+        id: c.id,
+        title: c.title,
+        startAt: c.startAt,
+        endAt: c.endAt
+      })),
+      timeZone: preferences.timeZone
+    }
+  });
+}
+async function runUpdateMeetingPreferencesHandler(runtime, message, state, options, callback) {
+  const respond = makeSchedulingRespond({
+    runtime,
+    message,
+    state,
+    callback,
+    actionName: "UPDATE_MEETING_PREFERENCES"
+  });
+  if (await denyIfNoAccess(runtime, message)) {
+    return respond({
+      success: false,
+      scenario: "scheduling_access_denied",
+      fallback: "Scheduling actions are restricted to the owner and authorized users.",
+      data: { error: "PERMISSION_DENIED" }
+    });
+  }
+  const params = getParams(options);
+  const patch = normalizeLifeOpsMeetingPreferencesPatch(params);
+  if (Object.keys(patch).length === 0) {
+    return respond({
+      success: false,
+      scenario: "scheduling_preferences_no_fields",
+      fallback: "No valid preference fields were provided. Supply preferredStartLocal/preferredEndLocal as HH:MM, numeric defaultDurationMinutes/travelBufferMinutes, or a blackoutWindows array.",
+      data: { error: "NO_FIELDS" }
+    });
+  }
+  const updated = await updateLifeOpsMeetingPreferences(runtime, patch);
+  if (!updated) {
+    return respond({
+      success: false,
+      scenario: "scheduling_preferences_update_failed",
+      fallback: "Could not persist meeting preferences.",
+      data: { error: "PREFERENCES_UPDATE_FAILED" }
+    });
+  }
+  const fallback = `Updated meeting preferences (${updated.preferredStartLocal}\u2013${updated.preferredEndLocal} ${updated.timeZone}, default ${updated.defaultDurationMinutes} min, travel buffer ${updated.travelBufferMinutes} min, ${updated.blackoutWindows.length} blackout window${updated.blackoutWindows.length === 1 ? "" : "s"}).`;
+  return respond({
+    success: true,
+    scenario: "scheduling_preferences_updated",
+    fallback,
+    context: {
+      preferredStartLocal: updated.preferredStartLocal,
+      preferredEndLocal: updated.preferredEndLocal,
+      timeZone: updated.timeZone,
+      defaultDurationMinutes: updated.defaultDurationMinutes,
+      travelBufferMinutes: updated.travelBufferMinutes,
+      blackoutWindowCount: updated.blackoutWindows.length
+    },
+    data: { preferences: updated, updatedFields: Object.keys(patch) }
+  });
+}
+function normalizeSchedulingSubaction(value) {
+  if (typeof value !== "string") {
+    return null;
+  }
+  const normalized = value.trim().toLowerCase();
+  switch (normalized) {
+    case "start":
+    case "propose":
+    case "respond":
+    case "finalize":
+    case "cancel":
+    case "list_active":
+    case "list_proposals":
+      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 void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function buildSchedulingPlanPrompt(args) {
+  const instructions = resolveOptimizedPromptForRuntime(
+    args.runtime,
+    "schedule_plan",
+    SCHEDULE_PLAN_INSTRUCTIONS
+  );
+  return [
+    instructions,
+    "",
+    `Current request:
+${args.currentMessage}`,
+    `Resolved intent:
+${args.intent}`,
+    `Structured parameters:
+${Object.entries(args.params).map(([key, value]) => `${key}: ${String(value)}`).join("\n")}`,
+    `Recent conversation:
+${args.recentConversation}`
+  ].join("\n");
+}
+async function resolveSchedulingPlanWithLlm(args) {
+  const recentConversation = (await collectRecentConversationTexts({
+    runtime: args.runtime,
+    message: args.message,
+    state: args.state,
+    limit: 8
+  })).join("\n");
+  const currentMessage = typeof args.message.content.text === "string" ? args.message.content.text : "";
+  const prompt = buildSchedulingPlanPrompt({
+    runtime: args.runtime,
+    currentMessage,
+    intent: args.intent,
+    params: args.params,
+    recentConversation
+  });
+  try {
+    const result = await runWithTrajectoryContext(
+      { purpose: "schedule_plan" },
+      () => args.runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt
+      })
+    );
+    const rawResponse = typeof result === "string" ? result : "";
+    const parsed = parseJsonModelRecord(rawResponse);
+    if (!parsed) {
+      return {
+        subaction: null,
+        shouldAct: null
+      };
+    }
+    return {
+      subaction: normalizeSchedulingSubaction(parsed.subaction),
+      shouldAct: normalizeShouldAct(parsed.shouldAct),
+      response: normalizePlannerResponse(parsed.response)
+    };
+  } catch (error) {
+    args.runtime.logger.warn(
+      {
+        src: "action:scheduling",
+        error: error instanceof Error ? error.message : String(error)
+      },
+      "Scheduling planning model call failed"
+    );
+    return {
+      subaction: null,
+      shouldAct: null
+    };
+  }
+}
+function formatNegotiationSummary(n) {
+  return `Negotiation ${n.id} \u2014 "${n.subject}" (${n.durationMinutes} min, state=${n.state})`;
+}
+function formatProposalSummary(p) {
+  return `Proposal ${p.id}: ${p.startAt} \u2192 ${p.endAt} by ${p.proposedBy} (status=${p.status})`;
+}
+async function runSchedulingNegotiationHandler(runtime, message, state, options, callback) {
+  const respond = makeSchedulingRespond({
+    runtime,
+    message,
+    state,
+    callback,
+    actionName: "PERSONAL_ASSISTANT"
+  });
+  const params = options?.parameters ?? {};
+  const messageBody = typeof message.content.text === "string" ? message.content.text : "";
+  const planIntent = (params.intent ?? messageBody).trim();
+  const explicitSubaction = normalizeSchedulingSubaction(params.subaction);
+  const llmPlan = await resolveSchedulingPlanWithLlm({
+    runtime,
+    message,
+    state,
+    intent: planIntent,
+    params
+  });
+  const subaction = explicitSubaction ?? llmPlan.subaction;
+  if (llmPlan.shouldAct === false && !explicitSubaction) {
+    const fallback = llmPlan.response ?? "Do you want to start, propose, respond, finalize, cancel, or list scheduling negotiations?";
+    return respond({
+      success: false,
+      scenario: "scheduling_negotiation_clarification",
+      fallback,
+      values: {
+        success: false,
+        error: "PLANNER_SHOULDACT_FALSE",
+        noop: true
+      },
+      data: { noop: true, error: "PLANNER_SHOULDACT_FALSE" }
+    });
+  }
+  if (!subaction) {
+    const fallback = llmPlan.response ?? "Do you want to start, propose, respond, finalize, cancel, or list scheduling negotiations?";
+    return respond({
+      success: false,
+      scenario: "scheduling_negotiation_missing_subaction",
+      fallback,
+      values: { requiresConfirmation: true },
+      data: {
+        error: "MISSING_SUBACTION",
+        requiresConfirmation: true
+      }
+    });
+  }
+  const { LifeOpsService, LifeOpsServiceError } = await loadLifeOpsServiceModule();
+  const service = new LifeOpsService(runtime);
+  try {
+    if (subaction === "start") {
+      const subject = params.subject ?? params.intent ?? messageBody.trim();
+      if (!subject) {
+        return respond({
+          success: false,
+          scenario: "scheduling_negotiation_start_missing_subject",
+          fallback: "I need a subject (what the meeting is about) to start a negotiation.",
+          values: { requiresConfirmation: true },
+          data: {
+            error: "MISSING_SUBJECT",
+            requiresConfirmation: true
+          }
+        });
+      }
+      const neg = await service.startNegotiation({
+        subject,
+        relationshipId: params.relationshipId ?? null,
+        durationMinutes: params.durationMinutes,
+        timezone: params.timezone
+      });
+      return respond({
+        success: true,
+        scenario: "scheduling_negotiation_started",
+        fallback: `Started ${formatNegotiationSummary(neg)} and notified the counterparty.`,
+        context: {
+          negotiationId: neg.id,
+          subject: neg.subject,
+          durationMinutes: neg.durationMinutes,
+          state: neg.state
+        },
+        data: { negotiation: neg }
+      });
+    }
+    if (subaction === "propose") {
+      if (!params.negotiationId || !params.startAt || !params.endAt) {
+        return respond({
+          success: false,
+          scenario: "scheduling_negotiation_propose_missing_fields",
+          fallback: "Propose needs negotiationId, startAt, and endAt (ISO-8601).",
+          values: { requiresConfirmation: true },
+          data: {
+            error: "MISSING_PROPOSAL_FIELDS",
+            requiresConfirmation: true
+          }
+        });
+      }
+      const proposedBy = params.proposedBy ?? "agent";
+      const proposal = await service.proposeTime({
+        negotiationId: params.negotiationId,
+        startAt: params.startAt,
+        endAt: params.endAt,
+        proposedBy
+      });
+      const fallback2 = proposedBy === "counterparty" ? `Recorded ${formatProposalSummary(proposal)}.` : `Recorded ${formatProposalSummary(proposal)} and sent it to the counterparty.`;
+      return respond({
+        success: true,
+        scenario: "scheduling_negotiation_proposed",
+        fallback: fallback2,
+        context: {
+          proposalId: proposal.id,
+          startAt: proposal.startAt,
+          endAt: proposal.endAt,
+          proposedBy,
+          status: proposal.status
+        },
+        data: { proposal }
+      });
+    }
+    if (subaction === "respond") {
+      if (!params.proposalId || !params.response) {
+        return respond({
+          success: false,
+          scenario: "scheduling_negotiation_respond_missing_fields",
+          fallback: "Respond needs proposalId and response.",
+          data: { error: "MISSING_RESPONSE_FIELDS" }
+        });
+      }
+      const proposal = await service.respondToProposal(
+        params.proposalId,
+        params.response
+      );
+      return respond({
+        success: true,
+        scenario: "scheduling_negotiation_respond",
+        fallback: `Proposal ${proposal.id} is now ${proposal.status}.`,
+        context: { proposalId: proposal.id, status: proposal.status },
+        data: { proposal }
+      });
+    }
+    if (subaction === "finalize") {
+      if (!params.negotiationId || !params.proposalId) {
+        return respond({
+          success: false,
+          scenario: "scheduling_negotiation_finalize_missing_fields",
+          fallback: "Finalize needs negotiationId and proposalId.",
+          data: { error: "MISSING_FINALIZE_FIELDS" }
+        });
+      }
+      const neg = await service.finalizeNegotiation(
+        params.negotiationId,
+        params.proposalId
+      );
+      return respond({
+        success: true,
+        scenario: "scheduling_negotiation_finalized",
+        fallback: `Confirmed ${formatNegotiationSummary(neg)} and sent confirmation to the counterparty.`,
+        context: {
+          negotiationId: neg.id,
+          subject: neg.subject,
+          durationMinutes: neg.durationMinutes,
+          state: neg.state
+        },
+        data: { negotiation: neg }
+      });
+    }
+    if (subaction === "cancel") {
+      if (!params.negotiationId) {
+        return respond({
+          success: false,
+          scenario: "scheduling_negotiation_cancel_missing_id",
+          fallback: "Cancel needs negotiationId.",
+          data: { error: "MISSING_NEGOTIATION_ID" }
+        });
+      }
+      await service.cancelNegotiation(params.negotiationId, params.reason);
+      return respond({
+        success: true,
+        scenario: "scheduling_negotiation_cancelled",
+        fallback: `Cancelled negotiation ${params.negotiationId} and notified the counterparty.`,
+        context: { negotiationId: params.negotiationId },
+        data: { negotiationId: params.negotiationId }
+      });
+    }
+    if (subaction === "list_proposals") {
+      if (!params.negotiationId) {
+        return respond({
+          success: false,
+          scenario: "scheduling_negotiation_list_proposals_missing_id",
+          fallback: "list_proposals needs negotiationId.",
+          data: { error: "MISSING_NEGOTIATION_ID" }
+        });
+      }
+      const proposals = await service.listProposals(params.negotiationId);
+      const fallback2 = proposals.length ? `Proposals for ${params.negotiationId}:
+${proposals.map(formatProposalSummary).join("\n")}` : `No proposals for ${params.negotiationId}.`;
+      return respond({
+        success: true,
+        scenario: "scheduling_negotiation_list_proposals",
+        fallback: fallback2,
+        context: {
+          negotiationId: params.negotiationId,
+          proposalCount: proposals.length
+        },
+        data: { proposals }
+      });
+    }
+    const active = await service.listActiveNegotiations({ limit: 20 });
+    const fallback = active.length ? `Active negotiations:
+${active.map(formatNegotiationSummary).join("\n")}` : "No active scheduling negotiations.";
+    return respond({
+      success: true,
+      scenario: "scheduling_negotiation_list_active",
+      fallback,
+      context: { activeCount: active.length },
+      data: { negotiations: active }
+    });
+  } catch (error) {
+    if (error instanceof LifeOpsServiceError) {
+      return respond({
+        success: false,
+        scenario: "scheduling_negotiation_service_error",
+        fallback: `Scheduling error: ${error.message}`,
+        context: { status: error.status, detail: error.message },
+        values: { requiresConfirmation: true },
+        data: {
+          error: "SERVICE_ERROR",
+          status: error.status,
+          detail: error.message,
+          requiresConfirmation: true
+        }
+      });
+    }
+    throw error;
+  }
+}
+export {
+  SCHEDULE_PLAN_INSTRUCTIONS2 as SCHEDULE_PLAN_INSTRUCTIONS,
+  buildSchedulingPlanPrompt,
+  computeProposedSlots,
+  extractBundledMeetingCounterparties,
+  formatProposedSlotsReply,
+  runCheckAvailabilityHandler,
+  runProposeMeetingTimesHandler,
+  runSchedulingNegotiationHandler,
+  runUpdateMeetingPreferencesHandler
+};
+//# sourceMappingURL=scheduling-handler.js.map