@absolutejs/voice 0.0.22-beta.115 → 0.0.22-beta.117

package/dist/campaignDialers.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceCampaignDialer, VoiceCampaignDialerInput } from './campaign';
+import { applyVoiceCampaignTelephonyOutcome, VoiceCampaignDialer, VoiceCampaignDialerInput, type VoiceCampaignRecord, type VoiceCampaignStore, type VoiceCampaignTickResult } from './campaign';
 type VoiceCampaignDialerFetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
 type VoiceCampaignDialerMetadataInput = VoiceCampaignDialerInput & {
     provider: 'plivo' | 'telnyx' | 'twilio';
@@ -46,7 +46,45 @@ export type VoicePlivoCampaignDialerOptions = {
     from: string;
     metadata?: VoiceCampaignDialerMetadata;
 };
+export type VoiceCampaignDialerProofProvider = 'plivo' | 'telnyx' | 'twilio';
+export type VoiceCampaignDialerProofCarrierRequest = {
+    body: unknown;
+    method: string;
+    provider: VoiceCampaignDialerProofProvider;
+    url: string;
+};
+export type VoiceCampaignDialerProofProviderResult = {
+    campaignId: string;
+    carrierRequests: VoiceCampaignDialerProofCarrierRequest[];
+    final?: VoiceCampaignRecord;
+    outcomes: Awaited<ReturnType<typeof applyVoiceCampaignTelephonyOutcome>>[];
+    provider: VoiceCampaignDialerProofProvider;
+    tick: VoiceCampaignTickResult;
+};
+export type VoiceCampaignDialerProofReport = {
+    generatedAt: number;
+    mode: 'dry-run';
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProviderResult[];
+};
+export type VoiceCampaignDialerProofStatus = {
+    generatedAt: number;
+    mode: 'dry-run';
+    ok: boolean;
+    providers: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    safe: true;
+};
+export type VoiceCampaignDialerProofOptions = {
+    baseUrl?: string;
+    from?: string;
+    providers?: VoiceCampaignDialerProofProvider[];
+    runPath?: string;
+    store?: VoiceCampaignStore;
+};
 export declare const createVoiceTwilioCampaignDialer: (options: VoiceTwilioCampaignDialerOptions) => VoiceCampaignDialer;
 export declare const createVoiceTelnyxCampaignDialer: (options: VoiceTelnyxCampaignDialerOptions) => VoiceCampaignDialer;
 export declare const createVoicePlivoCampaignDialer: (options: VoicePlivoCampaignDialerOptions) => VoiceCampaignDialer;
+export declare const getVoiceCampaignDialerProofStatus: (options?: Pick<VoiceCampaignDialerProofOptions, "providers" | "runPath">) => VoiceCampaignDialerProofStatus;
+export declare const runVoiceCampaignDialerProof: (options?: VoiceCampaignDialerProofOptions) => Promise<VoiceCampaignDialerProofReport>;
 export {};

package/dist/client/campaignDialerProof.d.ts

@@ -0,0 +1,23 @@
+import type { VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus } from '../campaignDialers';
+export type VoiceCampaignDialerProofClientOptions = {
+    fetch?: typeof fetch;
+    intervalMs?: number;
+    runPath?: string;
+};
+export type VoiceCampaignDialerProofSnapshot = {
+    error: string | null;
+    isLoading: boolean;
+    report?: VoiceCampaignDialerProofReport;
+    status?: VoiceCampaignDialerProofStatus;
+    updatedAt?: number;
+};
+export declare const fetchVoiceCampaignDialerProofStatus: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofStatus>;
+export declare const runVoiceCampaignDialerProofAction: (path?: string, options?: Pick<VoiceCampaignDialerProofClientOptions, "fetch">) => Promise<VoiceCampaignDialerProofReport>;
+export declare const createVoiceCampaignDialerProofStore: (path?: string, options?: VoiceCampaignDialerProofClientOptions) => {
+    close: () => void;
+    getServerSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    getSnapshot: () => VoiceCampaignDialerProofSnapshot;
+    refresh: () => Promise<VoiceCampaignDialerProofStatus | undefined>;
+    runProof: () => Promise<VoiceCampaignDialerProofReport>;
+    subscribe: (listener: () => void) => () => void;
+};

package/dist/client/index.d.ts

@@ -15,6 +15,7 @@ export { createVoiceProviderStatusStore, fetchVoiceProviderStatus } from './prov
 export { createVoiceProviderCapabilitiesStore, fetchVoiceProviderCapabilities } from './providerCapabilities';
 export { createVoiceTurnQualityStore, fetchVoiceTurnQuality } from './turnQuality';
 export { createVoiceTurnLatencyStore, fetchVoiceTurnLatency, runVoiceTurnLatencyProof } from './turnLatency';
+export { createVoiceCampaignDialerProofStore, fetchVoiceCampaignDialerProofStatus, runVoiceCampaignDialerProofAction } from './campaignDialerProof';
 export { createVoiceTraceTimelineStore, fetchVoiceTraceTimeline } from './traceTimeline';
 export { createVoiceProviderSimulationControlsStore } from './providerSimulationControls';
 export { bindVoiceProviderSimulationControls, createVoiceProviderSimulationControlsViewModel, defineVoiceProviderSimulationControlsElement, mountVoiceProviderSimulationControls, renderVoiceProviderSimulationControlsHTML } from './providerSimulationControlsWidget';
@@ -34,6 +35,7 @@ export type { VoiceProviderStatusClientOptions, VoiceProviderStatusSnapshot } fr
 export type { VoiceProviderCapabilitiesClientOptions, VoiceProviderCapabilitiesSnapshot } from './providerCapabilities';
 export type { VoiceTurnQualityClientOptions, VoiceTurnQualitySnapshot } from './turnQuality';
 export type { VoiceTurnLatencyClientOptions, VoiceTurnLatencySnapshot } from './turnLatency';
+export type { VoiceCampaignDialerProofClientOptions, VoiceCampaignDialerProofSnapshot } from './campaignDialerProof';
 export type { VoiceTraceTimelineClientOptions, VoiceTraceTimelineSnapshot } from './traceTimeline';
 export type { VoiceProviderSimulationControlsOptions, VoiceProviderSimulationControlsSnapshot, VoiceProviderSimulationProvider } from './providerSimulationControls';
 export type { VoiceProviderSimulationControlsViewModel } from './providerSimulationControlsWidget';

package/dist/client/index.js

@@ -2560,6 +2560,123 @@ var createVoiceTurnLatencyStore = (path = "/api/turn-latency", options = {}) =>
     }
   };
 };
