@openclaw/voice-call 2026.3.12 → 2026.3.13

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 2026.3.13
+
+### Changes
+
+- Version alignment with core OpenClaw release numbers.
+
 ## 2026.3.12
 
 ### Changes

package/README.md

@@ -89,56 +89,18 @@ Notes:
 - Twilio/Telnyx/Plivo require a **publicly reachable** webhook URL.
 - `mock` is a local dev provider (no network calls).
 - Telnyx requires `telnyx.publicKey` (or `TELNYX_PUBLIC_KEY`) unless `skipSignatureVerification` is true.
-- `tunnel.allowNgrokFreeTierLoopbackBypass: true` allows Twilio webhooks with invalid signatures **only** when `tunnel.provider="ngrok"` and `serve.bind` is loopback (ngrok local agent). Use for local dev only.
-
-Streaming security defaults:
-
-- `streaming.preStartTimeoutMs` closes sockets that never send a valid `start` frame.
-- `streaming.maxPendingConnections` caps total unauthenticated pre-start sockets.
-- `streaming.maxPendingConnectionsPerIp` caps unauthenticated pre-start sockets per source IP.
-- `streaming.maxConnections` caps total open media stream sockets (pending + active).
+- advanced webhook, streaming, and tunnel notes: `https://docs.openclaw.ai/plugins/voice-call`
 
 ## Stale call reaper
 
-Use `staleCallReaperSeconds` to end calls that never receive a terminal webhook
-(for example, notify-mode calls that never complete). The default is `0`
-(disabled).
-
-Recommended ranges:
-
-- **Production:** `120`–`300` seconds for notify-style flows.
-- Keep this value **higher than `maxDurationSeconds`** so normal calls can
-  finish. A good starting point is `maxDurationSeconds + 30–60` seconds.
-
-Example:
-
-```json5
-{
-  staleCallReaperSeconds: 360,
-}
-```
+See the plugin docs for recommended ranges and production examples:
+`https://docs.openclaw.ai/plugins/voice-call#stale-call-reaper`
 
 ## TTS for calls
 
 Voice Call uses the core `messages.tts` configuration (OpenAI or ElevenLabs) for
-streaming speech on calls. You can override it under the plugin config with the
-same shape — overrides deep-merge with `messages.tts`.
-
-```json5
-{
-  tts: {
-    provider: "openai",
-    openai: {
-      voice: "alloy",
-    },
-  },
-}
-```
-
-Notes:
-
-- Edge TTS is ignored for voice calls (telephony audio needs PCM; Edge output is unreliable).
-- Core TTS is used when Twilio media streaming is enabled; otherwise calls fall back to provider native voices.
+streaming speech on calls. Override examples and provider caveats live here:
+`https://docs.openclaw.ai/plugins/voice-call#tts-for-calls`
 
 ## CLI
 

package/index.ts

@@ -227,6 +227,37 @@ const voiceCallPlugin = {
       params.respond(true, { callId: result.callId, initiated: true });
     };
 
