@openclaw/voice-call 2026.1.29 → 2026.2.1

package/src/providers/twilio.ts

@@ -1,7 +1,7 @@
 import crypto from "node:crypto";
-
 import type { TwilioConfig } from "../config.js";
 import type { MediaStreamHandler } from "../media-stream.js";
+import type { TelephonyTtsProvider } from "../telephony-tts.js";
 import type {
   HangupCallInput,
   InitiateCallInput,
@@ -14,10 +14,9 @@ import type {
   WebhookContext,
   WebhookVerificationResult,
 } from "../types.js";
-import { escapeXml, mapVoiceToPolly } from "../voice-mapping.js";
-import { chunkAudio } from "../telephony-audio.js";
-import type { TelephonyTtsProvider } from "../telephony-tts.js";
 import type { VoiceCallProvider } from "./base.js";
+import { chunkAudio } from "../telephony-audio.js";
+import { escapeXml, mapVoiceToPolly } from "../voice-mapping.js";
 import { twilioApiRequest } from "./twilio/api.js";
 import { verifyTwilioProviderWebhook } from "./twilio/webhook.js";
 
@@ -85,10 +84,14 @@ export class TwilioProvider implements VoiceCallProvider {
    */
   private deleteStoredTwimlForProviderCall(providerCallId: string): void {
     const webhookUrl = this.callWebhookUrls.get(providerCallId);
-    if (!webhookUrl) return;
+    if (!webhookUrl) {
+      return;
+    }
 
     const callIdMatch = webhookUrl.match(/callId=([^&]+)/);
-    if (!callIdMatch) return;
+    if (!callIdMatch) {
+      return;
+    }
 
     this.deleteStoredTwiml(callIdMatch[1]);
   }
@@ -211,22 +214,20 @@ export class TwilioProvider implements VoiceCallProvider {
   /**
    * Parse Twilio direction to normalized format.
    */
-  private static parseDirection(
-    direction: string | null,
-  ): "inbound" | "outbound" | undefined {
-    if (direction === "inbound") return "inbound";
-    if (direction === "outbound-api" || direction === "outbound-dial")
+  private static parseDirection(direction: string | null): "inbound" | "outbound" | undefined {
+    if (direction === "inbound") {
+      return "inbound";
+    }
+    if (direction === "outbound-api" || direction === "outbound-dial") {
       return "outbound";
+    }
     return undefined;
   }
 
   /**
    * Convert Twilio webhook params to normalized event format.
    */
-  private normalizeEvent(
-    params: URLSearchParams,
-    callIdOverride?: string,
-  ): NormalizedEvent | null {
+  private normalizeEvent(params: URLSearchParams, callIdOverride?: string): NormalizedEvent | null {
     const callSid = params.get("CallSid") || "";
 
     const baseEvent = {
@@ -297,11 +298,12 @@ export class TwilioProvider implements VoiceCallProvider {
    * When a call is answered, connects to media stream for bidirectional audio.
    */
   private generateTwimlResponse(ctx?: WebhookContext): string {
-    if (!ctx) return TwilioProvider.EMPTY_TWIML;
+    if (!ctx) {
+      return TwilioProvider.EMPTY_TWIML;
+    }
 
     const params = new URLSearchParams(ctx.rawBody);
-    const type =
-      typeof ctx.query?.type === "string" ? ctx.query.type.trim() : undefined;
+    const type = typeof ctx.query?.type === "string" ? ctx.query.type.trim() : undefined;
     const isStatusCallback = type === "status";
     const callStatus = params.get("CallStatus");
     const direction = params.get("Direction");
@@ -329,9 +331,7 @@ export class TwilioProvider implements VoiceCallProvider {
       // Conversation mode: return streaming TwiML immediately for outbound calls.
       if (isOutbound) {
         const streamUrl = this.getStreamUrl();
-        return streamUrl
-          ? this.getStreamConnectXml(streamUrl)
-          : TwilioProvider.PAUSE_TWIML;
+        return streamUrl ? this.getStreamConnectXml(streamUrl) : TwilioProvider.PAUSE_TWIML;
       }
     }
 
@@ -344,9 +344,7 @@ export class TwilioProvider implements VoiceCallProvider {
     // For inbound calls, answer immediately with stream
     if (direction === "inbound") {
       const streamUrl = this.getStreamUrl();
-      return streamUrl
-        ? this.getStreamConnectXml(streamUrl)
-        : TwilioProvider.PAUSE_TWIML;
+      return streamUrl ? this.getStreamConnectXml(streamUrl) : TwilioProvider.PAUSE_TWIML;
     }
 
     // For outbound calls, only connect to stream when call is in-progress
@@ -355,9 +353,7 @@ export class TwilioProvider implements VoiceCallProvider {
     }
 
     const streamUrl = this.getStreamUrl();
-    return streamUrl
-      ? this.getStreamConnectXml(streamUrl)
-      : TwilioProvider.PAUSE_TWIML;
+    return streamUrl ? this.getStreamConnectXml(streamUrl) : TwilioProvider.PAUSE_TWIML;
   }
 
   /**
@@ -374,9 +370,7 @@ export class TwilioProvider implements VoiceCallProvider {
     const origin = url.origin;
 
     // Convert https:// to wss:// for WebSocket
-    const wsOrigin = origin
-      .replace(/^https:\/\//, "wss://")
-      .replace(/^http:\/\//, "ws://");
+    const wsOrigin = origin.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
 
     // Append the stream path
     const path = this.options.streamPath.startsWith("/")
@@ -433,10 +427,7 @@ export class TwilioProvider implements VoiceCallProvider {
       Timeout: "30",
     };
 
-    const result = await this.apiRequest<TwilioCallResponse>(
-      "/Calls.json",
-      params,
-    );
+    const result = await this.apiRequest<TwilioCallResponse>("/Calls.json", params);
 
     this.callWebhookUrls.set(result.sid, url.toString());
 
@@ -489,9 +480,7 @@ export class TwilioProvider implements VoiceCallProvider {
     // Fall back to TwiML <Say> (may not work on all accounts)
     const webhookUrl = this.callWebhookUrls.get(input.providerCallId);
     if (!webhookUrl) {
-      throw new Error(
-        "Missing webhook URL for this call (provider state not initialized)",
-      );
+      throw new Error("Missing webhook URL for this call (provider state not initialized)");
     }
 
     console.warn(
@@ -517,10 +506,7 @@ export class TwilioProvider implements VoiceCallProvider {
    * Generates audio with core TTS, converts to mu-law, and streams via WebSocket.
    * Uses a queue to serialize playback and prevent overlapping audio.
    */
-  private async playTtsViaStream(
-    text: string,
-    streamSid: string,
-  ): Promise<void> {
+  private async playTtsViaStream(text: string, streamSid: string): Promise<void> {
     if (!this.ttsProvider || !this.mediaStreamHandler) {
       throw new Error("TTS provider and media stream handler required");
     }
@@ -535,12 +521,16 @@ export class TwilioProvider implements VoiceCallProvider {
       // Generate audio with core TTS (returns mu-law at 8kHz)
       const muLawAudio = await ttsProvider.synthesizeForTelephony(text);
       for (const chunk of chunkAudio(muLawAudio, CHUNK_SIZE)) {
-        if (signal.aborted) break;
+        if (signal.aborted) {
+          break;
+        }
         handler.sendAudio(streamSid, chunk);
 
         // Pace the audio to match real-time playback
         await new Promise((resolve) => setTimeout(resolve, CHUNK_DELAY_MS));
-        if (signal.aborted) break;
+        if (signal.aborted) {
+          break;
+        }
       }
 
       if (!signal.aborted) {
@@ -556,9 +546,7 @@ export class TwilioProvider implements VoiceCallProvider {
   async startListening(input: StartListeningInput): Promise<void> {
     const webhookUrl = this.callWebhookUrls.get(input.providerCallId);
     if (!webhookUrl) {
-      throw new Error(
-        "Missing webhook URL for this call (provider state not initialized)",
-      );
+      throw new Error("Missing webhook URL for this call (provider state not initialized)");
     }
 
     const twiml = `<?xml version="1.0" encoding="UTF-8"?>

package/src/response-generator.ts

@@ -4,10 +4,8 @@
  */
 
 import crypto from "node:crypto";
-
-import { loadCoreAgentDeps, type CoreConfig } from "./core-bridge.js";
-
 import type { VoiceCallConfig } from "./config.js";
+import { loadCoreAgentDeps, type CoreConfig } from "./core-bridge.js";
 
 export type VoiceResponseParams = {
   /** Voice call config */
@@ -41,8 +39,7 @@ type SessionEntry = {
 export async function generateVoiceResponse(
   params: VoiceResponseParams,
 ): Promise<VoiceResponseResult> {
-  const { voiceConfig, callId, from, transcript, userMessage, coreConfig } =
-    params;
+  const { voiceConfig, callId, from, transcript, userMessage, coreConfig } = params;
 
   if (!coreConfig) {
     return { text: null, error: "Core config unavailable for voice response" };
@@ -54,10 +51,7 @@ export async function generateVoiceResponse(
   } catch (err) {
     return {
       text: null,
-      error:
-        err instanceof Error
-          ? err.message
-          : "Unable to load core agent dependencies",
+      error: err instanceof Error ? err.message : "Unable to load core agent dependencies",
     };
   }
   const cfg = coreConfig;
@@ -95,12 +89,9 @@ export async function generateVoiceResponse(
   });
 
   // Resolve model from config
-  const modelRef =
-    voiceConfig.responseModel ||
-    `${deps.DEFAULT_PROVIDER}/${deps.DEFAULT_MODEL}`;
+  const modelRef = voiceConfig.responseModel || `${deps.DEFAULT_PROVIDER}/${deps.DEFAULT_MODEL}`;
   const slashIndex = modelRef.indexOf("/");
-  const provider =
-    slashIndex === -1 ? deps.DEFAULT_PROVIDER : modelRef.slice(0, slashIndex);
+  const provider = slashIndex === -1 ? deps.DEFAULT_PROVIDER : modelRef.slice(0, slashIndex);
   const model = slashIndex === -1 ? modelRef : modelRef.slice(slashIndex + 1);
 
   // Resolve thinking level
@@ -118,17 +109,13 @@ export async function generateVoiceResponse(
   let extraSystemPrompt = basePrompt;
   if (transcript.length > 0) {
     const history = transcript
-      .map(
-        (entry) =>
-          `${entry.speaker === "bot" ? "You" : "Caller"}: ${entry.text}`,
-      )
+      .map((entry) => `${entry.speaker === "bot" ? "You" : "Caller"}: ${entry.text}`)
       .join("\n");
     extraSystemPrompt = `${basePrompt}\n\nConversation so far:\n${history}`;
   }
 
   // Resolve timeout
-  const timeoutMs =
-    voiceConfig.responseTimeoutMs ?? deps.resolveAgentTimeoutMs({ cfg });
+  const timeoutMs = voiceConfig.responseTimeoutMs ?? deps.resolveAgentTimeoutMs({ cfg });
   const runId = `voice:${callId}:${Date.now()}`;
 
   try {

package/src/runtime.ts

@@ -1,13 +1,13 @@
-import type { CoreConfig } from "./core-bridge.js";
 import type { VoiceCallConfig } from "./config.js";
+import type { CoreConfig } from "./core-bridge.js";
+import type { VoiceCallProvider } from "./providers/base.js";
+import type { TelephonyTtsRuntime } from "./telephony-tts.js";
 import { resolveVoiceCallConfig, validateProviderConfig } from "./config.js";
 import { CallManager } from "./manager.js";
-import type { VoiceCallProvider } from "./providers/base.js";
 import { MockProvider } from "./providers/mock.js";
 import { PlivoProvider } from "./providers/plivo.js";
 import { TelnyxProvider } from "./providers/telnyx.js";
 import { TwilioProvider } from "./providers/twilio.js";
-import type { TelephonyTtsRuntime } from "./telephony-tts.js";
 import { createTelephonyTtsProvider } from "./telephony-tts.js";
 import { startTunnel, type TunnelResult } from "./tunnel.js";
 import {
@@ -34,7 +34,9 @@ type Logger = {
 };
 
 function isLoopbackBind(bind: string | undefined): boolean {
-  if (!bind) return false;
+  if (!bind) {
+    return false;
+  }
   return bind === "127.0.0.1" || bind === "::1" || bind === "localhost";
 }
 
@@ -42,9 +44,7 @@ function resolveProvider(config: VoiceCallConfig): VoiceCallProvider {
   const allowNgrokFreeTierLoopbackBypass =
     config.tunnel?.provider === "ngrok" &&
     isLoopbackBind(config.serve?.bind) &&
-    (config.tunnel?.allowNgrokFreeTierLoopbackBypass ||
-      config.tunnel?.allowNgrokFreeTier ||
-      false);
+    (config.tunnel?.allowNgrokFreeTierLoopbackBypass || config.tunnel?.allowNgrokFreeTier || false);
 
   switch (config.provider) {
     case "telnyx":
@@ -63,9 +63,7 @@ function resolveProvider(config: VoiceCallConfig): VoiceCallProvider {
           allowNgrokFreeTierLoopbackBypass,
           publicUrl: config.publicUrl,
           skipVerification: config.skipSignatureVerification,
-          streamPath: config.streaming?.enabled
-            ? config.streaming.streamPath
-            : undefined,
+          streamPath: config.streaming?.enabled ? config.streaming.streamPath : undefined,
         },
       );
     case "plivo":
@@ -83,9 +81,7 @@ function resolveProvider(config: VoiceCallConfig): VoiceCallProvider {
     case "mock":
       return new MockProvider();
     default:
-      throw new Error(
-        `Unsupported voice-call provider: ${String(config.provider)}`,
-      );
+      throw new Error(`Unsupported voice-call provider: ${String(config.provider)}`);
   }
 }
 
@@ -106,9 +102,7 @@ export async function createVoiceCallRuntime(params: {
   const config = resolveVoiceCallConfig(rawConfig);
 
   if (!config.enabled) {
-    throw new Error(
-      "Voice call disabled. Enable the plugin entry in config.",
-    );
+    throw new Error("Voice call disabled. Enable the plugin entry in config.");
   }
 
   const validation = validateProviderConfig(config);
@@ -118,12 +112,7 @@ export async function createVoiceCallRuntime(params: {
 
   const provider = resolveProvider(config);
   const manager = new CallManager(config);
-  const webhookServer = new VoiceCallWebhookServer(
-    config,
-    manager,
-    provider,
-    coreConfig,
-  );
+  const webhookServer = new VoiceCallWebhookServer(config, manager, provider, coreConfig);
 
   const localUrl = await webhookServer.start();
 
@@ -143,9 +132,7 @@ export async function createVoiceCallRuntime(params: {
       publicUrl = tunnelResult?.publicUrl ?? null;
     } catch (err) {
       log.error(
-        `[voice-call] Tunnel setup failed: ${
-          err instanceof Error ? err.message : String(err)
-        }`,
+        `[voice-call] Tunnel setup failed: ${err instanceof Error ? err.message : String(err)}`,
       );
     }
   }

package/src/telephony-audio.ts

@@ -8,9 +8,13 @@ function clamp16(value: number): number {
  * Resample 16-bit PCM (little-endian mono) to 8kHz using linear interpolation.
  */
 export function resamplePcmTo8k(input: Buffer, inputSampleRate: number): Buffer {
-  if (inputSampleRate === TELEPHONY_SAMPLE_RATE) return input;
+  if (inputSampleRate === TELEPHONY_SAMPLE_RATE) {
+    return input;
+  }
   const inputSamples = Math.floor(input.length / 2);
-  if (inputSamples === 0) return Buffer.alloc(0);
+  if (inputSamples === 0) {
+    return Buffer.alloc(0);
+  }
 
   const ratio = inputSampleRate / TELEPHONY_SAMPLE_RATE;
   const outputSamples = Math.floor(inputSamples / ratio);
@@ -47,10 +51,7 @@ export function pcmToMulaw(pcm: Buffer): Buffer {
   return mulaw;
 }
 
-export function convertPcmToMulaw8k(
-  pcm: Buffer,
-  inputSampleRate: number,
-): Buffer {
+export function convertPcmToMulaw8k(pcm: Buffer, inputSampleRate: number): Buffer {
   const pcm8k = resamplePcmTo8k(pcm, inputSampleRate);
   return pcmToMulaw(pcm8k);
 }
@@ -58,10 +59,7 @@ export function convertPcmToMulaw8k(
 /**
  * Chunk audio buffer into 20ms frames for streaming (8kHz mono mu-law).
  */
-export function chunkAudio(
-  audio: Buffer,
-  chunkSize = 160,
-): Generator<Buffer, void, unknown> {
+export function chunkAudio(audio: Buffer, chunkSize = 160): Generator<Buffer, void, unknown> {
   return (function* () {
     for (let i = 0; i < audio.length; i += chunkSize) {
       yield audio.subarray(i, Math.min(i + chunkSize, audio.length));
@@ -74,8 +72,12 @@ function linearToMulaw(sample: number): number {
   const CLIP = 32635;
 
   const sign = sample < 0 ? 0x80 : 0;
-  if (sample < 0) sample = -sample;
-  if (sample > CLIP) sample = CLIP;
+  if (sample < 0) {
+    sample = -sample;
+  }
+  if (sample > CLIP) {
+    sample = CLIP;
+  }
 
   sample += BIAS;
   let exponent = 7;

package/src/telephony-tts.ts

@@ -1,5 +1,5 @@
-import type { CoreConfig } from "./core-bridge.js";
 import type { VoiceCallTtsConfig } from "./config.js";
+import type { CoreConfig } from "./core-bridge.js";
 import { convertPcmToMulaw8k } from "./telephony-audio.js";
 
 export type TelephonyTtsRuntime = {
@@ -44,20 +44,21 @@ export function createTelephonyTtsProvider(params: {
   };
 }
 
-function applyTtsOverride(
-  coreConfig: CoreConfig,
-  override?: VoiceCallTtsConfig,
-): CoreConfig {
-  if (!override) return coreConfig;
+function applyTtsOverride(coreConfig: CoreConfig, override?: VoiceCallTtsConfig): CoreConfig {
+  if (!override) {
+    return coreConfig;
+  }
 
   const base = coreConfig.messages?.tts;
   const merged = mergeTtsConfig(base, override);
-  if (!merged) return coreConfig;
+  if (!merged) {
+    return coreConfig;
+  }
 
   return {
     ...coreConfig,
     messages: {
-      ...(coreConfig.messages ?? {}),
+      ...coreConfig.messages,
       tts: merged,
     },
   };
@@ -67,9 +68,15 @@ function mergeTtsConfig(
   base?: VoiceCallTtsConfig,
   override?: VoiceCallTtsConfig,
 ): VoiceCallTtsConfig | undefined {
-  if (!base && !override) return undefined;
-  if (!override) return base;
-  if (!base) return override;
+  if (!base && !override) {
+    return undefined;
+  }
+  if (!override) {
+    return base;
+  }
+  if (!base) {
+    return override;
+  }
   return deepMerge(base, override);
 }
 
@@ -79,7 +86,9 @@ function deepMerge<T>(base: T, override: T): T {
   }
   const result: Record<string, unknown> = { ...base };
   for (const [key, value] of Object.entries(override)) {
-    if (value === undefined) continue;
+    if (value === undefined) {
+      continue;
+    }
     const existing = (base as Record<string, unknown>)[key];
     if (isPlainObject(existing) && isPlainObject(value)) {
       result[key] = deepMerge(existing, value);

package/src/tunnel.ts

@@ -1,5 +1,4 @@
 import { spawn } from "node:child_process";
-
 import { getTailscaleDnsName } from "./webhook.js";
 
 /**
@@ -52,14 +51,7 @@ export async function startNgrokTunnel(config: {
   }
 
   // Build ngrok command args
-  const args = [
-    "http",
-    String(config.port),
-    "--log",
-    "stdout",
-    "--log-format",
-    "json",
-  ];
+  const args = ["http", String(config.port), "--log", "stdout", "--log-format", "json"];
 
   // Add custom domain if provided (paid ngrok feature)
   if (config.domain) {
@@ -234,11 +226,9 @@ export async function startTailscaleTunnel(config: {
   const localUrl = `http://127.0.0.1:${config.port}${path}`;
 
   return new Promise((resolve, reject) => {
-    const proc = spawn(
-      "tailscale",
-      [config.mode, "--bg", "--yes", "--set-path", path, localUrl],
-      { stdio: ["ignore", "pipe", "pipe"] },
-    );
+    const proc = spawn("tailscale", [config.mode, "--bg", "--yes", "--set-path", path, localUrl], {
+      stdio: ["ignore", "pipe", "pipe"],
+    });
 
     const timeout = setTimeout(() => {
       proc.kill("SIGKILL");
@@ -249,9 +239,7 @@ export async function startTailscaleTunnel(config: {
       clearTimeout(timeout);
       if (code === 0) {
         const publicUrl = `https://${dnsName}${path}`;
-        console.log(
-          `[voice-call] Tailscale ${config.mode} active: ${publicUrl}`,
-        );
+        console.log(`[voice-call] Tailscale ${config.mode} active: ${publicUrl}`);
 
         resolve({
           publicUrl,
@@ -275,10 +263,7 @@ export async function startTailscaleTunnel(config: {
 /**
  * Stop a Tailscale serve/funnel tunnel.
  */
-async function stopTailscaleTunnel(
-  mode: "serve" | "funnel",
-  path: string,
-): Promise<void> {
+async function stopTailscaleTunnel(mode: "serve" | "funnel", path: string): Promise<void> {
   return new Promise((resolve) => {
     const proc = spawn("tailscale", [mode, "off", path], {
       stdio: "ignore",
@@ -299,9 +284,7 @@ async function stopTailscaleTunnel(
 /**
  * Start a tunnel based on configuration.
  */
-export async function startTunnel(
-  config: TunnelConfig,
-): Promise<TunnelResult | null> {
+export async function startTunnel(config: TunnelConfig): Promise<TunnelResult | null> {
   switch (config.provider) {
     case "ngrok":
       return startNgrokTunnel({

package/src/types.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-
 import type { CallMode } from "./config.js";
 
 // -----------------------------------------------------------------------------

package/src/utils.ts

@@ -3,7 +3,9 @@ import path from "node:path";
 
 export function resolveUserPath(input: string): string {
   const trimmed = input.trim();
-  if (!trimmed) return trimmed;
+  if (!trimmed) {
+    return trimmed;
+  }
   if (trimmed.startsWith("~")) {
     const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
     return path.resolve(expanded);

package/src/voice-mapping.ts

@@ -39,7 +39,9 @@ export const DEFAULT_POLLY_VOICE = "Polly.Joanna";
  * @returns Polly voice name suitable for Twilio TwiML
  */
 export function mapVoiceToPolly(voice: string | undefined): string {
-  if (!voice) return DEFAULT_POLLY_VOICE;
+  if (!voice) {
+    return DEFAULT_POLLY_VOICE;
+  }
 
   // Already a Polly/Google voice - pass through
   if (voice.startsWith("Polly.") || voice.startsWith("Google.")) {

package/src/webhook-security.test.ts

@@ -1,7 +1,5 @@
 import crypto from "node:crypto";
-
 import { describe, expect, it } from "vitest";
-
 import { verifyPlivoWebhook, verifyTwilioWebhook } from "./webhook-security.js";
 
 function canonicalizeBase64(input: string): string {
@@ -29,7 +27,9 @@ function plivoV3Signature(params: {
   const u = new URL(params.urlWithQuery);
   const baseNoQuery = `${u.protocol}//${u.host}${u.pathname}`;
   const queryPairs: Array<[string, string]> = [];
-  for (const [k, v] of u.searchParams.entries()) queryPairs.push([k, v]);
+  for (const [k, v] of u.searchParams.entries()) {
+    queryPairs.push([k, v]);
+  }
 
   const queryMap = new Map<string, string[]>();
   for (const [k, v] of queryPairs) {
@@ -37,10 +37,8 @@ function plivoV3Signature(params: {
   }
 
   const sortedQuery = Array.from(queryMap.keys())
-    .sort()
-    .flatMap((k) =>
-      [...(queryMap.get(k) ?? [])].sort().map((v) => `${k}=${v}`),
-    )
+    .toSorted()
+    .flatMap((k) => [...(queryMap.get(k) ?? [])].toSorted().map((v) => `${k}=${v}`))
     .join("&");
 
   const postParams = new URLSearchParams(params.postBody);
@@ -50,8 +48,8 @@ function plivoV3Signature(params: {
   }
 
   const sortedPost = Array.from(postMap.keys())
-    .sort()
-    .flatMap((k) => [...(postMap.get(k) ?? [])].sort().map((v) => `${k}${v}`))
+    .toSorted()
+    .flatMap((k) => [...(postMap.get(k) ?? [])].toSorted().map((v) => `${k}${v}`))
     .join("");
 
   const hasPost = sortedPost.length > 0;
@@ -71,24 +69,17 @@ function plivoV3Signature(params: {
   return canonicalizeBase64(digest);
 }
 
-function twilioSignature(params: {
-  authToken: string;
-  url: string;
-  postBody: string;
-}): string {
+function twilioSignature(params: { authToken: string; url: string; postBody: string }): string {
   let dataToSign = params.url;
-  const sortedParams = Array.from(
-    new URLSearchParams(params.postBody).entries(),
-  ).sort((a, b) => a[0].localeCompare(b[0]));
+  const sortedParams = Array.from(new URLSearchParams(params.postBody).entries()).toSorted((a, b) =>
+    a[0].localeCompare(b[0]),
+  );
 
   for (const [key, value] of sortedParams) {
     dataToSign += key + value;
   }
 
-  return crypto
-    .createHmac("sha1", params.authToken)
-    .update(dataToSign)
-    .digest("base64");
+  return crypto.createHmac("sha1", params.authToken).update(dataToSign).digest("base64");
 }
 
 describe("verifyPlivoWebhook", () => {