@absolutejs/voice 0.0.22-beta.66 → 0.0.22-beta.68

package/dist/index.js

@@ -10294,6 +10294,271 @@ var createVoiceToolContractRoutes = (options) => {
   }
   return routes;
 };
+// src/turnQuality.ts
+import { Elysia as Elysia14 } from "elysia";
+var DEFAULT_CONFIDENCE_WARN_THRESHOLD = 0.72;
+var escapeHtml15 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getTurnLatencyMs = (turn) => {
+  const firstTranscriptAt = turn.transcripts.map((transcript) => transcript.endedAtMs ?? transcript.startedAtMs).filter((value) => typeof value === "number").sort((left, right) => left - right)[0];
+  if (firstTranscriptAt === undefined) {
+    return;
+  }
+  return Math.max(0, turn.committedAt - firstTranscriptAt);
+};
+var summarizeTurn = (sessionId, turn, options) => {
+  const quality = turn.quality;
+  const correctionChanged = quality?.correction?.changed === true;
+  const fallbackUsed = quality?.fallbackUsed === true;
+  const lowConfidence = typeof quality?.averageConfidence === "number" && quality.averageConfidence < options.confidenceWarnThreshold;
+  const hasNoQuality = !quality;
+  const status = hasNoQuality ? "unknown" : quality.selectedTranscriptCount === 0 || turn.text.trim().length === 0 ? "fail" : fallbackUsed || correctionChanged || lowConfidence ? "warn" : "pass";
+  return {
+    averageConfidence: quality?.averageConfidence,
+    committedAt: turn.committedAt,
+    correctionChanged,
+    correctionProvider: quality?.correction?.provider,
+    correctionReason: quality?.correction?.reason,
+    costUnits: quality?.cost?.estimatedRelativeCostUnits,
+    fallbackSelectionReason: quality?.fallback?.selectionReason,
+    fallbackUsed,
+    finalTranscriptCount: quality?.finalTranscriptCount ?? 0,
+    latencyMs: getTurnLatencyMs(turn),
+    partialTranscriptCount: quality?.partialTranscriptCount ?? 0,
+    selectedTranscriptCount: quality?.selectedTranscriptCount ?? 0,
+    sessionId,
+    source: quality?.source,
+    status,
+    text: turn.text,
+    turnId: turn.id
+  };
+};
+var resolveSessions = async (options) => {
+  if (options.sessions) {
+    return options.sessions;
+  }
+  if (!options.store) {
+    return [];
+  }
+  const summaries = await options.store.list();
+  const ids = options.sessionIds ?? summaries.map((summary) => summary.id);
+  const hydrated = await Promise.all(ids.slice(0, options.limit ?? 25).map((id) => options.store?.get(id)));
+  const sessions = [];
+  for (const session of hydrated) {
+    if (session) {
+      sessions.push(session);
+    }
+  }
+  return sessions;
+};
+var summarizeVoiceTurnQuality = async (options) => {
+  const sessions = await resolveSessions(options);
+  const confidenceWarnThreshold = options.confidenceWarnThreshold ?? DEFAULT_CONFIDENCE_WARN_THRESHOLD;
+  const turns = sessions.flatMap((session) => session.turns.map((turn) => summarizeTurn(session.id, turn, { confidenceWarnThreshold }))).sort((left, right) => right.committedAt - left.committedAt);
+  const failed = turns.filter((turn) => turn.status === "fail").length;
+  const warnings = turns.filter((turn) => turn.status === "warn").length;
+  return {
+    checkedAt: Date.now(),
+    failed,
+    sessions: sessions.length,
+    status: failed > 0 ? "fail" : warnings > 0 ? "warn" : "pass",
+    total: turns.length,
+    turns,
+    warnings
+  };
+};
+var renderVoiceTurnQualityHTML = (report, options = {}) => {
+  const title = options.title ?? "Voice Turn Quality";
+  const turns = report.turns.map((turn) => `<article class="turn ${escapeHtml15(turn.status)}">
+  <div class="turn-header">
+    <div>
+      <p class="eyebrow">${escapeHtml15(turn.sessionId)} \xB7 ${escapeHtml15(turn.turnId)}</p>
+      <h2>${escapeHtml15(turn.text || "Empty turn")}</h2>
+    </div>
+    <strong>${escapeHtml15(turn.status)}</strong>
+  </div>
+  <dl>
+    <div><dt>Source</dt><dd>${escapeHtml15(turn.source ?? "unknown")}</dd></div>
+    <div><dt>Confidence</dt><dd>${turn.averageConfidence === undefined ? "n/a" : `${Math.round(turn.averageConfidence * 100)}%`}</dd></div>
+    <div><dt>Fallback</dt><dd>${turn.fallbackUsed ? `yes (${escapeHtml15(turn.fallbackSelectionReason ?? "selected")})` : "no"}</dd></div>
+    <div><dt>Correction</dt><dd>${turn.correctionChanged ? `changed${turn.correctionProvider ? ` by ${escapeHtml15(turn.correctionProvider)}` : ""}` : "none"}</dd></div>
+    <div><dt>Transcripts</dt><dd>${String(turn.selectedTranscriptCount)} selected \xB7 ${String(turn.finalTranscriptCount)} final \xB7 ${String(turn.partialTranscriptCount)} partial</dd></div>
+    <div><dt>Cost</dt><dd>${turn.costUnits === undefined ? "n/a" : String(turn.costUnits)}</dd></div>
+  </dl>
+</article>`).join("");
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml15(title)}</title><style>body{background:#101316;color:#f6f2e8;font-family:ui-sans-serif,system-ui,sans-serif;margin:0}main{margin:auto;max-width:1180px;padding:32px}.hero,.turn{background:#181d22;border:1px solid #2a323a;border-radius:20px;margin-bottom:16px;padding:20px}.hero{background:linear-gradient(135deg,rgba(251,191,36,.16),rgba(34,197,94,.1))}.eyebrow{color:#fbbf24;font-size:.78rem;font-weight:900;letter-spacing:.08em;text-transform:uppercase}h1{font-size:clamp(2.3rem,6vw,5rem);letter-spacing:-.06em;line-height:.9;margin:.2rem 0 1rem}h2{margin:.2rem 0 1rem}.summary{display:flex;flex-wrap:wrap;gap:10px}.pill{background:#0f1217;border:1px solid #3f3f46;border-radius:999px;padding:7px 10px}.turn-header{align-items:flex-start;display:flex;gap:16px;justify-content:space-between}.pass{color:#86efac}.warn,.unknown{color:#fde68a}.fail{color:#fca5a5}.turn.fail{border-color:rgba(248,113,113,.45)}dl{display:grid;gap:8px;grid-template-columns:repeat(auto-fit,minmax(160px,1fr))}dt{color:#a8b0b8;font-size:.8rem}dd{margin:0}@media(max-width:800px){main{padding:18px}.turn-header{display:block}}</style></head><body><main><section class="hero"><p class="eyebrow">Realtime STT Debugging</p><h1>${escapeHtml15(title)}</h1><div class="summary"><span class="pill ${escapeHtml15(report.status)}">${escapeHtml15(report.status)}</span><span class="pill">${String(report.total)} turns</span><span class="pill">${String(report.warnings)} warnings</span><span class="pill">${String(report.failed)} failed</span><span class="pill">${String(report.sessions)} sessions</span></div></section>${turns || '<section class="turn"><p>No committed turns found.</p></section>'}</main></body></html>`;
+};
+var createVoiceTurnQualityJSONHandler = (options) => async () => summarizeVoiceTurnQuality(options);
+var createVoiceTurnQualityHTMLHandler = (options) => async () => {
+  const report = await summarizeVoiceTurnQuality(options);
+  const render = options.render ?? ((input) => renderVoiceTurnQualityHTML(input, options));
+  const body = await render(report);
+  return new Response(body, {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceTurnQualityRoutes = (options) => {
+  const path = options.path ?? "/api/turn-quality";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia14({
+    name: options.name ?? "absolutejs-voice-turn-quality"
+  }).get(path, createVoiceTurnQualityJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceTurnQualityHTMLHandler(options));
+  }
+  return routes;
+};
+// src/outcomeContract.ts
+import { Elysia as Elysia15 } from "elysia";
+var escapeHtml16 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+var getPayloadString = (event, key) => typeof event.payload[key] === "string" ? event.payload[key] : undefined;
+var toList = async (input) => Array.isArray(input) ? input : await input?.list() ?? [];
+var hydrateSessions = async (input) => {
+  if (!input)
+    return [];
+  if (Array.isArray(input))
+    return input;
+  const summaries = await input.list();
+  const sessions = await Promise.all(summaries.map((summary) => input.get(summary.id)));
+  const hydrated = [];
+  for (const session of sessions) {
+    if (session) {
+      hydrated.push(session);
+    }
+  }
+  return hydrated;
+};
+var dispositionForSession = (session) => session.call?.disposition ?? (session.status === "completed" ? "completed" : undefined);
+var matchesDisposition = (disposition, expected) => expected === undefined || disposition === expected;
+var reportContract = (input) => {
+  const { contract } = input;
+  const sessions = input.sessions.filter((session) => (!contract.scenarioId || session.scenarioId === contract.scenarioId) && matchesDisposition(dispositionForSession(session), contract.expectedDisposition));
+  const sessionIds = new Set(sessions.map((session) => session.id));
+  const reviews = input.reviews.filter((review) => matchesDisposition(review.summary.outcome, contract.expectedDisposition));
+  const tasks = input.tasks.filter((task) => matchesDisposition(task.outcome, contract.expectedDisposition));
+  const handoffs = input.handoffs.filter((handoff) => (!contract.expectedDisposition || handoff.action === contract.expectedDisposition || contract.expectedDisposition === "transferred" && handoff.action === "transfer" || contract.expectedDisposition === "escalated" && handoff.action === "escalate") && (sessionIds.size === 0 || sessionIds.has(handoff.sessionId)));
+  const events = input.events.filter((event) => {
+    const eventSessionId = getPayloadString(event, "sessionId");
+    const eventOutcome = getPayloadString(event, "outcome") ?? getPayloadString(event, "disposition");
+    return (sessionIds.size === 0 || !eventSessionId || sessionIds.has(eventSessionId)) && (!contract.expectedDisposition || eventOutcome === contract.expectedDisposition);
+  });
+  const issues = [];
+  const minSessions = contract.minSessions ?? 1;
+  if (sessions.length < minSessions) {
+    issues.push({
+      code: "outcome.sessions_missing",
+      message: `Expected at least ${minSessions} matching session(s), saw ${sessions.length}.`
+    });
+  }
+  if (contract.requireReview !== false && reviews.length === 0) {
+    issues.push({
+      code: "outcome.review_missing",
+      message: "Expected at least one matching review artifact."
+    });
+  }
+  if (contract.requireTask && tasks.length < (contract.minTasks ?? 1)) {
+    issues.push({
+      code: "outcome.task_missing",
+      message: `Expected at least ${contract.minTasks ?? 1} matching task(s), saw ${tasks.length}.`
+    });
+  }
+  for (const action of contract.requireHandoffActions ?? []) {
+    if (!handoffs.some((handoff) => handoff.action === action)) {
+      issues.push({
+        code: "outcome.handoff_missing",
+        message: `Expected handoff action ${action}.`
+      });
+    }
+  }
+  for (const type of contract.requireIntegrationEvents ?? []) {
+    if (!events.some((event) => event.type === type)) {
+      issues.push({
+        code: "outcome.integration_event_missing",
+        message: `Expected integration event ${type}.`
+      });
+    }
+  }
+  return {
+    contractId: contract.id,
+    description: contract.description,
+    issues,
+    label: contract.label,
+    matched: {
+      handoffs: handoffs.length,
+      integrationEvents: events.length,
+      reviews: reviews.length,
+      sessions: sessions.length,
+      tasks: tasks.length
+    },
+    pass: issues.length === 0
+  };
+};
+var runVoiceOutcomeContractSuite = async (options) => {
+  const [sessions, reviews, tasks, events, handoffs] = await Promise.all([
+    hydrateSessions(options.sessions),
+    toList(options.reviews),
+    toList(options.tasks),
+    toList(options.events),
+    toList(options.handoffs)
+  ]);
+  const contracts = options.contracts.map((contract) => reportContract({ contract, events, handoffs, reviews, sessions, tasks }));
+  const passed = contracts.filter((contract) => contract.pass).length;
+  const failed = contracts.length - passed;
+  return {
+    checkedAt: Date.now(),
+    contracts,
+    failed,
+    passed,
+    status: failed > 0 ? "fail" : "pass",
+    total: contracts.length
+  };
+};
+var renderVoiceOutcomeContractHTML = (report, options = {}) => {
+  const title = options.title ?? "Voice Outcome Contracts";
+  const contracts = report.contracts.map((contract) => `<section class="contract ${contract.pass ? "pass" : "fail"}">
+  <div class="contract-header">
+    <div>
+      <p class="eyebrow">${escapeHtml16(contract.contractId)}</p>
+      <h2>${escapeHtml16(contract.label ?? contract.contractId)}</h2>
+      ${contract.description ? `<p>${escapeHtml16(contract.description)}</p>` : ""}
+    </div>
+    <strong>${contract.pass ? "pass" : "fail"}</strong>
+  </div>
+  <div class="grid">
+    <span>sessions ${String(contract.matched.sessions)}</span>
+    <span>reviews ${String(contract.matched.reviews)}</span>
+    <span>tasks ${String(contract.matched.tasks)}</span>
+    <span>handoffs ${String(contract.matched.handoffs)}</span>
+    <span>events ${String(contract.matched.integrationEvents)}</span>
+  </div>
+  ${contract.issues.length ? `<ul>${contract.issues.map((issue) => `<li>${escapeHtml16(issue.message)}</li>`).join("")}</ul>` : ""}
+</section>`).join("");
+  return `<!doctype html><html lang="en"><head><meta charset="utf-8" /><meta name="viewport" content="width=device-width, initial-scale=1" /><title>${escapeHtml16(title)}</title><style>body{background:#101316;color:#f6f2e8;font-family:ui-sans-serif,system-ui,sans-serif;margin:0}main{margin:auto;max-width:1180px;padding:32px}.hero,.contract{background:#181d22;border:1px solid #2a323a;border-radius:20px;margin-bottom:16px;padding:20px}.hero{background:linear-gradient(135deg,rgba(34,197,94,.14),rgba(14,165,233,.12))}.eyebrow{color:#7dd3fc;font-size:.78rem;font-weight:900;letter-spacing:.08em;text-transform:uppercase}h1{font-size:clamp(2.3rem,6vw,5rem);letter-spacing:-.06em;line-height:.9;margin:.2rem 0 1rem}h2{margin:.2rem 0}.summary,.grid{display:flex;flex-wrap:wrap;gap:10px}.pill,.grid span{background:#0f1217;border:1px solid #3f3f46;border-radius:999px;padding:7px 10px}.contract-header{display:flex;gap:16px;justify-content:space-between}.pass{color:#86efac}.fail{color:#fca5a5}.contract.fail{border-color:rgba(248,113,113,.45)}li{margin:8px 0}@media(max-width:800px){main{padding:18px}.contract-header{display:block}}</style></head><body><main><section class="hero"><p class="eyebrow">Business Outcome Verification</p><h1>${escapeHtml16(title)}</h1><div class="summary"><span class="pill ${report.status}">${report.status}</span><span class="pill">${String(report.passed)} passing</span><span class="pill">${String(report.failed)} failing</span><span class="pill">${String(report.total)} contracts</span></div></section>${contracts || '<section class="contract"><p>No outcome contracts configured.</p></section>'}</main></body></html>`;
+};
+var createVoiceOutcomeContractJSONHandler = (options) => async () => runVoiceOutcomeContractSuite(options);
+var createVoiceOutcomeContractHTMLHandler = (options) => async () => {
+  const report = await runVoiceOutcomeContractSuite(options);
+  const render = options.render ?? ((input) => renderVoiceOutcomeContractHTML(input, options));
+  return new Response(await render(report), {
+    headers: {
+      "Content-Type": "text/html; charset=utf-8",
+      ...options.headers
+    }
+  });
+};
+var createVoiceOutcomeContractRoutes = (options) => {
+  const path = options.path ?? "/api/outcome-contracts";
+  const htmlPath = options.htmlPath === undefined ? `${path}/htmx` : options.htmlPath;
+  const routes = new Elysia15({
+    name: options.name ?? "absolutejs-voice-outcome-contracts"
+  }).get(path, createVoiceOutcomeContractJSONHandler(options));
+  if (htmlPath) {
+    routes.get(htmlPath, createVoiceOutcomeContractHTMLHandler(options));
+  }
+  return routes;
+};
 // src/fileStore.ts
 import { mkdir as mkdir2, readFile, readdir, rename, rm, writeFile } from "fs/promises";
 import { join } from "path";
@@ -12387,7 +12652,7 @@ var createVoiceMemoryStore = () => {
   return { get, getOrCreate, list, remove, set };
 };
 // src/opsWebhook.ts
-import { Elysia as Elysia14 } from "elysia";
+import { Elysia as Elysia16 } from "elysia";
 var toHex5 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceOpsWebhookBody = async (input) => {
   const encoder = new TextEncoder;
@@ -12517,7 +12782,7 @@ var verifyVoiceOpsWebhookSignature = async (input) => {
 };
 var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-ops/webhook";
-  return new Elysia14().post(path, async ({ body, request, set }) => {
+  return new Elysia16().post(path, async ({ body, request, set }) => {
     const bodyText = typeof body === "string" ? body : JSON.stringify(body);
     if (options.signingSecret) {
       const verification = await verifyVoiceOpsWebhookSignature({
@@ -14664,6 +14929,7 @@ export {
   validateVoiceWorkflowRouteResult,
   transcodeTwilioInboundPayloadToPCM16,
   transcodePCMToTwilioOutboundPayload,
+  summarizeVoiceTurnQuality,
   summarizeVoiceTraceSinkDeliveries,
   summarizeVoiceTrace,
   summarizeVoiceSessions,
@@ -14688,6 +14954,7 @@ export {
   runVoiceSessionEvals,
   runVoiceScenarioFixtureEvals,
   runVoiceScenarioEvals,
+  runVoiceOutcomeContractSuite,
   resolveVoiceTraceRedactionOptions,
   resolveVoiceSTTRoutingStrategy,
   resolveVoiceRuntimePreset,
@@ -14703,6 +14970,7 @@ export {
   resolveAudioConditioningConfig,
   requeueVoiceOpsTask,
   reopenVoiceOpsTask,
+  renderVoiceTurnQualityHTML,
   renderVoiceTraceMarkdown,
   renderVoiceTraceHTML,
   renderVoiceToolContractHTML,
@@ -14713,6 +14981,7 @@ export {
   renderVoiceQualityHTML,
   renderVoiceProviderHealthHTML,
   renderVoiceProviderCapabilityHTML,
+  renderVoiceOutcomeContractHTML,
   renderVoiceOpsConsoleHTML,
   renderVoiceHandoffHealthHTML,
   renderVoiceEvalHTML,
@@ -14757,6 +15026,9 @@ export {
   createVoiceWebhookDeliveryWorkerLoop,
   createVoiceWebhookDeliveryWorker,
   createVoiceTwilioRedirectHandoffAdapter,
+  createVoiceTurnQualityRoutes,
+  createVoiceTurnQualityJSONHandler,
+  createVoiceTurnQualityHTMLHandler,
   createVoiceTraceSinkStore,
   createVoiceTraceSinkDeliveryWorkerLoop,
   createVoiceTraceSinkDeliveryWorker,
@@ -14816,6 +15088,9 @@ export {
   createVoicePostgresReviewStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
+  createVoiceOutcomeContractRoutes,
+  createVoiceOutcomeContractJSONHandler,
+  createVoiceOutcomeContractHTMLHandler,
   createVoiceOpsWebhookSink,
   createVoiceOpsWebhookReceiverRoutes,
   createVoiceOpsWebhookEnvelope,

package/dist/outcomeContract.d.ts

@@ -0,0 +1,112 @@
+import { Elysia } from 'elysia';
+import type { StoredVoiceHandoffDelivery, VoiceCallDisposition, VoiceHandoffAction, VoiceHandoffDeliveryStore, VoiceSessionRecord, VoiceSessionStore } from './types';
+import type { StoredVoiceIntegrationEvent, StoredVoiceOpsTask, VoiceIntegrationEventType } from './ops';
+import type { StoredVoiceCallReviewArtifact } from './testing/review';
+export type VoiceOutcomeContractStatus = 'pass' | 'fail';
+export type VoiceOutcomeContractDefinition = {
+    description?: string;
+    expectedDisposition?: VoiceCallDisposition;
+    id: string;
+    label?: string;
+    minSessions?: number;
+    minTasks?: number;
+    requireHandoffActions?: VoiceHandoffAction[];
+    requireIntegrationEvents?: VoiceIntegrationEventType[];
+    requireReview?: boolean;
+    requireTask?: boolean;
+    scenarioId?: string;
+};
+export type VoiceOutcomeContractIssue = {
+    code: string;
+    message: string;
+};
+export type VoiceOutcomeContractReport = {
+    contractId: string;
+    description?: string;
+    issues: VoiceOutcomeContractIssue[];
+    label?: string;
+    matched: {
+        handoffs: number;
+        integrationEvents: number;
+        reviews: number;
+        sessions: number;
+        tasks: number;
+    };
+    pass: boolean;
+};
+export type VoiceOutcomeContractSuiteReport = {
+    checkedAt: number;
+    contracts: VoiceOutcomeContractReport[];
+    failed: number;
+    passed: number;
+    status: VoiceOutcomeContractStatus;
+    total: number;
+};
+type ListStore<T> = {
+    list: () => Promise<T[]> | T[];
+};
+export type VoiceOutcomeContractOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = {
+    contracts: VoiceOutcomeContractDefinition[];
+    events?: StoredVoiceIntegrationEvent[] | ListStore<StoredVoiceIntegrationEvent>;
+    handoffs?: StoredVoiceHandoffDelivery[] | VoiceHandoffDeliveryStore;
+    reviews?: StoredVoiceCallReviewArtifact[] | ListStore<StoredVoiceCallReviewArtifact>;
+    sessions?: TSession[] | VoiceSessionStore<TSession>;
+    tasks?: StoredVoiceOpsTask[] | ListStore<StoredVoiceOpsTask>;
+};
+export type VoiceOutcomeContractHTMLHandlerOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractOptions<TSession> & {
+    headers?: HeadersInit;
+    render?: (report: VoiceOutcomeContractSuiteReport) => string | Promise<string>;
+    title?: string;
+};
+export type VoiceOutcomeContractRoutesOptions<TSession extends VoiceSessionRecord = VoiceSessionRecord> = VoiceOutcomeContractHTMLHandlerOptions<TSession> & {
+    htmlPath?: false | string;
+    name?: string;
+    path?: string;
+};
+export declare const runVoiceOutcomeContractSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const renderVoiceOutcomeContractHTML: (report: VoiceOutcomeContractSuiteReport, options?: {
+    title?: string;
+}) => string;
+export declare const createVoiceOutcomeContractJSONHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => () => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const createVoiceOutcomeContractHTMLHandler: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractHTMLHandlerOptions<TSession>) => () => Promise<Response>;
+export declare const createVoiceOutcomeContractRoutes: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractRoutesOptions<TSession>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceOutcomeContractSuiteReport;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export {};

package/dist/react/VoiceTurnQuality.d.ts

@@ -0,0 +1,6 @@
+import { type VoiceTurnQualityWidgetOptions } from '../client/turnQualityWidget';
+export type VoiceTurnQualityProps = VoiceTurnQualityWidgetOptions & {
+    className?: string;
+    path?: string;
+};
+export declare const VoiceTurnQuality: ({ className, path, ...options }: VoiceTurnQualityProps) => import("react/jsx-runtime").JSX.Element;

package/dist/react/index.d.ts

@@ -3,6 +3,7 @@ export { VoiceProviderSimulationControls } from './VoiceProviderSimulationContro
 export { VoiceProviderCapabilities } from './VoiceProviderCapabilities';
 export { VoiceProviderStatus } from './VoiceProviderStatus';
 export { VoiceRoutingStatus } from './VoiceRoutingStatus';
+export { VoiceTurnQuality } from './VoiceTurnQuality';
 export { useVoiceAppKitStatus } from './useVoiceAppKitStatus';
 export { useVoiceStream } from './useVoiceStream';
 export { useVoiceController } from './useVoiceController';
@@ -10,4 +11,5 @@ export { useVoiceProviderStatus } from './useVoiceProviderStatus';
 export { useVoiceProviderCapabilities } from './useVoiceProviderCapabilities';
 export { useVoiceProviderSimulationControls } from './useVoiceProviderSimulationControls';
 export { useVoiceRoutingStatus } from './useVoiceRoutingStatus';
+export { useVoiceTurnQuality } from './useVoiceTurnQuality';
 export { useVoiceWorkflowStatus } from './useVoiceWorkflowStatus';