@absolutejs/voice 0.0.22-beta.114 → 0.0.22-beta.116

package/dist/campaignDialers.d.ts

@@ -0,0 +1,90 @@
+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';
+};
+type VoiceCampaignDialerMetadata = Record<string, string | number | boolean | undefined> | ((input: VoiceCampaignDialerMetadataInput) => Record<string, string | number | boolean | undefined> | Promise<Record<string, string | number | boolean | undefined>>);
+type VoiceCampaignURLInput = {
+    attempt: VoiceCampaignDialerInput['attempt'];
+    campaign: VoiceCampaignDialerInput['campaign'];
+    recipient: VoiceCampaignDialerInput['recipient'];
+};
+type VoiceCampaignURLResolver = string | ((input: VoiceCampaignURLInput) => string | Promise<string>);
+export type VoiceTwilioCampaignDialerOptions = {
+    accountSid: string;
+    answerMethod?: 'GET' | 'POST';
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authToken: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    machineDetection?: string;
+    metadata?: VoiceCampaignDialerMetadata;
+    statusCallbackEvents?: string[];
+    statusCallbackMethod?: 'GET' | 'POST';
+    statusCallbackUrl?: VoiceCampaignURLResolver;
+};
+export type VoiceTelnyxCampaignDialerOptions = {
+    apiBaseUrl?: string;
+    apiKey: string;
+    clientState?: VoiceCampaignDialerMetadata;
+    connectionId: string;
+    fetch?: VoiceCampaignDialerFetch;
+    from: string;
+    webhookUrl?: VoiceCampaignURLResolver;
+    webhookUrlMethod?: 'GET' | 'POST';
+};
+export type VoicePlivoCampaignDialerOptions = {
+    answerMethod?: 'GET' | 'POST';
+    answerUrl: VoiceCampaignURLResolver;
+    apiBaseUrl?: string;
+    authId: string;
+    authToken: string;
+    callbackMethod?: 'GET' | 'POST';
+    callbackUrl?: VoiceCampaignURLResolver;
+    fetch?: VoiceCampaignDialerFetch;
+    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/index.d.ts

@@ -1,6 +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, getVoiceCampaignDialerProofStatus, runVoiceCampaignDialerProof } from './campaignDialers';
 export { createVoiceAssistant, createVoiceExperiment, summarizeVoiceAssistantRuns } from './assistant';
 export { createVoiceAssistantHealthHTMLHandler, createVoiceAssistantHealthJSONHandler, createVoiceAssistantHealthRoutes, renderVoiceAssistantHealthHTML, summarizeVoiceAssistantHealth } from './assistantHealth';
 export { createVoiceBargeInRoutes, renderVoiceBargeInHTML, summarizeVoiceBargeIn } from './bargeInRoutes';
@@ -55,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

@@ -11256,6 +11256,358 @@ var createVoiceCampaignRoutes = (options) => {
   }
   return app;
 };
