@openclaw/voice-call 2026.5.2 → 2026.5.3-beta.1

package/src/manager/timers.test.ts

@@ -1,129 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-const { persistCallRecordMock } = vi.hoisted(() => ({
-  persistCallRecordMock: vi.fn(),
-}));
-
-vi.mock("./store.js", () => ({
-  persistCallRecord: persistCallRecordMock,
-}));
-
-import {
-  clearMaxDurationTimer,
-  clearTranscriptWaiter,
-  rejectTranscriptWaiter,
-  resolveTranscriptWaiter,
-  startMaxDurationTimer,
-  waitForFinalTranscript,
-} from "./timers.js";
-
-describe("voice-call manager timers", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("starts and clears max duration timers, persisting timeout metadata before delegation", async () => {
-    const call = { id: "call-1", state: "active" };
-    const ctx = {
-      activeCalls: new Map([["call-1", call]]),
-      maxDurationTimers: new Map(),
-      config: { maxDurationSeconds: 5 },
-      storePath: "/tmp/voice-call",
-    };
-    const onTimeout = vi.fn(async () => {});
-
-    startMaxDurationTimer({
-      ctx: ctx as never,
-      callId: "call-1",
-      onTimeout,
-    });
-
-    expect(ctx.maxDurationTimers.has("call-1")).toBe(true);
-
-    await vi.advanceTimersByTimeAsync(5_000);
-
-    expect(call).toEqual({ id: "call-1", state: "active", endReason: "timeout" });
-    expect(persistCallRecordMock).toHaveBeenCalledWith("/tmp/voice-call", call);
-    expect(onTimeout).toHaveBeenCalledWith("call-1");
-    expect(ctx.maxDurationTimers.has("call-1")).toBe(false);
-
-    startMaxDurationTimer({
-      ctx: ctx as never,
-      callId: "call-1",
-      onTimeout,
-    });
-    clearMaxDurationTimer(ctx as never, "call-1");
-    expect(ctx.maxDurationTimers.has("call-1")).toBe(false);
-  });
-
-  it("does not time out terminal calls", async () => {
-    const ctx = {
-      activeCalls: new Map([["call-1", { id: "call-1", state: "completed" }]]),
-      maxDurationTimers: new Map(),
-      config: { maxDurationSeconds: 5 },
-      storePath: "/tmp/voice-call",
-    };
-    const onTimeout = vi.fn(async () => {});
-
-    startMaxDurationTimer({
-      ctx: ctx as never,
-      callId: "call-1",
-      onTimeout,
-    });
-
-    await vi.advanceTimersByTimeAsync(5_000);
-
-    expect(persistCallRecordMock).not.toHaveBeenCalled();
-    expect(onTimeout).not.toHaveBeenCalled();
-  });
-
-  it("waits for transcripts, resolves matching tokens, rejects mismatches and timeouts", async () => {
-    const ctx = {
-      transcriptWaiters: new Map(),
-      config: { transcriptTimeoutMs: 1_000 },
-    };
-
-    const pending = waitForFinalTranscript(ctx as never, "call-1", "turn-1");
-    expect(resolveTranscriptWaiter(ctx as never, "call-1", "ignored", "turn-2")).toBe(false);
-    expect(resolveTranscriptWaiter(ctx as never, "call-1", "final transcript", "turn-1")).toBe(
-      true,
-    );
-    await expect(pending).resolves.toBe("final transcript");
-
-    const another = waitForFinalTranscript(ctx as never, "call-2");
-    rejectTranscriptWaiter(ctx as never, "call-2", "provider failed");
-    await expect(another).rejects.toThrow("provider failed");
-
-    const timedOut = waitForFinalTranscript(ctx as never, "call-3").catch((error) => error);
-    await vi.advanceTimersByTimeAsync(1_000);
-    await expect(timedOut).resolves.toEqual(
-      expect.objectContaining({
-        message: "Timed out waiting for transcript after 1000ms",
-      }),
-    );
-
-    const toClear = waitForFinalTranscript(ctx as never, "call-4");
-    clearTranscriptWaiter(ctx as never, "call-4");
-    expect(ctx.transcriptWaiters.has("call-4")).toBe(false);
-    void toClear.catch(() => {});
-  });
-
-  it("rejects duplicate transcript waiters for the same call", async () => {
-    const ctx = {
-      transcriptWaiters: new Map(),
-      config: { transcriptTimeoutMs: 1_000 },
-    };
-
-    const pending = waitForFinalTranscript(ctx as never, "call-1");
-    await expect(waitForFinalTranscript(ctx as never, "call-1")).rejects.toThrow(
-      "Already waiting for transcript",
-    );
-    rejectTranscriptWaiter(ctx as never, "call-1", "done");
-    await expect(pending).rejects.toThrow("done");
-  });
-});

