@openclaw/voice-call 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{config-CX9J-053.mjs → config-CsrGuamE.mjs}

@@ -2,13 +2,30 @@ import { TtsConfigSchema } from "../api.js";
 import { t as TWILIO_REGIONS } from "./twilio-region-wBOx-8sz.mjs";
 import { normalizeAgentId, parseAgentSessionKey } from "openclaw/plugin-sdk/routing";
 import { REALTIME_VOICE_AGENT_CONSULT_TOOL_NAME, REALTIME_VOICE_AGENT_CONSULT_TOOL_POLICIES, resolveRealtimeVoiceAgentConsultTools } from "openclaw/plugin-sdk/realtime-voice";
+import { z } from "zod";
 import { mergeDeep } from "openclaw/plugin-sdk/plugin-config-runtime";
 import { buildSecretInputSchema, hasConfiguredSecretInput, normalizeResolvedSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { canonicalizeMainSessionAlias } from "openclaw/plugin-sdk/session-store-runtime";
 import { resolveSpeechProviderApiKey } from "openclaw/plugin-sdk/speech-core";
 import { normalizeWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
-import { z } from "zod";
 import { MAX_TCP_PORT } from "openclaw/plugin-sdk/number-runtime";
+//#region extensions/voice-call/src/call-brief-schema.ts
+const text = (max) => z.string().trim().min(1).max(max);
+const CallBriefSchema = z.object({
+	task: text(2e3).optional(),
+	context: text(4e3).optional(),
+	language: text(100).optional(),
+	identity: z.union([text(500), z.object({
+		introduction: text(500),
+		disclose: z.enum(["volunteer", "when-asked"]).optional()
+	}).strict()]).optional(),
+	disclosures: z.array(text(500)).max(20).optional(),
+	approvals: text(2e3).optional(),
+	voicemailMessage: text(1e3).optional(),
+	successCriteria: text(1e3).optional(),
+	maxDurationSeconds: z.number().int().positive().optional()
+}).strict().refine((brief) => JSON.stringify(brief).length <= 8e3, "Call brief exceeds 8000 characters");
+//#endregion
 //#region extensions/voice-call/src/allowlist.ts
 function normalizePhoneNumber(input) {
 	return input?.replace(/\D/g, "") ?? "";
@@ -19,6 +36,51 @@ function isAllowlistedCaller(normalizedFrom, allowFrom) {
 	return (allowFrom ?? []).some((num) => normalizePhoneNumber(num) === normalizedFrom);
 }
 //#endregion
+//#region extensions/voice-call/src/errand-config.ts
+const CallReportsConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	includeTranscript: z.boolean().default(true),
+	summaryModel: z.string().trim().min(1).optional(),
+	inboundSessionKey: z.string().trim().min(1).optional()
+}).strict().default({
+	enabled: false,
+	includeTranscript: true
+});
+const CallLiveConfigSchema = z.object({
+	transcript: z.boolean().default(false),
+	minIntervalMs: z.number().int().positive().default(5e3)
+}).strict().default({
+	transcript: false,
+	minIntervalMs: 5e3
+});
+const CallCallbacksConfigSchema = z.object({
+	enabled: z.boolean().default(false),
+	windowMinutes: z.number().int().positive().default(60),
+	greeting: z.string().trim().min(1).optional(),
+	brief: CallBriefSchema.optional()
+}).strict().default({
+	enabled: false,
+	windowMinutes: 60
+}).describe("Accept recent outbound recipients as callbacks only when realtime voice is enabled.");
+const DEFAULT_VOICEMAIL_HOLD_OPENING_MAX_MS = 3e4;
+const CallVoicemailConfigSchema = z.object({
+	detection: z.enum(["off", "twilio"]).default("off"),
+	onMachine: z.enum(["leave-message", "hang-up"]).default("leave-message"),
+	holdOpeningMaxMs: z.number().int().positive().default(DEFAULT_VOICEMAIL_HOLD_OPENING_MAX_MS),
+	machineDetectionSpeechThresholdMs: z.number().int().min(1e3).max(6e3).default(6e3),
+	machineDetectionSpeechEndThresholdMs: z.number().int().min(500).max(5e3).default(1200),
+	machineDetectionSilenceTimeoutMs: z.number().int().min(2e3).max(1e4).default(5e3),
+	machineDetectionTimeoutMs: z.number().int().min(3e3).max(59e3).multipleOf(1e3).default(3e4)
+}).strict().default({
+	detection: "off",
+	onMachine: "leave-message",
+	holdOpeningMaxMs: DEFAULT_VOICEMAIL_HOLD_OPENING_MAX_MS,
+	machineDetectionSpeechThresholdMs: 6e3,
+	machineDetectionSpeechEndThresholdMs: 1200,
+	machineDetectionSilenceTimeoutMs: 5e3,
+	machineDetectionTimeoutMs: 3e4
+});
+//#endregion
 //#region extensions/voice-call/src/realtime-call-control.ts
 /** Stable provider-facing tool name for ending the current phone call. */
 const REALTIME_VOICE_END_CALL_TOOL_NAME = "openclaw_end_call";
@@ -103,11 +165,7 @@ const VoiceCallServeConfigSchema = z.object({
 	port: z.number().int().positive().default(3334),
 	bind: z.string().default("127.0.0.1"),
 	path: z.string().min(1).default("/voice/webhook")
-}).strict().default({
-	port: 3334,
-	bind: "127.0.0.1",
-	path: "/voice/webhook"
-});
+}).strict();
 const VoiceCallTunnelConfigSchema = z.object({
 	provider: z.enum([
 		"none",
@@ -121,10 +179,7 @@ const VoiceCallTunnelConfigSchema = z.object({
 	ngrokDomain: z.string().min(1).optional(),
 	/** Trust loopback forwarding for ngrok URL reconstruction; signatures remain mandatory. */
 	allowNgrokFreeTierLoopbackBypass: z.boolean().default(false)
-}).strict().default({
-	provider: "none",
-	allowNgrokFreeTierLoopbackBypass: false
-});
+}).strict();
 const VoiceCallWebhookSecurityConfigSchema = z.object({
 	/** Only these hosts are accepted from forwarding headers. */
 	allowedHosts: z.array(z.string().min(1)).default([]),
@@ -138,11 +193,7 @@ const VoiceCallWebhookSecurityConfigSchema = z.object({
 	* the remote IP matches one of these addresses.
 	*/
 	trustedProxyIPs: z.array(z.string().min(1)).default([])
-}).strict().default({
-	allowedHosts: [],
-	trustForwardingHeaders: false,
-	trustedProxyIPs: []
-});
+}).strict();
 const CallModeSchema = z.enum(["notify", "conversation"]);
 const VoiceCallSessionScopeSchema = z.enum([
 	"per-phone",
@@ -153,10 +204,7 @@ const OutboundConfigSchema = z.object({
 	defaultMode: CallModeSchema.default("notify"),
 	/** Seconds to wait after TTS before auto-hangup in notify mode */
 	notifyHangupDelaySec: z.number().int().nonnegative().default(3)
-}).strict().default({
-	defaultMode: "notify",
-	notifyHangupDelaySec: 3
-});
+}).strict();
 const RealtimeToolSchema = z.object({
 	type: z.literal("function"),
 	name: z.string().min(1),
@@ -186,13 +234,7 @@ const VoiceCallRealtimeFastContextConfigSchema = z.object({
 	sources: z.array(VoiceCallRealtimeFastContextSourceSchema).min(1).default(["memory", "sessions"]),
 	/** Fall back to the full agent consult when fast context has no answer. */
 	fallbackToConsult: z.boolean().default(false)
-}).strict().default({
-	enabled: false,
-	timeoutMs: 800,
-	maxResults: 3,
-	sources: ["memory", "sessions"],
-	fallbackToConsult: false
-});
+}).strict();
 const VoiceCallRealtimeAgentContextConfigSchema = z.object({
 	/** Include configured identity and selected profile files alongside the always-on agent context. */
 	enabled: z.boolean().default(false),
@@ -207,17 +249,7 @@ const VoiceCallRealtimeAgentContextConfigSchema = z.object({
 		"IDENTITY.md",
 		"USER.md"
 	])
-}).strict().default({
-	enabled: false,
-	maxChars: 6e3,
-	includeIdentity: true,
-	includeWorkspaceFiles: true,
-	files: [
-		"SOUL.md",
-		"IDENTITY.md",
-		"USER.md"
-	]
-});
+}).strict();
 const VoiceCallRealtimeConsultThinkingLevelSchema = z.enum([
 	"off",
 	"minimal",
@@ -235,6 +267,8 @@ const VoiceCallRealtimeConfigSchema = z.object({
 	provider: z.string().min(1).optional(),
 	/** Optional override for the local WebSocket route path. */
 	streamPath: z.string().min(1).optional(),
+	/** End an active realtime call after this much speech inactivity. */
+	idleHangupMs: z.number().int().positive().optional(),
 	/** System instructions passed to the realtime provider. */
 	instructions: z.string().default(DEFAULT_VOICE_CALL_REALTIME_INSTRUCTIONS),
 	/** Tool policy for the shared OpenClaw agent consult tool. */
@@ -247,9 +281,9 @@ const VoiceCallRealtimeConfigSchema = z.object({
 	consultFastMode: z.boolean().optional(),
 	tools: z.array(RealtimeToolSchema).default([]),
 	/** Low-latency memory/session context for the consult tool. */
-	fastContext: VoiceCallRealtimeFastContextConfigSchema,
+	fastContext: VoiceCallRealtimeFastContextConfigSchema.default(VoiceCallRealtimeFastContextConfigSchema.parse({})),
 	/** Bounded agent persona/context injection for the fast realtime voice path. */
-	agentContext: VoiceCallRealtimeAgentContextConfigSchema,
+	agentContext: VoiceCallRealtimeAgentContextConfigSchema.default(VoiceCallRealtimeAgentContextConfigSchema.parse({})),
 	/** Provider-owned raw config blobs keyed by provider id. */
 	providers: VoiceCallProvidersConfigSchema
 }).strict().default({
@@ -281,15 +315,7 @@ const VoiceCallStreamingConfigSchema = z.object({
 	maxPendingConnectionsPerIp: z.number().int().positive().default(4),
 	/** Hard cap for all open media stream sockets (pending + active). */
 	maxConnections: z.number().int().positive().default(128)
-}).strict().default({
-	enabled: false,
-	streamPath: "/voice/stream",
-	providers: {},
-	preStartTimeoutMs: 5e3,
-	maxPendingConnections: 32,
-	maxPendingConnectionsPerIp: 4,
-	maxConnections: 128
-});
+}).strict();
 const VoiceCallConfigSchema = z.object({
 	enabled: z.boolean().default(false),
 	provider: z.enum([
@@ -309,7 +335,12 @@ const VoiceCallConfigSchema = z.object({
 	inboundGreeting: z.string().optional(),
 	/** Per-dialed-number overrides for inbound calls. Keys are E.164 numbers. */
 	numbers: z.record(E164Schema, VoiceCallNumberRouteConfigSchema).default({}),
-	outbound: OutboundConfigSchema,
+	outbound: OutboundConfigSchema.default(OutboundConfigSchema.parse({})),
+	reports: CallReportsConfigSchema,
+	live: CallLiveConfigSchema,
+	callbacks: CallCallbacksConfigSchema,
+	voicemail: CallVoicemailConfigSchema,
+	/** Maximum call duration in seconds */
 	maxDurationSeconds: z.number().int().positive().default(300),
 	/**
 	* Maximum age of a call in seconds before it is automatically reaped.
@@ -322,12 +353,12 @@ const VoiceCallConfigSchema = z.object({
 	transcriptTimeoutMs: z.number().int().positive().default(18e4),
 	ringTimeoutMs: z.number().int().positive().default(3e4),
 	maxConcurrentCalls: z.number().int().positive().default(1),
-	serve: VoiceCallServeConfigSchema,
+	serve: VoiceCallServeConfigSchema.default(VoiceCallServeConfigSchema.parse({})),
 	/** @deprecated Prefer tunnel config. */
 	tailscale: VoiceCallTailscaleConfigSchema,
-	tunnel: VoiceCallTunnelConfigSchema,
-	webhookSecurity: VoiceCallWebhookSecurityConfigSchema,
-	streaming: VoiceCallStreamingConfigSchema,
+	tunnel: VoiceCallTunnelConfigSchema.default(VoiceCallTunnelConfigSchema.parse({})),
+	webhookSecurity: VoiceCallWebhookSecurityConfigSchema.default(VoiceCallWebhookSecurityConfigSchema.parse({})),
+	streaming: VoiceCallStreamingConfigSchema.default(VoiceCallStreamingConfigSchema.parse({})),
 	realtime: VoiceCallRealtimeConfigSchema,
 	/** Session memory scope for voice conversations. */
 	sessionScope: VoiceCallSessionScopeSchema.default("per-phone"),
@@ -386,7 +417,6 @@ function normalizeVoiceCallTtsConfig(defaults, overrides) {
 }
 function resolveVoiceCallNumberRouteKey(config, phone) {
 	const routes = config.numbers;
-	if (!routes) return;
 	if (phone && Object.hasOwn(routes, phone)) return phone;
 	const normalizedPhone = normalizePhoneNumber(phone);
 	if (!normalizedPhone) return;
@@ -409,18 +439,15 @@ function resolveVoiceCallEffectiveConfig(config, phoneOrRouteKey) {
 		config: {
 			...config,
 			...route,
-			tts: normalizeVoiceCallTtsConfig(config.tts, route.tts),
-			numbers: config.numbers
+			tts: normalizeVoiceCallTtsConfig(config.tts, route.tts)
 		}
 	};
 }
 function sanitizeVoiceCallProviderConfigs(value) {
-	if (!value) return {};
-	return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0));
+	return Object.fromEntries(Object.entries(value ?? {}).filter((entry) => entry[1] !== void 0));
 }
 function sanitizeVoiceCallNumberRoutes(value) {
-	if (!value) return {};
-	return Object.fromEntries(Object.entries(value).filter((entry) => entry[1] !== void 0).map(([key, route]) => [key, VoiceCallNumberRouteConfigSchema.parse(route)]));
+	return Object.fromEntries(Object.entries(value ?? {}).filter(([, route]) => route !== void 0).map(([key, route]) => [key, VoiceCallNumberRouteConfigSchema.parse(route)]));
 }
 function resolveTwilioAuthToken(config) {
 	return normalizeResolvedSecretInputString({
@@ -457,6 +484,10 @@ function normalizeVoiceCallConfig(config) {
 			...defaults.outbound,
 			...config.outbound
 		},
+		reports: CallReportsConfigSchema.parse(config.reports),
+		live: CallLiveConfigSchema.parse(config.live),
+		callbacks: CallCallbacksConfigSchema.parse(config.callbacks),
+		voicemail: CallVoicemailConfigSchema.parse(config.voicemail),
 		serve,
 		tailscale: {
 			...defaults.tailscale,
@@ -495,14 +526,9 @@ function normalizeVoiceCallConfig(config) {
 }
 function resolveVoiceCallSessionKey(params) {
 	const explicit = params.explicitSessionKey?.trim();
-	if (explicit) return resolveVoiceCallAgentSessionKey({
-		config: params.config,
-		sessionKey: explicit,
-		coreSession: params.coreSession
-	});
-	if (params.config.sessionScope === "main") return resolveVoiceCallAgentSessionKey({
+	if (explicit || params.config.sessionScope === "main") return resolveVoiceCallAgentSessionKey({
 		config: params.config,
-		sessionKey: "main",
+		sessionKey: explicit || "main",
 		coreSession: params.coreSession
 	});
 	const prefix = `agent:${normalizeAgentId(params.config.agentId)}:voice`;
@@ -554,7 +580,7 @@ function resolveVoiceCallConfig(config) {
 	resolved.tunnel.ngrokAuthToken = resolved.tunnel.ngrokAuthToken ?? resolveSpeechProviderApiKey(process.env.NGROK_AUTHTOKEN);
 	resolved.tunnel.ngrokDomain = resolved.tunnel.ngrokDomain ?? resolveSpeechProviderApiKey(process.env.NGROK_DOMAIN);
 	resolved.webhookSecurity.trustForwardingHeaders = resolved.webhookSecurity.trustForwardingHeaders ?? false;
-	return normalizeVoiceCallConfig(resolved);
+	return resolved;
 }
 function validateProviderConfig(config) {
 	const errors = [];
@@ -590,4 +616,4 @@ function validateProviderConfig(config) {
 	};
 }
 //#endregion
-export { resolveVoiceCallEffectiveConfig as a, resolveVoiceCallSessionKey as c, REALTIME_VOICE_END_CALL_TOOL_NAME as d, resolveVoiceCallRealtimeTools as f, resolveVoiceCallConfig as i, resolveVoiceCallStreamExposurePaths as l, normalizePhoneNumber as m, normalizeVoiceCallConfig as n, resolveVoiceCallNumberRouteKeyForCall as o, isAllowlistedCaller as p, resolveTwilioAuthToken as r, resolveVoiceCallPublicPathPrefix as s, VoiceCallConfigSchema as t, validateProviderConfig as u };
+export { resolveVoiceCallEffectiveConfig as a, resolveVoiceCallSessionKey as c, REALTIME_VOICE_END_CALL_TOOL_NAME as d, resolveVoiceCallRealtimeTools as f, CallBriefSchema as g, normalizePhoneNumber as h, resolveVoiceCallConfig as i, resolveVoiceCallStreamExposurePaths as l, isAllowlistedCaller as m, normalizeVoiceCallConfig as n, resolveVoiceCallNumberRouteKeyForCall as o, DEFAULT_VOICEMAIL_HOLD_OPENING_MAX_MS as p, resolveTwilioAuthToken as r, resolveVoiceCallPublicPathPrefix as s, VoiceCallConfigSchema as t, validateProviderConfig as u };

package/dist/.setup/{mock-eLv_Dc4o.mjs → mock-rySvj-G6.mjs}

@@ -43,12 +43,15 @@ var MockProvider = class {
 		}
 	}
 	normalizeEvent(evt) {
-		if (!evt.type || !evt.callId) return null;
+		if (!evt.type || typeof evt.callId !== "string" || !evt.callId) return null;
 		const base = {
 			id: evt.id ?? crypto.randomUUID(),
 			callId: evt.callId,
-			providerCallId: evt.providerCallId,
-			timestamp: evt.timestamp ?? Date.now()
+			providerCallId: typeof evt.providerCallId === "string" ? evt.providerCallId : void 0,
+			timestamp: evt.timestamp ?? Date.now(),
+			direction: evt.direction === "inbound" || evt.direction === "outbound" ? evt.direction : void 0,
+			from: typeof evt.from === "string" ? evt.from : void 0,
+			to: typeof evt.to === "string" ? evt.to : void 0
 		};
 		switch (evt.type) {
 			case "call.initiated":
@@ -58,6 +61,11 @@ var MockProvider = class {
 				...base,
 				type: evt.type
 			};
+			case "call.amd": return evt.answeredBy ? {
+				...base,
+				type: evt.type,
+				answeredBy: evt.answeredBy
+			} : null;
 			case "call.speaking": return {
 				...base,
 				type: evt.type,
@@ -111,6 +119,7 @@ var MockProvider = class {
 	}
 	async hangupCall(_input) {}
 	async playTts(_input) {}
+	async playMessageAndHangup(_input) {}
 	async sendDtmf(_input) {}
 	async startListening(_input) {}
 	async stopListening(_input) {}

package/dist/.setup/{plivo-CpPIENu4.mjs → plivo-COfD-Kuc.mjs}

@@ -1,6 +1,6 @@
-import { s as getHeader } from "./runtime-entry-CbSKxSKk.mjs";
-import { t as escapeXml } from "./voice-mapping-B_iAUkER.mjs";
-import { i as verifyPlivoWebhook, n as readProviderCallStatus, r as reconstructWebhookUrl, t as guardedJsonApiRequest } from "./guarded-json-api-x55yqHvW.mjs";
+import { c as getHeader } from "./runtime-entry-STjFmi_B.mjs";
+import { t as escapeXml } from "./voice-mapping-1lzFmzOF.mjs";
+import { n as reconstructWebhookUrl, r as verifyPlivoWebhook, t as createCarrierApi } from "./carrier-api-BYKw_fsQ.mjs";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import crypto from "node:crypto";
 //#region extensions/voice-call/src/providers/plivo.ts
@@ -40,27 +40,9 @@ var PlivoProvider = class PlivoProvider {
 		this.pendingListenByCallId = /* @__PURE__ */ new Map();
 		if (!config.authId) throw new Error("Plivo Auth ID is required");
 		if (!config.authToken) throw new Error("Plivo Auth Token is required");
-		this.authId = config.authId;
 		this.authToken = config.authToken;
-		this.baseUrl = `https://api.plivo.com/v1/Account/${this.authId}`;
-		this.apiHost = new URL(this.baseUrl).hostname;
 		this.options = options;
-	}
-	async apiRequest(params) {
-		const { method, endpoint, body, allowNotFound } = params;
-		return await guardedJsonApiRequest({
-			url: `${this.baseUrl}${endpoint}`,
-			method,
-			headers: {
-				Authorization: `Basic ${Buffer.from(`${this.authId}:${this.authToken}`).toString("base64")}`,
-				"Content-Type": "application/json"
-			},
-			body,
-			allowNotFound,
-			allowedHostnames: [this.apiHost],
-			auditContext: "voice-call.plivo.api",
-			errorPrefix: "Plivo API error"
-		});
+		this.api = createCarrierApi("Plivo", `https://api.plivo.com/v1/Account/${config.authId}`, `Basic ${Buffer.from(`${config.authId}:${config.authToken}`).toString("base64")}`);
 	}
 	verifyWebhook(ctx) {
 		const result = verifyPlivoWebhook(ctx, this.authToken, {
@@ -91,27 +73,22 @@ var PlivoProvider = class PlivoProvider {
 		const callId = normalizeOptionalString(ctx.query?.callId);
 		let event = null;
 		let providerResponseBody;
-		if (flow === "xml-speak") {
-			const pending = callId ? this.pendingSpeakByCallId.get(callId) : void 0;
-			if (callId) this.pendingSpeakByCallId.delete(callId);
-			const actionUrl = pending?.listenAfterPlayback && callId ? this.buildActionUrl(ctx, callId) : null;
-			providerResponseBody = pending ? actionUrl ? PlivoProvider.xmlGetInputSpeech({
-				text: pending.text,
-				language: pending.locale,
-				actionUrl
-			}) : PlivoProvider.xmlSpeak(pending.text, pending.locale) : PlivoProvider.xmlKeepAlive();
-		} else if (flow === "xml-listen") {
-			const pending = callId ? this.pendingListenByCallId.get(callId) : void 0;
-			if (callId) this.pendingListenByCallId.delete(callId);
-			const actionUrl = this.buildActionUrl(ctx, callId);
+		if (flow === "xml-speak" || flow === "xml-listen") {
+			const speaks = flow === "xml-speak";
+			const pendingSpeak = speaks && callId ? this.pendingSpeakByCallId.get(callId) : void 0;
+			const pendingListen = !speaks && callId ? this.pendingListenByCallId.get(callId) : void 0;
+			const language = speaks ? pendingSpeak?.locale : pendingListen?.language;
+			if (callId) (speaks ? this.pendingSpeakByCallId : this.pendingListenByCallId).delete(callId);
+			const actionUrl = !speaks || pendingSpeak?.listenAfterPlayback && callId ? this.buildActionUrl(ctx, callId) : null;
 			providerResponseBody = actionUrl && callId ? PlivoProvider.xmlGetInputSpeech({
-				actionUrl,
-				language: pending?.language
-			}) : PlivoProvider.xmlKeepAlive();
+				text: pendingSpeak?.text,
+				language,
+				actionUrl
+			}) : pendingSpeak ? PlivoProvider.xmlKeepAlive(`  <Speak language="${escapeXml(language || "en-US")}">${escapeXml(pendingSpeak.text)}</Speak>\n`) : PlivoProvider.xmlKeepAlive();
 		} else {
 			const dedupeKey = options?.verifiedRequestKey ?? createPlivoRequestDedupeKey(ctx);
 			event = this.normalizeEvent(parsed, callId, dedupeKey);
-			providerResponseBody = flow === "answer" || flow === "getinput" ? PlivoProvider.xmlKeepAlive() : PlivoProvider.xmlEmpty();
+			providerResponseBody = flow === "answer" || flow === "getinput" ? PlivoProvider.xmlKeepAlive() : "<?xml version=\"1.0\" encoding=\"UTF-8\"?><Response></Response>";
 		}
 		return {
 			events: event ? [event] : [],
@@ -185,18 +162,14 @@ var PlivoProvider = class PlivoProvider {
 		const hangupUrl = new URL(webhookUrl);
 		hangupUrl.searchParams.set("flow", "hangup");
 		this.callIdToWebhookUrl.set(input.callId, input.webhookUrl);
-		const result = await this.apiRequest({
-			method: "POST",
-			endpoint: "/Call/",
-			body: {
-				from: PlivoProvider.normalizeNumber(input.from),
-				to: PlivoProvider.normalizeNumber(input.to),
-				answer_url: answerUrl.toString(),
-				answer_method: "POST",
-				hangup_url: hangupUrl.toString(),
-				hangup_method: "POST",
-				hangup_on_ring: this.options.ringTimeoutSec ?? 30
-			}
+		const result = await this.api.request("/Call/", {
+			from: PlivoProvider.normalizeNumber(input.from),
+			to: PlivoProvider.normalizeNumber(input.to),
+			answer_url: answerUrl.toString(),
+			answer_method: "POST",
+			hangup_url: hangupUrl.toString(),
+			hangup_method: "POST",
+			hangup_on_ring: this.options.ringTimeoutSec ?? 30
 		});
 		const requestUuid = Array.isArray(result.request_uuid) ? result.request_uuid[0] : result.request_uuid;
 		if (!requestUuid) throw new Error("Plivo call create returned no request_uuid");
@@ -207,14 +180,12 @@ var PlivoProvider = class PlivoProvider {
 	}
 	async hangupCall(input) {
 		const callUuid = this.requestUuidToCallUuid.get(input.providerCallId);
-		await this.apiRequest({
+		await this.api.request(`/Call/${callUuid || input.providerCallId}/`, void 0, {
 			method: "DELETE",
-			endpoint: `/Call/${callUuid || input.providerCallId}/`,
 			allowNotFound: true
 		});
-		if (!callUuid) await this.apiRequest({
+		if (!callUuid) await this.api.request(`/Request/${input.providerCallId}/`, void 0, {
 			method: "DELETE",
-			endpoint: `/Request/${input.providerCallId}/`,
 			allowNotFound: true
 		});
 		this.releaseCallState({
@@ -239,14 +210,10 @@ var PlivoProvider = class PlivoProvider {
 		transferUrl.searchParams.set("provider", "plivo");
 		transferUrl.searchParams.set("flow", params.flow);
 		transferUrl.searchParams.set("callId", params.callId);
-		await this.apiRequest({
-			method: "POST",
-			endpoint: `/Call/${params.callUuid}/`,
-			body: {
-				legs: "aleg",
-				aleg_url: transferUrl.toString(),
-				aleg_method: "POST"
-			}
+		await this.api.request(`/Call/${params.callUuid}/`, {
+			legs: "aleg",
+			aleg_url: transferUrl.toString(),
+			aleg_method: "POST"
 		});
 	}
 	async playTts(input) {
@@ -281,15 +248,7 @@ var PlivoProvider = class PlivoProvider {
 			"machine",
 			"hangup"
 		]);
-		return readProviderCallStatus(() => guardedJsonApiRequest({
-			url: `${this.baseUrl}/Call/${input.providerCallId}/`,
-			method: "GET",
-			headers: { Authorization: `Basic ${Buffer.from(`${this.authId}:${this.authToken}`).toString("base64")}` },
-			allowNotFound: true,
-			allowedHostnames: [this.apiHost],
-			auditContext: "plivo-get-call-status",
-			errorPrefix: "Plivo get call status error"
-		}), (data) => {
+		return this.api.getCallStatus(`/Call/${input.providerCallId}/`, (data) => {
 			const status = data.call_status ?? "unknown";
 			return {
 				status,
@@ -302,31 +261,18 @@ var PlivoProvider = class PlivoProvider {
 		if (normalizeLowercaseStringOrEmpty(trimmed).startsWith("sip:")) return trimmed;
 		return trimmed.replace(/[^\d+]/g, "");
 	}
-	static xmlEmpty() {
-		return `<?xml version="1.0" encoding="UTF-8"?><Response></Response>`;
-	}
-	static xmlKeepAlive() {
-		return `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Wait length="300" />
-</Response>`;
-	}
-	static xmlSpeak(text, locale) {
+	static xmlKeepAlive(content = "") {
 		return `<?xml version="1.0" encoding="UTF-8"?>
 <Response>
-  <Speak language="${escapeXml(locale || "en-US")}">${escapeXml(text)}</Speak>
-  <Wait length="300" />
+${content}  <Wait length="300" />
 </Response>`;
 	}
 	static xmlGetInputSpeech(params) {
 		const language = params.language || "en-US";
 		const prompt = params.text === void 0 ? "" : `    <Speak language="${escapeXml(language)}">${escapeXml(params.text)}</Speak>\n`;
-		return `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <GetInput inputType="speech" method="POST" action="${escapeXml(params.actionUrl)}" language="${escapeXml(language)}" executionTimeout="30" speechEndTimeout="2" redirect="false">
+		return PlivoProvider.xmlKeepAlive(`  <GetInput inputType="speech" method="POST" action="${escapeXml(params.actionUrl)}" language="${escapeXml(language)}" executionTimeout="30" speechEndTimeout="2" redirect="false">
 ${prompt}  </GetInput>
-  <Wait length="300" />
-</Response>`;
+`);
 	}
 	buildActionUrl(ctx, callId) {
 		const base = this.baseWebhookUrlFromCtx(ctx);