@absolutejs/voice 0.0.22-beta.254 → 0.0.22-beta.256

package/dist/agentSquadContract.d.ts

@@ -65,5 +65,34 @@ export type VoiceAgentSquadContractRunOptions<TContext = unknown, TSession exten
     squad: VoiceAgent<TContext, TSession, TResult>;
     trace?: VoiceTraceEventStore;
 };
+export type VoiceAgentSquadContractAssertionInput = {
+    maxBlockedHandoffs?: number;
+    maxFailed?: number;
+    maxIssues?: number;
+    minContracts?: number;
+    minHandoffs?: number;
+    requiredContractIds?: string[];
+    requiredFinalAgentIds?: string[];
+    requiredHandoffStatuses?: VoiceAgentSquadHandoffStatus[];
+    requiredHandoffTargets?: string[];
+    requiredScenarioIds?: string[];
+};
+export type VoiceAgentSquadContractAssertionReport = {
+    blockedHandoffs: number;
+    contractIds: string[];
+    failed: number;
+    finalAgentIds: string[];
+    handoffStatuses: VoiceAgentSquadHandoffStatus[];
+    handoffTargets: string[];
+    handoffs: number;
+    issues: string[];
+    issueCount: number;
+    ok: boolean;
+    passed: number;
+    scenarioIds: string[];
+    total: number;
+};
 export declare const runVoiceAgentSquadContract: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAgentSquadContractRunOptions<TContext, TSession, TResult>) => Promise<VoiceAgentSquadContractReport<TResult>>;
 export declare const assertVoiceAgentSquadContract: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options: VoiceAgentSquadContractRunOptions<TContext, TSession, TResult>) => Promise<VoiceAgentSquadContractReport<TResult>>;
+export declare const evaluateVoiceAgentSquadContractEvidence: (reports: readonly VoiceAgentSquadContractReport[], input?: VoiceAgentSquadContractAssertionInput) => VoiceAgentSquadContractAssertionReport;
+export declare const assertVoiceAgentSquadContractEvidence: (reports: readonly VoiceAgentSquadContractReport[], input?: VoiceAgentSquadContractAssertionInput) => VoiceAgentSquadContractAssertionReport;

package/dist/index.d.ts

@@ -32,14 +32,14 @@ export { createVoiceSimulationSuiteRoutes, renderVoiceSimulationSuiteHTML, runVo
 export { createVoiceWorkflowContract, createVoiceWorkflowContractHandler, createVoiceWorkflowContractPreset, createVoiceWorkflowScenario, recordVoiceWorkflowContractTrace, validateVoiceWorkflowRouteResult } from './workflowContract';
 export { createVoiceSessionListRoutes, createVoiceSessionReplayHTMLHandler, createVoiceSessionReplayJSONHandler, createVoiceSessionReplayRoutes, createVoiceSessionsHTMLHandler, createVoiceSessionsJSONHandler, renderVoiceSessionsHTML, summarizeVoiceProviderFallbackRecovery, summarizeVoiceSessions, summarizeVoiceSessionReplay } from './sessionReplay';
 export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool } from './agent';
-export { assertVoiceAgentSquadContract, runVoiceAgentSquadContract } from './agentSquadContract';
+export { assertVoiceAgentSquadContractEvidence, assertVoiceAgentSquadContract, evaluateVoiceAgentSquadContractEvidence, runVoiceAgentSquadContract } from './agentSquadContract';
 export { createVoiceToolIdempotencyKey, createVoiceToolRuntime } from './toolRuntime';
-export { createVoiceToolContract, createVoiceToolContractHTMLHandler, createVoiceToolContractJSONHandler, createVoiceToolContractRoutes, createVoiceToolRuntimeContractDefaults, renderVoiceToolContractHTML, runVoiceToolContractSuite, runVoiceToolContract } from './toolContract';
+export { assertVoiceToolContractEvidence, createVoiceToolContract, createVoiceToolContractHTMLHandler, createVoiceToolContractJSONHandler, createVoiceToolContractRoutes, createVoiceToolRuntimeContractDefaults, evaluateVoiceToolContractEvidence, renderVoiceToolContractHTML, runVoiceToolContractSuite, runVoiceToolContract } from './toolContract';
 export { createVoiceTurnLatencyHTMLHandler, createVoiceTurnLatencyJSONHandler, createVoiceTurnLatencyRoutes, renderVoiceTurnLatencyHTML, summarizeVoiceTurnLatency } from './turnLatency';
 export { createVoiceLiveLatencyRoutes, renderVoiceLiveLatencyHTML, summarizeVoiceLiveLatency } from './liveLatency';
 export { assertVoiceLatencySLOGate, buildVoiceLatencySLOGate, renderVoiceLatencySLOMarkdown } from './latencySlo';
 export { createVoiceTurnQualityHTMLHandler, createVoiceTurnQualityJSONHandler, createVoiceTurnQualityRoutes, renderVoiceTurnQualityHTML, summarizeVoiceTurnQuality } from './turnQuality';
-export { createVoiceOutcomeContractHTMLHandler, createVoiceOutcomeContractJSONHandler, createVoiceOutcomeContractRoutes, renderVoiceOutcomeContractHTML, runVoiceOutcomeContractSuite } from './outcomeContract';
+export { assertVoiceOutcomeContractEvidence, createVoiceOutcomeContractHTMLHandler, createVoiceOutcomeContractJSONHandler, createVoiceOutcomeContractRoutes, evaluateVoiceOutcomeContractEvidence, renderVoiceOutcomeContractHTML, runVoiceOutcomeContractSuite } from './outcomeContract';
 export { applyVoiceTelephonyOutcome, createMemoryVoiceTelephonyWebhookIdempotencyStore, createVoiceTelephonyOutcomePolicy, createVoiceTelephonyWebhookHandler, createVoiceTelephonyWebhookRoutes, parseVoiceTelephonyWebhookEvent, resolveVoiceTelephonyOutcome, signVoiceTwilioWebhook, verifyVoiceTwilioWebhookSignature, voiceTelephonyOutcomeToRouteResult } from './telephonyOutcome';
 export { createVoicePhoneAgent } from './phoneAgent';
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileIncidentBundleStore, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, createVoiceFileAuditEventStore, createVoiceFileAuditSinkDeliveryStore, createVoiceFileCampaignStore, createVoiceFileIntegrationEventStore, createVoiceFileReviewStore, createVoiceFileRuntimeStorage, createVoiceFileSessionStore, createVoiceFileTaskStore, createVoiceFileTraceSinkDeliveryStore, createVoiceFileTraceEventStore } from './fileStore';
@@ -49,7 +49,7 @@ export { createOpenAIRealtimeAdapter } from './openaiRealtime';
 export { createOpenAIVoiceTTS } from './openaiTTS';
 export { createVoiceProviderHealthHTMLHandler, createVoiceProviderHealthJSONHandler, createVoiceProviderHealthRoutes, renderVoiceProviderHealthHTML, summarizeVoiceProviderHealth } from './providerHealth';
 export { createVoiceProviderCapabilityHTMLHandler, createVoiceProviderCapabilityJSONHandler, createVoiceProviderCapabilityRoutes, renderVoiceProviderCapabilityHTML, summarizeVoiceProviderCapabilities } from './providerCapabilities';
-export { assertVoiceProviderRoutingContract, runVoiceProviderRoutingContract } from './providerRoutingContract';
+export { assertVoiceProviderRoutingContractEvidence, assertVoiceProviderRoutingContract, evaluateVoiceProviderRoutingContractEvidence, runVoiceProviderRoutingContract } from './providerRoutingContract';
 export { assertVoiceProviderSloEvidence, buildVoiceProviderSloReport, createVoiceProviderSloRoutes, evaluateVoiceProviderSloEvidence, renderVoiceProviderSloHTML, renderVoiceProviderSloMarkdown } from './providerSlo';
 export { createVoicePhoneAgentProductionSmokeHTMLHandler, createVoicePhoneAgentProductionSmokeJSONHandler, createVoicePhoneAgentProductionSmokeRoutes, renderVoicePhoneAgentProductionSmokeHTML, runVoicePhoneAgentProductionSmokeContract } from './phoneAgentProductionSmoke';
 export { assertVoiceProductionReadinessEvidence, buildVoiceProductionReadinessGate, buildVoiceProductionReadinessReport, createVoiceProductionReadinessRoutes, evaluateVoiceProductionReadinessEvidence, renderVoiceProductionReadinessHTML, summarizeVoiceProductionReadinessGate } from './productionReadiness';
@@ -108,13 +108,13 @@ export type { OpenAIVoiceTTSOptions, OpenAIVoiceTTSVoice } from './openaiTTS';
 export type { OpenAIRealtimeAdapterOptions, OpenAIRealtimeModel, OpenAIRealtimeNoiseReduction, OpenAIRealtimeResponseMode, OpenAIRealtimeTranscriptionModel, OpenAIRealtimeVoice } from './openaiRealtime';
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
 export type { VoiceProviderCapabilityDefinition, VoiceProviderCapabilityHandlerOptions, VoiceProviderCapabilityHTMLHandlerOptions, VoiceProviderCapabilityKind, VoiceProviderCapabilityOptions, VoiceProviderCapabilityReport, VoiceProviderCapabilityRoutesOptions, VoiceProviderCapabilitySummary } from './providerCapabilities';
-export type { VoiceProviderRoutingContractDefinition, VoiceProviderRoutingContractIssue, VoiceProviderRoutingContractReport, VoiceProviderRoutingContractRunOptions, VoiceProviderRoutingExpectation, VoiceProviderRoutingStatus } from './providerRoutingContract';
+export type { VoiceProviderRoutingContractAssertionInput, VoiceProviderRoutingContractAssertionReport, VoiceProviderRoutingContractDefinition, VoiceProviderRoutingContractIssue, VoiceProviderRoutingContractReport, VoiceProviderRoutingContractRunOptions, VoiceProviderRoutingExpectation, VoiceProviderRoutingStatus } from './providerRoutingContract';
 export type { VoiceProviderSloAssertionInput, VoiceProviderSloAssertionReport, VoiceProviderSloIssue, VoiceProviderSloKindReport, VoiceProviderSloMetric, VoiceProviderSloReport, VoiceProviderSloReportOptions, VoiceProviderSloRoutesOptions, VoiceProviderSloSessionReport, VoiceProviderSloStatus, VoiceProviderSloThresholdConfig, VoiceProviderSloThresholds } from './providerSlo';
 export type { VoiceTurnLatencyHTMLHandlerOptions, VoiceTurnLatencyItem, VoiceTurnLatencyOptions, VoiceTurnLatencyReport, VoiceTurnLatencyRoutesOptions, VoiceTurnLatencyStage, VoiceTurnLatencyStatus } from './turnLatency';
 export type { VoiceLiveLatencyOptions, VoiceLiveLatencyReport, VoiceLiveLatencyRoutesOptions, VoiceLiveLatencySample, VoiceLiveLatencyStatus } from './liveLatency';
 export type { VoiceLatencySLOBudget, VoiceLatencySLOGateError, VoiceLatencySLOGateOptions, VoiceLatencySLOGateReport, VoiceLatencySLOMeasurement, VoiceLatencySLOStage, VoiceLatencySLOStageSummary, VoiceLatencySLOStatus } from './latencySlo';
 export type { VoiceTurnQualityHTMLHandlerOptions, VoiceTurnQualityItem, VoiceTurnQualityOptions, VoiceTurnQualityReport, VoiceTurnQualityRoutesOptions, VoiceTurnQualityStatus } from './turnQuality';
-export type { VoiceOutcomeContractDefinition, VoiceOutcomeContractHTMLHandlerOptions, VoiceOutcomeContractIssue, VoiceOutcomeContractOptions, VoiceOutcomeContractReport, VoiceOutcomeContractRoutesOptions, VoiceOutcomeContractStatus, VoiceOutcomeContractSuiteReport } from './outcomeContract';
+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, VoicePhoneAgentLifecycleStage, VoicePhoneAgentPlivoCarrier, VoicePhoneAgentRoutes, VoicePhoneAgentRoutesOptions, VoicePhoneAgentSetupReport, VoicePhoneAgentTelnyxCarrier, VoicePhoneAgentTwilioCarrier } from './phoneAgent';
 export type { VoicePhoneAgentProductionSmokeIssue, VoicePhoneAgentProductionSmokeHandlerOptions, VoicePhoneAgentProductionSmokeHTMLHandlerOptions, VoicePhoneAgentProductionSmokeOptions, VoicePhoneAgentProductionSmokeReport, VoicePhoneAgentProductionSmokeRoutesOptions, VoicePhoneAgentProductionSmokeRequirement } from './phoneAgentProductionSmoke';
@@ -131,9 +131,9 @@ export type { VoiceQualityLink, VoiceQualityMetric, VoiceQualityReport, VoiceQua
 export type { VoiceResilienceIOSimulator, VoiceResilienceLink, VoiceResiliencePageData, VoiceResilienceRoutesOptions, VoiceResilienceSimulationProvider, VoiceRoutingKindSummary, VoiceRoutingDecisionSummary, VoiceRoutingDecisionSummaryOptions, VoiceRoutingEvent, VoiceRoutingEventKind, VoiceRoutingSessionSummary, VoiceRoutingSessionSummaryOptions } from './resilienceRoutes';
 export type { VoiceIOProviderRouterEvent, VoiceIOProviderRouterOptions, VoiceIOProviderRouterPolicy, VoiceIOProviderRouterPolicyConfig, VoiceSTTProviderRouterOptions, VoiceTTSProviderRouterOptions } from './providerAdapters';
 export type { VoiceAgent, VoiceAgentMessage, VoiceAgentMessageRole, VoiceAgentModel, VoiceAgentModelInput, VoiceAgentModelOutput, VoiceAgentOptions, VoiceAgentRunResult, VoiceAgentSquadContextPolicyResult, VoiceAgentSquadHandoffPolicyResult, VoiceAgentSquadHandoffStatus, VoiceAgentSquadOptions, VoiceAgentSquadState, VoiceAgentSquadStateHandoff, VoiceAgentTool, VoiceAgentToolCall, VoiceAgentToolResult } from './agent';
-export type { VoiceAgentSquadContractDefinition, VoiceAgentSquadContractIssue, VoiceAgentSquadContractOutcome, VoiceAgentSquadContractReport, VoiceAgentSquadContractRunOptions, VoiceAgentSquadContractTurn, VoiceAgentSquadContractTurnReport, VoiceAgentSquadHandoffExpectation, VoiceAgentSquadTurnExpectation } from './agentSquadContract';
+export type { VoiceAgentSquadContractAssertionInput, VoiceAgentSquadContractAssertionReport, VoiceAgentSquadContractDefinition, VoiceAgentSquadContractIssue, VoiceAgentSquadContractOutcome, VoiceAgentSquadContractReport, VoiceAgentSquadContractRunOptions, VoiceAgentSquadContractTurn, VoiceAgentSquadContractTurnReport, VoiceAgentSquadHandoffExpectation, VoiceAgentSquadTurnExpectation } from './agentSquadContract';
 export type { VoiceToolRetryDelay, VoiceToolRuntime, VoiceToolRuntimeExecuteInput, VoiceToolRuntimeOptions, VoiceToolRuntimeResult } from './toolRuntime';
-export type { VoiceToolContractCase, VoiceToolContractCaseReport, VoiceToolContractDefinition, VoiceToolContractExpectation, VoiceToolContractHandlerOptions, VoiceToolContractHTMLHandlerOptions, VoiceToolContractIssue, VoiceToolContractReport, VoiceToolContractRoutesOptions, VoiceToolContractSuiteReport } from './toolContract';
+export type { VoiceToolContractAssertionInput, VoiceToolContractAssertionReport, VoiceToolContractCase, VoiceToolContractCaseReport, VoiceToolContractDefinition, VoiceToolContractExpectation, VoiceToolContractHandlerOptions, VoiceToolContractHTMLHandlerOptions, VoiceToolContractIssue, VoiceToolContractReport, VoiceToolContractRoutesOptions, VoiceToolContractSuiteReport } from './toolContract';
 export type { VoiceOpsRuntime, VoiceOpsRuntimeConfig, VoiceOpsRuntimeSummary, VoiceOpsRuntimeSinkWorkerConfig, VoiceOpsRuntimeTaskWorkerConfig, VoiceOpsRuntimeTickResult, VoiceOpsRuntimeWebhookWorkerConfig } from './opsRuntime';
 export type { VoiceOpsPresetName, VoiceOpsPresetOverrides, VoiceResolvedOpsPreset } from './opsPresets';
 export type { VoiceOutcomeRecipe, VoiceOutcomeRecipeName, VoiceOutcomeRecipeOptions } from './outcomeRecipes';

package/dist/index.js

@@ -14476,6 +14476,89 @@ var runVoiceOutcomeContractSuite = async (options) => {
     total: contracts.length
   };
 };
+var evaluateVoiceOutcomeContractEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxFailed = input.maxFailed ?? 0;
+  const maxIssues = input.maxIssues ?? 0;
+  const contractIds = [
+    ...new Set(report.contracts.map((contract) => contract.contractId))
+  ].sort();
+  const issueCount = report.contracts.reduce((total, contract) => total + contract.issues.length, 0);
+  const totals = report.contracts.reduce((result, contract) => ({
+    handoffs: result.handoffs + contract.matched.handoffs,
+    integrationEvents: result.integrationEvents + contract.matched.integrationEvents,
+    operationsRecordHrefs: result.operationsRecordHrefs + contract.operationsRecordHrefs.length,
+    reviews: result.reviews + contract.matched.reviews,
+    sessions: result.sessions + contract.matched.sessions,
+    tasks: result.tasks + contract.matched.tasks
+  }), {
+    handoffs: 0,
+    integrationEvents: 0,
+    operationsRecordHrefs: 0,
+    reviews: 0,
+    sessions: 0,
+    tasks: 0
+  });
+  const contractsMissingOperationRecordHrefs = report.contracts.filter((contract) => contract.operationsRecordHrefs.length === 0).length;
+  if (input.minContracts !== undefined && report.total < input.minContracts) {
+    issues.push(`Expected at least ${String(input.minContracts)} outcome contract(s), found ${String(report.total)}.`);
+  }
+  if (report.failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing outcome contract(s), found ${String(report.failed)}.`);
+  }
+  if (issueCount > maxIssues) {
+    issues.push(`Expected at most ${String(maxIssues)} outcome contract issue(s), found ${String(issueCount)}.`);
+  }
+  if (input.minSessions !== undefined && totals.sessions < input.minSessions) {
+    issues.push(`Expected at least ${String(input.minSessions)} matched outcome session(s), found ${String(totals.sessions)}.`);
+  }
+  if (input.minReviews !== undefined && totals.reviews < input.minReviews) {
+    issues.push(`Expected at least ${String(input.minReviews)} matched outcome review(s), found ${String(totals.reviews)}.`);
+  }
+  if (input.minTasks !== undefined && totals.tasks < input.minTasks) {
+    issues.push(`Expected at least ${String(input.minTasks)} matched outcome task(s), found ${String(totals.tasks)}.`);
+  }
+  if (input.minHandoffs !== undefined && totals.handoffs < input.minHandoffs) {
+    issues.push(`Expected at least ${String(input.minHandoffs)} matched outcome handoff(s), found ${String(totals.handoffs)}.`);
+  }
+  if (input.minIntegrationEvents !== undefined && totals.integrationEvents < input.minIntegrationEvents) {
+    issues.push(`Expected at least ${String(input.minIntegrationEvents)} matched outcome integration event(s), found ${String(totals.integrationEvents)}.`);
+  }
+  if (input.minOperationsRecordHrefs !== undefined && totals.operationsRecordHrefs < input.minOperationsRecordHrefs) {
+    issues.push(`Expected at least ${String(input.minOperationsRecordHrefs)} outcome operations record href(s), found ${String(totals.operationsRecordHrefs)}.`);
+  }
+  if ((input.requireOperationRecordHrefs ?? false) && contractsMissingOperationRecordHrefs > 0) {
+    issues.push(`Expected every outcome contract to include operations record hrefs; ${String(contractsMissingOperationRecordHrefs)} contract(s) missing.`);
+  }
+  for (const contractId of input.requiredContractIds ?? []) {
+    if (!contractIds.includes(contractId)) {
+      issues.push(`Missing outcome contract: ${contractId}.`);
+    }
+  }
+  return {
+    contractIds,
+    failed: report.failed,
+    handoffs: totals.handoffs,
+    integrationEvents: totals.integrationEvents,
+    issues,
+    issueCount,
+    ok: issues.length === 0,
+    operationsRecordHrefs: totals.operationsRecordHrefs,
+    passed: report.passed,
+    reviews: totals.reviews,
+    sessions: totals.sessions,
+    status: report.status,
+    tasks: totals.tasks,
+    total: report.total
+  };
+};
+var assertVoiceOutcomeContractEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceOutcomeContractEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice outcome contract evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var renderVoiceOutcomeContractHTML = (report, options = {}) => {
   const title = options.title ?? "Voice Outcome Contracts";
   const contracts = report.contracts.map((contract) => {
@@ -14910,6 +14993,78 @@ var runVoiceToolContractSuite = async (options) => {
     total: contracts.length
   };
 };
+var evaluateVoiceToolContractEvidence = (report, input = {}) => {
+  const issues = [];
+  const maxFailed = input.maxFailed ?? 0;
+  const maxIssues = input.maxIssues ?? 0;
+  const maxTimedOut = input.maxTimedOut ?? Infinity;
+  const cases = report.contracts.flatMap((contract) => contract.cases);
+  const contractIds = [
+    ...new Set(report.contracts.map((contract) => contract.contractId))
+  ].sort();
+  const toolNames = [
+    ...new Set(report.contracts.map((contract) => contract.toolName))
+  ].sort();
+  const caseStatuses = [...new Set(cases.map((testCase) => testCase.status))].sort();
+  const issueCount = report.contracts.reduce((total, contract) => total + contract.issues.length, 0);
+  const timedOut = cases.filter((testCase) => testCase.timedOut).length;
+  const missingOperationsRecordHrefs = cases.filter((testCase) => !testCase.operationsRecordHref).length;
+  if (input.minContracts !== undefined && report.total < input.minContracts) {
+    issues.push(`Expected at least ${String(input.minContracts)} tool contract(s), found ${String(report.total)}.`);
+  }
+  if (input.minCases !== undefined && cases.length < input.minCases) {
+    issues.push(`Expected at least ${String(input.minCases)} tool contract case(s), found ${String(cases.length)}.`);
+  }
+  if (report.failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing tool contract(s), found ${String(report.failed)}.`);
+  }
+  if (issueCount > maxIssues) {
+    issues.push(`Expected at most ${String(maxIssues)} tool contract issue(s), found ${String(issueCount)}.`);
+  }
+  if (timedOut > maxTimedOut) {
+    issues.push(`Expected at most ${String(maxTimedOut)} timed out tool contract case(s), found ${String(timedOut)}.`);
+  }
+  if ((input.requireOperationRecordHrefs ?? false) && missingOperationsRecordHrefs > 0) {
+    issues.push(`Expected every tool contract case to include an operations record href; ${String(missingOperationsRecordHrefs)} missing.`);
+  }
+  for (const contractId of input.requiredContractIds ?? []) {
+    if (!contractIds.includes(contractId)) {
+      issues.push(`Missing tool contract: ${contractId}.`);
+    }
+  }
+  for (const toolName of input.requiredToolNames ?? []) {
+    if (!toolNames.includes(toolName)) {
+      issues.push(`Missing tool contract tool: ${toolName}.`);
+    }
+  }
+  for (const status of input.requiredCaseStatuses ?? []) {
+    if (!caseStatuses.includes(status)) {
+      issues.push(`Missing tool contract case status: ${status}.`);
+    }
+  }
+  return {
+    caseStatuses,
+    cases: cases.length,
+    contractIds,
+    failed: report.failed,
+    issues,
+    issueCount,
+    missingOperationsRecordHrefs,
+    ok: issues.length === 0,
+    passed: report.passed,
+    status: report.status,
+    timedOut,
+    toolNames,
+    total: report.total
+  };
+};
+var assertVoiceToolContractEvidence = (report, input = {}) => {
+  const assertion = evaluateVoiceToolContractEvidence(report, input);
+  if (!assertion.ok) {
+    throw new Error(`Voice tool contract evidence assertion failed: ${assertion.issues.join(" ")}`);
+  }
+  return assertion;
+};
 var renderVoiceToolContractHTML = (report, options = {}) => {
   const title = options.title ?? "Voice Tool Contracts";
   const snippet = escapeHtml22(`app.use(
@@ -15983,6 +16138,91 @@ var assertVoiceAgentSquadContract = async (options) => {
   }
   return report;
 };
+var evaluateVoiceAgentSquadContractEvidence = (reports, input = {}) => {
+  const issues = [];
+  const maxFailed = input.maxFailed ?? 0;
+  const maxIssues = input.maxIssues ?? 0;
+  const maxBlockedHandoffs = input.maxBlockedHandoffs ?? Infinity;
+  const allHandoffs = reports.flatMap((report) => report.turns.flatMap((turn) => turn.handoffs));
+  const contractIds = [...new Set(reports.map((report) => report.contractId))].sort();
+  const scenarioIds = [
+    ...new Set(reports.map((report) => report.scenarioId).filter((scenarioId) => Boolean(scenarioId)))
+  ].sort();
+  const finalAgentIds = [
+    ...new Set(reports.flatMap((report) => report.turns.map((turn) => turn.agentId)))
+  ].sort();
+  const handoffTargets = [
+    ...new Set(allHandoffs.map((handoff) => handoff.targetAgentId).filter((target) => Boolean(target)))
+  ].sort();
+  const handoffStatuses = [
+    ...new Set(allHandoffs.map((handoff) => handoff.status).filter((status) => status !== undefined))
+  ].sort();
+  const failed = reports.filter((report) => !report.pass).length;
+  const issueCount = reports.reduce((total, report) => total + report.issues.length, 0);
+  const blockedHandoffs = allHandoffs.filter((handoff) => handoff.status === "blocked").length;
+  if (input.minContracts !== undefined && reports.length < input.minContracts) {
+    issues.push(`Expected at least ${String(input.minContracts)} agent squad contract(s), found ${String(reports.length)}.`);
+  }
+  if (failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing agent squad contract(s), found ${String(failed)}.`);
+  }
+  if (issueCount > maxIssues) {
+    issues.push(`Expected at most ${String(maxIssues)} agent squad contract issue(s), found ${String(issueCount)}.`);
+  }
+  if (input.minHandoffs !== undefined && allHandoffs.length < input.minHandoffs) {
+    issues.push(`Expected at least ${String(input.minHandoffs)} agent squad handoff(s), found ${String(allHandoffs.length)}.`);
+  }
+  if (blockedHandoffs > maxBlockedHandoffs) {
+    issues.push(`Expected at most ${String(maxBlockedHandoffs)} blocked agent squad handoff(s), found ${String(blockedHandoffs)}.`);
+  }
+  for (const contractId of input.requiredContractIds ?? []) {
+    if (!contractIds.includes(contractId)) {
+      issues.push(`Missing agent squad contract: ${contractId}.`);
+    }
+  }
+  for (const scenarioId of input.requiredScenarioIds ?? []) {
+    if (!scenarioIds.includes(scenarioId)) {
+      issues.push(`Missing agent squad scenario: ${scenarioId}.`);
+    }
+  }
+  for (const agentId of input.requiredFinalAgentIds ?? []) {
+    if (!finalAgentIds.includes(agentId)) {
+      issues.push(`Missing final agent: ${agentId}.`);
+    }
+  }
+  for (const target of input.requiredHandoffTargets ?? []) {
+    if (!handoffTargets.includes(target)) {
+      issues.push(`Missing agent squad handoff target: ${target}.`);
+    }
+  }
+  for (const status of input.requiredHandoffStatuses ?? []) {
+    if (!handoffStatuses.includes(status)) {
+      issues.push(`Missing agent squad handoff status: ${status}.`);
+    }
+  }
+  return {
+    blockedHandoffs,
+    contractIds,
+    failed,
+    finalAgentIds,
+    handoffStatuses,
+    handoffTargets,
+    handoffs: allHandoffs.length,
+    issues,
+    issueCount,
+    ok: issues.length === 0,
+    passed: reports.length - failed,
+    scenarioIds,
+    total: reports.length
+  };
+};
+var assertVoiceAgentSquadContractEvidence = (reports, input = {}) => {
+  const report = evaluateVoiceAgentSquadContractEvidence(reports, input);
+  if (!report.ok) {
+    throw new Error(`Voice agent squad contract evidence assertion failed: ${report.issues.join(" ")}`);
+  }
+  return report;
+};
 // src/turnLatency.ts
 import { Elysia as Elysia25 } from "elysia";
 var DEFAULT_WARN_AFTER_MS = 1800;
@@ -22146,6 +22386,110 @@ var assertVoiceProviderRoutingContract = async (options) => {
   }
   return report;
 };
+var evaluateVoiceProviderRoutingContractEvidence = (reports, input = {}) => {
+  const issues = [];
+  const maxFailed = input.maxFailed ?? 0;
+  const maxIssues = input.maxIssues ?? 0;
+  const events = reports.flatMap((report) => report.events);
+  const contractIds = [...new Set(reports.map((report) => report.contractId))].sort();
+  const scenarioIds = [
+    ...new Set(reports.map((report) => report.scenarioId).filter((scenarioId) => Boolean(scenarioId)))
+  ].sort();
+  const kinds = [...new Set(events.map((event) => event.kind))].sort();
+  const operations = [
+    ...new Set(events.map((event) => event.operation).filter((operation) => Boolean(operation)))
+  ].sort();
+  const providers = [
+    ...new Set(events.map((event) => event.provider).filter((provider) => Boolean(provider)))
+  ].sort();
+  const selectedProviders = [
+    ...new Set(events.map((event) => event.selectedProvider).filter((provider) => Boolean(provider)))
+  ].sort();
+  const fallbackProviders = [
+    ...new Set(events.map((event) => event.fallbackProvider).filter((provider) => Boolean(provider)))
+  ].sort();
+  const statuses = [
+    ...new Set(events.map((event) => event.status).filter((status) => status !== undefined))
+  ].sort();
+  const failed = reports.filter((report) => !report.pass).length;
+  const issueCount = reports.reduce((total, report) => total + report.issues.length, 0);
+  if (input.minContracts !== undefined && reports.length < input.minContracts) {
+    issues.push(`Expected at least ${String(input.minContracts)} provider routing contract(s), found ${String(reports.length)}.`);
+  }
+  if (failed > maxFailed) {
+    issues.push(`Expected at most ${String(maxFailed)} failing provider routing contract(s), found ${String(failed)}.`);
+  }
+  if (issueCount > maxIssues) {
+    issues.push(`Expected at most ${String(maxIssues)} provider routing contract issue(s), found ${String(issueCount)}.`);
+  }
+  if (input.minEvents !== undefined && events.length < input.minEvents) {
+    issues.push(`Expected at least ${String(input.minEvents)} provider routing event(s), found ${String(events.length)}.`);
+  }
+  for (const contractId of input.requiredContractIds ?? []) {
+    if (!contractIds.includes(contractId)) {
+      issues.push(`Missing provider routing contract: ${contractId}.`);
+    }
+  }
+  for (const scenarioId of input.requiredScenarioIds ?? []) {
+    if (!scenarioIds.includes(scenarioId)) {
+      issues.push(`Missing provider routing scenario: ${scenarioId}.`);
+    }
+  }
+  for (const kind of input.requiredKinds ?? []) {
+    if (!kinds.includes(kind)) {
+      issues.push(`Missing provider routing kind: ${kind}.`);
+    }
+  }
+  for (const operation of input.requiredOperations ?? []) {
+    if (!operations.includes(operation)) {
+      issues.push(`Missing provider routing operation: ${operation}.`);
+    }
+  }
+  for (const provider of input.requiredProviders ?? []) {
+    if (!providers.includes(provider)) {
+      issues.push(`Missing provider routing provider: ${provider}.`);
+    }
+  }
+  for (const provider of input.requiredSelectedProviders ?? []) {
+    if (!selectedProviders.includes(provider)) {
+      issues.push(`Missing selected provider: ${provider}.`);
+    }
+  }
+  for (const provider of input.requiredFallbackProviders ?? []) {
+    if (!fallbackProviders.includes(provider)) {
+      issues.push(`Missing fallback provider: ${provider}.`);
+    }
+  }
+  for (const status of input.requiredStatuses ?? []) {
+    if (!statuses.includes(status)) {
+      issues.push(`Missing provider routing status: ${status}.`);
+    }
+  }
+  return {
+    contractIds,
+    events: events.length,
+    failed,
+    fallbackProviders,
+    issues,
+    issueCount,
+    kinds,
+    ok: issues.length === 0,
+    operations,
+    passed: reports.length - failed,
+    providers,
+    scenarioIds,
+    selectedProviders,
+    statuses,
+    total: reports.length
+  };
+};
+var assertVoiceProviderRoutingContractEvidence = (reports, input = {}) => {
+  const report = evaluateVoiceProviderRoutingContractEvidence(reports, input);
+  if (!report.ok) {
+    throw new Error(`Voice provider routing contract evidence assertion failed: ${report.issues.join(" ")}`);
+  }
+  return report;
+};
 // src/providerSlo.ts
 import { Elysia as Elysia37 } from "elysia";
 var defaultThresholds = {
@@ -30506,19 +30850,23 @@ export {
   exportVoiceTrace,
   exportVoiceAuditTrail,
   evaluateVoiceTrace,
+  evaluateVoiceToolContractEvidence,
   evaluateVoiceTelephonyContract,
   evaluateVoiceQuality,
   evaluateVoiceProviderStackGaps,
   evaluateVoiceProviderStackEvidence,
   evaluateVoiceProviderSloEvidence,
+  evaluateVoiceProviderRoutingContractEvidence,
   evaluateVoiceProviderContractMatrixEvidence,
   evaluateVoiceProofTrendEvidence,
   evaluateVoiceProductionReadinessEvidence,
   evaluateVoicePlatformCoverage,
+  evaluateVoiceOutcomeContractEvidence,
   evaluateVoiceOperationsRecordGuardrails,
   evaluateVoiceObservabilityExportReplayEvidence,
   evaluateVoiceObservabilityExportDeliveryEvidence,
   evaluateVoiceGuardrailPolicy,
+  evaluateVoiceAgentSquadContractEvidence,
   encodeTwilioMulawBase64,
   deliverVoiceTraceEventsToSinks,
   deliverVoiceObservabilityExport,
@@ -30830,19 +31178,23 @@ export {
   buildVoiceAuditDeliveryReport,
   buildEmptyVoiceProofTrendReport,
   assignVoiceOpsTask,
+  assertVoiceToolContractEvidence,
   assertVoiceProviderStackEvidence,
   assertVoiceProviderSloEvidence,
+  assertVoiceProviderRoutingContractEvidence,
   assertVoiceProviderRoutingContract,
   assertVoiceProviderContractMatrixEvidence,
   assertVoiceProofTrendEvidence,
   assertVoiceProductionReadinessEvidence,
   assertVoicePlatformCoverage,
+  assertVoiceOutcomeContractEvidence,
   assertVoiceOperationsRecordGuardrails,
   assertVoiceObservabilityExportSchema,
   assertVoiceObservabilityExportReplayEvidence,
   assertVoiceObservabilityExportRecord,
   assertVoiceObservabilityExportDeliveryEvidence,
   assertVoiceLatencySLOGate,
+  assertVoiceAgentSquadContractEvidence,
   assertVoiceAgentSquadContract,
   applyVoiceTelephonyOutcome,
   applyVoiceOpsTaskPolicy,

package/dist/outcomeContract.d.ts

@@ -44,6 +44,35 @@ export type VoiceOutcomeContractSuiteReport = {
     status: VoiceOutcomeContractStatus;
     total: number;
 };
+export type VoiceOutcomeContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    minContracts?: number;
+    minHandoffs?: number;
+    minIntegrationEvents?: number;
+    minOperationsRecordHrefs?: number;
+    minReviews?: number;
+    minSessions?: number;
+    minTasks?: number;
+    requiredContractIds?: string[];
+    requireOperationRecordHrefs?: boolean;
+};
+export type VoiceOutcomeContractAssertionReport = {
+    contractIds: string[];
+    failed: number;
+    handoffs: number;
+    integrationEvents: number;
+    issues: string[];
+    issueCount: number;
+    ok: boolean;
+    operationsRecordHrefs: number;
+    passed: number;
+    reviews: number;
+    sessions: number;
+    status: VoiceOutcomeContractStatus;
+    tasks: number;
+    total: number;
+};
 type ListStore<T> = {
     list: () => Promise<T[]> | T[];
 };
@@ -67,6 +96,8 @@ export type VoiceOutcomeContractRoutesOptions<TSession extends VoiceSessionRecor
     path?: string;
 };
 export declare const runVoiceOutcomeContractSuite: <TSession extends VoiceSessionRecord = VoiceSessionRecord>(options: VoiceOutcomeContractOptions<TSession>) => Promise<VoiceOutcomeContractSuiteReport>;
+export declare const evaluateVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
+export declare const assertVoiceOutcomeContractEvidence: (report: VoiceOutcomeContractSuiteReport, input?: VoiceOutcomeContractAssertionInput) => VoiceOutcomeContractAssertionReport;
 export declare const renderVoiceOutcomeContractHTML: (report: VoiceOutcomeContractSuiteReport, options?: {
     title?: string;
 }) => string;

package/dist/providerRoutingContract.d.ts

@@ -34,5 +34,38 @@ export type VoiceProviderRoutingContractRunOptions = {
     events?: StoredVoiceTraceEvent[] | VoiceRoutingEvent[];
     store?: VoiceTraceEventStore;
 };
+export type VoiceProviderRoutingContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    minContracts?: number;
+    minEvents?: number;
+    requiredContractIds?: string[];
+    requiredFallbackProviders?: string[];
+    requiredKinds?: VoiceRoutingEventKind[];
+    requiredOperations?: string[];
+    requiredProviders?: string[];
+    requiredScenarioIds?: string[];
+    requiredSelectedProviders?: string[];
+    requiredStatuses?: VoiceProviderRoutingStatus[];
+};
+export type VoiceProviderRoutingContractAssertionReport = {
+    contractIds: string[];
+    events: number;
+    failed: number;
+    fallbackProviders: string[];
+    issues: string[];
+    issueCount: number;
+    kinds: VoiceRoutingEventKind[];
+    ok: boolean;
+    operations: string[];
+    passed: number;
+    providers: string[];
+    scenarioIds: string[];
+    selectedProviders: string[];
+    statuses: VoiceProviderRoutingStatus[];
+    total: number;
+};
 export declare const runVoiceProviderRoutingContract: (options: VoiceProviderRoutingContractRunOptions) => Promise<VoiceProviderRoutingContractReport>;
 export declare const assertVoiceProviderRoutingContract: (options: VoiceProviderRoutingContractRunOptions) => Promise<VoiceProviderRoutingContractReport>;
