@absolutejs/voice 0.0.22-beta.263 → 0.0.22-beta.265

package/dist/index.d.ts

@@ -40,8 +40,8 @@ export { createVoiceLiveLatencyRoutes, renderVoiceLiveLatencyHTML, summarizeVoic
 export { assertVoiceLatencySLOGate, buildVoiceLatencySLOGate, renderVoiceLatencySLOMarkdown } from './latencySlo';
 export { createVoiceTurnQualityHTMLHandler, createVoiceTurnQualityJSONHandler, createVoiceTurnQualityRoutes, renderVoiceTurnQualityHTML, summarizeVoiceTurnQuality } from './turnQuality';
 export { assertVoiceOutcomeContractEvidence, createVoiceOutcomeContractHTMLHandler, createVoiceOutcomeContractJSONHandler, createVoiceOutcomeContractRoutes, evaluateVoiceOutcomeContractEvidence, renderVoiceOutcomeContractHTML, runVoiceOutcomeContractSuite } from './outcomeContract';
-export { applyVoiceTelephonyOutcome, createMemoryVoiceTelephonyWebhookIdempotencyStore, createVoiceTelephonyOutcomePolicy, createVoiceTelephonyWebhookHandler, createVoiceTelephonyWebhookRoutes, parseVoiceTelephonyWebhookEvent, resolveVoiceTelephonyOutcome, signVoiceTwilioWebhook, verifyVoiceTwilioWebhookSignature, voiceTelephonyOutcomeToRouteResult } from './telephonyOutcome';
-export { assertVoicePhoneAssistantEvidence, createVoicePhoneAgent, evaluateVoicePhoneAssistantEvidence } from './phoneAgent';
+export { applyVoiceTelephonyOutcome, assertVoiceTelephonyWebhookNormalizationEvidence, createMemoryVoiceTelephonyWebhookIdempotencyStore, createVoiceTelephonyOutcomePolicy, createVoiceTelephonyWebhookHandler, createVoiceTelephonyWebhookRoutes, evaluateVoiceTelephonyWebhookNormalizationEvidence, parseVoiceTelephonyWebhookEvent, resolveVoiceTelephonyOutcome, signVoiceTwilioWebhook, verifyVoiceTwilioWebhookSignature, voiceTelephonyOutcomeToRouteResult } from './telephonyOutcome';
+export { assertVoicePhoneCallControlEvidence, assertVoicePhoneAssistantEvidence, createVoicePhoneAgent, evaluateVoicePhoneCallControlEvidence, evaluateVoicePhoneAssistantEvidence } from './phoneAgent';
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileIncidentBundleStore, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileAuditEventStore, createVoiceFileAuditSinkDeliveryStore, createVoiceFileCampaignStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
 export { createVoiceAssistantMemoryHandle, createVoiceAssistantMemoryRecord, createVoiceMemoryAssistantMemoryStore, resolveVoiceAssistantMemoryNamespace } from './assistantMemory';
 export { createAnthropicVoiceAssistantModel, createGeminiVoiceAssistantModel, createJSONVoiceAssistantModel, createOpenAIVoiceAssistantModel, resolveVoiceProviderRoutingPolicyPreset, createVoiceProviderRouter } from './modelAdapters';
@@ -115,8 +115,8 @@ export type { VoiceLiveLatencyOptions, VoiceLiveLatencyReport, VoiceLiveLatencyR
 export type { VoiceLatencySLOBudget, VoiceLatencySLOGateError, VoiceLatencySLOGateOptions, VoiceLatencySLOGateReport, VoiceLatencySLOMeasurement, VoiceLatencySLOStage, VoiceLatencySLOStageSummary, VoiceLatencySLOStatus } from './latencySlo';
 export type { VoiceTurnQualityHTMLHandlerOptions, VoiceTurnQualityItem, VoiceTurnQualityOptions, VoiceTurnQualityReport, VoiceTurnQualityRoutesOptions, VoiceTurnQualityStatus } from './turnQuality';
 export type { VoiceOutcomeContractAssertionInput, VoiceOutcomeContractAssertionReport, VoiceOutcomeContractDefinition, VoiceOutcomeContractHTMLHandlerOptions, VoiceOutcomeContractIssue, VoiceOutcomeContractOptions, VoiceOutcomeContractReport, VoiceOutcomeContractRoutesOptions, VoiceOutcomeContractStatus, VoiceOutcomeContractSuiteReport } from './outcomeContract';
-export type { VoiceTelephonyOutcomeAction, VoiceTelephonyOutcomeDecision, VoiceTelephonyOutcomePolicy, VoiceTelephonyOutcomeProviderEvent, VoiceTelephonyOutcomeRouteResult, VoiceTelephonyOutcomeStatusDecision, VoiceTelephonyWebhookDecision, VoiceTelephonyWebhookHandlerOptions, VoiceTelephonyWebhookIdempotencyStore, VoiceTelephonyWebhookParseInput, VoiceTelephonyWebhookProvider, VoiceTelephonyWebhookRoutesOptions, VoiceTelephonyWebhookVerificationResult, StoredVoiceTelephonyWebhookDecision } from './telephonyOutcome';
-export type { VoicePhoneAgentCarrier, VoicePhoneAgentCarrierSummary, VoicePhoneAssistantEvidenceInput, VoicePhoneAssistantEvidenceReport, VoicePhoneAgentLifecycleStage, VoicePhoneAgentPlivoCarrier, VoicePhoneAgentRoutes, VoicePhoneAgentRoutesOptions, VoicePhoneAgentSetupReport, VoicePhoneAgentTelnyxCarrier, VoicePhoneAgentTwilioCarrier } from './phoneAgent';
+export type { VoiceTelephonyOutcomeAction, VoiceTelephonyOutcomeDecision, VoiceTelephonyOutcomePolicy, VoiceTelephonyOutcomeProviderEvent, VoiceTelephonyOutcomeRouteResult, VoiceTelephonyOutcomeStatusDecision, VoiceTelephonyWebhookDecision, VoiceTelephonyWebhookHandlerOptions, VoiceTelephonyWebhookIdempotencyStore, VoiceTelephonyWebhookNormalizationEvidenceDecision, VoiceTelephonyWebhookNormalizationEvidenceInput, VoiceTelephonyWebhookNormalizationEvidenceReport, VoiceTelephonyWebhookParseInput, VoiceTelephonyWebhookProvider, VoiceTelephonyWebhookRoutesOptions, VoiceTelephonyWebhookVerificationResult, StoredVoiceTelephonyWebhookDecision } from './telephonyOutcome';
+export type { VoicePhoneAgentCarrier, VoicePhoneAgentCarrierSummary, VoicePhoneAssistantEvidenceInput, VoicePhoneAssistantEvidenceReport, VoicePhoneCallControlEvidenceInput, VoicePhoneCallControlEvidenceReport, VoicePhoneAgentLifecycleStage, VoicePhoneAgentPlivoCarrier, VoicePhoneAgentRoutes, VoicePhoneAgentRoutesOptions, VoicePhoneAgentSetupReport, VoicePhoneAgentTelnyxCarrier, VoicePhoneAgentTwilioCarrier } from './phoneAgent';
 export type { VoicePhoneAgentProductionSmokeIssue, VoicePhoneAgentProductionSmokeHandlerOptions, VoicePhoneAgentProductionSmokeHTMLHandlerOptions, VoicePhoneAgentProductionSmokeOptions, VoicePhoneAgentProductionSmokeReport, VoicePhoneAgentProductionSmokeRoutesOptions, VoicePhoneAgentProductionSmokeRequirement } from './phoneAgentProductionSmoke';
 export type { VoiceOpsConsoleLink, VoiceOpsConsoleReport, VoiceOpsConsoleRoutesOptions } from './opsConsoleRoutes';
 export type { VoiceOpsStatus, VoiceOpsStatusLink, VoiceOpsStatusOptions, VoiceOpsStatusReport, VoiceOpsStatusRoutesOptions } from './opsStatus';

package/dist/index.js

@@ -17364,6 +17364,14 @@ var DEFAULT_MACHINE_VOICEMAIL_VALUES = [
 ];
 var DEFAULT_NO_ANSWER_SIP_CODES = [408, 480, 486, 487, 603];
 var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var uniqueSorted3 = (values) => Array.from(new Set(values)).sort();
+var findMissing3 = (values, required) => {
+  if (!required?.length) {
+    return [];
+  }
+  const valueSet = new Set(values);
+  return required.filter((value) => !valueSet.has(value));
+};
 
 class VoiceTelephonyWebhookVerificationError extends Error {
   result;
@@ -17382,6 +17390,60 @@ var createMemoryVoiceTelephonyWebhookIdempotencyStore = () => {
     }
   };
 };
+var isTelephonyWebhookProvider = (value) => value === "generic" || value === "plivo" || value === "telnyx" || value === "twilio";
+var isTelephonyOutcomeAction = (value) => value === "complete" || value === "escalate" || value === "ignore" || value === "no-answer" || value === "transfer" || value === "voicemail";
+var isCallDisposition = (value) => value === "completed" || value === "escalated" || value === "failed" || value === "no-answer" || value === "transferred" || value === "voicemail";
+var evaluateVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
+  const issues = [];
+  const decisions = input.decisions ?? [];
+  const actions = uniqueSorted3(decisions.map((decision) => decision.decision?.action ?? decision.action).filter(isTelephonyOutcomeAction));
+  const dispositions = uniqueSorted3(decisions.map((decision) => decision.decision?.disposition ?? decision.disposition).filter(isCallDisposition));
+  const providers = uniqueSorted3(decisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
+  const sources = uniqueSorted3(decisions.map((decision) => decision.decision?.source ?? decision.source).filter((source) => typeof source === "string"));
+  const applied = decisions.filter((decision) => decision.applied === true).length;
+  const routeResults = decisions.filter((decision) => isRecord(decision.routeResult)).length;
+  const missingSessionIds = decisions.filter((decision) => !decision.sessionId).length;
+  if (input.minDecisions !== undefined && decisions.length < input.minDecisions) {
+    issues.push(`Expected at least ${String(input.minDecisions)} telephony webhook decision(s), found ${String(decisions.length)}.`);
+  }
+  if (input.minApplied !== undefined && applied < input.minApplied) {
+    issues.push(`Expected at least ${String(input.minApplied)} applied telephony webhook decision(s), found ${String(applied)}.`);
+  }
+  if (input.maxMissingSessionIds !== undefined && missingSessionIds > input.maxMissingSessionIds) {
+    issues.push(`Expected at most ${String(input.maxMissingSessionIds)} telephony webhook decision(s) without sessionId, found ${String(missingSessionIds)}.`);
+  }
+  if (input.requireRouteResults && routeResults < decisions.length) {
+    issues.push(`Expected every telephony webhook decision to include a route result, found ${String(routeResults)} of ${String(decisions.length)}.`);
+  }
+  for (const provider of findMissing3(providers, input.requiredProviders)) {
+    issues.push(`Missing telephony webhook provider: ${provider}.`);
+  }
+  for (const action of findMissing3(actions, input.requiredActions)) {
+    issues.push(`Missing telephony webhook action: ${action}.`);
+  }
+  for (const disposition of findMissing3(dispositions, input.requiredDispositions)) {
+    issues.push(`Missing telephony webhook disposition: ${disposition}.`);
+  }
+  return {
+    actions,
+    applied,
+    decisions: decisions.length,
+    dispositions,
+    issues,
+    missingSessionIds,
+    ok: issues.length === 0,
+    providers,
+    routeResults,
+    sources
+  };
+};
+var assertVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
+  const assertion = evaluateVoiceTelephonyWebhookNormalizationEvidence(input);
+  if (!assertion.ok) {
+    throw new Error(`Voice telephony webhook normalization evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var normalizeToken = (value) => typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-") : undefined;
 var firstString2 = (source, keys) => {
   for (const key of keys) {
@@ -20020,8 +20082,8 @@ var loadCarrierMatrixInputs = async (input) => {
 };
 var carrierAnswerLabel = (provider) => provider === "telnyx" ? "TeXML URL" : provider === "plivo" ? "Answer URL" : "TwiML URL";
 var findCarrierMatrixEntry = (matrix, carrier) => matrix?.entries.find((candidate) => candidate.provider === carrier.provider && (candidate.name === carrier.name || candidate.name === (carrier.name ?? carrier.provider)));
-var uniqueSorted3 = (values) => Array.from(new Set(values)).sort();
-var findMissing3 = (values, required) => {
+var uniqueSorted4 = (values) => Array.from(new Set(values)).sort();
+var findMissing4 = (values, required) => {
   if (!required?.length) {
     return [];
   }
@@ -20030,8 +20092,8 @@ var findMissing3 = (values, required) => {
 };
 var evaluateVoicePhoneAssistantEvidence = (report, input = {}) => {
   const issues = [];
-  const providers = uniqueSorted3(report.carriers.map((carrier) => carrier.provider));
-  const lifecycleStages = uniqueSorted3(report.lifecycleStages);
+  const providers = uniqueSorted4(report.carriers.map((carrier) => carrier.provider));
+  const lifecycleStages = uniqueSorted4(report.lifecycleStages);
   const carrierSummary = report.matrix?.summary;
   const carrierFailures = carrierSummary?.failing ?? 0;
   const carrierWarnings = carrierSummary?.warnings ?? 0;
@@ -20071,10 +20133,10 @@ var evaluateVoicePhoneAssistantEvidence = (report, input = {}) => {
   if (input.maxCarrierWarnings !== undefined && carrierWarnings > input.maxCarrierWarnings) {
     issues.push(`Expected at most ${String(input.maxCarrierWarnings)} phone carrier warning(s), found ${String(carrierWarnings)}.`);
   }
-  for (const provider of findMissing3(providers, input.requiredProviders)) {
+  for (const provider of findMissing4(providers, input.requiredProviders)) {
     issues.push(`Missing phone carrier provider: ${provider}.`);
   }
-  for (const stage of findMissing3(lifecycleStages, input.requiredLifecycleStages)) {
+  for (const stage of findMissing4(lifecycleStages, input.requiredLifecycleStages)) {
     issues.push(`Missing phone lifecycle stage: ${stage}.`);
   }
   const dialer = input.dialerProof ? evaluateVoiceCampaignDialerProofEvidence(input.dialerProof, {
@@ -20113,6 +20175,56 @@ var assertVoicePhoneAssistantEvidence = (report, input = {}) => {
   }
   return assertion;
 };
+var evaluateVoicePhoneCallControlEvidence = (input = {}) => {
+  const issues = [];
+  const setup = input.setup;
+  const productionSmokes = input.productionSmokes ?? [];
+  const lifecycleStages = uniqueSorted4(setup?.lifecycleStages ?? []);
+  const providers = uniqueSorted4(productionSmokes.map((report) => report.provider).filter((provider) => Boolean(provider)));
+  const outcomes = uniqueSorted4(productionSmokes.flatMap((report) => report.observed.lifecycleOutcomes));
+  const failedSmokeReports = productionSmokes.filter((report) => !report.pass).length;
+  const passingSmokeReports = productionSmokes.length - failedSmokeReports;
+  if (productionSmokes.length === 0) {
+    issues.push("Expected phone call-control smoke report(s) to be present.");
+  }
+  if (input.requireSetupLifecycleStages ?? true) {
+    if (!setup) {
+      issues.push("Expected phone setup report to be present.");
+    }
+    for (const stage of findMissing4(lifecycleStages, input.requiredLifecycleStages)) {
+      issues.push(`Missing phone call-control lifecycle stage: ${stage}.`);
+    }
+  }
+  if (input.minPassingSmokeReports !== undefined && passingSmokeReports < input.minPassingSmokeReports) {
+    issues.push(`Expected at least ${String(input.minPassingSmokeReports)} passing phone call-control smoke report(s), found ${String(passingSmokeReports)}.`);
+  }
+  if (input.maxFailedSmokeReports !== undefined && failedSmokeReports > input.maxFailedSmokeReports) {
+    issues.push(`Expected at most ${String(input.maxFailedSmokeReports)} failing phone call-control smoke report(s), found ${String(failedSmokeReports)}.`);
+  }
+  for (const provider of findMissing4(providers, input.requiredProviders)) {
+    issues.push(`Missing phone call-control provider: ${provider}.`);
+  }
+  for (const outcome of findMissing4(outcomes, input.requiredOutcomes)) {
+    issues.push(`Missing phone call-control outcome: ${outcome}.`);
+  }
+  return {
+    failedSmokeReports,
+    issues,
+    lifecycleStages,
+    ok: issues.length === 0,
+    outcomes,
+    passingSmokeReports,
+    providers,
+    smokeReports: productionSmokes.length
+  };
+};
+var assertVoicePhoneCallControlEvidence = (input = {}) => {
+  const assertion = evaluateVoicePhoneCallControlEvidence(input);
+  if (!assertion.ok) {
+    throw new Error(`Voice phone call-control evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var buildVoicePhoneAgentSetupInstructions = (input) => input.carriers.map((carrier) => {
   const entry = findCarrierMatrixEntry(input.matrix, carrier);
   const urls = entry?.setup.urls;
@@ -23045,7 +23157,7 @@ var statusRank = {
 var escapeHtml36 = (value) => value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
 var roundMetric3 = (value) => Math.round(value * 1e4) / 1e4;
 var rate3 = (count, total) => count / Math.max(1, total);
-var uniqueSorted4 = (values) => [
+var uniqueSorted5 = (values) => [
   ...new Set(values.filter((value) => typeof value === "string"))
 ].sort();
 var percentile3 = (values, rank) => {
@@ -23228,7 +23340,7 @@ var buildVoiceProviderSloReport = async (options = {}) => {
 var evaluateVoiceProviderSloEvidence = (report, input = {}) => {
   const issues = [];
   const kindReports = Object.values(report.kinds);
-  const providers = uniqueSorted4(kindReports.flatMap((kind) => kind.providers));
+  const providers = uniqueSorted5(kindReports.flatMap((kind) => kind.providers));
   const kinds = providerKinds.filter((kind) => report.kinds[kind].events > 0);
   const fallbacks = kindReports.reduce((total, kind) => total + kind.fallbacks, 0);
   const timeouts = kindReports.reduce((total, kind) => total + kind.timeouts, 0);
@@ -23949,7 +24061,7 @@ var hasPayloadValue = (payload, key, values) => {
   return typeof value === "string" && values.has(value);
 };
 var countIntegrationDeliveryStatus = (events, status) => events.filter((event) => event.deliveryStatus === status).length;
-var uniqueSorted5 = (values) => [
+var uniqueSorted6 = (values) => [
   ...new Set(values.filter((value) => typeof value === "string"))
 ].sort();
 var pushMissingValuesIssue = (input) => {
@@ -24128,11 +24240,11 @@ var buildVoiceOperationsRecord = async (options) => {
 var evaluateVoiceOperationsRecordGuardrails = (record, input = {}) => {
   const issues = [];
   const decisions = record.guardrails.decisions;
-  const proofs = uniqueSorted5(decisions.map((decision) => decision.proof));
-  const ruleIds = uniqueSorted5(decisions.flatMap((decision) => decision.findings.map((finding) => finding.ruleId)));
-  const stages = uniqueSorted5(decisions.map((decision) => decision.stage));
-  const statuses = uniqueSorted5(decisions.map((decision) => decision.status));
-  const toolNames = uniqueSorted5(decisions.map((decision) => decision.toolName));
+  const proofs = uniqueSorted6(decisions.map((decision) => decision.proof));
+  const ruleIds = uniqueSorted6(decisions.flatMap((decision) => decision.findings.map((finding) => finding.ruleId)));
+  const stages = uniqueSorted6(decisions.map((decision) => decision.stage));
+  const statuses = uniqueSorted6(decisions.map((decision) => decision.status));
+  const toolNames = uniqueSorted6(decisions.map((decision) => decision.toolName));
   const minDecisions = input.minDecisions ?? 1;
   if (record.guardrails.total < minDecisions) {
     issues.push(`Expected at least ${String(minDecisions)} guardrail decisions, found ${String(record.guardrails.total)}.`);
@@ -31369,6 +31481,7 @@ export {
   exportVoiceAuditTrail,
   evaluateVoiceTrace,
   evaluateVoiceToolContractEvidence,
+  evaluateVoiceTelephonyWebhookNormalizationEvidence,
   evaluateVoiceTelephonyContract,
   evaluateVoiceSimulationSuiteEvidence,
   evaluateVoiceQuality,
@@ -31380,6 +31493,7 @@ export {
   evaluateVoiceProofTrendEvidence,
   evaluateVoiceProductionReadinessEvidence,
   evaluateVoicePlatformCoverage,
+  evaluateVoicePhoneCallControlEvidence,
   evaluateVoicePhoneAssistantEvidence,
   evaluateVoiceOutcomeContractEvidence,
   evaluateVoiceOperationsRecordGuardrails,
@@ -31704,6 +31818,7 @@ export {
   buildEmptyVoiceProofTrendReport,
   assignVoiceOpsTask,
   assertVoiceToolContractEvidence,
+  assertVoiceTelephonyWebhookNormalizationEvidence,
   assertVoiceSimulationSuiteEvidence,
   assertVoiceProviderStackEvidence,
   assertVoiceProviderSloEvidence,
@@ -31713,6 +31828,7 @@ export {
   assertVoiceProofTrendEvidence,
   assertVoiceProductionReadinessEvidence,
   assertVoicePlatformCoverage,
+  assertVoicePhoneCallControlEvidence,
   assertVoicePhoneAssistantEvidence,
   assertVoiceOutcomeContractEvidence,
   assertVoiceOperationsRecordGuardrails,

package/dist/phoneAgent.d.ts

@@ -6,6 +6,7 @@ import { type VoiceTelephonyCarrierMatrix, type VoiceTelephonyCarrierMatrixRoute
 import { type VoicePhoneAgentProductionSmokeRoutesOptions } from './phoneAgentProductionSmoke';
 import { type VoiceCampaignDialerProofAssertionReport, type VoiceCampaignDialerProofProvider, type VoiceCampaignDialerProofReport } from './campaignDialers';
 import type { VoiceTelephonyProvider } from './telephony/contract';
+import type { VoicePhoneAgentProductionSmokeReport } from './phoneAgentProductionSmoke';
 import type { VoiceSessionRecord } from './types';
 export type VoicePhoneAgentLifecycleStage = 'ringing' | 'answered' | 'media-started' | 'transcript' | 'assistant-response' | 'transfer' | 'voicemail' | 'no-answer' | 'completed' | 'failed';
 type VoicePhoneAgentCarrierBase = {
@@ -110,7 +111,29 @@ export type VoicePhoneAssistantEvidenceReport = {
     setupPath?: string;
     smokePassing: number;
 };
+export type VoicePhoneCallControlEvidenceInput = {
+    maxFailedSmokeReports?: number;
+    minPassingSmokeReports?: number;
+    productionSmokes?: VoicePhoneAgentProductionSmokeReport[];
+    requiredLifecycleStages?: VoicePhoneAgentLifecycleStage[];
+    requiredOutcomes?: string[];
+    requiredProviders?: VoiceTelephonyProvider[];
+    requireSetupLifecycleStages?: boolean;
+    setup?: VoicePhoneAgentSetupReport;
+};
+export type VoicePhoneCallControlEvidenceReport = {
+    failedSmokeReports: number;
+    issues: string[];
+    lifecycleStages: VoicePhoneAgentLifecycleStage[];
+    ok: boolean;
+    outcomes: string[];
+    passingSmokeReports: number;
+    providers: VoiceTelephonyProvider[];
+    smokeReports: number;
+};
 export declare const evaluateVoicePhoneAssistantEvidence: (report: VoicePhoneAgentSetupReport, input?: VoicePhoneAssistantEvidenceInput) => VoicePhoneAssistantEvidenceReport;
 export declare const assertVoicePhoneAssistantEvidence: (report: VoicePhoneAgentSetupReport, input?: VoicePhoneAssistantEvidenceInput) => VoicePhoneAssistantEvidenceReport;
+export declare const evaluateVoicePhoneCallControlEvidence: (input?: VoicePhoneCallControlEvidenceInput) => VoicePhoneCallControlEvidenceReport;
+export declare const assertVoicePhoneCallControlEvidence: (input?: VoicePhoneCallControlEvidenceInput) => VoicePhoneCallControlEvidenceReport;
 export declare const createVoicePhoneAgent: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoicePhoneAgentRoutesOptions<TContext, TSession, TResult>) => VoicePhoneAgentRoutes;
 export {};

package/dist/telephonyOutcome.d.ts

@@ -65,6 +65,43 @@ export type StoredVoiceTelephonyWebhookDecision<TResult = unknown> = VoiceTeleph
     createdAt: number;
     updatedAt: number;
 };
+export type VoiceTelephonyWebhookNormalizationEvidenceDecision = {
+    action?: VoiceTelephonyOutcomeAction | string;
+    applied?: boolean;
+    decision?: {
+        action?: VoiceTelephonyOutcomeAction | string;
+        disposition?: VoiceCallDisposition | string;
+        source?: VoiceTelephonyOutcomeDecision['source'] | string;
+    };
+    disposition?: VoiceCallDisposition | string;
+    event?: VoiceTelephonyOutcomeProviderEvent;
+    provider?: VoiceTelephonyWebhookProvider | string;
+    routeResult?: unknown;
+    sessionId?: string;
+    source?: VoiceTelephonyOutcomeDecision['source'] | string;
+};
+export type VoiceTelephonyWebhookNormalizationEvidenceInput = {
+    decisions?: VoiceTelephonyWebhookNormalizationEvidenceDecision[];
+    maxMissingSessionIds?: number;
+    minApplied?: number;
+    minDecisions?: number;
+    requiredActions?: VoiceTelephonyOutcomeAction[];
+    requiredDispositions?: VoiceCallDisposition[];
+    requiredProviders?: VoiceTelephonyWebhookProvider[];
+    requireRouteResults?: boolean;
+};
+export type VoiceTelephonyWebhookNormalizationEvidenceReport = {
+    actions: VoiceTelephonyOutcomeAction[];
+    applied: number;
+    decisions: number;
+    dispositions: VoiceCallDisposition[];
+    issues: string[];
+    missingSessionIds: number;
+    ok: boolean;
+    providers: VoiceTelephonyWebhookProvider[];
+    routeResults: number;
+    sources: string[];
+};
 export type VoiceTelephonyWebhookIdempotencyStore<TResult = unknown> = {
     get: (key: string) => Promise<StoredVoiceTelephonyWebhookDecision<TResult> | undefined> | StoredVoiceTelephonyWebhookDecision<TResult> | undefined;
     set: (key: string, decision: StoredVoiceTelephonyWebhookDecision<TResult>) => Promise<void> | void;
@@ -139,6 +176,8 @@ export declare class VoiceTelephonyWebhookVerificationError extends Error {
     constructor(result: VoiceTelephonyWebhookVerificationResult);
 }
 export declare const createMemoryVoiceTelephonyWebhookIdempotencyStore: <TResult = unknown>() => VoiceTelephonyWebhookIdempotencyStore<TResult>;
+export declare const evaluateVoiceTelephonyWebhookNormalizationEvidence: (input?: VoiceTelephonyWebhookNormalizationEvidenceInput) => VoiceTelephonyWebhookNormalizationEvidenceReport;
+export declare const assertVoiceTelephonyWebhookNormalizationEvidence: (input?: VoiceTelephonyWebhookNormalizationEvidenceInput) => VoiceTelephonyWebhookNormalizationEvidenceReport;
 export declare const createVoiceTelephonyOutcomePolicy: (policy?: VoiceTelephonyOutcomePolicy) => Required<Pick<VoiceTelephonyOutcomePolicy, "completedStatuses" | "escalationStatuses" | "failedAsNoAnswer" | "failedStatuses" | "includeProviderPayload" | "machineDetectionVoicemailValues" | "noAnswerOnZeroDuration" | "noAnswerSipCodes" | "noAnswerStatuses" | "transferStatuses" | "voicemailStatuses">> & VoiceTelephonyOutcomePolicy;
 export declare const resolveVoiceTelephonyOutcome: (event: VoiceTelephonyOutcomeProviderEvent, policyInput?: VoiceTelephonyOutcomePolicy) => VoiceTelephonyOutcomeDecision;
 export declare const voiceTelephonyOutcomeToRouteResult: <TResult = unknown>(decision: VoiceTelephonyOutcomeDecision, result?: TResult) => VoiceTelephonyOutcomeRouteResult<TResult>;

package/dist/testing/index.js

@@ -8219,6 +8219,14 @@ var DEFAULT_MACHINE_VOICEMAIL_VALUES = [
 ];
 var DEFAULT_NO_ANSWER_SIP_CODES = [408, 480, 486, 487, 603];
 var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var uniqueSorted = (values) => Array.from(new Set(values)).sort();
+var findMissing = (values, required) => {
+  if (!required?.length) {
+    return [];
+  }
+  const valueSet = new Set(values);
+  return required.filter((value) => !valueSet.has(value));
+};
 
 class VoiceTelephonyWebhookVerificationError extends Error {
   result;
@@ -8237,6 +8245,60 @@ var createMemoryVoiceTelephonyWebhookIdempotencyStore = () => {
     }
   };
 };
+var isTelephonyWebhookProvider = (value) => value === "generic" || value === "plivo" || value === "telnyx" || value === "twilio";
+var isTelephonyOutcomeAction = (value) => value === "complete" || value === "escalate" || value === "ignore" || value === "no-answer" || value === "transfer" || value === "voicemail";
+var isCallDisposition = (value) => value === "completed" || value === "escalated" || value === "failed" || value === "no-answer" || value === "transferred" || value === "voicemail";
+var evaluateVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
+  const issues = [];
+  const decisions = input.decisions ?? [];
+  const actions = uniqueSorted(decisions.map((decision) => decision.decision?.action ?? decision.action).filter(isTelephonyOutcomeAction));
+  const dispositions = uniqueSorted(decisions.map((decision) => decision.decision?.disposition ?? decision.disposition).filter(isCallDisposition));
+  const providers = uniqueSorted(decisions.map((decision) => decision.provider ?? decision.event?.provider).filter(isTelephonyWebhookProvider));
+  const sources = uniqueSorted(decisions.map((decision) => decision.decision?.source ?? decision.source).filter((source) => typeof source === "string"));
+  const applied = decisions.filter((decision) => decision.applied === true).length;
+  const routeResults = decisions.filter((decision) => isRecord(decision.routeResult)).length;
+  const missingSessionIds = decisions.filter((decision) => !decision.sessionId).length;
+  if (input.minDecisions !== undefined && decisions.length < input.minDecisions) {
+    issues.push(`Expected at least ${String(input.minDecisions)} telephony webhook decision(s), found ${String(decisions.length)}.`);
+  }
+  if (input.minApplied !== undefined && applied < input.minApplied) {
+    issues.push(`Expected at least ${String(input.minApplied)} applied telephony webhook decision(s), found ${String(applied)}.`);
+  }
+  if (input.maxMissingSessionIds !== undefined && missingSessionIds > input.maxMissingSessionIds) {
+    issues.push(`Expected at most ${String(input.maxMissingSessionIds)} telephony webhook decision(s) without sessionId, found ${String(missingSessionIds)}.`);
+  }
+  if (input.requireRouteResults && routeResults < decisions.length) {
+    issues.push(`Expected every telephony webhook decision to include a route result, found ${String(routeResults)} of ${String(decisions.length)}.`);
+  }
+  for (const provider of findMissing(providers, input.requiredProviders)) {
+    issues.push(`Missing telephony webhook provider: ${provider}.`);
+  }
+  for (const action of findMissing(actions, input.requiredActions)) {
+    issues.push(`Missing telephony webhook action: ${action}.`);
+  }
+  for (const disposition of findMissing(dispositions, input.requiredDispositions)) {
+    issues.push(`Missing telephony webhook disposition: ${disposition}.`);
+  }
+  return {
+    actions,
+    applied,
+    decisions: decisions.length,
+    dispositions,
+    issues,
+    missingSessionIds,
+    ok: issues.length === 0,
+    providers,
+    routeResults,
+    sources
+  };
+};
+var assertVoiceTelephonyWebhookNormalizationEvidence = (input = {}) => {
+  const assertion = evaluateVoiceTelephonyWebhookNormalizationEvidence(input);
+  if (!assertion.ok) {
+    throw new Error(`Voice telephony webhook normalization evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var normalizeToken = (value) => typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-") : undefined;
 var firstString = (source, keys) => {
   for (const key of keys) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@absolutejs/voice",
-	"version": "0.0.22-beta.263",
+	"version": "0.0.22-beta.265",
 	"description": "Voice primitives and Elysia plugin for AbsoluteJS",
 	"repository": {
 		"type": "git",