+// src/campaignDialers.ts
+import { Buffer as Buffer3 } from "buffer";
+var resolveFetch = (fetcher) => {
+  const activeFetch = fetcher ?? globalThis.fetch;
+  if (!activeFetch) {
+    throw new Error("Campaign dialer requires fetch or globalThis.fetch.");
+  }
+  return activeFetch;
+};
+var resolveURL = async (resolver, input) => {
+  if (!resolver) {
+    return;
+  }
+  return typeof resolver === "function" ? await resolver(input) : resolver;
+};
+var baseCampaignMetadata = (input) => ({
+  attemptId: input.attempt.id,
+  campaignId: input.campaign.id,
+  recipientId: input.recipient.id,
+  voiceCampaignAttemptId: input.attempt.id,
+  voiceCampaignId: input.campaign.id,
+  voiceCampaignRecipientId: input.recipient.id
+});
+var resolveMetadata = async (metadata, input) => ({
+  ...baseCampaignMetadata(input),
+  ...typeof metadata === "function" ? await metadata(input) : metadata
+});
+var appendQuery = (url, params) => {
+  if (!url) {
+    return;
+  }
+  const parsed = new URL(url);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined) {
+      parsed.searchParams.set(key, String(value));
+    }
+  }
+  return parsed.toString();
+};
+var readJson = async (response) => {
+  const text = await response.text();
+  if (!text.trim()) {
+    return {};
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return {
+      text
+    };
+  }
+};
+var assertOk = async (response, provider) => {
+  const body = await readJson(response);
+  if (!response.ok) {
+    throw new Error(`${provider} campaign dialer failed with ${response.status}: ${JSON.stringify(body)}`);
+  }
+  return body;
+};
+var firstString2 = (values) => {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) {
+      return value.trim();
+    }
+  }
+};
+var formBody = (values) => {
+  const body = new URLSearchParams;
+  for (const [key, value] of Object.entries(values)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item !== undefined) {
+          body.append(key, String(item));
+        }
+      }
+      continue;
+    }
+    if (value !== undefined) {
+      body.set(key, String(value));
+    }
+  }
+  return body;
+};
+var createVoiceTwilioCampaignDialer = (options) => async (input) => {
+  const fetcher = resolveFetch(options.fetch);
+  const metadata = await resolveMetadata(options.metadata, {
+    ...input,
+    provider: "twilio"
+  });
+  const answerUrl = appendQuery(await resolveURL(options.answerUrl, input), metadata);
+  const statusCallbackUrl = appendQuery(await resolveURL(options.statusCallbackUrl, input), metadata);
+  const response = await fetcher(`${options.apiBaseUrl ?? "https://api.twilio.com"}/2010-04-01/Accounts/${encodeURIComponent(options.accountSid)}/Calls.json`, {
+    body: formBody({
+      From: options.from,
+      MachineDetection: options.machineDetection,
+      Method: options.answerMethod,
+      StatusCallback: statusCallbackUrl,
+      StatusCallbackEvent: options.statusCallbackEvents,
+      StatusCallbackMethod: options.statusCallbackMethod,
+      To: input.recipient.phone,
+      Url: answerUrl
+    }),
+    headers: {
+      authorization: `Basic ${Buffer3.from(`${options.accountSid}:${options.authToken}`).toString("base64")}`,
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    method: "POST"
+  });
+  const body = await assertOk(response, "Twilio");
+  return {
+    externalCallId: firstString2([body.sid, body.callSid, body.call_sid]),
+    metadata: {
+      provider: "twilio",
+      response: body
+    },
+    status: "running"
+  };
+};
+var createVoiceTelnyxCampaignDialer = (options) => async (input) => {
+  const fetcher = resolveFetch(options.fetch);
+  const metadata = await resolveMetadata(options.clientState, {
+    ...input,
+    provider: "telnyx"
+  });
+  const webhookUrl = appendQuery(await resolveURL(options.webhookUrl, input), metadata);
+  const response = await fetcher(`${options.apiBaseUrl ?? "https://api.telnyx.com"}/v2/calls`, {
+    body: JSON.stringify({
+      client_state: Buffer3.from(JSON.stringify(metadata)).toString("base64"),
+      connection_id: options.connectionId,
+      from: options.from,
+      to: input.recipient.phone,
+      webhook_url: webhookUrl,
+      webhook_url_method: options.webhookUrlMethod
+    }),
+    headers: {
+      authorization: `Bearer ${options.apiKey}`,
+      "content-type": "application/json"
+    },
+    method: "POST"
+  });
+  const body = await assertOk(response, "Telnyx");
+  const data = typeof body.data === "object" && body.data !== null ? body.data : body;
+  return {
+    externalCallId: firstString2([
+      data.call_control_id,
+      data.call_session_id,
+      data.call_leg_id,
+      body.call_control_id,
+      body.call_session_id
+    ]),
+    metadata: {
+      provider: "telnyx",
+      response: body
+    },
+    status: "running"
+  };
+};
+var createVoicePlivoCampaignDialer = (options) => async (input) => {
+  const fetcher = resolveFetch(options.fetch);
+  const metadata = await resolveMetadata(options.metadata, {
+    ...input,
+    provider: "plivo"
+  });
+  const answerUrl = appendQuery(await resolveURL(options.answerUrl, input), metadata);
+  const callbackUrl = appendQuery(await resolveURL(options.callbackUrl, input), metadata);
+  const response = await fetcher(`${options.apiBaseUrl ?? "https://api.plivo.com"}/v1/Account/${encodeURIComponent(options.authId)}/Call/`, {
+    body: formBody({
+      answer_method: options.answerMethod,
+      answer_url: answerUrl,
+      callback_method: options.callbackMethod,
+      callback_url: callbackUrl,
+      from: options.from,
+      to: input.recipient.phone
+    }),
+    headers: {
+      authorization: `Basic ${Buffer3.from(`${options.authId}:${options.authToken}`).toString("base64")}`,
+      "content-type": "application/x-www-form-urlencoded"
+    },
+    method: "POST"
+  });
+  const body = await assertOk(response, "Plivo");
+  return {
+    externalCallId: firstString2([
+      body.request_uuid,
+      body.requestUuid,
+      body.call_uuid,
+      body.callUuid
+    ]),
+    metadata: {
+      provider: "plivo",
+      response: body
+    },
+    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";
 
@@ -12690,7 +13042,7 @@ var createMemoryVoiceTelephonyWebhookIdempotencyStore = () => {
   };
 };
 var normalizeToken = (value) => typeof value === "string" ? value.trim().toLowerCase().replace(/\s+/g, "-").replace(/_+/g, "-") : undefined;
-var firstString2 = (source, keys) => {
+var firstString3 = (source, keys) => {
   for (const key of keys) {
     const value = source[key];
     if (typeof value === "string" && value.trim()) {
@@ -13062,8 +13414,8 @@ var verifyVoiceTelephonyWebhook = async (input) => {
 var durationMsFromSeconds = (value) => typeof value === "number" ? value * 1000 : undefined;
 var parseVoiceTelephonyWebhookEvent = (input) => {
   const payload = flattenPayload(input.body);
-  const provider = firstString2(payload, ["provider", "Provider"]) ?? input.provider;
-  const status = firstString2(payload, [
+  const provider = firstString3(payload, ["provider", "Provider"]) ?? input.provider;
+  const status = firstString3(payload, [
     "CallStatus",
     "call_status",
     "callStatus",
@@ -13088,9 +13440,9 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
     "sip_code",
     "hangupCauseCode"
   ]);
-  const from = firstString2(payload, ["From", "from", "caller_id", "callerId"]);
-  const to = firstString2(payload, ["To", "to", "called_number", "calledNumber"]);
-  const target = firstString2(payload, [
+  const from = firstString3(payload, ["From", "from", "caller_id", "callerId"]);
+  const to = firstString3(payload, ["To", "to", "called_number", "calledNumber"]);
+  const target = firstString3(payload, [
     "transferTarget",
     "TransferTarget",
     "target",
@@ -13098,7 +13450,7 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
     "department"
   ]);
   return {
-    answeredBy: firstString2(payload, [
+    answeredBy: firstString3(payload, [
       "AnsweredBy",
       "answered_by",
       "answeredBy",
@@ -13107,9 +13459,12 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
     ]),
     durationMs,
     from,
-    metadata: payload,
+    metadata: {
+      ...input.query,
+      ...payload
+    },
     provider,
-    reason: firstString2(payload, [
+    reason: firstString3(payload, [
       "Reason",
       "reason",
       "HangupCause",
@@ -13125,7 +13480,7 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
 var defaultSessionId = (input) => {
   const payload = flattenPayload(input.body);
   const metadataSessionId = input.event.metadata?.sessionId;
-  return firstString2(input.query, ["sessionId", "session_id"]) ?? firstString2(payload, [
+  return firstString3(input.query, ["sessionId", "session_id"]) ?? firstString3(payload, [
     "sessionId",
     "session_id",
     "SessionId",
@@ -13140,7 +13495,7 @@ var defaultSessionId = (input) => {
 };
 var defaultIdempotencyKey = (input) => {
   const payload = flattenPayload(input.body);
-  const eventId = firstString2(payload, [
+  const eventId = firstString3(payload, [
     "id",
     "event_id",
     "eventId",
@@ -13301,11 +13656,11 @@ var createVoiceTelephonyWebhookRoutes = (options = {}) => {
 import { Elysia as Elysia28 } from "elysia";
 
 // src/telephony/plivo.ts
-import { Buffer as Buffer4 } from "buffer";
+import { Buffer as Buffer5 } from "buffer";
 import { Elysia as Elysia26 } from "elysia";
 
 // src/telephony/twilio.ts
-import { Buffer as Buffer3 } from "buffer";
+import { Buffer as Buffer4 } from "buffer";
 import { Elysia as Elysia25 } from "elysia";
 var TWILIO_MULAW_SAMPLE_RATE = 8000;
 var VOICE_PCM_SAMPLE_RATE = 16000;
@@ -13335,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) {
@@ -13349,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);
@@ -13596,7 +13951,7 @@ var bytesToInt16Array = (bytes) => {
   return output;
 };
 var decodeTwilioMulawBase64 = (payload) => {
-  const bytes = Uint8Array.from(Buffer3.from(payload, "base64"));
+  const bytes = Uint8Array.from(Buffer4.from(payload, "base64"));
   const samples = new Int16Array(bytes.length);
   for (let index = 0;index < bytes.length; index += 1) {
     samples[index] = decodeMulawSample(bytes[index] ?? 0);
@@ -13608,7 +13963,7 @@ var encodeTwilioMulawBase64 = (samples) => {
   for (let index = 0;index < samples.length; index += 1) {
     bytes[index] = encodeMulawSample(samples[index] ?? 0);
   }
-  return Buffer3.from(bytes).toString("base64");
+  return Buffer4.from(bytes).toString("base64");
 };
 var transcodeTwilioInboundPayloadToPCM16 = (payload) => {
   const narrowband = decodeTwilioMulawBase64(payload);
@@ -13617,7 +13972,7 @@ var transcodeTwilioInboundPayloadToPCM16 = (payload) => {
 };
 var transcodePCMToTwilioOutboundPayload = (chunk, format) => {
   if (format.container === "raw" && format.encoding === "mulaw" && format.channels === 1 && format.sampleRateHz === TWILIO_MULAW_SAMPLE_RATE) {
-    return Buffer3.from(chunk).toString("base64");
+    return Buffer4.from(chunk).toString("base64");
   }
   if (format.encoding !== "pcm_s16le") {
     throw new Error(`Unsupported outbound telephony audio format: ${format.container}/${format.encoding}`);
@@ -13658,7 +14013,7 @@ var createTwilioSocketAdapter = (socket, getState) => ({
       return;
     }
     if (message.type === "audio") {
-      const payload = transcodePCMToTwilioOutboundPayload(Uint8Array.from(Buffer3.from(message.chunkBase64, "base64")), message.format);
+      const payload = transcodePCMToTwilioOutboundPayload(Uint8Array.from(Buffer4.from(message.chunkBase64, "base64")), message.format);
       state.hasOutboundAudioSinceLastInbound = true;
       state.reviewRecorder?.recordTwilioOutbound({
         bytes: payload.length,
@@ -14017,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");
@@ -14184,7 +14539,7 @@ var createPlivoMediaStreamBridge = (socket, options) => {
     }
   };
 };
-var toBase642 = (bytes) => Buffer4.from(new Uint8Array(bytes)).toString("base64");
+var toBase642 = (bytes) => Buffer5.from(new Uint8Array(bytes)).toString("base64");
 var timingSafeEqual2 = (left, right) => {
   const encoder = new TextEncoder;
   const leftBytes = encoder.encode(left);
@@ -14238,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 = [
@@ -14486,11 +14841,11 @@ var createPlivoVoiceRoutes = (options = {}) => {
 };
 
 // src/telephony/telnyx.ts
-import { Buffer as Buffer5 } from "buffer";
+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");
@@ -14636,7 +14991,7 @@ var createTelnyxMediaStreamBridge = (socket, options) => {
     }
   };
 };
-var decodeBase64 = (value) => Uint8Array.from(Buffer5.from(value, "base64"));
+var decodeBase64 = (value) => Uint8Array.from(Buffer6.from(value, "base64"));
 var verifyVoiceTelnyxWebhookSignature = async (input) => {
   if (!input.publicKey) {
     return { ok: false, reason: "missing-secret" };
@@ -14662,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 = [
@@ -19262,6 +19617,7 @@ export {
   runVoiceScenarioEvals,
   runVoiceOutcomeContractSuite,
   runVoiceCampaignProof,
+  runVoiceCampaignDialerProof,
   resolveVoiceTraceRedactionOptions,
   resolveVoiceTelephonyOutcome,
   resolveVoiceSTTRoutingStrategy,
@@ -19321,6 +19677,7 @@ export {
   isVoiceOpsTaskOverdue,
   heartbeatVoiceOpsTask,
   hasVoiceOpsTaskSLABreach,
+  getVoiceCampaignDialerProofStatus,
   filterVoiceTraceEvents,
   failVoiceOpsTask,
   exportVoiceTrace,
@@ -19346,6 +19703,7 @@ export {
   createVoiceWebhookDeliveryWorkerLoop,
   createVoiceWebhookDeliveryWorker,
   createVoiceTwilioRedirectHandoffAdapter,
+  createVoiceTwilioCampaignDialer,
   createVoiceTurnQualityRoutes,
   createVoiceTurnQualityJSONHandler,
   createVoiceTurnQualityHTMLHandler,
@@ -19368,6 +19726,7 @@ export {
   createVoiceToolContractJSONHandler,
   createVoiceToolContractHTMLHandler,
   createVoiceToolContract,
+  createVoiceTelnyxCampaignDialer,
   createVoiceTelephonyWebhookRoutes,
   createVoiceTelephonyWebhookHandler,
   createVoiceTelephonyOutcomePolicy,
@@ -19424,6 +19783,7 @@ export {
   createVoicePostgresIntegrationEventStore,
   createVoicePostgresExternalObjectMapStore,
   createVoicePostgresCampaignStore,
+  createVoicePlivoCampaignDialer,
   createVoicePhoneAgent,
   createVoiceOutcomeContractRoutes,
   createVoiceOutcomeContractJSONHandler,

package/dist/testing/index.js

@@ -8434,7 +8434,10 @@ var parseVoiceTelephonyWebhookEvent = (input) => {
     ]),
     durationMs,
     from,
-    metadata: payload,
+    metadata: {
+      ...input.query,
+      ...payload
+    },
     provider,
     reason: firstString(payload, [
       "Reason",

package/package.json

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