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

package/dist/index.d.ts

@@ -11,7 +11,7 @@ export { createVoiceToolIdempotencyKey, createVoiceToolRuntime } from './toolRun
 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 { applyVoiceTelephonyOutcome, createVoiceTelephonyOutcomePolicy, createVoiceTelephonyWebhookHandler, createVoiceTelephonyWebhookRoutes, parseVoiceTelephonyWebhookEvent, 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';
@@ -57,7 +57,7 @@ export type { VoiceProviderHealthStatus, VoiceProviderHealthSummary, VoiceProvid
 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 { VoiceTelephonyOutcomeAction, VoiceTelephonyOutcomeDecision, VoiceTelephonyOutcomePolicy, VoiceTelephonyOutcomeProviderEvent, VoiceTelephonyOutcomeRouteResult, VoiceTelephonyOutcomeStatusDecision, VoiceTelephonyWebhookDecision, VoiceTelephonyWebhookHandlerOptions, VoiceTelephonyWebhookParseInput, VoiceTelephonyWebhookProvider, VoiceTelephonyWebhookRoutesOptions } 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

@@ -10560,6 +10560,7 @@ var createVoiceOutcomeContractRoutes = (options) => {
   return routes;
 };
 // src/telephonyOutcome.ts
+import { Elysia as Elysia16 } from "elysia";
 var DEFAULT_COMPLETED_STATUSES = [
   "answered",
   "completed",
@@ -10599,7 +10600,55 @@ var DEFAULT_MACHINE_VOICEMAIL_VALUES = [
   "voicemail"
 ];
 var DEFAULT_NO_ANSWER_SIP_CODES = [408, 480, 486, 487, 603];
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
 var normalizeToken = (value) => typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-") : undefined;
+var firstString = (source, keys) => {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return String(value);
+    }
+  }
+};
+var firstNumber = (source, keys) => {
+  for (const key of keys) {
+    const value = source[key];
+    if (typeof value === "number" && Number.isFinite(value)) {
+      return value;
+    }
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed)) {
+        return parsed;
+      }
+    }
+  }
+};
+var parseMaybeJSON = (value) => {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return;
+  }
+};
+var flattenPayload = (value) => {
+  if (!isRecord(value)) {
+    return {};
+  }
+  const data = isRecord(value.data) ? value.data : undefined;
+  const payload = isRecord(value.payload) ? value.payload : undefined;
+  const event = isRecord(value.event) ? value.event : undefined;
+  return {
+    ...value,
+    ...payload,
+    ...event,
+    ...data,
+    ...isRecord(data?.payload) ? data.payload : undefined
+  };
+};
 var normalizeList = (values, fallback) => new Set((values ?? fallback).map(normalizeToken).filter(Boolean));
 var metadataValue = (metadata, keys) => {
   for (const key of keys) {
@@ -10833,6 +10882,172 @@ var applyVoiceTelephonyOutcome = async (api, decision, result) => {
       break;
   }
 };
+var parseRequestBody = async (request) => {
+  const contentType = request.headers.get("content-type") ?? "";
+  const text = await request.text();
+  if (!text) {
+    return {};
+  }
+  if (contentType.includes("application/json")) {
+    return parseMaybeJSON(text) ?? {};
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    return Object.fromEntries(new URLSearchParams(text));
+  }
+  return parseMaybeJSON(text) ?? Object.fromEntries(new URLSearchParams(text));
+};
+var durationMsFromSeconds = (value) => typeof value === "number" ? value * 1000 : undefined;
+var parseVoiceTelephonyWebhookEvent = (input) => {
+  const payload = flattenPayload(input.body);
+  const provider = firstString(payload, ["provider", "Provider"]) ?? input.provider;
+  const status = firstString(payload, [
+    "CallStatus",
+    "call_status",
+    "callStatus",
+    "DialCallStatus",
+    "dial_call_status",
+    "status",
+    "event_type",
+    "type"
+  ]);
+  const durationMs = firstNumber(payload, ["durationMs", "duration_ms"]) ?? durationMsFromSeconds(firstNumber(payload, [
+    "CallDuration",
+    "call_duration",
+    "callDuration",
+    "DialCallDuration",
+    "dial_call_duration",
+    "duration"
+  ]));
+  const sipCode = firstNumber(payload, [
+    "SipResponseCode",
+    "sip_response_code",
+    "sipCode",
+    "sip_code",
+    "hangupCauseCode"
+  ]);
+  const from = firstString(payload, ["From", "from", "caller_id", "callerId"]);
+  const to = firstString(payload, ["To", "to", "called_number", "calledNumber"]);
+  const target = firstString(payload, [
+    "transferTarget",
+    "TransferTarget",
+    "target",
+    "queue",
+    "department"
+  ]);
+  return {
+    answeredBy: firstString(payload, [
+      "AnsweredBy",
+      "answered_by",
+      "answeredBy",
+      "machineDetection",
+      "machine_detection"
+    ]),
+    durationMs,
+    from,
+    metadata: payload,
+    provider,
+    reason: firstString(payload, [
+      "Reason",
+      "reason",
+      "HangupCause",
+      "hangup_cause",
+      "hangupCause"
+    ]),
+    sipCode,
+    status,
+    target,
+    to
+  };
+};
+var defaultSessionId = (input) => {
+  const payload = flattenPayload(input.body);
+  const metadataSessionId = input.event.metadata?.sessionId;
+  return firstString(input.query, ["sessionId", "session_id"]) ?? firstString(payload, [
+    "sessionId",
+    "session_id",
+    "SessionId",
+    "CallSid",
+    "call_sid",
+    "callSid",
+    "CallUUID",
+    "call_uuid",
+    "callControlId",
+    "call_control_id"
+  ]) ?? (typeof metadataSessionId === "string" ? metadataSessionId : undefined);
+};
+var createVoiceTelephonyWebhookHandler = (options = {}) => async (input) => {
+  const provider = options.provider ?? "generic";
+  const query = input.query ?? {};
+  const body = await parseRequestBody(input.request);
+  const event = options.parse ? await options.parse({
+    body,
+    headers: input.request.headers,
+    provider,
+    query,
+    request: input.request
+  }) : parseVoiceTelephonyWebhookEvent({
+    body,
+    headers: input.request.headers,
+    provider,
+    query,
+    request: input.request
+  });
+  const sessionId = await (options.resolveSessionId?.({
+    body,
+    event,
+    query,
+    request: input.request
+  }) ?? defaultSessionId({ body, event, query }));
+  const decision = resolveVoiceTelephonyOutcome(event, options.policy);
+  const resultResolver = options.result;
+  const result = typeof resultResolver === "function" ? await resultResolver({
+    decision,
+    event,
+    sessionId
+  }) : resultResolver;
+  const routeResult = voiceTelephonyOutcomeToRouteResult(decision, result);
+  const shouldApply = typeof options.apply === "function" ? options.apply({
+    applied: false,
+    decision,
+    event,
+    routeResult,
+    sessionId
+  }) : options.apply === true;
+  let applied = false;
+  if (shouldApply && decision.action !== "ignore" && options.getSessionHandle) {
+    const api = await options.getSessionHandle({
+      context: options.context,
+      decision,
+      event,
+      request: input.request,
+      sessionId
+    });
+    if (api) {
+      await applyVoiceTelephonyOutcome(api, decision, result);
+      applied = true;
+    }
+  }
+  const webhookDecision = {
+    applied,
+    decision,
+    event,
+    routeResult,
+    sessionId
+  };
+  await options.onDecision?.({
+    ...webhookDecision,
+    context: options.context,
+    request: input.request
+  });
+  return webhookDecision;
+};
+var createVoiceTelephonyWebhookRoutes = (options = {}) => {
+  const path = options.path ?? "/api/voice/telephony/webhook";
+  const handler = createVoiceTelephonyWebhookHandler(options);
+  return new Elysia16({
+    name: options.name ?? "absolutejs-voice-telephony-webhooks"
+  }).post(path, async ({ query, request }) => handler({ query, request }));
+};
 // src/fileStore.ts
 import { mkdir as mkdir2, readFile, readdir, rename, rm, writeFile } from "fs/promises";
 import { join } from "path";
@@ -12926,7 +13141,7 @@ var createVoiceMemoryStore = () => {
   return { get, getOrCreate, list, remove, set };
 };
 // src/opsWebhook.ts
-import { Elysia as Elysia16 } from "elysia";
+import { Elysia as Elysia17 } from "elysia";
 var toHex5 = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 var signVoiceOpsWebhookBody = async (input) => {
   const encoder = new TextEncoder;
@@ -13056,7 +13271,7 @@ var verifyVoiceOpsWebhookSignature = async (input) => {
 };
 var createVoiceOpsWebhookReceiverRoutes = (options = {}) => {
   const path = options.path ?? "/api/voice-ops/webhook";
-  return new Elysia16().post(path, async ({ body, request, set }) => {
+  return new Elysia17().post(path, async ({ body, request, set }) => {
     const bodyText = typeof body === "string" ? body : JSON.stringify(body);
     if (options.signingSecret) {
       const verification = await verifyVoiceOpsWebhookSignature({
@@ -15271,6 +15486,7 @@ export {
   recordVoiceWorkflowContractTrace,
   recordVoiceRuntimeOps,
   pruneVoiceTraceEvents,
+  parseVoiceTelephonyWebhookEvent,
   matchesVoiceOpsTaskAssignmentRule,
   markVoiceOpsTaskSLABreached,
   listVoiceRoutingEvents,
@@ -15320,6 +15536,8 @@ export {
   createVoiceToolContractJSONHandler,
   createVoiceToolContractHTMLHandler,
   createVoiceToolContract,
+  createVoiceTelephonyWebhookRoutes,
+  createVoiceTelephonyWebhookHandler,
   createVoiceTelephonyOutcomePolicy,
   createVoiceTaskUpdatedEvent,
   createVoiceTaskSLABreachedEvent,

package/dist/telephonyOutcome.d.ts

@@ -1,3 +1,4 @@
+import { Elysia } from 'elysia';
 import type { VoiceCallDisposition, VoiceRouteResult, VoiceSessionHandle, VoiceSessionRecord } from './types';
 export type VoiceTelephonyOutcomeAction = 'complete' | 'escalate' | 'ignore' | 'no-answer' | 'transfer' | 'voicemail';
 export type VoiceTelephonyOutcomeProviderEvent = {
@@ -43,7 +44,100 @@ export type VoiceTelephonyOutcomePolicy = {
     voicemailStatuses?: string[];
 };
 export type VoiceTelephonyOutcomeRouteResult<TResult = unknown> = VoiceRouteResult<TResult>;
+export type VoiceTelephonyWebhookProvider = 'generic' | 'plivo' | 'telnyx' | 'twilio';
+export type VoiceTelephonyWebhookParseInput = {
+    body: unknown;
+    headers: Headers;
+    provider: VoiceTelephonyWebhookProvider;
+    query: Record<string, unknown>;
+    request: Request;
+};
+export type VoiceTelephonyWebhookDecision<TResult = unknown> = {
+    applied: boolean;
+    decision: VoiceTelephonyOutcomeDecision;
+    event: VoiceTelephonyOutcomeProviderEvent;
+    routeResult: VoiceTelephonyOutcomeRouteResult<TResult>;
+    sessionId?: string;
+};
+export type VoiceTelephonyWebhookHandlerOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    apply?: boolean | ((input: VoiceTelephonyWebhookDecision<TResult>) => boolean);
+    context?: TContext;
+    getSessionHandle?: (input: {
+        context: TContext;
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        request: Request;
+        sessionId?: string;
+    }) => Promise<VoiceSessionHandle<TContext, TSession, TResult> | undefined> | VoiceSessionHandle<TContext, TSession, TResult> | undefined;
+    onDecision?: (input: VoiceTelephonyWebhookDecision<TResult> & {
+        context: TContext;
+        request: Request;
+    }) => Promise<void> | void;
+    parse?: (input: VoiceTelephonyWebhookParseInput) => Promise<VoiceTelephonyOutcomeProviderEvent> | VoiceTelephonyOutcomeProviderEvent;
+    policy?: VoiceTelephonyOutcomePolicy;
+    provider?: VoiceTelephonyWebhookProvider;
+    resolveSessionId?: (input: {
+        body: unknown;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        query: Record<string, unknown>;
+        request: Request;
+    }) => Promise<string | undefined> | string | undefined;
+    result?: TResult | ((input: {
+        decision: VoiceTelephonyOutcomeDecision;
+        event: VoiceTelephonyOutcomeProviderEvent;
+        sessionId?: string;
+    }) => Promise<TResult | undefined> | TResult | undefined);
+};
+export type VoiceTelephonyWebhookRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult> & {
+    name?: string;
+    path?: string;
+};
 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>;
+export declare const parseVoiceTelephonyWebhookEvent: (input: VoiceTelephonyWebhookParseInput) => VoiceTelephonyOutcomeProviderEvent;
+export declare const createVoiceTelephonyWebhookHandler: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookHandlerOptions<TContext, TSession, TResult>) => (input: {
+    query?: Record<string, unknown>;
+    request: Request;
+}) => Promise<VoiceTelephonyWebhookDecision<TResult>>;
+export declare const createVoiceTelephonyWebhookRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/package.json

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