@absolutejs/voice 0.0.22-beta.511 → 0.0.22-beta.513

package/dist/index.js

@@ -10,6 +10,19 @@ var __name = (target, name) => {
   });
   return target;
 };
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
 var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
 var __typeError = (msg) => {
   throw TypeError(msg);
@@ -70,6 +83,115 @@ var __decorateElement = (array, flags, name, decorators, target, extra) => {
 };
 var __require = import.meta.require;
 
+// src/calendarSlots.ts
+var exports_calendarSlots = {};
+__export(exports_calendarSlots, {
+  summarizeVoiceCalendarSlot: () => summarizeVoiceCalendarSlot,
+  generateVoiceCalendarSlots: () => generateVoiceCalendarSlots
+});
+var parseHHMM = (value) => {
+  const match = /^([0-9]{1,2}):([0-9]{2})$/u.exec(value);
+  if (!match)
+    throw new Error(`Invalid time string (expected HH:MM): ${value}`);
+  return Number(match[1]) * 60 + Number(match[2]);
+}, partsAt = (ms, timezone) => {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    day: "2-digit",
+    hour: "2-digit",
+    hour12: false,
+    minute: "2-digit",
+    month: "2-digit",
+    timeZone: timezone,
+    weekday: "short",
+    year: "numeric"
+  });
+  const map = {};
+  for (const part of formatter.formatToParts(new Date(ms))) {
+    if (part.type !== "literal")
+      map[part.type] = part.value;
+  }
+  const weekdayMap = {
+    Fri: 5,
+    Mon: 1,
+    Sat: 6,
+    Sun: 0,
+    Thu: 4,
+    Tue: 2,
+    Wed: 3
+  };
+  const hourValue = map.hour === "24" ? "00" : map.hour ?? "0";
+  return {
+    date: `${map.year}-${map.month}-${map.day}`,
+    minutes: Number(hourValue) * 60 + Number(map.minute ?? "0"),
+    weekday: weekdayMap[map.weekday ?? ""] ?? 0
+  };
+}, overlaps = (aStart, aEnd, bStart, bEnd) => aStart < bEnd && bStart < aEnd, generateVoiceCalendarSlots = (input) => {
+  if (input.durationMinutes <= 0) {
+    throw new Error("durationMinutes must be positive");
+  }
+  if (input.toMs <= input.fromMs)
+    return [];
+  const granularity = input.granularityMinutes ?? 15;
+  const buffer = input.bufferMinutes ?? 0;
+  const max = input.maxSlots ?? Infinity;
+  const hoursByDay = new Map;
+  for (const block of input.businessHours) {
+    const list = hoursByDay.get(block.weekday) ?? [];
+    list.push(block);
+    hoursByDay.set(block.weekday, list);
+  }
+  const blackoutDates = new Set((input.blackoutDates ?? []).map((b) => b.date));
+  const slots = [];
+  const stepMs = granularity * 60000;
+  const durationMs = input.durationMinutes * 60000;
+  const bufferMs = buffer * 60000;
+  let cursor = input.fromMs;
+  while (cursor + durationMs <= input.toMs && slots.length < max) {
+    const slotEnd = cursor + durationMs;
+    const startParts = partsAt(cursor, input.timezone);
+    if (blackoutDates.has(startParts.date)) {
+      cursor += stepMs;
+      continue;
+    }
+    const dayHours = hoursByDay.get(startParts.weekday);
+    if (!dayHours || dayHours.length === 0) {
+      cursor += stepMs;
+      continue;
+    }
+    const endParts = partsAt(slotEnd - 1, input.timezone);
+    const fitsHours = dayHours.some((block) => {
+      const startMin = parseHHMM(block.start);
+      const endMin = parseHHMM(block.end);
+      return startParts.minutes >= startMin && endParts.minutes < endMin && startParts.date === endParts.date;
+    });
+    if (!fitsHours) {
+      cursor += stepMs;
+      continue;
+    }
+    const collides = (input.bookedRanges ?? []).some((booked) => overlaps(cursor - bufferMs, slotEnd + bufferMs, booked.startMs, booked.endMs));
+    if (!collides) {
+      slots.push({
+        durationMinutes: input.durationMinutes,
+        endMs: slotEnd,
+        startMs: cursor
+      });
+    }
+    cursor += stepMs;
+  }
+  return slots;
+}, summarizeVoiceCalendarSlot = (slot, options = {}) => {
+  const formatter = new Intl.DateTimeFormat(options.locale ?? "en-US", {
+    day: "numeric",
+    hour: "numeric",
+    hour12: true,
+    minute: "2-digit",
+    month: "long",
+    timeZone: options.timezone,
+    weekday: "long"
+  });
+  return formatter.format(new Date(slot.startMs));
+};
+
 // src/audioConditioning.ts
 var DEFAULT_TARGET_LEVEL = 0.08;
 var DEFAULT_MAX_GAIN = 3;
@@ -49602,6 +49724,871 @@ var createVoiceSupervisorPermissions = (options = {}) => {
   };
 };
 var VOICE_SUPERVISOR_TIER_CAPABILITIES = TIER_CAPABILITIES;
