@absolutejs/voice 0.0.22-beta.76 → 0.0.22-beta.78

package/dist/index.d.ts

@@ -81,7 +81,11 @@ export type { VoiceS3ReviewStoreClient, VoiceS3ReviewStoreFile, VoiceS3ReviewSto
 export type { VoiceSQLiteRuntimeStorage, VoiceSQLiteStoreOptions } from './sqliteStore';
 export type { StoredVoiceIntegrationEvent, StoredVoiceExternalObjectMap, StoredVoiceOpsTask, VoiceExternalObjectMap, VoiceExternalObjectMapStore, VoiceOpsTaskAgeBucket, VoiceOpsTaskAnalyticsOptions, VoiceOpsTaskAnalyticsSummary, VoiceOpsTaskAssignmentRule, VoiceOpsTaskAssignmentRuleCondition, VoiceOpsTaskAssignmentRules, VoiceOpsTaskAssigneeAnalytics, VoiceOpsDispositionTaskPolicies, VoiceOpsSLABreachPolicy, VoiceIntegrationDeliveryStatus, VoiceIntegrationEvent, VoiceIntegrationEventStore, VoiceIntegrationSinkDelivery, VoiceIntegrationEventType, VoiceIntegrationWebhookConfig, VoiceOpsTask, VoiceOpsTaskHistoryEntry, VoiceOpsTaskKind, VoiceOpsTaskPolicy, VoiceOpsTaskPriority, VoiceOpsTaskStatus, VoiceOpsTaskStore, VoiceOpsTaskSummary, VoiceOpsTaskWorkerAnalytics } from './ops';
 export { createTwilioMediaStreamBridge, createTwilioVoiceRoutes, createTwilioVoiceResponse, decodeTwilioMulawBase64, encodeTwilioMulawBase64, transcodePCMToTwilioOutboundPayload, transcodeTwilioInboundPayloadToPCM16 } from './telephony/twilio';
+export { evaluateVoiceTelephonyContract } from './telephony/contract';
+export { createTelnyxVoiceResponse, createTelnyxVoiceRoutes, verifyVoiceTelnyxWebhookSignature } from './telephony/telnyx';
 export type { TwilioInboundMessage, TwilioMediaStreamBridge, TwilioMediaStreamBridgeOptions, TwilioMediaStreamSocket, TwilioOutboundClearMessage, TwilioOutboundMarkMessage, TwilioOutboundMediaMessage, TwilioOutboundMessage, TwilioVoiceRouteParameters, TwilioVoiceResponseOptions, TwilioVoiceSmokeCheck, TwilioVoiceSmokeOptions, TwilioVoiceSmokeReport, TwilioVoiceSetupOptions, TwilioVoiceSetupStatus, TwilioVoiceRoutesOptions } from './telephony/twilio';
+export type { VoiceTelephonyContractIssue, VoiceTelephonyContractOptions, VoiceTelephonyContractReport, VoiceTelephonyContractRequirement, VoiceTelephonyProvider, VoiceTelephonySetupStatus, VoiceTelephonySmokeCheck, VoiceTelephonySmokeReport } from './telephony/contract';
+export type { TelnyxVoiceResponseOptions, TelnyxVoiceRoutesOptions, TelnyxVoiceSetupOptions, TelnyxVoiceSetupStatus, TelnyxVoiceSmokeCheck, TelnyxVoiceSmokeOptions, TelnyxVoiceSmokeReport } from './telephony/telnyx';
 export { shapeTelephonyAssistantText } from './telephony/response';
 export type { TelephonyResponseShapeMode, TelephonyResponseShapeOptions } from './telephony/response';
 export * from './types';

package/dist/index.js

@@ -15904,6 +15904,372 @@ var createTwilioVoiceRoutes = (options) => {
     return report;
   });
 };
