@absolutejs/voice 0.0.22-beta.506 → 0.0.22-beta.508

package/dist/index.js

@@ -48011,6 +48011,556 @@ var createVoiceLiveMonitorRoutes = (options) => {
   }
   return app;
 };
+// src/costPredictor.ts
+var lookupRates2 = (priceBook, provider, model) => {
+  if (!provider)
+    return;
+  const namespacedKey = model ? `${provider.toLowerCase()}:${model.toLowerCase()}` : undefined;
+  if (namespacedKey && priceBook[namespacedKey]) {
+    return priceBook[namespacedKey];
+  }
+  const bare = provider.toLowerCase();
+  return priceBook[bare];
+};
+var round = (value, places = 6) => {
+  const factor = 10 ** places;
+  return Math.round(value * factor) / factor;
+};
+var predictVoiceCallCost = (input) => {
+  const priceBook = input.priceBook ?? DEFAULT_VOICE_PRICE_BOOK;
+  const p = input.profile;
+  const llm = lookupRates2(priceBook, p.llmProvider, p.llmModel)?.llm;
+  const tts = p.ttsProvider ? lookupRates2(priceBook, p.ttsProvider, p.ttsModel)?.tts : undefined;
+  const stt = p.sttProvider ? lookupRates2(priceBook, p.sttProvider, p.sttModel)?.stt : undefined;
+  const telephony = p.telephonyProvider ? lookupRates2(priceBook, p.telephonyProvider, undefined)?.telephony : undefined;
+  const totalInputTokens = p.inputTokensPerTurn * p.turnsPerCall;
+  const totalOutputTokens = p.outputTokensPerTurn * p.turnsPerCall;
+  const llmUsd = llm ? totalInputTokens * llm.inputPerMillionTokensUsd / 1e6 + totalOutputTokens * llm.outputPerMillionTokensUsd / 1e6 : 0;
+  const totalChars = p.ttsCharsPerTurn * p.turnsPerCall;
+  let ttsUsd = 0;
+  if (tts?.perMillionCharactersUsd !== undefined && totalChars > 0) {
+    ttsUsd = totalChars * tts.perMillionCharactersUsd / 1e6;
+  } else if (tts?.perSecondUsd !== undefined) {
+    const audioSec = totalChars / 13.75;
+    ttsUsd = audioSec * tts.perSecondUsd;
+  }
+  const sttSeconds = p.minutesPerCall * 60;
+  const sttUsd = stt ? sttSeconds * stt.perSecondUsd : 0;
+  const telephonyUsd = telephony ? p.minutesPerCall * telephony.perMinuteUsd : 0;
+  const totalPerCall = llmUsd + ttsUsd + sttUsd + telephonyUsd;
+  const callsPerDay = (p.inboundPerDay ?? 0) + (p.outboundPerDay ?? 0);
+  const monthlyCalls = callsPerDay * 30;
+  return {
+    callsPerDay,
+    monthly: {
+      llmUsd: round(llmUsd * monthlyCalls),
+      sttUsd: round(sttUsd * monthlyCalls),
+      telephonyUsd: round(telephonyUsd * monthlyCalls),
+      totalUsd: round(totalPerCall * monthlyCalls),
+      ttsUsd: round(ttsUsd * monthlyCalls)
+    },
+    perCall: {
+      llmUsd: round(llmUsd),
+      sttUsd: round(sttUsd),
+      telephonyUsd: round(telephonyUsd),
+      totalUsd: round(totalPerCall),
+      ttsUsd: round(ttsUsd)
+    }
+  };
+};
+var compareVoiceCostScenarios = (input) => {
+  const baselineDef = input.scenarios.find((s) => s.id === input.baselineId);
+  if (!baselineDef) {
+    throw new Error(`Baseline scenario '${input.baselineId}' not found in scenarios list`);
+  }
+  const baseline = predictVoiceCallCost({
+    priceBook: input.priceBook,
+    profile: baselineDef.profile
+  });
+  return {
+    baseline,
+    scenarios: input.scenarios.map((scenario) => {
+      const prediction = predictVoiceCallCost({
+        priceBook: input.priceBook,
+        profile: scenario.profile
+      });
+      return {
+        delta: {
+          monthlyUsd: round(prediction.monthly.totalUsd - baseline.monthly.totalUsd),
+          perCallUsd: round(prediction.perCall.totalUsd - baseline.perCall.totalUsd)
+        },
+        prediction,
+        scenarioId: scenario.id
+      };
+    })
+  };
+};
+// src/iceServers.ts
+var toBase643 = (bytes) => {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let bin = "";
+  for (const byte of bytes)
+    bin += String.fromCharCode(byte);
+  return btoa(bin);
+};
+var defaultHmacSha1Base64 = async (key, message) => {
+  const encoder2 = new TextEncoder;
+  const cryptoKey = await crypto.subtle.importKey("raw", encoder2.encode(key), { hash: "SHA-1", name: "HMAC" }, false, ["sign"]);
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, encoder2.encode(message));
+  return toBase643(new Uint8Array(signature));
+};
+var createCoturnIceServers = async (input) => {
+  const ttlSec = input.ttlSec ?? 3600;
+  const now = input.now ?? Math.floor(Date.now() / 1000);
+  const expires = now + ttlSec;
+  const ephemeralUsername = `${expires}:${input.username}`;
+  const credential = await (input.hmacSha1Base64 ?? defaultHmacSha1Base64)(input.sharedSecret, ephemeralUsername);
+  const stun = input.stunUrls ?? ["stun:stun.l.google.com:19302"];
+  return [
+    { urls: stun },
+    {
+      credential,
+      urls: [
+        `turn:${input.turnHost}?transport=udp`,
+        `turn:${input.turnHost}?transport=tcp`,
+        `turns:${input.turnHost}?transport=tcp`
+      ],
+      username: ephemeralUsername
+    }
+  ];
+};
+var toBasicAuth2 = (sid, token) => `Basic ${btoa(`${sid}:${token}`)}`;
+var createTwilioNTSIceServers = async (input) => {
+  if (!input.accountSid || !input.authToken) {
+    throw new Error("Twilio NTS requires accountSid + authToken");
+  }
+  const fetchImpl = input.fetch ?? globalThis.fetch.bind(globalThis);
+  const response = await fetchImpl(`https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(input.accountSid)}/Tokens.json`, {
+    headers: {
+      accept: "application/json",
+      authorization: toBasicAuth2(input.accountSid, input.authToken)
+    },
+    method: "POST"
+  });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Twilio NTS Tokens failed: ${response.status} ${response.statusText} ${text.slice(0, 200)}`);
+  }
+  const payload = await response.json();
+  const entries = payload.ice_servers ?? [];
+  return entries.map((entry) => ({
+    credential: entry.credential,
+    urls: entry.urls ?? entry.url ?? [],
+    username: entry.username
+  }));
+};
+// src/holdAudio.ts
+var DEFAULT_CUES2 = [
+  { text: "Let me look that up for you." },
+  { text: "One moment while I check on that." },
+  { text: "Still looking into this." }
+];
+var createVoiceHoldAudioDriver = (options) => {
+  const cues = options.cues ?? DEFAULT_CUES2;
+  const cooldownMs = Math.max(0, options.cooldownMs ?? 4000);
+  const thinkingThresholdMs = Math.max(0, options.thinkingThresholdMs ?? 1500);
+  let thinkingSince;
+  let lastCueAt;
+  let cueIndex = 0;
+  let timer;
+  let firing = false;
+  const tryFire = async (now) => {
+    if (firing || cues.length === 0)
+      return;
+    if (thinkingSince === undefined)
+      return;
+    if (now - thinkingSince < thinkingThresholdMs)
+      return;
+    if (lastCueAt !== undefined && now - lastCueAt < cooldownMs)
+      return;
+    const cue = cues[cueIndex % cues.length];
+    if (!cue)
+      return;
+    firing = true;
+    try {
+      await options.onCue(cue);
+    } finally {
+      firing = false;
+      lastCueAt = now;
+      cueIndex += 1;
+    }
+  };
+  const scheduleNext = (now) => {
+    if (thinkingSince === undefined)
+      return;
+    if (timer)
+      clearTimeout(timer);
+    const elapsed = now - thinkingSince;
+    const delay = Math.max(0, lastCueAt === undefined ? thinkingThresholdMs - elapsed : cooldownMs - (now - lastCueAt));
+    timer = setTimeout(() => {
+      timer = undefined;
+      const nextNow = Date.now();
+      tryFire(nextNow).then(() => {
+        if (thinkingSince !== undefined)
+          scheduleNext(Date.now());
+      });
+    }, delay);
+  };
+  const clearTimer = () => {
+    if (timer)
+      clearTimeout(timer);
+    timer = undefined;
+  };
+  return {
+    noteResponse: () => {
+      clearTimer();
+      thinkingSince = undefined;
+    },
+    noteThinking: (timestampMs) => {
+      const now = timestampMs ?? Date.now();
+      if (thinkingSince === undefined) {
+        thinkingSince = now;
+      }
+      scheduleNext(now);
+    },
+    reset: () => {
+      clearTimer();
+      thinkingSince = undefined;
+      lastCueAt = undefined;
+      cueIndex = 0;
+    }
+  };
+};
+// src/promptInjectionGuard.ts
+var DEFAULT_VOICE_PROMPT_INJECTION_RULES = [
+  {
+    label: "ignore-prior-instructions",
+    pattern: /\bignore (?:all |the |any )?(?:previous|prior|above|earlier) (?:instructions|rules|prompts?)\b/iu,
+    severity: "high"
+  },
+  {
+    label: "role-override",
+    pattern: /\byou are (?:now )?(?:a |an )?(?:different|new) (?:assistant|model|role)\b/iu,
+    severity: "high"
+  },
+  {
+    label: "system-prompt-leak",
+    pattern: /\b(?:reveal|show|print|repeat|tell (?:me|us)|share) (?:your |the )?(?:system|hidden|secret) (?:prompt|instructions|message)\b/iu,
+    severity: "high"
+  },
+  {
+    label: "developer-impersonation",
+    pattern: /\b(?:as your |i am the )?(?:developer|engineer|owner|admin)(?: of)?\b[^.]{0,40}\b(?:override|disable|bypass)/iu,
+    severity: "medium"
+  },
+  {
+    label: "jailbreak-persona",
+    pattern: /\b(?:DAN|do anything now|jailbreak|developer mode|god mode)\b/iu,
+    severity: "high"
+  },
+  {
+    label: "tool-misuse-request",
+    pattern: /\b(?:call|invoke|use) (?:the )?(?:transfer|hangup|end[_ ]call)(?:[_ ]?(?:tool|function))?\b/iu,
+    severity: "low"
+  }
+];
+var extractText2 = (input) => typeof input === "string" ? input : input.text;
+var createVoicePromptInjectionGuard = (options = {}) => {
+  const rules = options.rules ?? DEFAULT_VOICE_PROMPT_INJECTION_RULES;
+  const replacement = options.sanitizedReplacement ?? "[REDACTED:INJECTION]";
+  return {
+    evaluate: (input) => {
+      const text = extractText2(input);
+      const matches = [];
+      for (const rule of rules) {
+        rule.pattern.lastIndex = 0;
+        const match = rule.pattern.exec(text);
+        if (match) {
+          matches.push({
+            label: rule.label,
+            matchedText: match[0],
+            severity: rule.severity
+          });
+        }
+      }
+      return { matches, ok: matches.length === 0 };
+    },
+    rules,
+    sanitize: (text) => {
+      let result = text;
+      for (const rule of rules) {
+        result = result.replace(new RegExp(rule.pattern, "gi"), replacement);
+      }
+      return result;
+    }
+  };
+};
+// src/postCallSurvey.ts
+var DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS = [
+  {
+    id: "nps",
+    max: 10,
+    min: 0,
+    prompt: "On a scale of zero to ten, how likely are you to recommend this service?",
+    required: true,
+    type: "rating"
+  },
+  {
+    id: "resolved",
+    prompt: "Did we resolve the reason for your call today?",
+    required: true,
+    type: "boolean"
+  },
+  {
+    id: "comment",
+    prompt: "Anything else you'd like to share before we wrap up?",
+    type: "comment"
+  }
+];
+var bucketize = (rating) => {
+  if (rating === null)
+    return null;
+  if (rating >= 9)
+    return "promoter";
+  if (rating >= 7)
+    return "passive";
+  return "detractor";
+};
+var validateRating = (question, value) => {
+  if (typeof value !== "number" || Number.isNaN(value)) {
+    throw new TypeError(`Question ${question.id} requires a numeric rating`);
+  }
+  const min = question.min ?? 0;
+  const max = question.max ?? 10;
+  if (value < min || value > max) {
+    throw new RangeError(`Question ${question.id} expects a rating between ${min} and ${max}`);
+  }
+  return value;
+};
+var createVoicePostCallSurvey = (options) => {
+  const now = options.now ?? (() => Date.now());
+  const questions = options.questions ?? DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS;
+  const response = {
+    answers: [],
+    completedAt: null,
+    npsBucket: null,
+    sessionId: options.sessionId,
+    startedAt: now()
+  };
+  const indexById = new Map(questions.map((q) => [q.id, q]));
+  let cursor = 0;
+  const next = () => cursor < questions.length ? questions[cursor] ?? null : null;
+  const record = (questionId, value) => {
+    const question = indexById.get(questionId);
+    if (!question)
+      throw new Error(`Unknown survey question: ${questionId}`);
+    let stored = value;
+    if (question.type === "rating")
+      stored = validateRating(question, value);
+    if (question.type === "boolean") {
+      if (typeof value !== "boolean") {
+        throw new TypeError(`Question ${questionId} requires a boolean answer`);
+      }
+      stored = value;
+    }
+    if (question.type === "comment" && value !== null && typeof value !== "string") {
+      throw new TypeError(`Question ${questionId} requires a string answer`);
+    }
+    if (question.required && (stored === null || stored === "")) {
+      throw new Error(`Question ${questionId} is required`);
+    }
+    const answer = { questionId, value: stored };
+    response.answers.push(answer);
+    if (questionId === "nps" && typeof stored === "number") {
+      response.npsBucket = bucketize(stored);
+    }
+    const idx = questions.findIndex((q) => q.id === questionId);
+    if (idx >= 0)
+      cursor = Math.max(cursor, idx + 1);
+    return answer;
+  };
+  const skip = () => {
+    const question = next();
+    if (!question)
+      return null;
+    if (question.required) {
+      throw new Error(`Cannot skip required question: ${question.id}`);
+    }
+    response.answers.push({ questionId: question.id, value: null });
+    cursor += 1;
+    return question;
+  };
+  const complete = () => {
+    for (const question of questions) {
+      if (question.required && !response.answers.some((a) => a.questionId === question.id && a.value !== null)) {
+        throw new Error(`Survey is missing required answer: ${question.id}`);
+      }
+    }
+    response.completedAt = now();
+    return response;
+  };
+  return {
+    complete,
+    getResponse: () => response,
+    next,
+    questions,
+    record,
+    skip
+  };
+};
+var summarizeVoicePostCallSurveys = (responses) => {
+  const completed = responses.filter((r) => r.completedAt !== null);
+  const ratings = completed.flatMap((r) => r.answers).filter((a) => a.questionId === "nps" && typeof a.value === "number");
+  const promoters = ratings.filter((a) => a.value >= 9).length;
+  const detractors = ratings.filter((a) => a.value <= 6).length;
+  const denom = ratings.length || 1;
+  return {
+    completion: responses.length === 0 ? 0 : completed.length / responses.length,
+    detractors,
+    nps: ratings.length === 0 ? null : (promoters - detractors) / denom * 100,
+    promoters,
+    sampleSize: ratings.length
+  };
+};
+// src/dtmfCollector.ts
+var VOICE_DTMF_DIGITS = [
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "*",
+  "#"
+];
+var isDigit = (value) => VOICE_DTMF_DIGITS.includes(value);
+var collectVoiceDTMFInput = (options) => {
+  const now = options.now ?? (() => Date.now());
+  const minLength = options.minLength ?? 1;
+  const maxLength = options.maxLength ?? minLength;
+  if (maxLength < minLength) {
+    throw new RangeError(`maxLength (${maxLength}) cannot be less than minLength (${minLength})`);
+  }
+  const terminator = options.terminator === undefined ? "#" : options.terminator;
+  const timeoutMs = options.timeoutMs ?? 8000;
+  const interDigitTimeoutMs = options.interDigitTimeoutMs ?? 3000;
+  const startedAt = now();
+  let lastDigitAt = startedAt;
+  let state = { digits: "", status: "collecting" };
+  const listeners = new Set;
+  const notify = () => {
+    for (const listener of listeners)
+      listener(state);
+  };
+  const checkTimeouts = (at) => {
+    if (state.status !== "collecting")
+      return false;
+    if (at - startedAt > timeoutMs) {
+      state = { digits: state.digits, reason: "timeout", status: "rejected" };
+      notify();
+      return true;
+    }
+    if (state.digits.length > 0 && at - lastDigitAt > interDigitTimeoutMs) {
+      state = { digits: state.digits, reason: "timeout", status: "rejected" };
+      notify();
+      return true;
+    }
+    return false;
+  };
+  const finish = (reason) => {
+    if (state.status !== "collecting")
+      return;
+    const digits = state.digits;
+    if (digits.length < minLength) {
+      state = { digits, reason: "too-short", status: "rejected" };
+      notify();
+      return;
+    }
+    if (options.validator) {
+      const verdict = options.validator(digits);
+      if (verdict !== true) {
+        state = { digits, reason: "invalid", status: "rejected" };
+        notify();
+        return;
+      }
+    }
+    state = { digits, reason, status: "completed" };
+    notify();
+  };
+  return {
+    cancel() {
+      if (state.status === "collecting") {
+        state = { digits: state.digits, status: "cancelled" };
+        notify();
+      }
+      return state;
+    },
+    feed(digit, at = now()) {
+      if (state.status !== "collecting")
+        return state;
+      if (checkTimeouts(at))
+        return state;
+      if (!isDigit(digit)) {
+        state = {
+          digits: state.digits,
+          reason: "invalid",
+          status: "rejected"
+        };
+        notify();
+        return state;
+      }
+      lastDigitAt = at;
+      if (terminator && digit === terminator) {
+        finish("terminator");
+        return state;
+      }
+      const digits = state.digits + digit;
+      state = { digits, status: "collecting" };
+      if (digits.length >= maxLength) {
+        finish("length");
+      } else {
+        notify();
+      }
+      return state;
+    },
+    getState: () => state,
+    prompt: options.prompt,
+    subscribe(listener) {
+      listeners.add(listener);
+      listener(state);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    tick(at = now()) {
+      checkTimeouts(at);
+      return state;
+    }
+  };
+};
+var validateVoiceDTMFLuhn = (digits) => {
+  if (!/^\d+$/u.test(digits))
+    return false;
+  let sum = 0;
+  let alt = false;
+  for (let i = digits.length - 1;i >= 0; i--) {
+    let n = Number(digits[i]);
+    if (alt) {
+      n *= 2;
+      if (n > 9)
+        n -= 9;
+    }
+    sum += n;
+    alt = !alt;
+  }
+  return sum % 10 === 0;
+};
 export {
   writeVoiceProofPack,
   writeVoiceMediaPipelineArtifacts,
@@ -48032,6 +48582,7 @@ export {
   verifyVoiceOpsWebhookSignature,
   validateVoiceWorkflowRouteResult,
   validateVoiceObservabilityExportRecord,
+  validateVoiceDTMFLuhn,
   ttsAdapterSessionCanCancel,
   transcodeTwilioInboundPayloadToPCM16,
   transcodePCMToTwilioOutboundPayload,
@@ -48052,6 +48603,7 @@ export {
   summarizeVoiceProviderCapabilities,
   summarizeVoiceProofAssertions,
   summarizeVoiceProductionReadinessGate,
+  summarizeVoicePostCallSurveys,
   summarizeVoiceOpsTasks,
   summarizeVoiceOpsTaskQueue,
   summarizeVoiceOpsTaskAnalytics,
@@ -48254,6 +48806,7 @@ export {
   pruneVoiceIncidentBundleArtifacts,
   provisionTwilioPhoneNumber,
   provisionTelnyxPhoneNumber,
+  predictVoiceCallCost,
   parseVoiceTelephonyWebhookEvent,
   parseVoiceSessionSnapshot,
   normalizeVoiceProofTrendReport,
@@ -48501,6 +49054,7 @@ export {
   createVoiceProofPackBuildContext,
   createVoiceProofPackArtifacts,
   createVoiceProofAssertion,
+  createVoicePromptInjectionGuard,
   createVoiceProfileTraceTagger,
   createVoiceProfileSwitchReadinessRoutes,
   createVoiceProfileSwitchPolicyProofRoutes,
@@ -48522,6 +49076,7 @@ export {
   createVoicePostgresCampaignStore,
   createVoicePostgresAuditSinkDeliveryStore,
   createVoicePostgresAuditEventStore,
+  createVoicePostCallSurvey,
   createVoicePostCallAnalysisRoutes,
   createVoicePlivoWebhookVerifier,
   createVoicePlivoCampaignDialer,
@@ -48593,6 +49148,7 @@ export {
   createVoiceHubSpotTaskUpdateSink,
   createVoiceHubSpotTaskSyncSinks,
   createVoiceHubSpotTaskSink,
+  createVoiceHoldAudioDriver,
   createVoiceHelpdeskTicketSink,
   createVoiceHandoffHealthRoutes,
   createVoiceHandoffHealthJSONHandler,
@@ -48688,6 +49244,7 @@ export {
   createVoiceAIJudgeCompletion,
   createTwilioVoiceRoutes,
   createTwilioVoiceResponse,
+  createTwilioNTSIceServers,
   createTwilioMediaStreamBridge,
   createTelnyxVoiceRoutes,
   createTelnyxVoiceResponse,
@@ -48719,12 +49276,15 @@ export {
   createGeminiVoiceAssistantModel,
   createDomainPhraseHints,
   createDomainLexicon,
+  createCoturnIceServers,
   createAnthropicVoiceAssistantModel,
   createAIVoiceModel,
   conditionAudioChunk,
   computePcmDurationMs,
   completeVoiceOpsTask,
   compareVoiceEvalBaseline,
+  compareVoiceCostScenarios,
+  collectVoiceDTMFInput,
   claimVoiceOpsTask,
   buildVoiceTraceReplay,
   buildVoiceTraceDeliveryReport,
@@ -48876,11 +49436,14 @@ export {
   VOICE_WEBHOOK_TIMESTAMP_HEADER,
   VOICE_WEBHOOK_SIGNATURE_HEADER,
   VOICE_LIVE_OPS_ACTIONS,
+  VOICE_DTMF_DIGITS,
   VOICE_CALLER_MEMORY_KEY,
   TURN_PROFILE_DEFAULTS,
   DEFAULT_VOICE_REDACTION_PATTERNS,
   DEFAULT_VOICE_PROOF_TREND_PROFILE_DEFINITIONS,
   DEFAULT_VOICE_PROOF_TRENDS_MAX_AGE_MS,
+  DEFAULT_VOICE_PROMPT_INJECTION_RULES,
   DEFAULT_VOICE_PRICE_BOOK,
+  DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS,
   BROWSER_NOISE_SUPPRESSOR_PRESETS
 };

package/dist/postCallSurvey.d.ts

@@ -0,0 +1,41 @@
+export type VoicePostCallSurveyQuestion = {
+    id: string;
+    prompt: string;
+    type: "rating" | "boolean" | "comment";
+    min?: number;
+    max?: number;
+    required?: boolean;
+};
+export type VoicePostCallSurveyAnswer = {
+    questionId: string;
+    value: number | boolean | string | null;
+};
+export type VoicePostCallSurveyResponse = {
+    sessionId: string;
+    startedAt: number;
+    completedAt: number | null;
+    answers: VoicePostCallSurveyAnswer[];
+    npsBucket: "promoter" | "passive" | "detractor" | null;
+};
+export type CreateVoicePostCallSurveyOptions = {
+    sessionId: string;
+    questions?: VoicePostCallSurveyQuestion[];
+    now?: () => number;
+};
+export declare const DEFAULT_VOICE_POST_CALL_SURVEY_QUESTIONS: VoicePostCallSurveyQuestion[];
+export declare const createVoicePostCallSurvey: (options: CreateVoicePostCallSurveyOptions) => {
+    complete: () => VoicePostCallSurveyResponse;
+    getResponse: () => VoicePostCallSurveyResponse;
+    next: () => VoicePostCallSurveyQuestion | null;
+    questions: VoicePostCallSurveyQuestion[];
+    record: (questionId: string, value: number | boolean | string | null) => VoicePostCallSurveyAnswer;
+    skip: () => VoicePostCallSurveyQuestion | null;
+};
+export type VoicePostCallSurvey = ReturnType<typeof createVoicePostCallSurvey>;
+export declare const summarizeVoicePostCallSurveys: (responses: VoicePostCallSurveyResponse[]) => {
+    completion: number;
+    detractors: number;
+    nps: number | null;
+    promoters: number;
+    sampleSize: number;
+};

package/dist/promptInjectionGuard.d.ts

@@ -0,0 +1,30 @@
+import type { Transcript } from "./types";
+export type VoicePromptInjectionRule = {
+    /** Reason emitted in the verdict when this rule matches. */
+    label: string;
+    /** Regex applied to the transcript text (case-insensitive by convention). */
+    pattern: RegExp;
+    /** Severity tag for downstream routing. */
+    severity?: "high" | "low" | "medium";
+};
+export type VoicePromptInjectionVerdict = {
+    matches: Array<{
+        label: string;
+        matchedText: string;
+        severity?: VoicePromptInjectionRule["severity"];
+    }>;
+    ok: boolean;
+};
+export declare const DEFAULT_VOICE_PROMPT_INJECTION_RULES: VoicePromptInjectionRule[];
+export type CreateVoicePromptInjectionGuardOptions = {
+    /** Custom rule set. Defaults to DEFAULT_VOICE_PROMPT_INJECTION_RULES. */
+    rules?: ReadonlyArray<VoicePromptInjectionRule>;
+    /** Replacement string for sanitized text. Default '[REDACTED:INJECTION]'. */
+    sanitizedReplacement?: string;
+};
+export type VoicePromptInjectionGuard = {
+    evaluate: (input: string | Transcript) => VoicePromptInjectionVerdict;
+    rules: ReadonlyArray<VoicePromptInjectionRule>;
+    sanitize: (input: string) => string;
+};
+export declare const createVoicePromptInjectionGuard: (options?: CreateVoicePromptInjectionGuardOptions) => VoicePromptInjectionGuard;