package/src/manager/timers.ts

@@ -1,113 +0,0 @@
-import { TerminalStates, type CallId } from "../types.js";
-import type { CallManagerContext } from "./context.js";
-import { persistCallRecord } from "./store.js";
-
-type TimerContext = Pick<
-  CallManagerContext,
-  "activeCalls" | "maxDurationTimers" | "config" | "storePath" | "transcriptWaiters"
->;
-type MaxDurationTimerContext = Pick<
-  TimerContext,
-  "activeCalls" | "maxDurationTimers" | "config" | "storePath"
->;
-type TranscriptWaiterContext = Pick<TimerContext, "transcriptWaiters">;
-
-export function clearMaxDurationTimer(
-  ctx: Pick<MaxDurationTimerContext, "maxDurationTimers">,
-  callId: CallId,
-): void {
-  const timer = ctx.maxDurationTimers.get(callId);
-  if (timer) {
-    clearTimeout(timer);
-    ctx.maxDurationTimers.delete(callId);
-  }
-}
-
-export function startMaxDurationTimer(params: {
-  ctx: MaxDurationTimerContext;
-  callId: CallId;
-  onTimeout: (callId: CallId) => Promise<void>;
-  timeoutMs?: number;
-}): void {
-  clearMaxDurationTimer(params.ctx, params.callId);
-
-  const maxDurationMs = params.timeoutMs ?? params.ctx.config.maxDurationSeconds * 1000;
-  console.log(
-    `[voice-call] Starting max duration timer (${Math.ceil(maxDurationMs / 1000)}s) for call ${params.callId}`,
-  );
-
-  const timer = setTimeout(async () => {
-    params.ctx.maxDurationTimers.delete(params.callId);
-    const call = params.ctx.activeCalls.get(params.callId);
-    if (call && !TerminalStates.has(call.state)) {
-      console.log(
-        `[voice-call] Max duration reached (${Math.ceil(maxDurationMs / 1000)}s), ending call ${params.callId}`,
-      );
-      call.endReason = "timeout";
-      persistCallRecord(params.ctx.storePath, call);
-      await params.onTimeout(params.callId);
-    }
-  }, maxDurationMs);
-
-  params.ctx.maxDurationTimers.set(params.callId, timer);
-}
-
-export function clearTranscriptWaiter(ctx: TranscriptWaiterContext, callId: CallId): void {
-  const waiter = ctx.transcriptWaiters.get(callId);
-  if (!waiter) {
-    return;
-  }
-  clearTimeout(waiter.timeout);
-  ctx.transcriptWaiters.delete(callId);
-}
-
-export function rejectTranscriptWaiter(
-  ctx: TranscriptWaiterContext,
-  callId: CallId,
-  reason: string,
-): void {
-  const waiter = ctx.transcriptWaiters.get(callId);
-  if (!waiter) {
-    return;
-  }
-  clearTranscriptWaiter(ctx, callId);
-  waiter.reject(new Error(reason));
-}
-
-export function resolveTranscriptWaiter(
-  ctx: TranscriptWaiterContext,
-  callId: CallId,
-  transcript: string,
-  turnToken?: string,
-): boolean {
-  const waiter = ctx.transcriptWaiters.get(callId);
-  if (!waiter) {
-    return false;
-  }
-  if (waiter.turnToken && waiter.turnToken !== turnToken) {
-    return false;
-  }
-  clearTranscriptWaiter(ctx, callId);
-  waiter.resolve(transcript);
-  return true;
-}
-
-export function waitForFinalTranscript(
-  ctx: TimerContext,
-  callId: CallId,
-  turnToken?: string,
-): Promise<string> {
-  if (ctx.transcriptWaiters.has(callId)) {
-    return Promise.reject(new Error("Already waiting for transcript"));
-  }
-
-  const timeoutMs = ctx.config.transcriptTimeoutMs;
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      ctx.transcriptWaiters.delete(callId);
-      reject(new Error(`Timed out waiting for transcript after ${timeoutMs}ms`));
-    }, timeoutMs);
-
-    ctx.transcriptWaiters.set(callId, { resolve, reject, timeout, turnToken });
-  });
-}

package/src/manager/twiml.test.ts