+// src/client/campaignDialerProof.ts
+var fetchVoiceCampaignDialerProofStatus = async (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path);
+  if (!response.ok) {
+    throw new Error(`Voice campaign dialer proof status failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var runVoiceCampaignDialerProofAction = async (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  const response = await fetchImpl(path, { method: "POST" });
+  if (!response.ok) {
+    throw new Error(`Voice campaign dialer proof failed: HTTP ${response.status}`);
+  }
+  return await response.json();
+};
+var createVoiceCampaignDialerProofStore = (path = "/api/voice/campaigns/dialer-proof", options = {}) => {
+  const listeners = new Set;
+  let closed = false;
+  let timer;
+  let snapshot = {
+    error: null,
+    isLoading: false
+  };
+  const emit = () => {
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const refresh = async () => {
+    if (closed) {
+      return snapshot.status;
+    }
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const status = await fetchVoiceCampaignDialerProofStatus(path, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isLoading: false,
+        status,
+        updatedAt: Date.now()
+      };
+      emit();
+      return status;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const runProof = async () => {
+    const runPath = options.runPath ?? snapshot.status?.runPath ?? path;
+    snapshot = { ...snapshot, error: null, isLoading: true };
+    emit();
+    try {
+      const report = await runVoiceCampaignDialerProofAction(runPath, options);
+      snapshot = {
+        ...snapshot,
+        error: null,
+        isLoading: false,
+        report,
+        status: {
+          generatedAt: Date.now(),
+          mode: report.mode,
+          ok: report.ok,
+          providers: report.providers.map((provider) => provider.provider),
+          runPath,
+          safe: true
+        },
+        updatedAt: Date.now()
+      };
+      emit();
+      return report;
+    } catch (error) {
+      snapshot = {
+        ...snapshot,
+        error: error instanceof Error ? error.message : String(error),
+        isLoading: false
+      };
+      emit();
+      throw error;
+    }
+  };
+  const close = () => {
+    closed = true;
+    if (timer) {
+      clearInterval(timer);
+      timer = undefined;
+    }
+    listeners.clear();
+  };
+  if (options.intervalMs && options.intervalMs > 0) {
+    timer = setInterval(() => {
+      refresh().catch(() => {});
+    }, options.intervalMs);
+  }
+  return {
+    close,
+    getServerSnapshot: () => snapshot,
+    getSnapshot: () => snapshot,
+    refresh,
+    runProof,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    }
+  };
+};
 // src/client/traceTimeline.ts
 var fetchVoiceTraceTimeline = async (path = "/api/voice-traces", options = {}) => {
   const fetchImpl = options.fetch ?? globalThis.fetch;
@@ -3423,6 +3540,7 @@ var createVoiceWorkflowStatusStore = (path = "/evals/scenarios/json", options =
 };
 export {
   runVoiceTurnLatencyProof,
+  runVoiceCampaignDialerProofAction,
   renderVoiceTurnQualityHTML,
   renderVoiceTurnLatencyHTML,
   renderVoiceTraceTimelineWidgetHTML,
@@ -3453,6 +3571,7 @@ export {
   fetchVoiceRoutingStatus,
   fetchVoiceProviderStatus,
   fetchVoiceProviderCapabilities,
+  fetchVoiceCampaignDialerProofStatus,
   fetchVoiceAppKitStatus,
   defineVoiceTurnQualityElement,
   defineVoiceTurnLatencyElement,
@@ -3484,6 +3603,7 @@ export {
   createVoiceDuplexController,
   createVoiceController,
   createVoiceConnection,
+  createVoiceCampaignDialerProofStore,
   createVoiceBargeInMonitor,
   createVoiceAudioPlayer,
   createVoiceAppKitStatusStore,

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export { voice } from './plugin';
 export { createVoiceAppKit, createVoiceAppKitRoutes, summarizeVoiceAppKitStatus } from './appKit';
 export { applyVoiceCampaignTelephonyOutcome, buildVoiceCampaignObservabilityReport, createVoiceCampaignTelephonyOutcomeHandler, createVoiceCampaign, createVoiceCampaignRoutes, createVoiceCampaignWorker, createVoiceCampaignWorkerLoop, createVoiceMemoryCampaignStore, renderVoiceCampaignObservabilityHTML, renderVoiceCampaignsHTML, runVoiceCampaignProof, summarizeVoiceCampaigns } from './campaign';
-export { createVoicePlivoCampaignDialer, createVoiceTelnyxCampaignDialer, createVoiceTwilioCampaignDialer } from './campaignDialers';
+export { createVoicePlivoCampaignDialer, createVoiceTelnyxCampaignDialer, createVoiceTwilioCampaignDialer, getVoiceCampaignDialerProofStatus, runVoiceCampaignDialerProof } from './campaignDialers';
 export { createVoiceAssistant, createVoiceExperiment, summarizeVoiceAssistantRuns } from './assistant';
 export { createVoiceAssistantHealthHTMLHandler, createVoiceAssistantHealthJSONHandler, createVoiceAssistantHealthRoutes, renderVoiceAssistantHealthHTML, summarizeVoiceAssistantHealth } from './assistantHealth';
 export { createVoiceBargeInRoutes, renderVoiceBargeInHTML, summarizeVoiceBargeIn } from './bargeInRoutes';
@@ -56,6 +56,7 @@ export { resolveTurnDetectionConfig, TURN_PROFILE_DEFAULTS } from './turnProfile
 export { createVoiceCallReviewFromLiveTelephonyReport, createVoiceCallReviewRecorder, renderVoiceCallReviewHTML, renderVoiceCallReviewMarkdown } from './testing/review';
 export type { VoiceAppKitLink, VoiceAppKitRoutes, VoiceAppKitRoutesOptions, VoiceAppKitStatus, VoiceAppKitStatusOptions, VoiceAppKitStatusReport, VoiceAppKitSurface } from './appKit';
 export type { VoiceCampaign, VoiceCampaignAttempt, VoiceCampaignAttemptResultInput, VoiceCampaignAttemptStatus, VoiceCampaignCreateInput, VoiceCampaignDialer, VoiceCampaignDialerInput, VoiceCampaignDialerResult, VoiceCampaignProofOptions, VoiceCampaignProofReport, VoiceCampaignRecipient, VoiceCampaignRecipientInput, VoiceCampaignRecipientStatus, VoiceCampaignRecord, VoiceCampaignRoutesOptions, VoiceCampaignRuntime, VoiceCampaignRuntimeOptions, VoiceCampaignStatus, VoiceCampaignStore, VoiceCampaignSummary, VoiceCampaignTickResult } from './campaign';
+export type { VoiceCampaignDialerProofCarrierRequest, VoiceCampaignDialerProofOptions, VoiceCampaignDialerProofProvider, VoiceCampaignDialerProofProviderResult, VoiceCampaignDialerProofReport, VoiceCampaignDialerProofStatus, VoicePlivoCampaignDialerOptions, VoiceTelnyxCampaignDialerOptions, VoiceTwilioCampaignDialerOptions } from './campaignDialers';
 export type { VoiceBargeInReport, VoiceBargeInRoutesOptions } from './bargeInRoutes';
 export type { VoiceAssistant, VoiceAssistantArtifactPlan, VoiceAssistantExperiment, VoiceAssistantExperimentOptions, VoiceAssistantGuardrailInput, VoiceAssistantGuardrails, VoiceAssistantMemoryLifecycle, VoiceAssistantMemoryLifecycleInput, VoiceAssistantOptions, VoiceAssistantOutputGuardrailInput, VoiceAssistantPreset, VoiceAssistantRunsSummary, VoiceAssistantRunSummary, VoiceAssistantVariant } from './assistant';
 export type { VoiceAssistantHealthFailure, VoiceAssistantHealthHTMLHandlerOptions, VoiceAssistantHealthRoutesOptions, VoiceAssistantHealthSummary, VoiceAssistantHealthSummaryOptions } from './assistantHealth';

package/dist/index.js

@@ -11451,6 +11451,163 @@ var createVoicePlivoCampaignDialer = (options) => async (input) => {
     status: "running"
   };
 };
+var campaignDialerProofProviders = [
+  "twilio",
+  "telnyx",
+  "plivo"
+];
+var joinUrlPath = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var serializeProofRequestBody = (body) => {
+  if (body instanceof URLSearchParams) {
+    return Object.fromEntries(body.entries());
+  }
+  if (typeof body === "string") {
+    try {
+      return JSON.parse(body);
+    } catch {
+      return body;
+    }
+  }
+  return body ? String(body) : undefined;
+};
+var createProofFetch = (provider, requests) => {
+  let sequence = 0;
+  return async (url, init) => {
+    sequence += 1;
+    requests.push({
+      body: serializeProofRequestBody(init?.body),
+      method: init?.method ?? "GET",
+      provider,
+      url: String(url)
+    });
+    const externalCallId = `dry-run-${provider}-${sequence}`;
+    const payload = provider === "twilio" ? { sid: externalCallId } : provider === "telnyx" ? { data: { call_control_id: externalCallId } } : { request_uuid: externalCallId };
+    return Response.json(payload);
+  };
+};
+var createProofDialer = (input) => {
+  const fetch2 = createProofFetch(input.provider, input.requests);
+  if (input.provider === "twilio") {
+    return createVoiceTwilioCampaignDialer({
+      accountSid: "AC_dry_run",
+      answerUrl: joinUrlPath(input.baseUrl, "/api/twilio/voice"),
+      apiBaseUrl: "https://twilio.dry-run.absolutejs.local",
+      authToken: "dry-run-token",
+      fetch: fetch2,
+      from: input.from,
+      statusCallbackEvents: ["answered", "completed"],
+      statusCallbackUrl: joinUrlPath(input.baseUrl, "/api/telephony-webhook")
+    });
+  }
+  if (input.provider === "telnyx") {
+    return createVoiceTelnyxCampaignDialer({
+      apiBaseUrl: "https://telnyx.dry-run.absolutejs.local",
+      apiKey: "dry-run-token",
+      connectionId: "dry-run-connection",
+      fetch: fetch2,
+      from: input.from,
+      webhookUrl: joinUrlPath(input.baseUrl, "/api/telnyx/webhook")
+    });
+  }
+  return createVoicePlivoCampaignDialer({
+    answerUrl: joinUrlPath(input.baseUrl, "/api/plivo/voice"),
+    apiBaseUrl: "https://plivo.dry-run.absolutejs.local",
+    authId: "dry-run-auth-id",
+    authToken: "dry-run-token",
+    callbackUrl: joinUrlPath(input.baseUrl, "/api/plivo/webhook"),
+    fetch: fetch2,
+    from: input.from
+  });
+};
+var runCampaignDialerProofForProvider = async (input) => {
+  const carrierRequests = [];
+  const runtime = createVoiceCampaign({
+    dialer: createProofDialer({
+      baseUrl: input.baseUrl,
+      from: input.from,
+      provider: input.provider,
+      requests: carrierRequests
+    }),
+    store: input.store
+  });
+  const proof = await runVoiceCampaignProof({
+    campaign: {
+      description: "Dry-run carrier dialer proof with campaign metadata and webhook outcome resolution.",
+      id: `campaign-dialer-proof-${input.provider}-${crypto.randomUUID()}`,
+      metadata: {
+        mode: "dry-run",
+        provider: input.provider
+      },
+      name: `AbsoluteJS Voice ${input.provider} Campaign Dialer Proof`
+    },
+    completeAttempts: false,
+    recipients: [
+      {
+        id: `dialer-proof-${input.provider}-recipient`,
+        metadata: {
+          provider: input.provider,
+          source: "campaign-dialer-proof"
+        },
+        name: `${input.provider} dry-run recipient`,
+        phone: "+15550001001"
+      }
+    ],
+    runtime
+  });
+  const outcomes = await Promise.all(proof.tick.started.map((attempt) => applyVoiceCampaignTelephonyOutcome({
+    decision: {
+      action: "complete",
+      confidence: "high",
+      disposition: "completed",
+      source: "status"
+    },
+    event: {
+      metadata: {
+        attemptId: attempt.id,
+        campaignId: attempt.campaignId,
+        externalCallId: attempt.externalCallId,
+        voiceCampaignAttemptId: attempt.id,
+        voiceCampaignId: attempt.campaignId
+      },
+      provider: input.provider,
+      status: "completed"
+    }
+  }, {
+    runtime
+  })));
+  return {
+    campaignId: proof.campaign.campaign.id,
+    carrierRequests,
+    final: await runtime.get(proof.campaign.campaign.id),
+    outcomes,
+    provider: input.provider,
+    tick: proof.tick
+  };
+};
+var getVoiceCampaignDialerProofStatus = (options = {}) => ({
+  generatedAt: Date.now(),
+  mode: "dry-run",
+  ok: true,
+  providers: options.providers ?? campaignDialerProofProviders,
+  runPath: options.runPath,
+  safe: true
+});
+var runVoiceCampaignDialerProof = async (options = {}) => {
+  const providers = options.providers ?? campaignDialerProofProviders;
+  const store = options.store ?? createVoiceMemoryCampaignStore();
+  const results = await Promise.all(providers.map((provider) => runCampaignDialerProofForProvider({
+    baseUrl: options.baseUrl ?? "http://localhost",
+    from: options.from ?? "+15550009999",
+    provider,
+    store
+  })));
+  return {
+    generatedAt: Date.now(),
+    mode: "dry-run",
+    ok: results.every((result) => result.carrierRequests.length > 0 && result.outcomes.every((outcome) => outcome.applied)),
+    providers: results
+  };
+};
 // src/simulationSuite.ts
 import { Elysia as Elysia20 } from "elysia";
 
@@ -13533,7 +13690,7 @@ var resolveTwilioStreamParameters = async (parameters, input) => {
   }
   return parameters;
 };
-var joinUrlPath = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var joinUrlPath2 = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
 var escapeHtml25 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var getWebhookVerificationUrl = (webhook, input) => {
   if (!webhook?.verificationUrl) {
@@ -13547,8 +13704,8 @@ var getWebhookVerificationUrl = (webhook, input) => {
 var buildTwilioVoiceSetupStatus = async (options, input) => {
   const origin = resolveRequestOrigin(input.request);
   const stream = await resolveTwilioStreamUrl(options, input);
-  const twiml = joinUrlPath(origin, input.twimlPath);
-  const webhook = joinUrlPath(origin, input.webhookPath);
+  const twiml = joinUrlPath2(origin, input.twimlPath);
+  const webhook = joinUrlPath2(origin, input.webhookPath);
   const verificationUrl = getWebhookVerificationUrl(options.webhook, input);
   const missing = Object.entries(options.setup?.requiredEnv ?? {}).filter((entry) => !entry[1]).map(([name]) => name);
   const signingConfigured = Boolean(options.webhook?.signingSecret || options.webhook?.verify);
@@ -14215,7 +14372,7 @@ var createTwilioVoiceRoutes = (options) => {
 // src/telephony/plivo.ts
 var escapeXml3 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var escapeHtml26 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-var joinUrlPath2 = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var joinUrlPath3 = (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");
@@ -14436,8 +14593,8 @@ var verifyVoicePlivoWebhookSignature = async (input) => {
 var buildPlivoVoiceSetupStatus = async (options, input) => {
   const origin = resolveRequestOrigin2(input.request);
   const stream = await resolvePlivoStreamUrl(options, input);
-  const answer = joinUrlPath2(origin, input.answerPath);
-  const webhook = joinUrlPath2(origin, input.webhookPath);
+  const answer = joinUrlPath3(origin, input.answerPath);
+  const webhook = joinUrlPath3(origin, input.webhookPath);
   const missing = Object.entries(options.setup?.requiredEnv ?? {}).filter((entry) => !entry[1]).map(([name]) => name);
   const signingConfigured = Boolean(options.webhook?.authToken || options.webhook?.verify);
   const warnings = [
@@ -14688,7 +14845,7 @@ import { Buffer as Buffer6 } from "buffer";
 import { Elysia as Elysia27 } from "elysia";
 var escapeXml4 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&apos;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 var escapeHtml27 = (value) => value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("'", "&#39;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-var joinUrlPath3 = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
+var joinUrlPath4 = (origin, path) => `${origin.replace(/\/$/, "")}${path.startsWith("/") ? path : `/${path}`}`;
 var resolveRequestOrigin3 = (request) => {
   const url = new URL(request.url);
   const forwardedHost = request.headers.get("x-forwarded-host");
@@ -14860,8 +15017,8 @@ var verifyVoiceTelnyxWebhookSignature = async (input) => {
 var buildTelnyxVoiceSetupStatus = async (options, input) => {
   const origin = resolveRequestOrigin3(input.request);
   const stream = await resolveTelnyxStreamUrl(options, input);
-  const texml = joinUrlPath3(origin, input.texmlPath);
-  const webhook = joinUrlPath3(origin, input.webhookPath);
+  const texml = joinUrlPath4(origin, input.texmlPath);
+  const webhook = joinUrlPath4(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 = [
@@ -19460,6 +19617,7 @@ export {
   runVoiceScenarioEvals,
   runVoiceOutcomeContractSuite,
   runVoiceCampaignProof,
+  runVoiceCampaignDialerProof,
   resolveVoiceTraceRedactionOptions,
   resolveVoiceTelephonyOutcome,
   resolveVoiceSTTRoutingStrategy,
@@ -19519,6 +19677,7 @@ export {
   isVoiceOpsTaskOverdue,
   heartbeatVoiceOpsTask,
   hasVoiceOpsTaskSLABreach,
+  getVoiceCampaignDialerProofStatus,
   filterVoiceTraceEvents,
   failVoiceOpsTask,
   exportVoiceTrace,

package/dist/react/index.d.ts

@@ -7,6 +7,7 @@ export { VoiceTraceTimeline } from './VoiceTraceTimeline';
 export { VoiceTurnLatency } from './VoiceTurnLatency';
 export { VoiceTurnQuality } from './VoiceTurnQuality';
 export { useVoiceAppKitStatus } from './useVoiceAppKitStatus';
+export { useVoiceCampaignDialerProof } from './useVoiceCampaignDialerProof';
 export { useVoiceStream } from './useVoiceStream';
 export { useVoiceController } from './useVoiceController';
 export { useVoiceProviderStatus } from './useVoiceProviderStatus';