+// src/telephony/contract.ts
+var DEFAULT_REQUIREMENTS = [
+  "stream-url",
+  "wss-stream",
+  "webhook-url",
+  "signed-webhook",
+  "smoke-pass"
+];
+var hasFailingSmokeCheck = (smoke) => smoke?.checks.some((check) => check.status === "fail") ?? false;
+var evaluateVoiceTelephonyContract = (input) => {
+  const requirements = input.options?.requirements ?? DEFAULT_REQUIREMENTS;
+  const issues = [];
+  const hasRequirement = (requirement) => requirements.includes(requirement);
+  if (hasRequirement("stream-url") && !input.setup.urls.stream) {
+    issues.push({
+      message: "Missing media stream URL.",
+      requirement: "stream-url",
+      severity: "error"
+    });
+  }
+  if (hasRequirement("wss-stream") && !input.setup.urls.stream.startsWith("wss://")) {
+    issues.push({
+      message: "Media stream URL must use wss://.",
+      requirement: "wss-stream",
+      severity: "error"
+    });
+  }
+  if (hasRequirement("webhook-url") && !input.setup.urls.webhook) {
+    issues.push({
+      message: "Missing carrier webhook URL.",
+      requirement: "webhook-url",
+      severity: "error"
+    });
+  }
+  if (hasRequirement("signed-webhook") && !input.setup.signing.configured) {
+    issues.push({
+      message: "Carrier webhook signature verification is not configured.",
+      requirement: "signed-webhook",
+      severity: "error"
+    });
+  }
+  if (hasRequirement("smoke-pass")) {
+    if (!input.smoke) {
+      issues.push({
+        message: "Missing telephony smoke test report.",
+        requirement: "smoke-pass",
+        severity: "error"
+      });
+    } else if (!input.smoke.pass || hasFailingSmokeCheck(input.smoke)) {
+      issues.push({
+        message: "Telephony smoke test did not pass.",
+        requirement: "smoke-pass",
+        severity: "error"
+      });
+    }
+  }
+  for (const warning of input.setup.warnings) {
+    issues.push({
+      message: warning,
+      requirement: "stream-url",
+      severity: "warning"
+    });
+  }
+  for (const name of input.setup.missing) {
+    issues.push({
+      message: `${name} is missing.`,
+      requirement: "webhook-url",
+      severity: "error"
+    });
+  }
+  return {
+    issues,
+    pass: issues.every((issue) => issue.severity !== "error"),
+    provider: input.setup.provider,
+    requirements,
+    setup: input.setup,
+    smoke: input.smoke
+  };
+};
+// src/telephony/telnyx.ts
+import { Buffer as Buffer4 } from "buffer";
+import { Elysia as Elysia19 } from "elysia";
+var escapeXml3 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var escapeHtml18 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+var joinUrlPath2 = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var resolveRequestOrigin2 = (request) => {
+  const url = new URL(request.url);
+  const forwardedHost = request.headers.get("x-forwarded-host");
+  const forwardedProto = request.headers.get("x-forwarded-proto");
+  const host = forwardedHost ?? request.headers.get("host") ?? url.host;
+  const protocol = forwardedProto ?? url.protocol.replace(":", "");
+  return `${protocol}://${host}`;
+};
+var extractTelnyxStreamUrl = (texml) => texml.match(/<Stream\b[^>]*\surl="([^"]+)"/i)?.[1]?.replaceAll("&amp;", "&");
+var createSmokeCheck2 = (name, status, message, details) => ({
+  details,
+  message,
+  name,
+  status
+});
+var resolveTelnyxStreamUrl = async (options, input) => {
+  if (typeof options.texml?.streamUrl === "function") {
+    return options.texml.streamUrl(input);
+  }
+  if (typeof options.texml?.streamUrl === "string") {
+    return options.texml.streamUrl;
+  }
+  const origin = resolveRequestOrigin2(input.request);
+  const wsOrigin = origin.replace(/^http:/, "ws:").replace(/^https:/, "wss:");
+  return `${wsOrigin}${input.streamPath}`;
+};
+var createTelnyxVoiceResponse = (options) => {
+  const attributes = [
+    `url="${escapeXml3(options.streamUrl)}"`,
+    options.streamName ? `name="${escapeXml3(options.streamName)}"` : undefined,
+    options.track ? `track="${escapeXml3(options.track)}"` : undefined,
+    options.codec ? `codec="${escapeXml3(options.codec)}"` : undefined,
+    options.bidirectionalMode ? `bidirectionalMode="${escapeXml3(options.bidirectionalMode)}"` : undefined,
+    options.bidirectionalCodec ? `bidirectionalCodec="${escapeXml3(options.bidirectionalCodec)}"` : undefined
+  ].filter((value) => Boolean(value)).join(" ");
+  return `<?xml version="1.0" encoding="UTF-8"?><Response><Start><Stream ${attributes} /></Start></Response>`;
+};
+var decodeBase64 = (value) => Uint8Array.from(Buffer4.from(value, "base64"));
+var verifyVoiceTelnyxWebhookSignature = async (input) => {
+  if (!input.publicKey) {
+    return { ok: false, reason: "missing-secret" };
+  }
+  const signature = input.headers.get("telnyx-signature-ed25519");
+  const timestamp = input.headers.get("telnyx-timestamp");
+  if (!signature || !timestamp) {
+    return { ok: false, reason: "missing-signature" };
+  }
+  const toleranceSeconds = input.toleranceSeconds ?? 300;
+  const timestampNumber = Number(timestamp);
+  if (Number.isFinite(timestampNumber) && Math.abs(Date.now() / 1000 - timestampNumber) > toleranceSeconds) {
+    return { ok: false, reason: "invalid-signature" };
+  }
+  try {
+    const key = await crypto.subtle.importKey("raw", decodeBase64(input.publicKey), "Ed25519", false, ["verify"]);
+    const ok = await crypto.subtle.verify("Ed25519", key, decodeBase64(signature), new TextEncoder().encode(`${timestamp}|${input.body}`));
+    return ok ? { ok: true } : { ok: false, reason: "invalid-signature" };
+  } catch {
+    return { ok: false, reason: "invalid-signature" };
+  }
+};
+var buildTelnyxVoiceSetupStatus = async (options, input) => {
+  const origin = resolveRequestOrigin2(input.request);
+  const stream = await resolveTelnyxStreamUrl(options, input);
+  const texml = joinUrlPath2(origin, input.texmlPath);
+  const webhook = joinUrlPath2(origin, input.webhookPath);
+  const missing = Object.entries(options.setup?.requiredEnv ?? {}).filter((entry) => !entry[1]).map(([name]) => name);
+  const signingConfigured = Boolean(options.webhook?.publicKey || options.webhook?.verify);
+  const warnings = [
+    ...stream.startsWith("wss://") ? [] : ["Telnyx media streams should use wss:// in production."],
+    ...signingConfigured ? [] : ["Webhook signature verification is not configured."]
+  ];
+  return {
+    generatedAt: Date.now(),
+    missing,
+    provider: "telnyx",
+    ready: missing.length === 0 && signingConfigured && warnings.length === 0,
+    signing: {
+      configured: signingConfigured,
+      mode: options.webhook?.verify ? "custom" : options.webhook?.publicKey ? "provider-signature" : "none",
+      verificationUrl: webhook
+    },
+    urls: {
+      stream,
+      texml,
+      webhook
+    },
+    warnings
+  };
+};
+var renderTelnyxSetupHTML = (status, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
+<p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Telnyx setup</p>
+<h1>${escapeHtml18(title)}</h1>
+<p><strong>Status:</strong> ${status.ready ? "Ready" : "Needs attention"}</p>
+<ul>
+<li><strong>TeXML:</strong> <code>${escapeHtml18(status.urls.texml)}</code></li>
+<li><strong>Media stream:</strong> <code>${escapeHtml18(status.urls.stream)}</code></li>
+<li><strong>Status webhook:</strong> <code>${escapeHtml18(status.urls.webhook)}</code></li>
+</ul>
+${status.missing.length ? `<h2>Missing env</h2><ul>${status.missing.map((name) => `<li><code>${escapeHtml18(name)}</code></li>`).join("")}</ul>` : ""}
+${status.warnings.length ? `<h2>Warnings</h2><ul>${status.warnings.map((warning) => `<li>${escapeHtml18(warning)}</li>`).join("")}</ul>` : ""}
+</main>`;
+var renderTelnyxSmokeHTML = (report, title) => `<main style="font-family: ui-sans-serif, system-ui; max-width: 860px; margin: 40px auto; padding: 0 20px;">
+<p style="letter-spacing: .12em; text-transform: uppercase; color: #52606d;">Telnyx smoke test</p>
+<h1>${escapeHtml18(title)}</h1>
+<p><strong>Status:</strong> ${report.pass ? "Pass" : "Fail"}</p>
+<ul>${report.checks.map((check) => `<li><strong>${escapeHtml18(check.name)}</strong>: ${escapeHtml18(check.status)}${check.message ? ` - ${escapeHtml18(check.message)}` : ""}</li>`).join("")}</ul>
+</main>`;
+var runTelnyxSmokeTest = async (input) => {
+  const setup = await buildTelnyxVoiceSetupStatus(input.options, input);
+  const checks = [];
+  const texmlResponse = await input.app.handle(new Request(setup.urls.texml));
+  const texml = await texmlResponse.text();
+  const streamUrl = extractTelnyxStreamUrl(texml);
+  checks.push(createSmokeCheck2("texml", texmlResponse.ok && Boolean(streamUrl) ? "pass" : "fail", streamUrl ? "TeXML includes a media stream URL." : 'TeXML is missing <Stream url="...">.', {
+    status: texmlResponse.status,
+    streamUrl
+  }));
+  checks.push(createSmokeCheck2("stream-url", streamUrl?.startsWith("wss://") ? "pass" : "fail", streamUrl?.startsWith("wss://") ? "Media stream URL uses wss://." : "Media stream URL should use wss:// for Telnyx.", {
+    streamUrl
+  }));
+  const webhookBody = {
+    data: {
+      event_type: input.options.smoke?.eventType ?? "call.hangup",
+      id: "telnyx-smoke-event",
+      payload: {
+        call_control_id: input.options.smoke?.callControlId ?? "telnyx-smoke-call",
+        call_leg_id: input.options.smoke?.callLegId ?? "telnyx-smoke-leg",
+        call_session_id: input.options.smoke?.sessionId ?? "telnyx-smoke-session",
+        hangup_cause: "busy",
+        sip_hangup_cause: 486
+      },
+      record_type: "event"
+    }
+  };
+  const webhookResponse = await input.app.handle(new Request(setup.urls.webhook, {
+    body: JSON.stringify(webhookBody),
+    headers: {
+      "content-type": "application/json"
+    },
+    method: "POST"
+  }));
+  const webhookText = await webhookResponse.text();
+  const webhookPayload = (() => {
+    try {
+      return JSON.parse(webhookText);
+    } catch {
+      return webhookText;
+    }
+  })();
+  checks.push(createSmokeCheck2("webhook", webhookResponse.ok ? "pass" : "fail", webhookResponse.ok ? "Synthetic Telnyx event was accepted." : "Synthetic Telnyx event failed.", {
+    status: webhookResponse.status
+  }));
+  for (const warning of setup.warnings) {
+    checks.push(createSmokeCheck2("setup-warning", "warn", warning));
+  }
+  for (const name of setup.missing) {
+    checks.push(createSmokeCheck2("missing-env", "fail", `${name} is missing.`));
+  }
+  const baseReport = {
+    checks,
+    generatedAt: Date.now(),
+    pass: checks.every((check) => check.status !== "fail"),
+    provider: "telnyx",
+    setup,
+    texml: {
+      status: texmlResponse.status,
+      streamUrl
+    },
+    twiml: {
+      status: texmlResponse.status,
+      streamUrl
+    },
+    webhook: {
+      body: webhookPayload,
+      status: webhookResponse.status
+    }
+  };
+  return {
+    ...baseReport,
+    contract: evaluateVoiceTelephonyContract({
+      setup,
+      smoke: baseReport
+    })
+  };
+};
+var createTelnyxVoiceRoutes = (options = {}) => {
+  const streamPath = options.streamPath ?? "/api/voice/telnyx/stream";
+  const texmlPath = options.texml?.path ?? "/api/voice/telnyx";
+  const webhookPath = options.webhook?.path ?? "/api/voice/telnyx/webhook";
+  const setupPath = options.setup?.path === false ? false : options.setup?.path ?? "/api/voice/telnyx/setup";
+  const smokePath = options.smoke?.path === false ? false : options.smoke?.path ?? "/api/voice/telnyx/smoke";
+  const webhookPolicy = options.webhook?.policy ?? options.outcomePolicy ?? createVoiceTelephonyOutcomePolicy();
+  const verify = options.webhook?.verify ?? (options.webhook?.publicKey ? (input) => verifyVoiceTelnyxWebhookSignature({
+    body: input.rawBody,
+    headers: input.headers,
+    publicKey: options.webhook?.publicKey,
+    toleranceSeconds: options.webhook?.toleranceSeconds
+  }) : undefined);
+  const app = new Elysia19({
+    name: options.name ?? "absolutejs-voice-telnyx"
+  }).get(texmlPath, async ({ query, request }) => {
+    const streamUrl = await resolveTelnyxStreamUrl(options, {
+      query,
+      request,
+      streamPath
+    });
+    return new Response(createTelnyxVoiceResponse({
+      ...options.texml?.response,
+      streamUrl
+    }), {
+      headers: {
+        "content-type": "text/xml; charset=utf-8"
+      }
+    });
+  }).post(texmlPath, async ({ query, request }) => {
+    const streamUrl = await resolveTelnyxStreamUrl(options, {
+      query,
+      request,
+      streamPath
+    });
+    return new Response(createTelnyxVoiceResponse({
+      ...options.texml?.response,
+      streamUrl
+    }), {
+      headers: {
+        "content-type": "text/xml; charset=utf-8"
+      }
+    });
+  }).use(createVoiceTelephonyWebhookRoutes({
+    ...options.webhook ?? {},
+    context: options.context,
+    path: webhookPath,
+    policy: webhookPolicy,
+    provider: "telnyx",
+    requireVerification: Boolean(options.webhook?.publicKey),
+    resolveSessionId: options.webhook?.resolveSessionId ?? (({ event }) => {
+      const metadata = event.metadata;
+      return typeof metadata?.call_session_id === "string" ? metadata.call_session_id : typeof metadata?.callSessionId === "string" ? metadata.callSessionId : typeof metadata?.call_control_id === "string" ? metadata.call_control_id : undefined;
+    }),
+    verify
+  }));
+  const withSetup = setupPath ? app.get(setupPath, async ({ query, request }) => {
+    const status = await buildTelnyxVoiceSetupStatus(options, {
+      query,
+      request,
+      streamPath,
+      texmlPath,
+      webhookPath
+    });
+    if (query.format === "html") {
+      return new Response(renderTelnyxSetupHTML(status, options.setup?.title ?? "AbsoluteJS Telnyx Voice Setup"), {
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      });
+    }
+    return status;
+  }) : app;
+  if (!smokePath) {
+    return withSetup;
+  }
+  return withSetup.get(smokePath, async ({ query, request }) => {
+    const report = await runTelnyxSmokeTest({
+      app,
+      options,
+      query,
+      request,
+      streamPath,
+      texmlPath,
+      webhookPath
+    });
+    if (query.format === "html") {
+      return new Response(renderTelnyxSmokeHTML(report, options.smoke?.title ?? "AbsoluteJS Telnyx Voice Smoke Test"), {
+        headers: {
+          "content-type": "text/html; charset=utf-8"
+        }
+      });
+    }
+    return report;
+  });
+};
 // src/telephony/response.ts
 var normalizeWhitespace = (value) => value.replace(/\s+/g, " ").trim();
 var DEFAULT_MAX_WORDS = 12;
@@ -15962,6 +16328,7 @@ export {
   voiceTelephonyOutcomeToRouteResult,
   voice,
   verifyVoiceTwilioWebhookSignature,
+  verifyVoiceTelnyxWebhookSignature,
   verifyVoiceOpsWebhookSignature,
   validateVoiceWorkflowRouteResult,
   transcodeTwilioInboundPayloadToPCM16,
@@ -16046,6 +16413,7 @@ export {
   failVoiceOpsTask,
   exportVoiceTrace,
   evaluateVoiceTrace,
+  evaluateVoiceTelephonyContract,
   evaluateVoiceQuality,
   encodeTwilioMulawBase64,
   deliverVoiceTraceEventsToSinks,
@@ -16202,6 +16570,8 @@ export {
   createTwilioVoiceRoutes,
   createTwilioVoiceResponse,
   createTwilioMediaStreamBridge,
+  createTelnyxVoiceRoutes,
+  createTelnyxVoiceResponse,
   createStoredVoiceOpsTask,
   createStoredVoiceIntegrationEvent,
   createStoredVoiceExternalObjectMap,

package/dist/telephony/contract.d.ts

@@ -0,0 +1,61 @@
+export type VoiceTelephonyProvider = 'generic' | 'plivo' | 'telnyx' | 'twilio';
+export type VoiceTelephonySetupStatus<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    generatedAt: number;
+    missing: string[];
+    provider: TProvider;
+    ready: boolean;
+    signing: {
+        configured: boolean;
+        mode: 'custom' | 'none' | 'provider-signature' | 'twilio-signature';
+        verificationUrl?: string;
+    };
+    urls: {
+        stream: string;
+        twiml?: string;
+        webhook: string;
+    };
+    warnings: string[];
+};
+export type VoiceTelephonySmokeCheck = {
+    details?: Record<string, unknown>;
+    message?: string;
+    name: string;
+    status: 'fail' | 'pass' | 'warn';
+};
+export type VoiceTelephonySmokeReport<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    checks: VoiceTelephonySmokeCheck[];
+    generatedAt: number;
+    pass: boolean;
+    provider: TProvider;
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    twiml?: {
+        status: number;
+        streamUrl?: string;
+    };
+    webhook?: {
+        body?: unknown;
+        status: number;
+    };
+};
+export type VoiceTelephonyContractRequirement = 'signed-webhook' | 'smoke-pass' | 'stream-url' | 'webhook-url' | 'wss-stream';
+export type VoiceTelephonyContractIssue = {
+    requirement: VoiceTelephonyContractRequirement;
+    severity: 'error' | 'warning';
+    message: string;
+};
+export type VoiceTelephonyContractReport<TProvider extends VoiceTelephonyProvider = VoiceTelephonyProvider> = {
+    issues: VoiceTelephonyContractIssue[];
+    pass: boolean;
+    provider: TProvider;
+    requirements: VoiceTelephonyContractRequirement[];
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    smoke?: VoiceTelephonySmokeReport<TProvider>;
+};
+export type VoiceTelephonyContractOptions = {
+    requirements?: VoiceTelephonyContractRequirement[];
+};
+export declare const evaluateVoiceTelephonyContract: <TProvider extends VoiceTelephonyProvider>(input: {
+    options?: VoiceTelephonyContractOptions;
+    setup: VoiceTelephonySetupStatus<TProvider>;
+    smoke?: VoiceTelephonySmokeReport<TProvider>;
+}) => VoiceTelephonyContractReport<TProvider>;

package/dist/telephony/telnyx.d.ts

@@ -0,0 +1,139 @@
+import { Elysia } from 'elysia';
+import { type VoiceTelephonyContractReport, type VoiceTelephonySetupStatus, type VoiceTelephonySmokeCheck, type VoiceTelephonySmokeReport } from './contract';
+import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions, type VoiceTelephonyWebhookVerificationResult } from '../telephonyOutcome';
+import type { VoiceSessionRecord } from '../types';
+export type TelnyxVoiceResponseOptions = {
+    bidirectionalCodec?: 'AMR-WB' | 'G722' | 'OPUS' | 'PCMA' | 'PCMU';
+    bidirectionalMode?: 'mp3' | 'rtp';
+    codec?: 'AMR-WB' | 'G722' | 'OPUS' | 'PCMA' | 'PCMU' | 'default';
+    streamName?: string;
+    streamUrl: string;
+    track?: 'both_tracks' | 'inbound_track' | 'outbound_track';
+};
+export type TelnyxVoiceSetupStatus = VoiceTelephonySetupStatus<'telnyx'> & {
+    urls: VoiceTelephonySetupStatus<'telnyx'>['urls'] & {
+        texml: string;
+    };
+};
+export type TelnyxVoiceSetupOptions = {
+    path?: false | string;
+    requiredEnv?: Record<string, string | undefined>;
+    title?: string;
+};
+export type TelnyxVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type TelnyxVoiceSmokeReport = VoiceTelephonySmokeReport<'telnyx'> & {
+    contract: VoiceTelephonyContractReport<'telnyx'>;
+    setup: TelnyxVoiceSetupStatus;
+    texml?: {
+        status: number;
+        streamUrl?: string;
+    };
+};
+export type TelnyxVoiceSmokeOptions = {
+    callControlId?: string;
+    callLegId?: string;
+    eventType?: string;
+    path?: false | string;
+    sessionId?: string;
+    title?: string;
+};
+export type TelnyxVoiceRoutesOptions<TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown> = {
+    context?: TContext;
+    name?: string;
+    outcomePolicy?: VoiceTelephonyOutcomePolicy;
+    setup?: TelnyxVoiceSetupOptions;
+    smoke?: TelnyxVoiceSmokeOptions;
+    streamPath?: string;
+    texml?: {
+        path?: string;
+        response?: Omit<TelnyxVoiceResponseOptions, 'streamUrl'>;
+        streamUrl?: string | ((input: {
+            query: Record<string, unknown>;
+            request: Request;
+            streamPath: string;
+        }) => Promise<string> | string);
+    };
+    webhook?: Omit<VoiceTelephonyWebhookRoutesOptions<TContext, TSession, TResult>, 'context' | 'path' | 'policy' | 'provider'> & {
+        path?: string;
+        policy?: VoiceTelephonyOutcomePolicy;
+        publicKey?: string;
+        toleranceSeconds?: number;
+    };
+};
+export declare const createTelnyxVoiceResponse: (options: TelnyxVoiceResponseOptions) => string;
+export declare const verifyVoiceTelnyxWebhookSignature: (input: {
+    body: string;
+    headers: Headers;
+    publicKey?: string;
+    toleranceSeconds?: number;
+}) => Promise<VoiceTelephonyWebhookVerificationResult>;
+export declare const createTelnyxVoiceRoutes: <TContext = unknown, TSession extends VoiceSessionRecord = VoiceSessionRecord, TResult = unknown>(options?: TelnyxVoiceRoutesOptions<TContext, TSession, TResult>) => 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: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+} & {
+    [x: string]: {
+        post: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response | import("..").VoiceTelephonyWebhookDecision<TResult>;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+} & {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/telephony/twilio.d.ts

@@ -1,4 +1,5 @@
 import { Elysia } from 'elysia';
+import type { VoiceTelephonySetupStatus, VoiceTelephonySmokeCheck, VoiceTelephonySmokeReport } from './contract';
 import { type VoiceTelephonyOutcomePolicy, type VoiceTelephonyWebhookRoutesOptions } from '../telephonyOutcome';
 import { type VoiceCallReviewArtifact, type VoiceCallReviewConfig } from '../testing/review';
 import type { AudioFormat, VoiceLogger, VoicePluginConfig, VoiceSessionRecord, VoiceServerMessage } from '../types';
@@ -113,48 +114,19 @@ export type TwilioVoiceRouteParameters = Record<string, string | number | boolea
     query: Record<string, unknown>;
     request: Request;
 }) => Promise<Record<string, string | number | boolean | undefined>> | Record<string, string | number | boolean | undefined>);
-export type TwilioVoiceSetupStatus = {
-    generatedAt: number;
-    missing: string[];
-    provider: 'twilio';
-    ready: boolean;
-    signing: {
-        configured: boolean;
-        mode: 'custom' | 'none' | 'twilio-signature';
-        verificationUrl?: string;
-    };
-    urls: {
-        stream: string;
+export type TwilioVoiceSetupStatus = VoiceTelephonySetupStatus<'twilio'> & {
+    urls: VoiceTelephonySetupStatus<'twilio'>['urls'] & {
         twiml: string;
-        webhook: string;
     };
-    warnings: string[];
 };
 export type TwilioVoiceSetupOptions = {
     path?: false | string;
     requiredEnv?: Record<string, string | undefined>;
     title?: string;
 };
-export type TwilioVoiceSmokeCheck = {
-    details?: Record<string, unknown>;
-    message?: string;
-    name: string;
-    status: 'fail' | 'pass' | 'warn';
-};
-export type TwilioVoiceSmokeReport = {
-    checks: TwilioVoiceSmokeCheck[];
-    generatedAt: number;
-    pass: boolean;
-    provider: 'twilio';
+export type TwilioVoiceSmokeCheck = VoiceTelephonySmokeCheck;
+export type TwilioVoiceSmokeReport = VoiceTelephonySmokeReport<'twilio'> & {
     setup: TwilioVoiceSetupStatus;
-    twiml?: {
-        status: number;
-        streamUrl?: string;
-    };
-    webhook?: {
-        body?: unknown;
-        status: number;
-    };
 };
 export type TwilioVoiceSmokeOptions = {
     callSid?: string;

package/package.json

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