@@ -1,13 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { generateNotifyTwiml } from "./twiml.js";
-
-describe("generateNotifyTwiml", () => {
-  it("renders escaped xml with the requested voice", () => {
-    expect(generateNotifyTwiml(`Call <ended> & "logged"`, "Polly.Joanna"))
-      .toBe(`<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Say voice="Polly.Joanna">Call &lt;ended&gt; &amp; &quot;logged&quot;</Say>
-  <Hangup/>
-</Response>`);
-  });
-});

package/src/manager/twiml.ts

@@ -1,17 +0,0 @@
-import { escapeXml } from "../voice-mapping.js";
-
-export function generateNotifyTwiml(message: string, voice: string): string {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Say voice="${voice}">${escapeXml(message)}</Say>
-  <Hangup/>
-</Response>`;
-}
-
-export function generateDtmfRedirectTwiml(digits: string, webhookUrl: string): string {
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<Response>
-  <Play digits="${escapeXml(digits)}" />
-  <Redirect method="POST">${escapeXml(webhookUrl)}</Redirect>
-</Response>`;
-}

package/src/manager.closed-loop.test.ts

@@ -1,236 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { createManagerHarness, FakeProvider, markCallAnswered } from "./manager.test-harness.js";
-
-function requireCall(
-  manager: Awaited<ReturnType<typeof createManagerHarness>>["manager"],
-  callId: string,
-) {
-  const call = manager.getCall(callId);
-  if (!call) {
-    throw new Error(`expected active call ${callId}`);
-  }
-  return call;
-}
-
-function requireTurnToken(provider: Awaited<ReturnType<typeof createManagerHarness>>["provider"]) {
-  const firstStart = provider.startListeningCalls[0];
-  if (!firstStart?.turnToken) {
-    throw new Error("expected closed-loop turn to capture a turn token");
-  }
-  return firstStart.turnToken;
-}
-
-describe("CallManager closed-loop turns", () => {
-  it("completes a closed-loop turn without live audio", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000003");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-closed-loop-answered");
-
-    const turnPromise = manager.continueCall(started.callId, "How can I help?");
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    manager.processEvent({
-      id: "evt-closed-loop-speech",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "Please check status",
-      isFinal: true,
-    });
-
-    const turn = await turnPromise;
-    expect(turn.success).toBe(true);
-    expect(turn.transcript).toBe("Please check status");
-    expect(provider.startListeningCalls).toHaveLength(1);
-    expect(provider.stopListeningCalls).toHaveLength(1);
-
-    const call = requireCall(manager, started.callId);
-    expect(call.transcript.map((entry) => entry.text)).toEqual([
-      "How can I help?",
-      "Please check status",
-    ]);
-    const metadata = call.metadata ?? {};
-    expect(typeof metadata.lastTurnLatencyMs).toBe("number");
-    expect(typeof metadata.lastTurnListenWaitMs).toBe("number");
-    expect(metadata.turnCount).toBe(1);
-  });
-
-  it("rejects overlapping continueCall requests for the same call", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000004");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-overlap-answered");
-
-    const first = manager.continueCall(started.callId, "First prompt");
-    const second = await manager.continueCall(started.callId, "Second prompt");
-    expect(second.success).toBe(false);
-    expect(second.error).toBe("Already waiting for transcript");
-
-    manager.processEvent({
-      id: "evt-overlap-speech",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "Done",
-      isFinal: true,
-    });
-
-    const firstResult = await first;
-    expect(firstResult.success).toBe(true);
-    expect(firstResult.transcript).toBe("Done");
-    expect(provider.startListeningCalls).toHaveLength(1);
-    expect(provider.stopListeningCalls).toHaveLength(1);
-  });
-
-  it("ignores speech events with mismatched turnToken while waiting for transcript", async () => {
-    const { manager, provider } = await createManagerHarness(
-      {
-        transcriptTimeoutMs: 5000,
-      },
-      new FakeProvider("twilio"),
-    );
-
-    const started = await manager.initiateCall("+15550000004");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-turn-token-answered");
-
-    const turnPromise = manager.continueCall(started.callId, "Prompt");
-    await new Promise((resolve) => setTimeout(resolve, 0));
-
-    const expectedTurnToken = requireTurnToken(provider);
-
-    manager.processEvent({
-      id: "evt-turn-token-bad",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "stale replay",
-      isFinal: true,
-      turnToken: "wrong-token",
-    });
-
-    const pendingState = await Promise.race([
-      turnPromise.then(() => "resolved"),
-      new Promise<"pending">((resolve) => setTimeout(() => resolve("pending"), 0)),
-    ]);
-    expect(pendingState).toBe("pending");
-
-    manager.processEvent({
-      id: "evt-turn-token-good",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "final answer",
-      isFinal: true,
-      turnToken: expectedTurnToken,
-    });
-
-    const turnResult = await turnPromise;
-    expect(turnResult.success).toBe(true);
-    expect(turnResult.transcript).toBe("final answer");
-
-    const call = requireCall(manager, started.callId);
-    expect(call.transcript.map((entry) => entry.text)).toEqual(["Prompt", "final answer"]);
-  });
-
-  it("tracks latency metadata across multiple closed-loop turns", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000005");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-multi-answered");
-
-    const firstTurn = manager.continueCall(started.callId, "First question");
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    manager.processEvent({
-      id: "evt-multi-speech-1",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "First answer",
-      isFinal: true,
-    });
-    await firstTurn;
-
-    const secondTurn = manager.continueCall(started.callId, "Second question");
-    await new Promise((resolve) => setTimeout(resolve, 0));
-    manager.processEvent({
-      id: "evt-multi-speech-2",
-      type: "call.speech",
-      callId: started.callId,
-      providerCallId: "request-uuid",
-      timestamp: Date.now(),
-      transcript: "Second answer",
-      isFinal: true,
-    });
-    const secondResult = await secondTurn;
-
-    expect(secondResult.success).toBe(true);
-
-    const call = requireCall(manager, started.callId);
-    expect(call.transcript.map((entry) => entry.text)).toEqual([
-      "First question",
-      "First answer",
-      "Second question",
-      "Second answer",
-    ]);
-    const metadata = call.metadata ?? {};
-    expect(metadata.turnCount).toBe(2);
-    expect(typeof metadata.lastTurnLatencyMs).toBe("number");
-    expect(typeof metadata.lastTurnListenWaitMs).toBe("number");
-    expect(provider.startListeningCalls).toHaveLength(2);
-    expect(provider.stopListeningCalls).toHaveLength(2);
-  });
-
-  it("handles repeated closed-loop turns without waiter churn", async () => {
-    const { manager, provider } = await createManagerHarness({
-      transcriptTimeoutMs: 5000,
-    });
-
-    const started = await manager.initiateCall("+15550000006");
-    expect(started.success).toBe(true);
-
-    markCallAnswered(manager, started.callId, "evt-loop-answered");
-
-    for (let i = 1; i <= 5; i++) {
-      const turnPromise = manager.continueCall(started.callId, `Prompt ${i}`);
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      manager.processEvent({
-        id: `evt-loop-speech-${i}`,
-        type: "call.speech",
-        callId: started.callId,
-        providerCallId: "request-uuid",
-        timestamp: Date.now(),
-        transcript: `Answer ${i}`,
-        isFinal: true,
-      });
-      const result = await turnPromise;
-      expect(result.success).toBe(true);
-      expect(result.transcript).toBe(`Answer ${i}`);
-    }
-
-    const call = requireCall(manager, started.callId);
-    const metadata = call.metadata ?? {};
-    expect(metadata.turnCount).toBe(5);
-    expect(provider.startListeningCalls).toHaveLength(5);
-    expect(provider.stopListeningCalls).toHaveLength(5);
-  });
-});