+    const respondToCallMessageAction = async (params: {
+      requestParams: GatewayRequestHandlerOptions["params"];
+      respond: GatewayRequestHandlerOptions["respond"];
+      action: (
+        request: Exclude<Awaited<ReturnType<typeof resolveCallMessageRequest>>, { error: string }>,
+      ) => Promise<{
+        success: boolean;
+        error?: string;
+        transcript?: string;
+      }>;
+      failure: string;
+      includeTranscript?: boolean;
+    }) => {
+      const request = await resolveCallMessageRequest(params.requestParams);
+      if ("error" in request) {
+        params.respond(false, { error: request.error });
+        return;
+      }
+      const result = await params.action(request);
+      if (!result.success) {
+        params.respond(false, { error: result.error || params.failure });
+        return;
+      }
+      params.respond(
+        true,
+        params.includeTranscript
+          ? { success: true, transcript: result.transcript }
+          : { success: true },
+      );
+    };
+
     api.registerGatewayMethod(
       "voicecall.initiate",
       async ({ params, respond }: GatewayRequestHandlerOptions) => {
@@ -264,17 +295,13 @@ const voiceCallPlugin = {
       "voicecall.continue",
       async ({ params, respond }: GatewayRequestHandlerOptions) => {
         try {
-          const request = await resolveCallMessageRequest(params);
-          if ("error" in request) {
-            respond(false, { error: request.error });
-            return;
-          }
-          const result = await request.rt.manager.continueCall(request.callId, request.message);
-          if (!result.success) {
-            respond(false, { error: result.error || "continue failed" });
-            return;
-          }
-          respond(true, { success: true, transcript: result.transcript });
+          await respondToCallMessageAction({
+            requestParams: params,
+            respond,
+            action: (request) => request.rt.manager.continueCall(request.callId, request.message),
+            failure: "continue failed",
+            includeTranscript: true,
+          });
         } catch (err) {
           sendError(respond, err);
         }
@@ -285,17 +312,12 @@ const voiceCallPlugin = {
       "voicecall.speak",
       async ({ params, respond }: GatewayRequestHandlerOptions) => {
         try {
-          const request = await resolveCallMessageRequest(params);
-          if ("error" in request) {
-            respond(false, { error: request.error });
-            return;
-          }
-          const result = await request.rt.manager.speak(request.callId, request.message);
-          if (!result.success) {
-            respond(false, { error: result.error || "speak failed" });
-            return;
-          }
-          respond(true, { success: true });
+          await respondToCallMessageAction({
+            requestParams: params,
+            respond,
+            action: (request) => request.rt.manager.speak(request.callId, request.message),
+            failure: "speak failed",
+          });
         } catch (err) {
           sendError(respond, err);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/voice-call",
-  "version": "2026.3.12",
+  "version": "2026.3.13",
   "description": "OpenClaw voice-call plugin",
   "type": "module",
   "dependencies": {

package/src/manager.restore.test.ts

@@ -9,121 +9,87 @@ import {
 } from "./manager.test-harness.js";
 
 describe("CallManager verification on restore", () => {
-  it("skips stale calls reported terminal by provider", async () => {
+  async function initializeManager(params?: {
+    callOverrides?: Parameters<typeof makePersistedCall>[0];
+    providerResult?: FakeProvider["getCallStatusResult"];
+    configureProvider?: (provider: FakeProvider) => void;
+    configOverrides?: Partial<{ maxDurationSeconds: number }>;
+  }) {
     const storePath = createTestStorePath();
-    const call = makePersistedCall();
+    const call = makePersistedCall(params?.callOverrides);
     writeCallsToStore(storePath, [call]);
 
     const provider = new FakeProvider();
-    provider.getCallStatusResult = { status: "completed", isTerminal: true };
+    if (params?.providerResult) {
+      provider.getCallStatusResult = params.providerResult;
+    }
+    params?.configureProvider?.(provider);
 
     const config = VoiceCallConfigSchema.parse({
       enabled: true,
       provider: "plivo",
       fromNumber: "+15550000000",
+      ...params?.configOverrides,
     });
     const manager = new CallManager(config, storePath);
     await manager.initialize(provider, "https://example.com/voice/webhook");
 
+    return { call, manager };
+  }
+
+  it("skips stale calls reported terminal by provider", async () => {
+    const { manager } = await initializeManager({
+      providerResult: { status: "completed", isTerminal: true },
+    });
+
     expect(manager.getActiveCalls()).toHaveLength(0);
   });
 
   it("keeps calls reported active by provider", async () => {
-    const storePath = createTestStorePath();
-    const call = makePersistedCall();
-    writeCallsToStore(storePath, [call]);
-
-    const provider = new FakeProvider();
-    provider.getCallStatusResult = { status: "in-progress", isTerminal: false };
-
-    const config = VoiceCallConfigSchema.parse({
-      enabled: true,
-      provider: "plivo",
-      fromNumber: "+15550000000",
+    const { call, manager } = await initializeManager({
+      providerResult: { status: "in-progress", isTerminal: false },
     });
-    const manager = new CallManager(config, storePath);
-    await manager.initialize(provider, "https://example.com/voice/webhook");
 
     expect(manager.getActiveCalls()).toHaveLength(1);
     expect(manager.getActiveCalls()[0]?.callId).toBe(call.callId);
   });
 
   it("keeps calls when provider returns unknown (transient error)", async () => {
-    const storePath = createTestStorePath();
-    const call = makePersistedCall();
-    writeCallsToStore(storePath, [call]);
-
-    const provider = new FakeProvider();
-    provider.getCallStatusResult = { status: "error", isTerminal: false, isUnknown: true };
-
-    const config = VoiceCallConfigSchema.parse({
-      enabled: true,
-      provider: "plivo",
-      fromNumber: "+15550000000",
+    const { manager } = await initializeManager({
+      providerResult: { status: "error", isTerminal: false, isUnknown: true },
     });
-    const manager = new CallManager(config, storePath);
-    await manager.initialize(provider, "https://example.com/voice/webhook");
 
     expect(manager.getActiveCalls()).toHaveLength(1);
   });
 
   it("skips calls older than maxDurationSeconds", async () => {
-    const storePath = createTestStorePath();
-    const call = makePersistedCall({
-      startedAt: Date.now() - 600_000,
-      answeredAt: Date.now() - 590_000,
+    const { manager } = await initializeManager({
+      callOverrides: {
+        startedAt: Date.now() - 600_000,
+        answeredAt: Date.now() - 590_000,
+      },
+      configOverrides: { maxDurationSeconds: 300 },
     });
-    writeCallsToStore(storePath, [call]);
-
-    const provider = new FakeProvider();
-
-    const config = VoiceCallConfigSchema.parse({
-      enabled: true,
-      provider: "plivo",
-      fromNumber: "+15550000000",
-      maxDurationSeconds: 300,
-    });
-    const manager = new CallManager(config, storePath);
-    await manager.initialize(provider, "https://example.com/voice/webhook");
 
     expect(manager.getActiveCalls()).toHaveLength(0);
   });
 
   it("skips calls without providerCallId", async () => {
-    const storePath = createTestStorePath();
-    const call = makePersistedCall({ providerCallId: undefined, state: "initiated" });
-    writeCallsToStore(storePath, [call]);
-
-    const provider = new FakeProvider();
-
-    const config = VoiceCallConfigSchema.parse({
-      enabled: true,
-      provider: "plivo",
-      fromNumber: "+15550000000",
+    const { manager } = await initializeManager({
+      callOverrides: { providerCallId: undefined, state: "initiated" },
     });
-    const manager = new CallManager(config, storePath);
-    await manager.initialize(provider, "https://example.com/voice/webhook");
 
     expect(manager.getActiveCalls()).toHaveLength(0);
   });
 
   it("keeps call when getCallStatus throws (verification failure)", async () => {
-    const storePath = createTestStorePath();
-    const call = makePersistedCall();
-    writeCallsToStore(storePath, [call]);
-
-    const provider = new FakeProvider();
-    provider.getCallStatus = async () => {
-      throw new Error("network failure");
-    };
-
-    const config = VoiceCallConfigSchema.parse({
-      enabled: true,
-      provider: "plivo",
-      fromNumber: "+15550000000",
+    const { manager } = await initializeManager({
+      configureProvider: (provider) => {
+        provider.getCallStatus = async () => {
+          throw new Error("network failure");
+        };
+      },
     });
-    const manager = new CallManager(config, storePath);
-    await manager.initialize(provider, "https://example.com/voice/webhook");
 
     expect(manager.getActiveCalls()).toHaveLength(1);
   });

package/src/providers/telnyx.test.ts

@@ -22,6 +22,34 @@ function decodeBase64Url(input: string): Buffer {
   return Buffer.from(padded, "base64");
 }
 
+function createSignedTelnyxCtx(params: {
+  privateKey: crypto.KeyObject;
+  rawBody: string;
+}): WebhookContext {
+  const timestamp = String(Math.floor(Date.now() / 1000));
+  const signedPayload = `${timestamp}|${params.rawBody}`;
+  const signature = crypto
+    .sign(null, Buffer.from(signedPayload), params.privateKey)
+    .toString("base64");
+
+  return createCtx({
+    rawBody: params.rawBody,
+    headers: {
+      "telnyx-signature-ed25519": signature,
+      "telnyx-timestamp": timestamp,
+    },
+  });
+}
+
+function expectReplayVerification(
+  results: Array<{ ok: boolean; isReplay?: boolean; verifiedRequestKey?: string }>,
+) {
+  expect(results.map((result) => result.ok)).toEqual([true, true]);
+  expect(results.map((result) => Boolean(result.isReplay))).toEqual([false, true]);
+  expect(results[0]?.verifiedRequestKey).toEqual(expect.any(String));
+  expect(results[1]?.verifiedRequestKey).toBe(results[0]?.verifiedRequestKey);
+}
+
 function expectWebhookVerificationSucceeds(params: {
   publicKey: string;
   privateKey: crypto.KeyObject;
@@ -35,20 +63,8 @@ function expectWebhookVerificationSucceeds(params: {
     event_type: "call.initiated",
     payload: { call_control_id: "x" },
   });
-  const timestamp = String(Math.floor(Date.now() / 1000));
-  const signedPayload = `${timestamp}|${rawBody}`;
-  const signature = crypto
-    .sign(null, Buffer.from(signedPayload), params.privateKey)
-    .toString("base64");
-
   const result = provider.verifyWebhook(
-    createCtx({
-      rawBody,
-      headers: {
-        "telnyx-signature-ed25519": signature,
-        "telnyx-timestamp": timestamp,
-      },
-    }),
+    createSignedTelnyxCtx({ privateKey: params.privateKey, rawBody }),
   );
   expect(result.ok).toBe(true);
 }
@@ -117,26 +133,12 @@ describe("TelnyxProvider.verifyWebhook", () => {
       payload: { call_control_id: "call-replay-test" },
       nonce: crypto.randomUUID(),
     });
-    const timestamp = String(Math.floor(Date.now() / 1000));
-    const signedPayload = `${timestamp}|${rawBody}`;
-    const signature = crypto.sign(null, Buffer.from(signedPayload), privateKey).toString("base64");
-    const ctx = createCtx({
-      rawBody,
-      headers: {
-        "telnyx-signature-ed25519": signature,
-        "telnyx-timestamp": timestamp,
-      },
-    });
+    const ctx = createSignedTelnyxCtx({ privateKey, rawBody });
 
     const first = provider.verifyWebhook(ctx);
     const second = provider.verifyWebhook(ctx);
 
-    expect(first.ok).toBe(true);
-    expect(first.isReplay).toBeFalsy();
-    expect(first.verifiedRequestKey).toBeTruthy();
-    expect(second.ok).toBe(true);
-    expect(second.isReplay).toBe(true);
-    expect(second.verifiedRequestKey).toBe(first.verifiedRequestKey);
+    expectReplayVerification([first, second]);
   });
 });
 

package/src/providers/twilio.test.ts

@@ -21,6 +21,12 @@ function createContext(rawBody: string, query?: WebhookContext["query"]): Webhoo
   };
 }
 
+function expectStreamingTwiml(body: string) {
+  expect(body).toContain(STREAM_URL);
+  expect(body).toContain('<Parameter name="token" value="');
+  expect(body).toContain("<Connect>");
+}
+
 describe("TwilioProvider", () => {
   it("returns streaming TwiML for outbound conversation calls before in-progress", () => {
     const provider = createProvider();
@@ -30,9 +36,8 @@ describe("TwilioProvider", () => {
 
     const result = provider.parseWebhookEvent(ctx);
 
-    expect(result.providerResponseBody).toContain(STREAM_URL);
-    expect(result.providerResponseBody).toContain('<Parameter name="token" value="');
-    expect(result.providerResponseBody).toContain("<Connect>");
+    expect(result.providerResponseBody).toBeDefined();
+    expectStreamingTwiml(result.providerResponseBody ?? "");
   });
 
   it("returns empty TwiML for status callbacks", () => {
@@ -55,9 +60,8 @@ describe("TwilioProvider", () => {
 
     const result = provider.parseWebhookEvent(ctx);
 
-    expect(result.providerResponseBody).toContain(STREAM_URL);
-    expect(result.providerResponseBody).toContain('<Parameter name="token" value="');
-    expect(result.providerResponseBody).toContain("<Connect>");
+    expect(result.providerResponseBody).toBeDefined();
+    expectStreamingTwiml(result.providerResponseBody ?? "");
   });
 
   it("returns queue TwiML for second inbound call when first call is active", () => {

package/src/webhook-security.test.ts

@@ -98,6 +98,51 @@ function expectReplayResultPair(
   expect(second.verifiedRequestKey).toBe(first.verifiedRequestKey);
 }
 
+function expectAcceptedWebhookVersion(
+  result: { ok: boolean; version?: string },
+  version: "v2" | "v3",
+) {
+  expect(result).toMatchObject({ ok: true, version });
+}
+
+function verifyTwilioNgrokLoopback(signature: string) {
+  return verifyTwilioWebhook(
+    {
+      headers: {
+        host: "127.0.0.1:3334",
+        "x-forwarded-proto": "https",
+        "x-forwarded-host": "local.ngrok-free.app",
+        "x-twilio-signature": signature,
+      },
+      rawBody: "CallSid=CS123&CallStatus=completed&From=%2B15550000000",
+      url: "http://127.0.0.1:3334/voice/webhook",
+      method: "POST",
+      remoteAddress: "127.0.0.1",
+    },
+    "test-auth-token",
+    { allowNgrokFreeTierLoopbackBypass: true },
+  );
+}
+
+function verifyTwilioSignedRequest(params: {
+  headers: Record<string, string>;
+  rawBody: string;
+  authToken: string;
+  publicUrl: string;
+}) {
+  return verifyTwilioWebhook(
+    {
+      headers: params.headers,
+      rawBody: params.rawBody,
+      url: "http://local/voice/webhook?callId=abc",
+      method: "POST",
+      query: { callId: "abc" },
+    },
+    params.authToken,
+    { publicUrl: params.publicUrl },
+  );
+}
+
 describe("verifyPlivoWebhook", () => {
   it("accepts valid V2 signature", () => {
     const authToken = "test-auth-token";
@@ -127,8 +172,7 @@ describe("verifyPlivoWebhook", () => {
       authToken,
     );
 
-    expect(result.ok).toBe(true);
-    expect(result.version).toBe("v2");
+    expectAcceptedWebhookVersion(result, "v2");
   });
 
   it("accepts valid V3 signature (including multi-signature header)", () => {
@@ -161,8 +205,7 @@ describe("verifyPlivoWebhook", () => {
       authToken,
     );
 
-    expect(result.ok).toBe(true);
-    expect(result.version).toBe("v3");
+    expectAcceptedWebhookVersion(result, "v3");
   });
 
   it("rejects missing signatures", () => {
@@ -317,35 +360,10 @@ describe("verifyTwilioWebhook", () => {
       "i-twilio-idempotency-token": "idem-replay-1",
     };
 
-    const first = verifyTwilioWebhook(
-      {
-        headers,
-        rawBody: postBody,
-        url: "http://local/voice/webhook?callId=abc",
-        method: "POST",
-        query: { callId: "abc" },
-      },
-      authToken,
-      { publicUrl },
-    );
-    const second = verifyTwilioWebhook(
-      {
-        headers,
-        rawBody: postBody,
-        url: "http://local/voice/webhook?callId=abc",
-        method: "POST",
-        query: { callId: "abc" },
-      },
-      authToken,
-      { publicUrl },
-    );
+    const first = verifyTwilioSignedRequest({ headers, rawBody: postBody, authToken, publicUrl });
+    const second = verifyTwilioSignedRequest({ headers, rawBody: postBody, authToken, publicUrl });
 
-    expect(first.ok).toBe(true);
-    expect(first.isReplay).toBeFalsy();
-    expect(first.verifiedRequestKey).toBeTruthy();
-    expect(second.ok).toBe(true);
-    expect(second.isReplay).toBe(true);
-    expect(second.verifiedRequestKey).toBe(first.verifiedRequestKey);
+    expectReplayResultPair(first, second);
   });
 
   it("treats changed idempotency header as replay for identical signed requests", () => {
@@ -355,45 +373,30 @@ describe("verifyTwilioWebhook", () => {
     const postBody = "CallSid=CS778&CallStatus=completed&From=%2B15550000000";
     const signature = twilioSignature({ authToken, url: urlWithQuery, postBody });
 
-    const first = verifyTwilioWebhook(
-      {
-        headers: {
-          host: "example.com",
-          "x-forwarded-proto": "https",
-          "x-twilio-signature": signature,
-          "i-twilio-idempotency-token": "idem-replay-a",
-        },
-        rawBody: postBody,
-        url: "http://local/voice/webhook?callId=abc",
-        method: "POST",
-        query: { callId: "abc" },
+    const first = verifyTwilioSignedRequest({
+      headers: {
+        host: "example.com",
+        "x-forwarded-proto": "https",
+        "x-twilio-signature": signature,
+        "i-twilio-idempotency-token": "idem-replay-a",
       },
+      rawBody: postBody,
       authToken,
-      { publicUrl },
-    );
-    const second = verifyTwilioWebhook(
-      {
-        headers: {
-          host: "example.com",
-          "x-forwarded-proto": "https",
-          "x-twilio-signature": signature,
-          "i-twilio-idempotency-token": "idem-replay-b",
-        },
-        rawBody: postBody,
-        url: "http://local/voice/webhook?callId=abc",
-        method: "POST",
-        query: { callId: "abc" },
+      publicUrl,
+    });
+    const second = verifyTwilioSignedRequest({
+      headers: {
+        host: "example.com",
+        "x-forwarded-proto": "https",
+        "x-twilio-signature": signature,
+        "i-twilio-idempotency-token": "idem-replay-b",
       },
+      rawBody: postBody,
       authToken,
-      { publicUrl },
-    );
+      publicUrl,
+    });
 
-    expect(first.ok).toBe(true);
-    expect(first.isReplay).toBe(false);
-    expect(first.verifiedRequestKey).toBeTruthy();
-    expect(second.ok).toBe(true);
-    expect(second.isReplay).toBe(true);
-    expect(second.verifiedRequestKey).toBe(first.verifiedRequestKey);
+    expectReplayResultPair(first, second);
   });
 
   it("rejects invalid signatures even when attacker injects forwarded host", () => {
@@ -422,57 +425,22 @@ describe("verifyTwilioWebhook", () => {
   });
 
   it("accepts valid signatures for ngrok free tier on loopback when compatibility mode is enabled", () => {
-    const authToken = "test-auth-token";
-    const postBody = "CallSid=CS123&CallStatus=completed&From=%2B15550000000";
     const webhookUrl = "https://local.ngrok-free.app/voice/webhook";
 
     const signature = twilioSignature({
-      authToken,
+      authToken: "test-auth-token",
       url: webhookUrl,
-      postBody,
+      postBody: "CallSid=CS123&CallStatus=completed&From=%2B15550000000",
     });
 
-    const result = verifyTwilioWebhook(
-      {
-        headers: {
-          host: "127.0.0.1:3334",
-          "x-forwarded-proto": "https",
-          "x-forwarded-host": "local.ngrok-free.app",
-          "x-twilio-signature": signature,
-        },
-        rawBody: postBody,
-        url: "http://127.0.0.1:3334/voice/webhook",
-        method: "POST",
-        remoteAddress: "127.0.0.1",
-      },
-      authToken,
-      { allowNgrokFreeTierLoopbackBypass: true },
-    );
+    const result = verifyTwilioNgrokLoopback(signature);
 
     expect(result.ok).toBe(true);
     expect(result.verificationUrl).toBe(webhookUrl);
   });
 
   it("does not allow invalid signatures for ngrok free tier on loopback", () => {
-    const authToken = "test-auth-token";
-    const postBody = "CallSid=CS123&CallStatus=completed&From=%2B15550000000";
-
-    const result = verifyTwilioWebhook(
-      {
-        headers: {
-          host: "127.0.0.1:3334",
-          "x-forwarded-proto": "https",
-          "x-forwarded-host": "local.ngrok-free.app",
-          "x-twilio-signature": "invalid",
-        },
-        rawBody: postBody,
-        url: "http://127.0.0.1:3334/voice/webhook",
-        method: "POST",
-        remoteAddress: "127.0.0.1",
-      },
-      authToken,
-      { allowNgrokFreeTierLoopbackBypass: true },
-    );
+    const result = verifyTwilioNgrokLoopback("invalid");
 
     expect(result.ok).toBe(false);
     expect(result.reason).toMatch(/Invalid signature/);

package/src/webhook.test.ts

@@ -56,6 +56,28 @@ const createManager = (calls: CallRecord[]) => {
   return { manager, endCall, processEvent };
 };
 
+async function runStaleCallReaperCase(params: {
+  callAgeMs: number;
+  staleCallReaperSeconds: number;
+  advanceMs: number;
+}) {
+  const now = new Date("2026-02-16T00:00:00Z");
+  vi.setSystemTime(now);
+
+  const call = createCall(now.getTime() - params.callAgeMs);
+  const { manager, endCall } = createManager([call]);
+  const config = createConfig({ staleCallReaperSeconds: params.staleCallReaperSeconds });
+  const server = new VoiceCallWebhookServer(config, manager, provider);
+
+  try {
+    await server.start();
+    await vi.advanceTimersByTimeAsync(params.advanceMs);
+    return { call, endCall };
+  } finally {
+    await server.stop();
+  }
+}
+
 async function postWebhookForm(server: VoiceCallWebhookServer, baseUrl: string, body: string) {
   const address = (
     server as unknown as { server?: { address?: () => unknown } }
@@ -81,39 +103,21 @@ describe("VoiceCallWebhookServer stale call reaper", () => {
   });
 
   it("ends calls older than staleCallReaperSeconds", async () => {
-    const now = new Date("2026-02-16T00:00:00Z");
-    vi.setSystemTime(now);
-
-    const call = createCall(now.getTime() - 120_000);
-    const { manager, endCall } = createManager([call]);
-    const config = createConfig({ staleCallReaperSeconds: 60 });
-    const server = new VoiceCallWebhookServer(config, manager, provider);
-
-    try {
-      await server.start();
-      await vi.advanceTimersByTimeAsync(30_000);
-      expect(endCall).toHaveBeenCalledWith(call.callId);
-    } finally {
-      await server.stop();
-    }
+    const { call, endCall } = await runStaleCallReaperCase({
+      callAgeMs: 120_000,
+      staleCallReaperSeconds: 60,
+      advanceMs: 30_000,
+    });
+    expect(endCall).toHaveBeenCalledWith(call.callId);
   });
 
   it("skips calls that are younger than the threshold", async () => {
-    const now = new Date("2026-02-16T00:00:00Z");
-    vi.setSystemTime(now);
-
-    const call = createCall(now.getTime() - 10_000);
-    const { manager, endCall } = createManager([call]);
-    const config = createConfig({ staleCallReaperSeconds: 60 });
-    const server = new VoiceCallWebhookServer(config, manager, provider);
-
-    try {
-      await server.start();
-      await vi.advanceTimersByTimeAsync(30_000);
-      expect(endCall).not.toHaveBeenCalled();
-    } finally {
-      await server.stop();
-    }
+    const { endCall } = await runStaleCallReaperCase({
+      callAgeMs: 10_000,
+      staleCallReaperSeconds: 60,
+      advanceMs: 30_000,
+    });
+    expect(endCall).not.toHaveBeenCalled();
   });
 
   it("does not run when staleCallReaperSeconds is disabled", async () => {