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

package/src/telephony-tts.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import type { VoiceCallTtsConfig } from "./config.js";
 import type { CoreConfig } from "./core-bridge.js";
 import { createTelephonyTtsProvider } from "./telephony-tts.js";
@@ -6,14 +6,36 @@ import { createTelephonyTtsProvider } from "./telephony-tts.js";
 function createCoreConfig(): CoreConfig {
   const tts: VoiceCallTtsConfig = {
     provider: "openai",
-    openai: {
-      model: "gpt-4o-mini-tts",
-      voice: "alloy",
+    providers: {
+      openai: {
+        model: "gpt-4o-mini-tts",
+        voice: "alloy",
+      },
     },
   };
   return { messages: { tts } };
 }
 
+function requireMergedTtsConfig(mergedConfig: CoreConfig | undefined) {
+  const tts = mergedConfig?.messages?.tts;
+  if (!tts) {
+    throw new Error("telephony TTS runtime did not receive merged TTS config");
+  }
+  return tts as Record<string, unknown>;
+}
+
+function requireOpenAIProviderConfig(tts: Record<string, unknown>): Record<string, unknown> {
+  const providers =
+    tts.providers && typeof tts.providers === "object"
+      ? (tts.providers as Record<string, unknown>)
+      : null;
+  const openai = providers?.openai;
+  if (!openai || typeof openai !== "object") {
+    throw new Error("merged TTS config did not preserve providers.openai");
+  }
+  return openai as Record<string, unknown>;
+}
+
 async function mergeOverride(override: unknown): Promise<Record<string, unknown>> {
   let mergedConfig: CoreConfig | undefined;
   const provider = createTelephonyTtsProvider({
@@ -32,8 +54,7 @@ async function mergeOverride(override: unknown): Promise<Record<string, unknown>
   });
 
   await provider.synthesizeForTelephony("hello");
-  expect(mergedConfig?.messages?.tts).toBeDefined();
-  return mergedConfig?.messages?.tts as Record<string, unknown>;
+  return requireMergedTtsConfig(mergedConfig);
 }
 
 afterEach(() => {
@@ -43,9 +64,9 @@ afterEach(() => {
 describe("createTelephonyTtsProvider deepMerge hardening", () => {
   it("merges safe nested overrides", async () => {
     const tts = await mergeOverride({
-      openai: { voice: "coral" },
+      providers: { openai: { voice: "coral" } },
     });
-    const openai = tts.openai as Record<string, unknown>;
+    const openai = requireOpenAIProviderConfig(tts);
 
     expect(openai.voice).toBe("coral");
     expect(openai.model).toBe("gpt-4o-mini-tts");
@@ -53,9 +74,9 @@ describe("createTelephonyTtsProvider deepMerge hardening", () => {
 
   it("blocks top-level __proto__ keys", async () => {
     const tts = await mergeOverride(
-      JSON.parse('{"__proto__":{"polluted":"top"},"openai":{"voice":"coral"}}'),
+      JSON.parse('{"__proto__":{"polluted":"top"},"providers":{"openai":{"voice":"coral"}}}'),
     );
-    const openai = tts.openai as Record<string, unknown>;
+    const openai = requireOpenAIProviderConfig(tts);
 
     expect((Object.prototype as Record<string, unknown>).polluted).toBeUndefined();
     expect(tts.polluted).toBeUndefined();
@@ -64,12 +85,112 @@ describe("createTelephonyTtsProvider deepMerge hardening", () => {
 
   it("blocks nested __proto__ keys", async () => {
     const tts = await mergeOverride(
-      JSON.parse('{"openai":{"model":"safe","__proto__":{"polluted":"nested"}}}'),
+      JSON.parse('{"providers":{"openai":{"model":"safe","__proto__":{"polluted":"nested"}}}}'),
     );
-    const openai = tts.openai as Record<string, unknown>;
+    const openai = requireOpenAIProviderConfig(tts);
 
     expect((Object.prototype as Record<string, unknown>).polluted).toBeUndefined();
     expect(openai.polluted).toBeUndefined();
     expect(openai.model).toBe("safe");
   });
+
+  it("logs fallback metadata when telephony TTS uses a fallback provider", async () => {
+    const warn = vi.fn();
+    const provider = createTelephonyTtsProvider({
+      coreConfig: createCoreConfig(),
+      runtime: {
+        textToSpeechTelephony: async () => ({
+          success: true,
+          audioBuffer: Buffer.alloc(2),
+          sampleRate: 8000,
+          provider: "microsoft",
+          fallbackFrom: "elevenlabs",
+          attemptedProviders: ["elevenlabs", "microsoft"],
+        }),
+      },
+      logger: { warn },
+    });
+
+    await provider.synthesizeForTelephony("hello");
+    expect(warn).toHaveBeenCalledWith(
+      "[voice-call] Telephony TTS fallback used from=elevenlabs to=microsoft attempts=elevenlabs -> microsoft",
+    );
+  });
+
+  it("strips telephony TTS directive tags before synthesis", async () => {
+    let requestText: string | undefined;
+    const provider = createTelephonyTtsProvider({
+      coreConfig: createCoreConfig(),
+      runtime: {
+        textToSpeechTelephony: async ({ text }) => {
+          requestText = text;
+          return {
+            success: true,
+            audioBuffer: Buffer.alloc(2),
+            sampleRate: 8000,
+          };
+        },
+      },
+    });
+
+    await provider.synthesizeForTelephony("[[tts]]Hello caller[[/tts]]");
+
+    expect(requestText).toBe("Hello caller");
+  });
+
+  it("uses hidden telephony TTS directive text for synthesis", async () => {
+    let requestText: string | undefined;
+    let requestOverrides: unknown;
+    const provider = createTelephonyTtsProvider({
+      coreConfig: createCoreConfig(),
+      runtime: {
+        textToSpeechTelephony: async ({ text, overrides }) => {
+          requestText = text;
+          requestOverrides = overrides;
+          return {
+            success: true,
+            audioBuffer: Buffer.alloc(2),
+            sampleRate: 8000,
+          };
+        },
+      },
+    });
+
+    await provider.synthesizeForTelephony(
+      "Visible text [[tts:text]]Speak this instead[[/tts:text]]",
+    );
+
+    expect(requestText).toBe("Speak this instead");
+    expect(requestOverrides).toMatchObject({ ttsText: "Speak this instead" });
+  });
+
+  it("exposes configured timeoutMs as synthesisTimeoutMs", () => {
+    const provider = createTelephonyTtsProvider({
+      coreConfig: { messages: { tts: { provider: "openai", timeoutMs: 15000 } } },
+      runtime: {
+        textToSpeechTelephony: async () => ({
+          success: true,
+          audioBuffer: Buffer.alloc(2),
+          sampleRate: 8000,
+        }),
+      },
+    });
+
+    expect(provider.synthesisTimeoutMs).toBe(15000);
+  });
+
+  it("keeps the telephony timeout default when timeoutMs is not configured", () => {
+    const provider = createTelephonyTtsProvider({
+      coreConfig: createCoreConfig(),
+      runtime: {
+        textToSpeechTelephony: async () => ({
+          success: true,
+          audioBuffer: Buffer.alloc(2),
+          sampleRate: 8000,
+        }),
+      },
+    });
+
+    expect(provider.synthesisTimeoutMs).toBe(8000);
+  });
 });

package/src/telephony-tts.ts

@@ -1,3 +1,9 @@
+import {
+  parseTtsDirectives,
+  type SpeechModelOverridePolicy,
+  type SpeechProviderConfig,
+  type TtsDirectiveOverrides,
+} from "openclaw/plugin-sdk/speech";
 import type { VoiceCallTtsConfig } from "./config.js";
 import type { CoreConfig } from "./core-bridge.js";
 import { deepMergeDefined } from "./deep-merge.js";
@@ -8,38 +14,91 @@ export type TelephonyTtsRuntime = {
     text: string;
     cfg: CoreConfig;
     prefsPath?: string;
+    overrides?: TtsDirectiveOverrides;
   }) => Promise<{
     success: boolean;
     audioBuffer?: Buffer;
     sampleRate?: number;
     provider?: string;
+    fallbackFrom?: string;
+    attemptedProviders?: string[];
     error?: string;
   }>;
 };
 
 export type TelephonyTtsProvider = {
+  synthesisTimeoutMs: number;
   synthesizeForTelephony: (text: string) => Promise<Buffer>;
 };
 
+export const TELEPHONY_DEFAULT_TTS_TIMEOUT_MS = 8000;
+
+type TelephonyModelOverrideConfig = {
+  enabled?: boolean;
+  allowText?: boolean;
+  allowProvider?: boolean;
+  allowVoice?: boolean;
+  allowModelId?: boolean;
+  allowVoiceSettings?: boolean;
+  allowNormalization?: boolean;
+  allowSeed?: boolean;
+};
+
 export function createTelephonyTtsProvider(params: {
   coreConfig: CoreConfig;
   ttsOverride?: VoiceCallTtsConfig;
   runtime: TelephonyTtsRuntime;
+  logger?: {
+    warn?: (message: string) => void;
+  };
 }): TelephonyTtsProvider {
-  const { coreConfig, ttsOverride, runtime } = params;
+  const { coreConfig, ttsOverride, runtime, logger } = params;
   const mergedConfig = applyTtsOverride(coreConfig, ttsOverride);
+  const ttsConfig = mergedConfig.messages?.tts;
+  const modelOverrides = resolveTelephonyModelOverridePolicy(
+    readTelephonyModelOverrides(ttsConfig),
+  );
+  const providerConfigs = collectTelephonyProviderConfigs(ttsConfig);
+  const activeProvider = normalizeProviderId(ttsConfig?.provider);
+  const synthesisTimeoutMs =
+    mergedConfig.messages?.tts?.timeoutMs ?? TELEPHONY_DEFAULT_TTS_TIMEOUT_MS;
 
   return {
+    synthesisTimeoutMs,
     synthesizeForTelephony: async (text: string) => {
+      const directives = parseTtsDirectives(text, modelOverrides, {
+        cfg: mergedConfig,
+        providerConfigs,
+        preferredProviderId: activeProvider,
+      });
+      if (directives.warnings.length > 0) {
+        logger?.warn?.(
+          `[voice-call] Ignored telephony TTS directive overrides (${directives.warnings.join("; ")})`,
+        );
+      }
+      const cleanText = directives.hasDirective
+        ? directives.ttsText?.trim() || directives.cleanedText.trim()
+        : text;
       const result = await runtime.textToSpeechTelephony({
-        text,
+        text: cleanText,
         cfg: mergedConfig,
+        overrides: directives.overrides,
       });
 
       if (!result.success || !result.audioBuffer || !result.sampleRate) {
         throw new Error(result.error ?? "TTS conversion failed");
       }
 
+      if (result.fallbackFrom && result.provider && result.fallbackFrom !== result.provider) {
+        const attemptedChain =
+          result.attemptedProviders && result.attemptedProviders.length > 0
+            ? result.attemptedProviders.join(" -> ")
+            : `${result.fallbackFrom} -> ${result.provider}`;
+        logger?.warn?.(
+          `[voice-call] Telephony TTS fallback used from=${result.fallbackFrom} to=${result.provider} attempts=${attemptedChain}`,
+        );
+      }
+
       return convertPcmToMulaw8k(result.audioBuffer, result.sampleRate);
     },
   };
@@ -80,3 +139,97 @@ function mergeTtsConfig(
   }
   return deepMergeDefined(base, override) as VoiceCallTtsConfig;
 }
+
+function resolveTelephonyModelOverridePolicy(
+  overrides: TelephonyModelOverrideConfig | undefined,
+): SpeechModelOverridePolicy {
+  const enabled = overrides?.enabled ?? true;
+  if (!enabled) {
+    return {
+      enabled: false,
+      allowText: false,
+      allowProvider: false,
+      allowVoice: false,
+      allowModelId: false,
+      allowVoiceSettings: false,
+      allowNormalization: false,
+      allowSeed: false,
+    };
+  }
+  const allow = (value: boolean | undefined, defaultValue = true) => value ?? defaultValue;
+  return {
+    enabled: true,
+    allowText: allow(overrides?.allowText),
+    allowProvider: allow(overrides?.allowProvider, false),
+    allowVoice: allow(overrides?.allowVoice),
+    allowModelId: allow(overrides?.allowModelId),
+    allowVoiceSettings: allow(overrides?.allowVoiceSettings),
+    allowNormalization: allow(overrides?.allowNormalization),
+    allowSeed: allow(overrides?.allowSeed),
+  };
+}
+
+function readTelephonyModelOverrides(
+  ttsConfig: VoiceCallTtsConfig | undefined,
+): TelephonyModelOverrideConfig | undefined {
+  const value = (ttsConfig as Record<string, unknown> | undefined)?.modelOverrides;
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as TelephonyModelOverrideConfig)
+    : undefined;
+}
+
+function normalizeProviderId(value: unknown): string | undefined {
+  return typeof value === "string" ? value.trim().toLowerCase() || undefined : undefined;
+}
+
+function asProviderConfig(value: unknown): SpeechProviderConfig {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as SpeechProviderConfig)
+    : {};
+}
+
+function collectTelephonyProviderConfigs(
+  ttsConfig: VoiceCallTtsConfig | undefined,
+): Record<string, SpeechProviderConfig> {
+  if (!ttsConfig) {
+    return {};
+  }
+  const entries: Record<string, SpeechProviderConfig> = {};
+  const rawProviders =
+    ttsConfig.providers &&
+    typeof ttsConfig.providers === "object" &&
+    !Array.isArray(ttsConfig.providers)
+      ? (ttsConfig.providers as Record<string, unknown>)
+      : {};
+  for (const [providerId, value] of Object.entries(rawProviders)) {
+    const normalized = normalizeProviderId(providerId) ?? providerId;
+    entries[normalized] = asProviderConfig(value);
+  }
+  const reservedKeys = new Set([
+    "auto",
+    "enabled",
+    "maxTextLength",
+    "mode",
+    "modelOverrides",
+    "persona",
+    "personas",
+    "prefsPath",
+    "provider",
+    "providers",
+    "summaryModel",
+    "timeoutMs",
+  ]);
+  for (const [key, value] of Object.entries(ttsConfig as Record<string, unknown>)) {
+    if (
+      reservedKeys.has(key) ||
+      typeof value !== "object" ||
+      value === null ||
+      Array.isArray(value)
+    ) {
+      continue;
+    }
+    const normalized = normalizeProviderId(key) ?? key;
+    entries[normalized] ??= asProviderConfig(value);
+  }
+  return entries;
+}

package/src/test-fixtures.ts

@@ -1,4 +1,5 @@
 import type { VoiceCallConfig } from "./config.js";
+import { DEFAULT_VOICE_CALL_REALTIME_INSTRUCTIONS } from "./realtime-defaults.js";
 
 export function createVoiceCallBaseConfig(params?: {
   provider?: "telnyx" | "twilio" | "plivo" | "mock";
@@ -10,6 +11,7 @@ export function createVoiceCallBaseConfig(params?: {
     fromNumber: "+15550001234",
     inboundPolicy: "disabled",
     allowFrom: [],
+    numbers: {},
     outbound: { defaultMode: "notify", notifyHangupDelaySec: 3 },
     maxDurationSeconds: 300,
     staleCallReaperSeconds: 600,
@@ -17,6 +19,7 @@ export function createVoiceCallBaseConfig(params?: {
     transcriptTimeoutMs: 180000,
     ringTimeoutMs: 30000,
     maxConcurrentCalls: 1,
+    sessionScope: "per-phone",
     serve: { port: 3334, bind: "127.0.0.1", path: "/voice/webhook" },
     tailscale: { mode: "off", path: "/voice/webhook" },
     tunnel: {
@@ -30,23 +33,41 @@ export function createVoiceCallBaseConfig(params?: {
     },
     streaming: {
       enabled: false,
-      sttProvider: "openai-realtime",
-      sttModel: "gpt-4o-transcribe",
-      silenceDurationMs: 800,
-      vadThreshold: 0.5,
+      providers: {
+        openai: {
+          model: "gpt-4o-transcribe",
+          silenceDurationMs: 800,
+          vadThreshold: 0.5,
+        },
+      },
       streamPath: "/voice/stream",
       preStartTimeoutMs: 5000,
       maxPendingConnections: 32,
       maxPendingConnectionsPerIp: 4,
       maxConnections: 128,
     },
+    realtime: {
+      enabled: false,
+      streamPath: "/voice/stream/realtime",
+      instructions: DEFAULT_VOICE_CALL_REALTIME_INSTRUCTIONS,
+      toolPolicy: "safe-read-only",
+      tools: [],
+      fastContext: {
+        enabled: false,
+        timeoutMs: 800,
+        maxResults: 3,
+        sources: ["memory", "sessions"],
+        fallbackToConsult: false,
+      },
+      providers: {},
+    },
     skipSignatureVerification: false,
-    stt: { provider: "openai", model: "whisper-1" },
     tts: {
       provider: "openai",
-      openai: { model: "gpt-4o-mini-tts", voice: "coral" },
+      providers: {
+        openai: { model: "gpt-4o-mini-tts", voice: "coral" },
+      },
     },
-    responseModel: "openai/gpt-4o-mini",
     responseTimeoutMs: 30000,
   };
 }

package/src/tts-provider-voice.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from "vitest";
+import { resolvePreferredTtsVoice } from "./tts-provider-voice.js";
+
+describe("resolvePreferredTtsVoice", () => {
+  it("returns provider voice when present", () => {
+    expect(
+      resolvePreferredTtsVoice({
+        tts: {
+          provider: "openai",
+          providers: {
+            openai: {
+              voice: "coral",
+            },
+          },
+        },
+      }),
+    ).toBe("coral");
+  });
+
+  it("falls back to voiceId for providers that use that field", () => {
+    expect(
+      resolvePreferredTtsVoice({
+        tts: {
+          provider: "elevenlabs",
+          providers: {
+            elevenlabs: {
+              voiceId: "voice-123",
+            },
+          },
+        },
+      }),
+    ).toBe("voice-123");
+  });
+});

package/src/tts-provider-voice.ts

@@ -0,0 +1,21 @@
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+import type { VoiceCallTtsConfig } from "./config.js";
+
+function resolveProviderVoiceSetting(providerConfig: unknown): string | undefined {
+  if (!providerConfig || typeof providerConfig !== "object") {
+    return undefined;
+  }
+  const candidate = providerConfig as {
+    voice?: unknown;
+    voiceId?: unknown;
+  };
+  return normalizeOptionalString(candidate.voice) ?? normalizeOptionalString(candidate.voiceId);
+}
+
+export function resolvePreferredTtsVoice(config: { tts?: VoiceCallTtsConfig }): string | undefined {
+  const providerId = config.tts?.provider;
+  if (!providerId) {
+    return undefined;
+  }
+  return resolveProviderVoiceSetting(config.tts?.providers?.[providerId]);
+}

package/src/tunnel.test.ts

@@ -0,0 +1,166 @@
+import { EventEmitter } from "node:events";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+class FakeChildProcess extends EventEmitter {
+  readonly stdout = new EventEmitter();
+  readonly stderr = new EventEmitter();
+  killedWith: NodeJS.Signals | null = null;
+
+  kill(signal: NodeJS.Signals = "SIGTERM"): boolean {
+    this.killedWith = signal;
+    queueMicrotask(() => this.emit("close", null));
+    return true;
+  }
+
+  close(code: number | null = 0): void {
+    this.emit("close", code);
+  }
+
+  fail(error: Error): void {
+    this.emit("error", error);
+  }
+}
+
+const mocks = vi.hoisted(() => ({
+  spawn: vi.fn(),
+  getTailscaleDnsName: vi.fn(),
+}));
+
+vi.mock("node:child_process", () => ({
+  spawn: mocks.spawn,
+}));
+
+vi.mock("./webhook/tailscale.js", () => ({
+  getTailscaleDnsName: mocks.getTailscaleDnsName,
+}));
+
+import { isNgrokAvailable, startNgrokTunnel, startTailscaleTunnel, startTunnel } from "./tunnel.js";
+
+function nextProcess(): FakeChildProcess {
+  const proc = new FakeChildProcess();
+  mocks.spawn.mockReturnValueOnce(proc as never);
+  return proc;
+}
+
+function emitNgrokUrl(proc: FakeChildProcess, url: string): void {
+  proc.stdout.emit("data", Buffer.from(`${JSON.stringify({ msg: "started tunnel", url })}\n`));
+}
+
+describe("voice-call tunnels", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mocks.getTailscaleDnsName.mockReset();
+  });
+
+  it("checks ngrok availability from the version command exit code", async () => {
+    const proc = nextProcess();
+    const result = isNgrokAvailable();
+    proc.close(0);
+
+    await expect(result).resolves.toBe(true);
+    expect(mocks.spawn).toHaveBeenCalledWith("ngrok", ["version"], expect.any(Object));
+  });
+
+  it("treats ngrok spawn failures as unavailable", async () => {
+    const proc = nextProcess();
+    const result = isNgrokAvailable();
+    proc.fail(new Error("spawn ngrok ENOENT"));
+
+    await expect(result).resolves.toBe(false);
+  });
+
+  it("starts ngrok and appends the webhook path to the public URL", async () => {
+    const proc = nextProcess();
+    const result = startNgrokTunnel({ port: 3334, path: "/voice/webhook" });
+
+    emitNgrokUrl(proc, "https://abc.ngrok.io");
+
+    await expect(result).resolves.toMatchObject({
+      publicUrl: "https://abc.ngrok.io/voice/webhook",
+      provider: "ngrok",
+    });
+    expect(mocks.spawn).toHaveBeenCalledWith(
+      "ngrok",
+      expect.arrayContaining(["http", "3334"]),
+      expect.any(Object),
+    );
+  });
+
+  it("sets ngrok auth token before starting the tunnel", async () => {
+    const authProc = nextProcess();
+    const tunnelProc = nextProcess();
+    const result = startNgrokTunnel({
+      port: 3334,
+      path: "/hook",
+      authToken: "token",
+    });
+
+    authProc.close(0);
+    await vi.waitFor(() => expect(mocks.spawn).toHaveBeenCalledTimes(2));
+    emitNgrokUrl(tunnelProc, "https://auth.ngrok.io");
+
+    await expect(result).resolves.toMatchObject({
+      publicUrl: "https://auth.ngrok.io/hook",
+    });
+    expect(mocks.spawn).toHaveBeenNthCalledWith(
+      1,
+      "ngrok",
+      ["config", "add-authtoken", "token"],
+      expect.any(Object),
+    );
+  });
+
+  it("rejects ngrok startup errors from stderr", async () => {
+    const proc = nextProcess();
+    const result = startNgrokTunnel({ port: 3334, path: "/hook" });
+
+    proc.stderr.emit("data", Buffer.from("ERR_NGROK_3200: invalid auth token"));
+
+    await expect(result).rejects.toThrow("ngrok error:");
+  });
+
+  it("starts Tailscale serve using the resolved tailnet DNS name", async () => {
+    mocks.getTailscaleDnsName.mockResolvedValue("host.tailnet.ts.net");
+    const proc = nextProcess();
+    const result = startTailscaleTunnel({
+      mode: "serve",
+      port: 3334,
+      path: "voice/webhook",
+    });
+
+    await vi.waitFor(() => expect(mocks.spawn).toHaveBeenCalled());
+    proc.close(0);
+
+    await expect(result).resolves.toMatchObject({
+      publicUrl: "https://host.tailnet.ts.net/voice/webhook",
+      provider: "tailscale-serve",
+    });
+    expect(mocks.spawn).toHaveBeenCalledWith(
+      "tailscale",
+      expect.arrayContaining(["serve", "--set-path", "/voice/webhook"]),
+      expect.any(Object),
+    );
+  });
+
+  it("rejects Tailscale tunnel startup when the DNS name is unavailable", async () => {
+    mocks.getTailscaleDnsName.mockResolvedValue(null);
+
+    await expect(
+      startTailscaleTunnel({ mode: "funnel", port: 3334, path: "/hook" }),
+    ).rejects.toThrow("Could not get Tailscale DNS name");
+    expect(mocks.spawn).not.toHaveBeenCalled();
+  });
+
+  it("dispatches tunnel providers from config", async () => {
+    await expect(startTunnel({ provider: "none", port: 3334, path: "/hook" })).resolves.toBeNull();
+
+    const proc = nextProcess();
+    const result = startTunnel({ provider: "ngrok", port: 3334, path: "/hook" });
+    emitNgrokUrl(proc, "https://dispatch.ngrok.io");
+
+    await expect(result).resolves.toMatchObject({
+      publicUrl: "https://dispatch.ngrok.io/hook",
+      provider: "ngrok",
+    });
+  });
+});

package/src/tunnel.ts

@@ -4,7 +4,7 @@ import { getTailscaleDnsName } from "./webhook/tailscale.js";
 /**
  * Tunnel configuration for exposing the webhook server.
  */
-export interface TunnelConfig {
+interface TunnelConfig {
   /** Tunnel provider: ngrok, tailscale-serve, or tailscale-funnel */
   provider: "ngrok" | "tailscale-serve" | "tailscale-funnel" | "none";
   /** Local port to tunnel */