+// src/calendarAdapter.ts
+var createVoiceInMemoryCalendarAdapter = (options) => {
+  const now = options.now ?? (() => Date.now());
+  const generateId = options.generateId ?? (() => `appt_${Math.random().toString(36).slice(2, 10)}`);
+  const appointments = new Map;
+  for (const range of options.bookedRanges ?? []) {
+    const id = generateId();
+    appointments.set(id, {
+      calendarId: "default",
+      createdAt: now(),
+      endMs: range.endMs,
+      id,
+      startMs: range.startMs,
+      status: "scheduled"
+    });
+  }
+  const liveRanges = () => Array.from(appointments.values()).filter((a) => a.status === "scheduled").map((a) => ({ endMs: a.endMs, startMs: a.startMs }));
+  return {
+    async book(input) {
+      const clash = liveRanges().some((r) => input.startMs < r.endMs && r.startMs < input.endMs);
+      if (clash)
+        throw new Error("Slot is already booked");
+      const id = generateId();
+      const appointment = {
+        calendarId: input.calendarId,
+        createdAt: now(),
+        endMs: input.endMs,
+        id,
+        startMs: input.startMs,
+        status: "scheduled",
+        ...input.title !== undefined ? { title: input.title } : {},
+        ...input.attendees !== undefined ? { attendees: input.attendees } : {},
+        ...input.notes !== undefined ? { notes: input.notes } : {},
+        ...input.metadata !== undefined ? { metadata: input.metadata } : {}
+      };
+      appointments.set(id, appointment);
+      return appointment;
+    },
+    async cancel(id) {
+      const existing = appointments.get(id);
+      if (!existing)
+        return null;
+      const cancelled = {
+        ...existing,
+        status: "cancelled"
+      };
+      appointments.set(id, cancelled);
+      return cancelled;
+    },
+    async get(id) {
+      return appointments.get(id) ?? null;
+    },
+    async listAvailability(query) {
+      const { generateVoiceCalendarSlots: generateVoiceCalendarSlots2 } = await Promise.resolve().then(() => exports_calendarSlots);
+      return generateVoiceCalendarSlots2({
+        bookedRanges: liveRanges(),
+        ...query.bufferMinutes !== undefined ? { bufferMinutes: query.bufferMinutes } : {},
+        businessHours: options.businessHours,
+        durationMinutes: query.durationMinutes,
+        fromMs: query.fromMs,
+        ...query.granularityMinutes !== undefined ? { granularityMinutes: query.granularityMinutes } : {},
+        ...query.maxSlots !== undefined ? { maxSlots: query.maxSlots } : {},
+        ...options.timezone !== undefined ? { timezone: options.timezone } : {},
+        toMs: query.toMs
+      });
+    },
+    providerName: "in-memory",
+    async reschedule(id, nextStartMs, nextEndMs) {
+      const existing = appointments.get(id);
+      if (!existing)
+        return null;
+      const others = liveRanges().filter((r) => r.startMs !== existing.startMs || r.endMs !== existing.endMs);
+      const clash = others.some((r) => nextStartMs < r.endMs && r.startMs < nextEndMs);
+      if (clash)
+        throw new Error("Cannot reschedule onto a booked slot");
+      const updated = {
+        ...existing,
+        endMs: nextEndMs,
+        startMs: nextStartMs
+      };
+      appointments.set(id, updated);
+      return updated;
+    }
+  };
+};
+// src/bookingFlow.ts
+var createVoiceBookingFlow = (options) => {
+  const initial = {
+    proposedSlots: [],
+    step: options.initialStep ?? (options.services ? "ask-service" : "ask-date")
+  };
+  let state = initial;
+  const listeners = new Set;
+  const setState = (next) => {
+    state = { ...state, ...next };
+    for (const listener of listeners)
+      listener(state);
+  };
+  const chooseService = (serviceId) => {
+    const services = options.services ?? [];
+    const service = services.find((s) => s.id === serviceId);
+    if (!service) {
+      setState({ error: `Unknown service: ${serviceId}`, step: "failed" });
+      return;
+    }
+    setState({
+      serviceDurationMinutes: service.durationMinutes,
+      serviceId: service.id,
+      step: "ask-date"
+    });
+  };
+  const proposeSlotsForDay = async (input) => {
+    const duration = state.serviceDurationMinutes ?? options.defaultDurationMinutes ?? 30;
+    const slots = await options.adapter.listAvailability({
+      calendarId: options.calendarId,
+      durationMinutes: duration,
+      fromMs: input.fromMs,
+      ...options.maxSlotsPerDay !== undefined ? { maxSlots: options.maxSlotsPerDay } : {},
+      toMs: input.toMs
+    });
+    setState({ proposedSlots: slots, step: slots.length > 0 ? "ask-time" : "ask-date" });
+    return slots;
+  };
+  const chooseSlot = (slotIndex) => {
+    const slot = state.proposedSlots[slotIndex];
+    if (!slot) {
+      setState({ error: "Invalid slot selection", step: "failed" });
+      return;
+    }
+    setState({ selectedSlot: slot, step: "confirm" });
+  };
+  const confirm = async (input = {}) => {
+    if (state.step !== "confirm" || !state.selectedSlot) {
+      setState({ error: "Nothing to confirm", step: "failed" });
+      return null;
+    }
+    setState({ step: "booking" });
+    try {
+      const appt = await options.adapter.book({
+        calendarId: options.calendarId,
+        endMs: state.selectedSlot.endMs,
+        startMs: state.selectedSlot.startMs,
+        ...input.attendees !== undefined ? { attendees: input.attendees } : {},
+        ...input.title !== undefined ? { title: input.title } : {},
+        ...input.notes !== undefined ? { notes: input.notes } : {}
+      });
+      setState({ appointment: appt, step: "booked" });
+      return appt;
+    } catch (error) {
+      setState({
+        error: error instanceof Error ? error.message : String(error),
+        step: "failed"
+      });
+      return null;
+    }
+  };
+  const reset = () => {
+    state = {
+      proposedSlots: [],
+      step: options.initialStep ?? (options.services ? "ask-service" : "ask-date")
+    };
+    for (const listener of listeners)
+      listener(state);
+  };
+  return {
+    chooseService,
+    chooseSlot,
+    confirm,
+    getState: () => state,
+    proposeSlotsForDay,
+    reset,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(state);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+// src/noShowPredictor.ts
+var clamp = (value, min = 0, max = 1) => Math.max(min, Math.min(max, value));
+var scoreVoiceNoShowRisk = (input) => {
+  const now = input.now ?? (() => Date.now());
+  const leadHours = (input.appointmentStartMs - input.bookedAtMs) / 3600000;
+  const startDate = new Date(input.appointmentStartMs);
+  const weekday = startDate.getUTCDay();
+  const hour = startDate.getUTCHours();
+  const history = input.history ?? [];
+  const past = history.filter((r) => r.scheduledStartMs < input.appointmentStartMs);
+  const priorNoShows = past.filter((r) => r.outcome === "no-show").length;
+  const priorKept = past.filter((r) => r.outcome === "kept").length;
+  let score = 0.15;
+  const drivers = [];
+  if (leadHours > 72) {
+    score += 0.1;
+    drivers.push({ kind: "lead-time-hours", value: leadHours });
+  } else if (leadHours < 12) {
+    score -= 0.05;
+    drivers.push({ kind: "lead-time-hours", value: leadHours });
+  }
+  if (weekday === 1) {
+    score += 0.04;
+    drivers.push({ kind: "weekday", value: weekday });
+  }
+  if (weekday === 5) {
+    score += 0.03;
+    drivers.push({ kind: "weekday", value: weekday });
+  }
+  if (hour < 9 || hour >= 17) {
+    score += 0.04;
+    drivers.push({ kind: "hour-of-day", value: hour });
+  }
+  if (priorNoShows > 0) {
+    const delta = Math.min(0.5, priorNoShows * 0.2);
+    score += delta;
+    drivers.push({ kind: "prior-no-show-count", value: priorNoShows });
+  }
+  if (priorKept > 2 && priorNoShows === 0) {
+    score -= 0.08;
+    drivers.push({ kind: "prior-kept-count", value: priorKept });
+  }
+  if (input.reminderConfirmed === true) {
+    score -= 0.15;
+    drivers.push({ kind: "reminder-confirmed", value: true });
+  } else if (input.reminderConfirmed === false) {
+    score += 0.1;
+    drivers.push({ kind: "reminder-confirmed", value: false });
+  }
+  if (input.callbackDistanceHours !== undefined && input.callbackDistanceHours > 24) {
+    score += 0.06;
+    drivers.push({
+      kind: "callback-distance-hours",
+      value: input.callbackDistanceHours
+    });
+  }
+  if (input.weatherDisruption) {
+    score += 0.18;
+    drivers.push({ kind: "weather-disruption", value: true });
+  }
+  const finalScore = clamp(score);
+  const band = finalScore >= 0.55 ? "high" : finalScore >= 0.3 ? "moderate" : "low";
+  return { band, drivers, score: finalScore };
+};
+var summarizeVoiceNoShowVerdict = (verdict) => {
+  const pct = Math.round(verdict.score * 100);
+  const top = verdict.drivers.slice(0, 2).map((d) => d.kind).join(", ");
+  return `${verdict.band} risk (${pct}%)${top ? ` \u2014 driven by ${top}` : ""}`;
+};
+// src/reminderScheduler.ts
+var DEFAULT_VOICE_REMINDER_TRIGGERS = [
+  {
+    channel: "sms",
+    id: "remind-24h",
+    offsetMinutesBeforeStart: 24 * 60
+  },
+  {
+    channel: "sms",
+    id: "remind-2h",
+    offsetMinutesBeforeStart: 120
+  },
+  {
+    channel: "call",
+    id: "remind-call-30m",
+    offsetMinutesBeforeStart: 30,
+    retryOnFailure: true
+  }
+];
+var createVoiceReminderScheduler = (options = {}) => {
+  const now = options.now ?? (() => Date.now());
+  const generateId = options.generateJobId ?? (() => `rem_${Math.random().toString(36).slice(2, 10)}`);
+  const defaultTriggers = options.defaultTriggers ?? DEFAULT_VOICE_REMINDER_TRIGGERS;
+  const maxAttempts = options.maxAttempts ?? 2;
+  const jobs = new Map;
+  const listeners = new Set;
+  const broadcast = (job) => {
+    for (const listener of listeners)
+      listener(job);
+  };
+  const schedule = (input) => {
+    const triggers = input.triggers.length > 0 ? input.triggers : defaultTriggers;
+    const at = now();
+    const created = [];
+    for (const trigger of triggers) {
+      const fireAt = input.appointmentStartMs - trigger.offsetMinutesBeforeStart * 60000;
+      if (fireAt <= at)
+        continue;
+      const job = {
+        appointmentId: input.appointmentId,
+        attempts: 0,
+        channel: trigger.channel,
+        id: generateId(),
+        scheduledAtMs: fireAt,
+        status: "pending",
+        triggerId: trigger.id,
+        ...input.metadata !== undefined ? { metadata: input.metadata } : {}
+      };
+      jobs.set(job.id, job);
+      created.push(job);
+      broadcast(job);
+    }
+    return created;
+  };
+  const due = (at = now()) => Array.from(jobs.values()).filter((j) => j.status === "pending" && j.scheduledAtMs <= at);
+  const markInFlight = (jobId) => {
+    const job = jobs.get(jobId);
+    if (!job || job.status !== "pending")
+      return false;
+    job.status = "in-flight";
+    job.attempts += 1;
+    broadcast(job);
+    return true;
+  };
+  const markSent = (jobId) => {
+    const job = jobs.get(jobId);
+    if (!job)
+      return false;
+    job.status = "sent";
+    broadcast(job);
+    return true;
+  };
+  const markFailed = (jobId, error) => {
+    const job = jobs.get(jobId);
+    if (!job)
+      return false;
+    job.lastError = error;
+    if (job.attempts < maxAttempts) {
+      job.status = "pending";
+      job.scheduledAtMs = now() + 5 * 60000;
+    } else {
+      job.status = "failed";
+    }
+    broadcast(job);
+    return true;
+  };
+  const cancelForAppointment = (appointmentId) => {
+    let count = 0;
+    for (const job of jobs.values()) {
+      if (job.appointmentId === appointmentId && (job.status === "pending" || job.status === "in-flight")) {
+        job.status = "cancelled";
+        broadcast(job);
+        count += 1;
+      }
+    }
+    return count;
+  };
+  return {
+    cancelForAppointment,
+    due,
+    list: (appointmentId) => Array.from(jobs.values()).filter((j) => !appointmentId || j.appointmentId === appointmentId),
+    markFailed,
+    markInFlight,
+    markSent,
+    schedule,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
+// src/callScorecard.ts
+var clampScore = (raw, max) => Math.max(0, Math.min(max, raw));
+var buildVoiceCallScorecard = (input) => {
+  const now = input.now ?? (() => Date.now());
+  const scaleMax = input.rubric.scaleMax ?? 5;
+  const passingGrade = input.rubric.passingGrade ?? 0.7;
+  const totalWeight = input.rubric.criteria.reduce((sum, c) => sum + c.weight, 0);
+  if (totalWeight <= 0) {
+    throw new Error("Rubric weights must sum to a positive number");
+  }
+  const results = [];
+  const failedRequiredCriteria = [];
+  const sectionAccum = new Map;
+  for (const criterion of input.rubric.criteria) {
+    const raw = input.scores[criterion.id];
+    if (!raw) {
+      throw new Error(`Missing score for criterion: ${criterion.id}`);
+    }
+    const score = clampScore(raw.score, scaleMax);
+    const passingScore = criterion.passingScore ?? scaleMax * 0.6;
+    const passed = score >= passingScore;
+    const result = {
+      criterionId: criterion.id,
+      passed,
+      score,
+      weight: criterion.weight,
+      ...raw.rationale !== undefined ? { rationale: raw.rationale } : {}
+    };
+    results.push(result);
+    if (!passed && criterion.required) {
+      failedRequiredCriteria.push(criterion.id);
+    }
+    const section = criterion.section ?? "default";
+    const entry = sectionAccum.get(section) ?? { weight: 0, weighted: 0 };
+    entry.weighted += score * criterion.weight;
+    entry.weight += criterion.weight;
+    sectionAccum.set(section, entry);
+  }
+  const weightedSum = results.reduce((sum, r) => sum + r.score * r.weight, 0);
+  const weightedScore = weightedSum / (totalWeight * scaleMax);
+  const sectionScores = {};
+  for (const [section, accum] of sectionAccum) {
+    sectionScores[section] = accum.weight === 0 ? 0 : accum.weighted / (accum.weight * scaleMax);
+  }
+  const grade = failedRequiredCriteria.length > 0 ? "fail" : weightedScore >= passingGrade ? "pass" : "needs-review";
+  return {
+    createdAt: now(),
+    failedRequiredCriteria,
+    grade,
+    passingGrade,
+    results,
+    reviewer: input.reviewer,
+    rubricId: input.rubric.id,
+    scaleMax,
+    sectionScores,
+    sessionId: input.sessionId,
+    weightedScore,
+    ...input.agentId !== undefined ? { agentId: input.agentId } : {},
+    ...input.reviewerId !== undefined ? { reviewerId: input.reviewerId } : {},
+    ...input.comments !== undefined ? { comments: input.comments } : {}
+  };
+};
+var DEFAULT_VOICE_SALES_RUBRIC = {
+  criteria: [
+    {
+      id: "greeting",
+      label: "Professional greeting",
+      section: "opening",
+      weight: 1
+    },
+    {
+      id: "needs-discovery",
+      label: "Discovers customer needs",
+      required: true,
+      section: "discovery",
+      weight: 2
+    },
+    {
+      id: "objection-handling",
+      label: "Handles objections clearly",
+      section: "objections",
+      weight: 2
+    },
+    {
+      id: "compliance-disclosure",
+      label: "Made required compliance disclosure",
+      required: true,
+      section: "compliance",
+      weight: 3
+    },
+    {
+      id: "close-or-next-step",
+      label: "Closes or sets a next step",
+      section: "close",
+      weight: 2
+    }
+  ],
+  id: "default-sales",
+  label: "Default sales QA rubric",
+  passingGrade: 0.75,
+  scaleMax: 5
+};
+// src/aiScorecard.ts
+var DEFAULT_SYSTEM_PROMPT3 = "You are an impartial quality reviewer scoring a voice-agent call transcript. " + "For each criterion, return a numeric score between 0 and the rubric's scaleMax, with a one-sentence rationale grounded in the transcript. " + 'Respond with strict JSON: {"scores":[{"criterionId":"\u2026","score":4,"rationale":"\u2026"}],"comments":"\u2026"}. ' + "Do not return prose outside the JSON.";
+var buildPrompt2 = (input) => {
+  const { rubric } = input;
+  const scaleMax = rubric.scaleMax ?? 5;
+  const criteriaBlock = rubric.criteria.map((criterion) => `- ${criterion.id}${criterion.required ? " (required)" : ""}: ${criterion.label} (weight=${criterion.weight}${criterion.section ? `, section=${criterion.section}` : ""})`).join(`
+`);
+  const metadataBlock = input.metadata ? `
+Metadata:
+${JSON.stringify(input.metadata, null, 2)}
+` : "";
+  return `Rubric: ${rubric.label} (scaleMax=${scaleMax})
+Criteria:
+${criteriaBlock}
+${metadataBlock}
+Transcript:
+${input.transcript}
+
+Return JSON only.`;
+};
+var extractJson3 = (raw) => {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    throw new Error("AI scorecard returned an empty response");
+  const fenced = /```(?:json)?\s*([\s\S]*?)```/iu.exec(trimmed);
+  const candidate = fenced ? fenced[1].trim() : trimmed;
+  try {
+    return JSON.parse(candidate);
+  } catch {
+    const start = candidate.indexOf("{");
+    const end = candidate.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      return JSON.parse(candidate.slice(start, end + 1));
+    }
+    throw new Error(`AI scorecard response was not valid JSON: ${raw.slice(0, 200)}`);
+  }
+};
+var parseVoiceAIScorecardResponse = (raw, rubric) => {
+  const payload = extractJson3(raw);
+  if (!payload || typeof payload !== "object") {
+    throw new Error("AI scorecard response is not a JSON object");
+  }
+  const root = payload;
+  const scoresRaw = root.scores;
+  if (!Array.isArray(scoresRaw)) {
+    throw new Error("AI scorecard response missing scores[] array");
+  }
+  const known = new Set(rubric.criteria.map((c) => c.id));
+  const parsed = [];
+  for (const entry of scoresRaw) {
+    if (!entry || typeof entry !== "object")
+      continue;
+    const item = entry;
+    const criterionId = String(item.criterionId ?? "").trim();
+    if (!criterionId || !known.has(criterionId))
+      continue;
+    const scoreValue = Number(item.score);
+    if (Number.isNaN(scoreValue))
+      continue;
+    parsed.push({
+      criterionId,
+      score: scoreValue,
+      ...typeof item.rationale === "string" ? { rationale: item.rationale } : {}
+    });
+  }
+  const comments = typeof root.comments === "string" ? root.comments : undefined;
+  return {
+    scores: parsed,
+    ...comments !== undefined ? { comments } : {}
+  };
+};
+var createVoiceAIScorecard = (options) => {
+  const systemPrompt = options.systemPrompt ?? DEFAULT_SYSTEM_PROMPT3;
+  return {
+    async scoreCall(input) {
+      const prompt = buildPrompt2(input);
+      const raw = await options.completion({ prompt, systemPrompt });
+      const parsed = parseVoiceAIScorecardResponse(raw, input.rubric);
+      const scoreMap = {};
+      for (const entry of parsed.scores) {
+        scoreMap[entry.criterionId] = {
+          score: entry.score,
+          ...entry.rationale !== undefined ? { rationale: entry.rationale } : {}
+        };
+      }
+      for (const criterion of input.rubric.criteria) {
+        if (!scoreMap[criterion.id]) {
+          scoreMap[criterion.id] = {
+            rationale: "No rationale returned by AI scorer",
+            score: 0
+          };
+        }
+      }
+      return buildVoiceCallScorecard({
+        reviewer: "llm",
+        rubric: input.rubric,
+        scores: scoreMap,
+        sessionId: input.sessionId,
+        ...input.agentId !== undefined ? { agentId: input.agentId } : {},
+        ...input.reviewerId !== undefined ? { reviewerId: input.reviewerId } : {},
+        ...parsed.comments !== undefined ? { comments: parsed.comments } : {},
+        ...input.now !== undefined ? { now: input.now } : {}
+      });
+    }
+  };
+};
+// src/agentPerformanceReport.ts
+var bucketKeyFor = (ms, bucket) => {
+  const date = new Date(ms);
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  if (bucket === "day")
+    return `${year}-${month}-${day}`;
+  if (bucket === "month")
+    return `${year}-${month}`;
+  const firstJan = Date.UTC(year, 0, 1);
+  const week = Math.floor((ms - firstJan) / (7 * 24 * 60 * 60 * 1000)) + 1;
+  return `${year}-W${String(week).padStart(2, "0")}`;
+};
+var buildVoiceAgentPerformanceReport = (input) => {
+  const bucket = input.bucket ?? "week";
+  const scorecards = input.scorecards.filter((card) => card.agentId === input.agentId && card.rubricId === input.rubricId).filter((card) => (input.fromMs === undefined || card.createdAt >= input.fromMs) && (input.toMs === undefined || card.createdAt <= input.toMs)).sort((a, b) => a.createdAt - b.createdAt);
+  const bucketMap = new Map;
+  for (const card of scorecards) {
+    const key = bucketKeyFor(card.createdAt, bucket);
+    const entry = bucketMap.get(key) ?? {
+      fail: 0,
+      needsReview: 0,
+      pass: 0,
+      sum: 0,
+      total: 0
+    };
+    entry.total += 1;
+    entry.sum += card.weightedScore;
+    if (card.grade === "pass")
+      entry.pass += 1;
+    else if (card.grade === "needs-review")
+      entry.needsReview += 1;
+    else
+      entry.fail += 1;
+    bucketMap.set(key, entry);
+  }
+  const buckets = Array.from(bucketMap.entries()).sort((a, b) => a[0] < b[0] ? -1 : 1).map(([bucketKey2, e]) => ({
+    averageWeightedScore: e.total > 0 ? e.sum / e.total : 0,
+    bucketKey: bucketKey2,
+    callsScored: e.total,
+    failRate: e.total > 0 ? e.fail / e.total : 0,
+    needsReviewRate: e.total > 0 ? e.needsReview / e.total : 0,
+    passRate: e.total > 0 ? e.pass / e.total : 0
+  }));
+  const criterionMap = new Map;
+  for (const card of scorecards) {
+    for (const result of card.results) {
+      const entry = criterionMap.get(result.criterionId) ?? {
+        firstAvg: null,
+        passes: 0,
+        scoreSum: 0,
+        total: 0
+      };
+      entry.scoreSum += result.score / card.scaleMax;
+      entry.total += 1;
+      if (result.passed)
+        entry.passes += 1;
+      criterionMap.set(result.criterionId, entry);
+    }
+  }
+  const firstHalf = scorecards.slice(0, Math.max(1, Math.floor(scorecards.length / 2)));
+  const secondHalf = scorecards.slice(Math.floor(scorecards.length / 2));
+  const halfAverage = (cards, criterionId) => {
+    const matches = cards.flatMap((c) => c.results.filter((r) => r.criterionId === criterionId).map((r) => r.score / c.scaleMax));
+    if (matches.length === 0)
+      return null;
+    return matches.reduce((a, b) => a + b, 0) / matches.length;
+  };
+  const criteria = [];
+  for (const [criterionId, e] of criterionMap) {
+    const earlier = halfAverage(firstHalf, criterionId);
+    const later = halfAverage(secondHalf, criterionId);
+    let trend = "flat";
+    let delta = 0;
+    if (earlier !== null && later !== null) {
+      delta = later - earlier;
+      if (delta > 0.05)
+        trend = "up";
+      else if (delta < -0.05)
+        trend = "down";
+    }
+    criteria.push({
+      averageScore: e.total > 0 ? e.scoreSum / e.total : 0,
+      criterionId,
+      delta,
+      passRate: e.total > 0 ? e.passes / e.total : 0,
+      trend
+    });
+  }
+  criteria.sort((a, b) => a.criterionId.localeCompare(b.criterionId));
+  const overallTotal = scorecards.length;
+  const overallSum = scorecards.reduce((s, c) => s + c.weightedScore, 0);
+  const overallPasses = scorecards.filter((c) => c.grade === "pass").length;
+  const ranked = [...criteria].sort((a, b) => a.averageScore - b.averageScore);
+  return {
+    agentId: input.agentId,
+    bestCriterion: ranked.at(-1)?.criterionId ?? null,
+    bucket,
+    buckets,
+    criteria,
+    fromMs: input.fromMs ?? scorecards[0]?.createdAt ?? 0,
+    overallAverageScore: overallTotal > 0 ? overallSum / overallTotal : 0,
+    overallPassRate: overallTotal > 0 ? overallPasses / overallTotal : 0,
+    rubricId: input.rubricId,
+    toMs: input.toMs ?? scorecards.at(-1)?.createdAt ?? 0,
+    totalCalls: overallTotal,
+    worstCriterion: ranked[0]?.criterionId ?? null
+  };
+};
+// src/scorecardCalibration.ts
+var normalize = (raw, scaleMax) => scaleMax === 0 ? 0 : raw / scaleMax;
+var correlation = (xs, ys) => {
+  if (xs.length === 0 || xs.length !== ys.length)
+    return 0;
+  const meanX = xs.reduce((a, b) => a + b, 0) / xs.length;
+  const meanY = ys.reduce((a, b) => a + b, 0) / ys.length;
+  let num = 0;
+  let denomX = 0;
+  let denomY = 0;
+  for (let i = 0;i < xs.length; i++) {
+    const dx = (xs[i] ?? 0) - meanX;
+    const dy = (ys[i] ?? 0) - meanY;
+    num += dx * dy;
+    denomX += dx * dx;
+    denomY += dy * dy;
+  }
+  if (denomX === 0 || denomY === 0)
+    return 0;
+  return num / Math.sqrt(denomX * denomY);
+};
+var computeVoiceScorecardCalibration = (pairs, options = {}) => {
+  if (pairs.length === 0) {
+    return {
+      gradeAgreementRate: 0,
+      meanAbsoluteError: 0,
+      pairsCompared: 0,
+      perCriterion: [],
+      rootMeanSquareError: 0,
+      weightedScoreCorrelation: 0,
+      worstDivergences: []
+    };
+  }
+  const topN = options.topDivergences ?? 10;
+  const gapsByCriterion = new Map;
+  const allGaps = [];
+  const divergences = [];
+  const humanWeighted = [];
+  const llmWeighted = [];
+  let gradeAgreed = 0;
+  let comparedPairs = 0;
+  for (const pair of pairs) {
+    if (pair.human.rubricId !== pair.llm.rubricId)
+      continue;
+    comparedPairs += 1;
+    if (pair.human.grade === pair.llm.grade)
+      gradeAgreed += 1;
+    humanWeighted.push(pair.human.weightedScore);
+    llmWeighted.push(pair.llm.weightedScore);
+    const humanByCriterion = new Map(pair.human.results.map((r) => [r.criterionId, r]));
+    const llmByCriterion = new Map(pair.llm.results.map((r) => [r.criterionId, r]));
+    const criteriaIds = new Set([
+      ...humanByCriterion.keys(),
+      ...llmByCriterion.keys()
+    ]);
+    for (const criterionId of criteriaIds) {
+      const h = humanByCriterion.get(criterionId);
+      const l = llmByCriterion.get(criterionId);
+      if (!h || !l)
+        continue;
+      const hn = normalize(h.score, pair.human.scaleMax);
+      const ln = normalize(l.score, pair.llm.scaleMax);
+      const gap = Math.abs(hn - ln);
+      allGaps.push(gap);
+      divergences.push({
+        criterionId,
+        humanScore: hn,
+        llmScore: ln,
+        normalizedGap: hn - ln,
+        sessionId: pair.sessionId
+      });
+      const entry = gapsByCriterion.get(criterionId) ?? {
+        absSum: 0,
+        biasSum: 0,
+        count: 0,
+        humanSum: 0,
+        llmSum: 0
+      };
+      entry.absSum += gap;
+      entry.biasSum += ln - hn;
+      entry.humanSum += hn;
+      entry.llmSum += ln;
+      entry.count += 1;
+      gapsByCriterion.set(criterionId, entry);
+    }
+  }
+  const mae = allGaps.length === 0 ? 0 : allGaps.reduce((a, b) => a + b, 0) / allGaps.length;
+  const rmse = allGaps.length === 0 ? 0 : Math.sqrt(allGaps.reduce((a, b) => a + b * b, 0) / allGaps.length);
+  const perCriterion = Array.from(gapsByCriterion.entries()).map(([criterionId, e]) => ({
+    averageHumanScore: e.count === 0 ? 0 : e.humanSum / e.count,
+    averageLLMScore: e.count === 0 ? 0 : e.llmSum / e.count,
+    bias: e.count === 0 ? 0 : e.biasSum / e.count,
+    criterionId,
+    meanAbsoluteError: e.count === 0 ? 0 : e.absSum / e.count
+  }));
+  return {
+    gradeAgreementRate: comparedPairs === 0 ? 0 : gradeAgreed / comparedPairs,
+    meanAbsoluteError: mae,
+    pairsCompared: comparedPairs,
+    perCriterion,
+    rootMeanSquareError: rmse,
+    weightedScoreCorrelation: correlation(humanWeighted, llmWeighted),
+    worstDivergences: divergences.sort((a, b) => Math.abs(b.normalizedGap) - Math.abs(a.normalizedGap)).slice(0, topN)
+  };
+};
+// src/qualityDriftDetector.ts
+var severityFor = (delta, watch, regression) => {
+  if (delta <= -regression)
+    return "regression";
+  if (delta <= -watch)
+    return "watch";
+  return "ok";
+};
+var averageScore = (cards) => cards.length === 0 ? 0 : cards.reduce((sum, c) => sum + c.weightedScore, 0) / cards.length;
+var averageCriterion = (cards, criterionId) => {
+  const matches = [];
+  for (const card of cards) {
+    for (const result of card.results) {
+      if (result.criterionId === criterionId) {
+        matches.push(result.score / card.scaleMax);
+      }
+    }
+  }
+  return matches.length === 0 ? 0 : matches.reduce((a, b) => a + b, 0) / matches.length;
+};
+var detectVoiceQualityDrift = (input) => {
+  const now = input.now ?? (() => Date.now());
+  const currentWindow = input.currentWindowMs ?? 7 * 24 * 60 * 60 * 1000;
+  const baselineWindow = input.baselineWindowMs ?? 30 * 24 * 60 * 60 * 1000;
+  const watch = input.watchThreshold ?? 0.05;
+  const regression = input.regressionThreshold ?? 0.1;
+  const cutoff = now();
+  const currentFrom = cutoff - currentWindow;
+  const baselineFrom = cutoff - currentWindow - baselineWindow;
+  const baselineTo = currentFrom;
+  const relevant = input.scorecards.filter((card) => card.rubricId === input.rubricId);
+  const baselineCards = relevant.filter((c) => c.createdAt >= baselineFrom && c.createdAt < baselineTo);
+  const currentCards = relevant.filter((c) => c.createdAt >= currentFrom && c.createdAt <= cutoff);
+  const baselineAvg = averageScore(baselineCards);
+  const currentAvg = averageScore(currentCards);
+  const overallDelta = currentAvg - baselineAvg;
+  const criterionIds = new Set;
+  for (const card of relevant) {
+    for (const result of card.results)
+      criterionIds.add(result.criterionId);
+  }
+  const criteria = [];
+  for (const criterionId of criterionIds) {
+    const baseline = averageCriterion(baselineCards, criterionId);
+    const current = averageCriterion(currentCards, criterionId);
+    const delta = current - baseline;
+    const severity = severityFor(delta, watch, regression);
+    criteria.push({
+      baselineAverage: baseline,
+      criterionId,
+      currentAverage: current,
+      delta,
+      severity
+    });
+  }
+  criteria.sort((a, b) => a.delta - b.delta);
+  const alertCount = criteria.filter((c) => c.severity !== "ok").length;
+  return {
+    alertCount,
+    baselineWindow: {
+      from: baselineFrom,
+      sampleSize: baselineCards.length,
+      to: baselineTo
+    },
+    criteria,
+    currentWindow: {
+      from: currentFrom,
+      sampleSize: currentCards.length,
+      to: cutoff
+    },
+    overall: {
+      baselineAverage: baselineAvg,
+      currentAverage: currentAvg,
+      delta: overallDelta,
+      severity: severityFor(overallDelta, watch, regression)
+    },
+    rubricId: input.rubricId,
+    scope: { from: baselineFrom, to: cutoff }
+  };
+};
 export {
   writeVoiceProofPack,
   writeVoiceMediaPipelineArtifacts,
@@ -49649,6 +50636,7 @@ export {
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
   summarizeVoiceOpsStatus,
+  summarizeVoiceNoShowVerdict,
   summarizeVoiceMediaPipelineReport,
   summarizeVoiceLiveLatency,
   summarizeVoiceIntegrationEvents,
@@ -49657,6 +50645,7 @@ export {
   summarizeVoiceCampaigns,
   summarizeVoiceCampaignDispositions,
   summarizeVoiceCallerTranscript,
+  summarizeVoiceCalendarSlot,
   summarizeVoiceBrowserMedia,
   summarizeVoiceBargeIn,
   summarizeVoiceAuditTrail,
@@ -49670,6 +50659,7 @@ export {
   shouldRetryCampaignAttempt,
   shapeTelephonyAssistantText,
   selectVoiceTraceEventsForPrune,
+  scoreVoiceNoShowRisk,
   saveVoiceIncidentBundleArtifact,
   runVoiceToolContractSuite,
   runVoiceToolContract,
@@ -49851,6 +50841,7 @@ export {
   predictVoiceCallCost,
   parseVoiceTelephonyWebhookEvent,
   parseVoiceSessionSnapshot,
+  parseVoiceAIScorecardResponse,
   normalizeVoiceProofTrendReport,
   normalizePhoneNumber,
   muteVoiceMonitorIssue,
@@ -49877,6 +50868,7 @@ export {
   getLatestVoiceTelephonyMediaReport,
   getLatestVoiceBrowserMediaReport,
   getDefaultVoiceTelephonyBenchmarkScenarios,
+  generateVoiceCalendarSlots,
   fromVapiAssistantConfig,
   formatVoiceProofTrendAge,
   formatVoiceCallPlayerTimestamp,
@@ -49928,6 +50920,7 @@ export {
   encodeTwilioMulawBase64,
   encodeStereoWav,
   encodePcmAsWav,
+  detectVoiceQualityDrift,
   describeVoiceIVRPlan,
   describeVoiceAssistantMode,
   describeVoiceAgentUIState,
@@ -50053,6 +51046,7 @@ export {
   createVoiceRetentionScheduler,
   createVoiceResilienceRoutes,
   createVoiceReplayTimelineHTMXRoute,
+  createVoiceReminderScheduler,
   createVoiceRedisTelnyxWebhookEventStore,
   createVoiceRedisTelephonyWebhookIdempotencyStore,
   createVoiceRedisTaskLeaseCoordinator,
@@ -50193,6 +51187,7 @@ export {
   createVoiceIncidentBundleRoutes,
   createVoiceInMemoryRealCallProfileRecoveryJobStore,
   createVoiceInMemoryMonitorRegistry,
+  createVoiceInMemoryCalendarAdapter,
   createVoiceIVRSession,
   createVoiceHubSpotTaskUpdateSink,
   createVoiceHubSpotTaskSyncSinks,
@@ -50267,6 +51262,7 @@ export {
   createVoiceCRMActivitySink,
   createVoiceBrowserMediaRoutes,
   createVoiceBrowserCallProfileRoutes,
+  createVoiceBookingFlow,
   createVoiceBearerAuthVerifier,
   createVoiceBargeInRoutes,
   createVoiceBackchannelDriver,
@@ -50293,6 +51289,7 @@ export {
   createVoiceAgentTool,
   createVoiceAgentSquad,
   createVoiceAgent,
+  createVoiceAIScorecard,
   createVoiceAIJudgeCompletion,
   createTwilioVoiceRoutes,
   createTwilioVoiceResponse,
@@ -50332,6 +51329,7 @@ export {
   createAnthropicVoiceAssistantModel,
   createAIVoiceModel,
   conditionAudioChunk,
+  computeVoiceScorecardCalibration,
   computePcmDurationMs,
   completeVoiceOpsTask,
   compareVoiceEvalBaseline,
@@ -50425,11 +51423,13 @@ export {
   buildVoiceCompetitiveCoverageReport,
   buildVoiceCampaignObservabilityReport,
   buildVoiceCallerMemoryNamespace,
+  buildVoiceCallScorecard,
   buildVoiceCallDebuggerReport,
   buildVoiceBrowserCallProfileReport,
   buildVoiceAuditTrailReport,
   buildVoiceAuditExport,
   buildVoiceAuditDeliveryReport,
+  buildVoiceAgentPerformanceReport,
   buildReplayTimelineReport,
   buildOTELTraceId,
   buildOTELSpanId,
@@ -50494,6 +51494,8 @@ export {
   VOICE_DTMF_DIGITS,
   VOICE_CALLER_MEMORY_KEY,
   TURN_PROFILE_DEFAULTS,
+  DEFAULT_VOICE_SALES_RUBRIC,
+  DEFAULT_VOICE_REMINDER_TRIGGERS,
   DEFAULT_VOICE_REDACTION_PATTERNS,
   DEFAULT_VOICE_PROOF_TREND_PROFILE_DEFINITIONS,
   DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS,