@absolutejs/voice 0.0.22-beta.67 → 0.0.22-beta.69

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export { createVoiceAgent, createVoiceAgentSquad, createVoiceAgentTool } from '.
 export { createVoiceToolIdempotencyKey, createVoiceToolRuntime } from './toolRuntime';
 export { createVoiceToolContract, createVoiceToolContractHTMLHandler, createVoiceToolContractJSONHandler, createVoiceToolContractRoutes, createVoiceToolRuntimeContractDefaults, renderVoiceToolContractHTML, runVoiceToolContractSuite, runVoiceToolContract } from './toolContract';
 export { createVoiceTurnQualityHTMLHandler, createVoiceTurnQualityJSONHandler, createVoiceTurnQualityRoutes, renderVoiceTurnQualityHTML, summarizeVoiceTurnQuality } from './turnQuality';
+export { createVoiceOutcomeContractHTMLHandler, createVoiceOutcomeContractJSONHandler, createVoiceOutcomeContractRoutes, renderVoiceOutcomeContractHTML, runVoiceOutcomeContractSuite } from './outcomeContract';
+export { applyVoiceTelephonyOutcome, createVoiceTelephonyOutcomePolicy, resolveVoiceTelephonyOutcome, voiceTelephonyOutcomeToRouteResult } from './telephonyOutcome';
 export { createStoredVoiceCallReviewArtifact, createStoredVoiceExternalObjectMap, createStoredVoiceIntegrationEvent, createStoredVoiceOpsTask, createVoiceFileExternalObjectMapStore, createVoiceFileAssistantMemoryStore, 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';
@@ -54,6 +56,8 @@ export type { AnthropicVoiceAssistantModelOptions, GeminiVoiceAssistantModelOpti
 export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProviderHealthSummaryOptions } from './providerHealth';
 export type { VoiceProviderCapabilityDefinition, VoiceProviderCapabilityHandlerOptions, VoiceProviderCapabilityHTMLHandlerOptions, VoiceProviderCapabilityKind, VoiceProviderCapabilityOptions, VoiceProviderCapabilityReport, VoiceProviderCapabilityRoutesOptions, VoiceProviderCapabilitySummary } from './providerCapabilities';
 export type { VoiceTurnQualityHTMLHandlerOptions, VoiceTurnQualityItem, VoiceTurnQualityOptions, VoiceTurnQualityReport, VoiceTurnQualityRoutesOptions, VoiceTurnQualityStatus } from './turnQuality';
+export type { VoiceOutcomeContractDefinition, VoiceOutcomeContractHTMLHandlerOptions, VoiceOutcomeContractIssue, VoiceOutcomeContractOptions, VoiceOutcomeContractReport, VoiceOutcomeContractRoutesOptions, VoiceOutcomeContractStatus, VoiceOutcomeContractSuiteReport } from './outcomeContract';
+export type { VoiceTelephonyOutcomeAction, VoiceTelephonyOutcomeDecision, VoiceTelephonyOutcomePolicy, VoiceTelephonyOutcomeProviderEvent, VoiceTelephonyOutcomeRouteResult, VoiceTelephonyOutcomeStatusDecision } from './telephonyOutcome';
 export type { VoiceOpsConsoleLink, VoiceOpsConsoleReport, VoiceOpsConsoleRoutesOptions } from './opsConsoleRoutes';
 export type { VoiceQualityLink, VoiceQualityMetric, VoiceQualityReport, VoiceQualityRoutesOptions, VoiceQualityStatus, VoiceQualityThresholds } from './qualityRoutes';
 export type { VoiceResilienceIOSimulator, VoiceResilienceLink, VoiceResiliencePageData, VoiceResilienceRoutesOptions, VoiceResilienceSimulationProvider, VoiceRoutingDecisionSummary, VoiceRoutingDecisionSummaryOptions, VoiceRoutingEvent, VoiceRoutingEventKind } from './resilienceRoutes';

package/dist/index.js

@@ -10410,6 +10410,429 @@ var createVoiceTurnQualityRoutes = (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/telephonyOutcome.ts
+var DEFAULT_COMPLETED_STATUSES = [
+  "answered",
+  "completed",
+  "complete",
+  "connected",
+  "in-progress",
+  "live"
+];
+var DEFAULT_NO_ANSWER_STATUSES = [
+  "busy",
+  "canceled",
+  "cancelled",
+  "failed",
+  "no-answer",
+  "no_answer",
+  "not-answered",
+  "ring-no-answer",
+  "timeout",
+  "unanswered"
+];
+var DEFAULT_VOICEMAIL_STATUSES = [
+  "answering-machine",
+  "machine",
+  "voicemail",
+  "voice-mail"
+];
+var DEFAULT_TRANSFER_STATUSES = ["bridged", "forwarded", "transferred"];
+var DEFAULT_ESCALATION_STATUSES = ["escalated", "human-required", "operator"];
+var DEFAULT_FAILED_STATUSES = ["busy", "failed", "no-answer"];
+var DEFAULT_MACHINE_VOICEMAIL_VALUES = [
+  "answering-machine",
+  "fax",
+  "machine",
+  "machine-end-beep",
+  "machine-end-other",
+  "machine-start",
+  "voicemail"
+];
+var DEFAULT_NO_ANSWER_SIP_CODES = [408, 480, 486, 487, 603];
+var normalizeToken = (value) => typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-") : undefined;
+var normalizeList = (values, fallback) => new Set((values ?? fallback).map(normalizeToken).filter(Boolean));
+var metadataValue = (metadata, keys) => {
+  for (const key of keys) {
+    const value = metadata?.[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+};
+var resolveTransferTarget = (event, policy) => {
+  if (typeof event.target === "string" && event.target.trim()) {
+    return event.target.trim();
+  }
+  const metadataTarget = metadataValue(event.metadata, [
+    "transferTarget",
+    "target",
+    "queue",
+    "department"
+  ]);
+  if (metadataTarget) {
+    return metadataTarget;
+  }
+  if (typeof policy.transferTarget === "function") {
+    const target = policy.transferTarget(event);
+    return typeof target === "string" && target.trim() ? target.trim() : undefined;
+  }
+  return typeof policy.transferTarget === "string" && policy.transferTarget.trim() ? policy.transferTarget.trim() : undefined;
+};
+var mergeMetadata = (event, policy) => ({
+  ...policy.includeProviderPayload ? {
+    answeredBy: event.answeredBy,
+    durationMs: event.durationMs,
+    provider: event.provider,
+    reason: event.reason,
+    sipCode: event.sipCode,
+    status: event.status
+  } : undefined,
+  ...policy.metadata,
+  ...event.metadata
+});
+var withDecisionDefaults = (decision, input) => {
+  if (typeof decision === "string") {
+    return buildDecision(decision, input);
+  }
+  return {
+    ...buildDecision(decision.action, input),
+    ...decision,
+    confidence: decision.confidence ?? "high",
+    metadata: {
+      ...mergeMetadata(input.event, input.policy),
+      ...decision.metadata
+    },
+    source: decision.source ?? input.source,
+    target: decision.target ?? (decision.action === "transfer" ? resolveTransferTarget(input.event, input.policy) : undefined)
+  };
+};
+var dispositionForAction = (action) => {
+  switch (action) {
+    case "complete":
+      return "completed";
+    case "escalate":
+      return "escalated";
+    case "no-answer":
+      return "no-answer";
+    case "transfer":
+      return "transferred";
+    case "voicemail":
+      return "voicemail";
+    default:
+      return;
+  }
+};
+var buildDecision = (action, input) => ({
+  action,
+  confidence: action === "ignore" ? "low" : "high",
+  disposition: dispositionForAction(action),
+  metadata: mergeMetadata(input.event, input.policy),
+  reason: input.event.reason,
+  source: input.source,
+  target: action === "transfer" ? resolveTransferTarget(input.event, input.policy) : undefined
+});
+var createVoiceTelephonyOutcomePolicy = (policy = {}) => ({
+  completedStatuses: policy.completedStatuses ?? DEFAULT_COMPLETED_STATUSES,
+  escalationStatuses: policy.escalationStatuses ?? DEFAULT_ESCALATION_STATUSES,
+  failedAsNoAnswer: policy.failedAsNoAnswer ?? true,
+  failedStatuses: policy.failedStatuses ?? DEFAULT_FAILED_STATUSES,
+  includeProviderPayload: policy.includeProviderPayload ?? true,
+  machineDetectionVoicemailValues: policy.machineDetectionVoicemailValues ?? DEFAULT_MACHINE_VOICEMAIL_VALUES,
+  metadata: policy.metadata,
+  minAnsweredDurationMs: policy.minAnsweredDurationMs,
+  noAnswerOnZeroDuration: policy.noAnswerOnZeroDuration ?? true,
+  noAnswerSipCodes: policy.noAnswerSipCodes ?? DEFAULT_NO_ANSWER_SIP_CODES,
+  noAnswerStatuses: policy.noAnswerStatuses ?? DEFAULT_NO_ANSWER_STATUSES,
+  statusMap: policy.statusMap,
+  transferStatuses: policy.transferStatuses ?? DEFAULT_TRANSFER_STATUSES,
+  transferTarget: policy.transferTarget,
+  voicemailStatuses: policy.voicemailStatuses ?? DEFAULT_VOICEMAIL_STATUSES
+});
+var resolveVoiceTelephonyOutcome = (event, policyInput = {}) => {
+  const policy = createVoiceTelephonyOutcomePolicy(policyInput);
+  const status = normalizeToken(event.status);
+  const provider = normalizeToken(event.provider);
+  const answeredBy = normalizeToken(event.answeredBy);
+  const target = resolveTransferTarget(event, policy);
+  if (status) {
+    const mapped = policy.statusMap?.[status] ?? (provider ? policy.statusMap?.[`${provider}:${status}`] : undefined);
+    if (mapped) {
+      return withDecisionDefaults(mapped, {
+        event,
+        policy,
+        source: "policy"
+      });
+    }
+  }
+  if (answeredBy && normalizeList(policy.machineDetectionVoicemailValues, []).has(answeredBy)) {
+    return buildDecision("voicemail", { event, policy, source: "answered-by" });
+  }
+  if (typeof event.sipCode === "number" && policy.noAnswerSipCodes.includes(event.sipCode)) {
+    return buildDecision("no-answer", { event, policy, source: "sip" });
+  }
+  if (target && status && normalizeList(policy.transferStatuses, []).has(status)) {
+    return buildDecision("transfer", { event, policy, source: "status" });
+  }
+  if (status && normalizeList(policy.voicemailStatuses, []).has(status)) {
+    return buildDecision("voicemail", { event, policy, source: "status" });
+  }
+  if (status && normalizeList(policy.escalationStatuses, []).has(status)) {
+    return buildDecision("escalate", { event, policy, source: "status" });
+  }
+  if (status && (policy.failedAsNoAnswer ? normalizeList(policy.noAnswerStatuses, []).has(status) || normalizeList(policy.failedStatuses, []).has(status) : normalizeList(policy.noAnswerStatuses, []).has(status))) {
+    return buildDecision("no-answer", { event, policy, source: "status" });
+  }
+  if (policy.noAnswerOnZeroDuration && typeof event.durationMs === "number" && event.durationMs <= 0) {
+    return buildDecision("no-answer", { event, policy, source: "duration" });
+  }
+  if (typeof policy.minAnsweredDurationMs === "number" && typeof event.durationMs === "number" && event.durationMs < policy.minAnsweredDurationMs) {
+    return {
+      ...buildDecision("no-answer", { event, policy, source: "duration" }),
+      confidence: "medium"
+    };
+  }
+  if (status && normalizeList(policy.completedStatuses, []).has(status)) {
+    return buildDecision("complete", { event, policy, source: "status" });
+  }
+  if (target) {
+    return {
+      ...buildDecision("transfer", { event, policy, source: "explicit-target" }),
+      confidence: "medium"
+    };
+  }
+  return buildDecision("ignore", { event, policy, source: "status" });
+};
+var voiceTelephonyOutcomeToRouteResult = (decision, result) => {
+  switch (decision.action) {
+    case "complete":
+      return { complete: true, result };
+    case "escalate":
+      return {
+        escalate: {
+          metadata: decision.metadata,
+          reason: decision.reason ?? "telephony-escalation"
+        },
+        result
+      };
+    case "no-answer":
+      return {
+        noAnswer: {
+          metadata: decision.metadata
+        },
+        result
+      };
+    case "transfer":
+      if (!decision.target) {
+        return { result };
+      }
+      return {
+        result,
+        transfer: {
+          metadata: decision.metadata,
+          reason: decision.reason,
+          target: decision.target
+        }
+      };
+    case "voicemail":
+      return {
+        result,
+        voicemail: {
+          metadata: decision.metadata
+        }
+      };
+    default:
+      return { result };
+  }
+};
+var applyVoiceTelephonyOutcome = async (api, decision, result) => {
+  switch (decision.action) {
+    case "complete":
+      await api.complete(result);
+      break;
+    case "escalate":
+      await api.escalate({
+        metadata: decision.metadata,
+        reason: decision.reason ?? "telephony-escalation",
+        result
+      });
+      break;
+    case "no-answer":
+      await api.markNoAnswer({
+        metadata: decision.metadata,
+        result
+      });
+      break;
+    case "transfer":
+      if (!decision.target) {
+        return;
+      }
+      await api.transfer({
+        metadata: decision.metadata,
+        reason: decision.reason,
+        result,
+        target: decision.target
+      });
+      break;
+    case "voicemail":
+      await api.markVoicemail({
+        metadata: decision.metadata,
+        result
+      });
+      break;
+    default:
+      break;
+  }
+};
 // src/fileStore.ts
 import { mkdir as mkdir2, readFile, readdir, rename, rm, writeFile } from "fs/promises";
 import { join } from "path";
@@ -12503,7 +12926,7 @@ var createVoiceMemoryStore = () => {
   return { get, getOrCreate, list, remove, set };
 };
 // src/opsWebhook.ts
-import { Elysia as Elysia15 } 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;
@@ -12633,7 +13056,7 @@ var verifyVoiceOpsWebhookSignature = async (input) => {
 };
 var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-ops/webhook";
-  return new Elysia15().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({
@@ -14775,6 +15198,7 @@ var shapeTelephonyAssistantText = (text, options = {}) => {
 export {
   withVoiceOpsTaskId,
   withVoiceIntegrationEventId,
+  voiceTelephonyOutcomeToRouteResult,
   voice,
   verifyVoiceOpsWebhookSignature,
   validateVoiceWorkflowRouteResult,
@@ -14805,7 +15229,9 @@ export {
   runVoiceSessionEvals,
   runVoiceScenarioFixtureEvals,
   runVoiceScenarioEvals,
+  runVoiceOutcomeContractSuite,
   resolveVoiceTraceRedactionOptions,
+  resolveVoiceTelephonyOutcome,
   resolveVoiceSTTRoutingStrategy,
   resolveVoiceRuntimePreset,
   resolveVoiceProviderRoutingPolicyPreset,
@@ -14831,6 +15257,7 @@ export {
   renderVoiceQualityHTML,
   renderVoiceProviderHealthHTML,
   renderVoiceProviderCapabilityHTML,
+  renderVoiceOutcomeContractHTML,
   renderVoiceOpsConsoleHTML,
   renderVoiceHandoffHealthHTML,
   renderVoiceEvalHTML,
@@ -14893,6 +15320,7 @@ export {
   createVoiceToolContractJSONHandler,
   createVoiceToolContractHTMLHandler,
   createVoiceToolContract,
+  createVoiceTelephonyOutcomePolicy,
   createVoiceTaskUpdatedEvent,
   createVoiceTaskSLABreachedEvent,
   createVoiceTaskCreatedEvent,
@@ -14937,6 +15365,9 @@ export {
   createVoicePostgresReviewStore,
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
+  createVoiceOutcomeContractRoutes,
+  createVoiceOutcomeContractJSONHandler,
+  createVoiceOutcomeContractHTMLHandler,
   createVoiceOpsWebhookSink,
   createVoiceOpsWebhookReceiverRoutes,
   createVoiceOpsWebhookEnvelope,
@@ -15024,6 +15455,7 @@ export {
   buildVoiceOpsConsoleReport,
   buildVoiceDiagnosticsMarkdown,
   assignVoiceOpsTask,
+  applyVoiceTelephonyOutcome,
   applyVoiceOpsTaskPolicy,
   applyVoiceOpsTaskAssignmentRule,
   applyVoiceHandoffDeliveryResult,

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/telephonyOutcome.d.ts

@@ -0,0 +1,49 @@
+import type { VoiceCallDisposition, VoiceRouteResult, VoiceSessionHandle, VoiceSessionRecord } from './types';
+export type VoiceTelephonyOutcomeAction = 'complete' | 'escalate' | 'ignore' | 'no-answer' | 'transfer' | 'voicemail';
+export type VoiceTelephonyOutcomeProviderEvent = {
+    answeredBy?: string;
+    durationMs?: number;
+    from?: string;
+    metadata?: Record<string, unknown>;
+    provider?: string;
+    reason?: string;
+    sipCode?: number;
+    status?: string;
+    target?: string;
+    to?: string;
+};
+export type VoiceTelephonyOutcomeDecision = {
+    action: VoiceTelephonyOutcomeAction;
+    confidence: 'high' | 'low' | 'medium';
+    disposition?: VoiceCallDisposition;
+    metadata?: Record<string, unknown>;
+    reason?: string;
+    source: 'answered-by' | 'duration' | 'explicit-target' | 'policy' | 'sip' | 'status';
+    target?: string;
+};
+export type VoiceTelephonyOutcomeStatusDecision = VoiceTelephonyOutcomeAction | Omit<VoiceTelephonyOutcomeDecision, 'confidence' | 'source'> & {
+    confidence?: VoiceTelephonyOutcomeDecision['confidence'];
+    source?: VoiceTelephonyOutcomeDecision['source'];
+};
+export type VoiceTelephonyOutcomePolicy = {
+    completedStatuses?: string[];
+    escalationStatuses?: string[];
+    failedAsNoAnswer?: boolean;
+    failedStatuses?: string[];
+    includeProviderPayload?: boolean;
+    machineDetectionVoicemailValues?: string[];
+    metadata?: Record<string, unknown>;
+    minAnsweredDurationMs?: number;
+    noAnswerOnZeroDuration?: boolean;
+    noAnswerSipCodes?: number[];
+    noAnswerStatuses?: string[];
+    statusMap?: Record<string, VoiceTelephonyOutcomeStatusDecision>;
+    transferStatuses?: string[];
+    transferTarget?: string | ((event: VoiceTelephonyOutcomeProviderEvent) => string | undefined);
+    voicemailStatuses?: string[];
+};
+export type VoiceTelephonyOutcomeRouteResult<TResult = unknown> = VoiceRouteResult<TResult>;
+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>;
+export declare const applyVoiceTelephonyOutcome: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(api: VoiceSessionHandle<TContext, TSession, TResult>, decision: VoiceTelephonyOutcomeDecision, result?: TResult) => Promise<void>;

package/package.json

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