package/src/manager.inbound-allowlist.test.ts

@@ -1,188 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { FakeProvider, createManagerHarness } from "./manager.test-harness.js";
-
-describe("CallManager inbound allowlist", () => {
-  it("rejects inbound calls with missing caller ID when allowlist enabled", async () => {
-    const { manager, provider } = await createManagerHarness({
-      inboundPolicy: "allowlist",
-      allowFrom: ["+15550001234"],
-    });
-
-    manager.processEvent({
-      id: "evt-allowlist-missing",
-      type: "call.initiated",
-      callId: "call-missing",
-      providerCallId: "provider-missing",
-      timestamp: Date.now(),
-      direction: "inbound",
-      to: "+15550000000",
-    });
-
-    expect(manager.getCallByProviderCallId("provider-missing")).toBeUndefined();
-    expect(provider.hangupCalls).toEqual([
-      expect.objectContaining({ providerCallId: "provider-missing" }),
-    ]);
-  });
-
-  it("rejects inbound calls with anonymous caller ID when allowlist enabled", async () => {
-    const { manager, provider } = await createManagerHarness({
-      inboundPolicy: "allowlist",
-      allowFrom: ["+15550001234"],
-    });
-
-    manager.processEvent({
-      id: "evt-allowlist-anon",
-      type: "call.initiated",
-      callId: "call-anon",
-      providerCallId: "provider-anon",
-      timestamp: Date.now(),
-      direction: "inbound",
-      from: "anonymous",
-      to: "+15550000000",
-    });
-
-    expect(manager.getCallByProviderCallId("provider-anon")).toBeUndefined();
-    expect(provider.hangupCalls).toEqual([
-      expect.objectContaining({ providerCallId: "provider-anon" }),
-    ]);
-  });
-
-  it("rejects inbound calls that only match allowlist suffixes", async () => {
-    const { manager, provider } = await createManagerHarness({
-      inboundPolicy: "allowlist",
-      allowFrom: ["+15550001234"],
-    });
-
-    manager.processEvent({
-      id: "evt-allowlist-suffix",
-      type: "call.initiated",
-      callId: "call-suffix",
-      providerCallId: "provider-suffix",
-      timestamp: Date.now(),
-      direction: "inbound",
-      from: "+99915550001234",
-      to: "+15550000000",
-    });
-
-    expect(manager.getCallByProviderCallId("provider-suffix")).toBeUndefined();
-    expect(provider.hangupCalls).toEqual([
-      expect.objectContaining({ providerCallId: "provider-suffix" }),
-    ]);
-  });
-
-  it("rejects duplicate inbound events with a single hangup call", async () => {
-    const { manager, provider } = await createManagerHarness({
-      inboundPolicy: "disabled",
-    });
-
-    manager.processEvent({
-      id: "evt-reject-init",
-      type: "call.initiated",
-      callId: "provider-dup",
-      providerCallId: "provider-dup",
-      timestamp: Date.now(),
-      direction: "inbound",
-      from: "+15552222222",
-      to: "+15550000000",
-    });
-
-    manager.processEvent({
-      id: "evt-reject-ring",
-      type: "call.ringing",
-      callId: "provider-dup",
-      providerCallId: "provider-dup",
-      timestamp: Date.now(),
-      direction: "inbound",
-      from: "+15552222222",
-      to: "+15550000000",
-    });
-
-    expect(manager.getCallByProviderCallId("provider-dup")).toBeUndefined();
-    expect(provider.hangupCalls).toEqual([
-      expect.objectContaining({ providerCallId: "provider-dup" }),
-    ]);
-  });
-
-  it("retries rejected inbound hangup after a transient provider failure", async () => {
-    class FlakyHangupProvider extends FakeProvider {
-      hangupFailuresRemaining = 1;
-
-      override async hangupCall(input: Parameters<FakeProvider["hangupCall"]>[0]): Promise<void> {
-        this.hangupCalls.push(input);
-        if (this.hangupFailuresRemaining > 0) {
-          this.hangupFailuresRemaining -= 1;
-          throw new Error("provider down");
-        }
-      }
-    }
-
-    const provider = new FlakyHangupProvider();
-    const { manager } = await createManagerHarness(
-      {
-        inboundPolicy: "disabled",
-      },
-      provider,
-    );
-
-    manager.processEvent({
-      id: "evt-reject-fail-init",
-      type: "call.initiated",
-      callId: "provider-flaky",
-      providerCallId: "provider-flaky",
-      timestamp: Date.now(),
-      direction: "inbound",
-      from: "+15553333333",
-      to: "+15550000000",
-    });
-    await Promise.resolve();
-
-    manager.processEvent({
-      id: "evt-reject-fail-ring",
-      type: "call.ringing",
-      callId: "provider-flaky",
-      providerCallId: "provider-flaky",
-      timestamp: Date.now(),
-      direction: "inbound",
-      from: "+15553333333",
-      to: "+15550000000",
-    });
-
-    expect(manager.getCallByProviderCallId("provider-flaky")).toBeUndefined();
-    expect(provider.hangupCalls).toEqual([
-      expect.objectContaining({ providerCallId: "provider-flaky" }),
-      expect.objectContaining({ providerCallId: "provider-flaky" }),
-    ]);
-  });
-
-  it("accepts inbound calls that exactly match the allowlist", async () => {
-    const { manager } = await createManagerHarness({
-      inboundPolicy: "allowlist",
-      allowFrom: ["+15550001234"],
-    });
-
-    manager.processEvent({
-      id: "evt-allowlist-exact",
-      type: "call.initiated",
-      callId: "call-exact",
-      providerCallId: "provider-exact",
-      timestamp: Date.now(),
-      direction: "inbound",
-      from: "+15550001234",
-      to: "+15550000000",
-    });
-
-    const call = manager.getCallByProviderCallId("provider-exact");
-    if (!call) {
-      throw new Error("expected exact allowlist match to keep the inbound call");
-    }
-    expect(call).toMatchObject({
-      providerCallId: "provider-exact",
-      direction: "inbound",
-      from: "+15550001234",
-      to: "+15550000000",
-    });
-    expect(call.callId).toMatch(
-      /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
-    );
-  });
-});