+export declare const evaluateVoiceProviderRoutingContractEvidence: (reports: readonly VoiceProviderRoutingContractReport[], input?: VoiceProviderRoutingContractAssertionInput) => VoiceProviderRoutingContractAssertionReport;
+export declare const assertVoiceProviderRoutingContractEvidence: (reports: readonly VoiceProviderRoutingContractReport[], input?: VoiceProviderRoutingContractAssertionInput) => VoiceProviderRoutingContractAssertionReport;

package/dist/toolContract.d.ts

@@ -64,6 +64,32 @@ export type VoiceToolContractSuiteReport = {
     status: 'fail' | 'pass';
     total: number;
 };
+export type VoiceToolContractAssertionInput = {
+    maxFailed?: number;
+    maxIssues?: number;
+    maxTimedOut?: number;
+    minCases?: number;
+    minContracts?: number;
+    requireOperationRecordHrefs?: boolean;
+    requiredCaseStatuses?: Array<'error' | 'ok'>;
+    requiredContractIds?: string[];
+    requiredToolNames?: string[];
+};
+export type VoiceToolContractAssertionReport = {
+    caseStatuses: Array<'error' | 'ok'>;
+    cases: number;
+    contractIds: string[];
+    failed: number;
+    issues: string[];
+    issueCount: number;
+    missingOperationsRecordHrefs: number;
+    ok: boolean;
+    passed: number;
+    status: VoiceToolContractSuiteReport['status'];
+    timedOut: number;
+    toolNames: string[];
+    total: number;
+};
 export type VoiceToolContractHandlerOptions = {
     contracts: VoiceToolContractDefinition[];
     operationsRecordHref?: false | string | ((sessionId: string) => string);
@@ -86,6 +112,8 @@ export declare const createVoiceToolContract: <TContext = unknown, TSession exte
 };
 export declare const createVoiceToolRuntimeContractDefaults: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TRouteResult = unknown>() => VoiceToolRuntimeOptions<TContext, TSession, TRouteResult>;
 export declare const runVoiceToolContractSuite: (options: VoiceToolContractHandlerOptions) => Promise<VoiceToolContractSuiteReport>;
+export declare const evaluateVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
+export declare const assertVoiceToolContractEvidence: (report: VoiceToolContractSuiteReport, input?: VoiceToolContractAssertionInput) => VoiceToolContractAssertionReport;
 export declare const renderVoiceToolContractHTML: (report: VoiceToolContractSuiteReport, options?: {
     title?: string;
 }) => string;

package/package.json

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