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

package/src/runtime.test.ts

@@ -1,3 +1,4 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type { VoiceCallConfig } from "./config.js";
 import type { CoreConfig } from "./core-bridge.js";
@@ -5,35 +6,88 @@ import { createVoiceCallBaseConfig } from "./test-fixtures.js";
 
 const mocks = vi.hoisted(() => ({
   resolveVoiceCallConfig: vi.fn(),
+  resolveTwilioAuthToken: vi.fn(),
   validateProviderConfig: vi.fn(),
   managerInitialize: vi.fn(),
+  managerGetCall: vi.fn(),
   webhookStart: vi.fn(),
   webhookStop: vi.fn(),
+  webhookSetRealtimeHandler: vi.fn(),
+  webhookGetRealtimeHandler: vi.fn(),
   webhookGetMediaStreamHandler: vi.fn(),
+  webhookCtorArgs: [] as unknown[][],
+  realtimeHandlerCtorArgs: [] as unknown[][],
+  realtimeHandlerRegisterToolHandler: vi.fn(),
+  realtimeHandlerSetPublicUrl: vi.fn(),
+  resolveConfiguredRealtimeVoiceProvider: vi.fn(),
+  getActiveMemorySearchManager: vi.fn(),
+  memorySearch: vi.fn(),
   startTunnel: vi.fn(),
   setupTailscaleExposure: vi.fn(),
   cleanupTailscaleExposure: vi.fn(),
 }));
 
 vi.mock("./config.js", () => ({
+  resolveVoiceCallSessionKey: (params: {
+    config: Pick<VoiceCallConfig, "sessionScope">;
+    callId: string;
+    phone?: string;
+    explicitSessionKey?: string;
+  }) => {
+    const explicit = params.explicitSessionKey?.trim();
+    if (explicit) {
+      return explicit;
+    }
+    if (params.config.sessionScope === "per-call") {
+      return `voice:call:${params.callId}`;
+    }
+    const normalizedPhone = params.phone?.replace(/\D/g, "");
+    return normalizedPhone ? `voice:${normalizedPhone}` : `voice:${params.callId}`;
+  },
+  resolveVoiceCallEffectiveConfig: (config: VoiceCallConfig) => ({ config }),
   resolveVoiceCallConfig: mocks.resolveVoiceCallConfig,
+  resolveTwilioAuthToken: mocks.resolveTwilioAuthToken,
   validateProviderConfig: mocks.validateProviderConfig,
 }));
 
 vi.mock("./manager.js", () => ({
   CallManager: class {
     initialize = mocks.managerInitialize;
+    getCall = mocks.managerGetCall;
   },
 }));
 
 vi.mock("./webhook.js", () => ({
   VoiceCallWebhookServer: class {
+    constructor(...args: unknown[]) {
+      mocks.webhookCtorArgs.push(args);
+    }
     start = mocks.webhookStart;
     stop = mocks.webhookStop;
+    setRealtimeHandler = mocks.webhookSetRealtimeHandler;
+    getRealtimeHandler = mocks.webhookGetRealtimeHandler;
     getMediaStreamHandler = mocks.webhookGetMediaStreamHandler;
   },
 }));
 
+vi.mock("./realtime-voice.runtime.js", () => ({
+  resolveConfiguredRealtimeVoiceProvider: mocks.resolveConfiguredRealtimeVoiceProvider,
+}));
+
+vi.mock("./webhook/realtime-handler.js", () => ({
+  RealtimeCallHandler: class {
+    constructor(...args: unknown[]) {
+      mocks.realtimeHandlerCtorArgs.push(args);
+    }
+    registerToolHandler = mocks.realtimeHandlerRegisterToolHandler;
+    setPublicUrl = mocks.realtimeHandlerSetPublicUrl;
+  },
+}));
+
+vi.mock("openclaw/plugin-sdk/memory-host-search", () => ({
+  getActiveMemorySearchManager: mocks.getActiveMemorySearchManager,
+}));
+
 vi.mock("./tunnel.js", () => ({
   startTunnel: mocks.startTunnel,
 }));
@@ -49,15 +103,66 @@ function createBaseConfig(): VoiceCallConfig {
   return createVoiceCallBaseConfig({ tunnelProvider: "ngrok" });
 }
 
+function createExternalProviderConfig(params: {
+  provider: "twilio" | "telnyx" | "plivo";
+  publicUrl?: string;
+}): VoiceCallConfig {
+  const config = createVoiceCallBaseConfig({
+    provider: params.provider,
+    tunnelProvider: "none",
+  });
+  config.twilio = {
+    accountSid: "AC123",
+    authToken: "secret",
+  };
+  config.telnyx = {
+    apiKey: "key",
+    connectionId: "conn",
+    publicKey: "pub",
+  };
+  config.plivo = {
+    authId: "MA123",
+    authToken: "secret",
+  };
+  if (params.publicUrl) {
+    config.publicUrl = params.publicUrl;
+  }
+  return config;
+}
+
 describe("createVoiceCallRuntime lifecycle", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     mocks.resolveVoiceCallConfig.mockImplementation((cfg: VoiceCallConfig) => cfg);
+    mocks.resolveTwilioAuthToken.mockImplementation(
+      (cfg: VoiceCallConfig) => cfg.twilio?.authToken,
+    );
     mocks.validateProviderConfig.mockReturnValue({ valid: true, errors: [] });
     mocks.managerInitialize.mockResolvedValue(undefined);
+    mocks.managerGetCall.mockReset();
     mocks.webhookStart.mockResolvedValue("http://127.0.0.1:3334/voice/webhook");
     mocks.webhookStop.mockResolvedValue(undefined);
+    mocks.webhookSetRealtimeHandler.mockReset();
+    mocks.webhookGetRealtimeHandler.mockReturnValue({
+      setPublicUrl: mocks.realtimeHandlerSetPublicUrl,
+    });
     mocks.webhookGetMediaStreamHandler.mockReturnValue(undefined);
+    mocks.webhookCtorArgs.length = 0;
+    mocks.realtimeHandlerCtorArgs.length = 0;
+    mocks.realtimeHandlerRegisterToolHandler.mockReset();
+    mocks.realtimeHandlerSetPublicUrl.mockReset();
+    mocks.resolveConfiguredRealtimeVoiceProvider.mockResolvedValue({
+      provider: { id: "openai" },
+      providerConfig: { model: "gpt-realtime" },
+    });
+    mocks.getActiveMemorySearchManager.mockReset();
+    mocks.memorySearch.mockReset();
+    mocks.getActiveMemorySearchManager.mockResolvedValue({
+      manager: {
+        search: mocks.memorySearch,
+      },
+    });
+    mocks.memorySearch.mockResolvedValue([]);
     mocks.startTunnel.mockResolvedValue(null);
     mocks.setupTailscaleExposure.mockResolvedValue(null);
     mocks.cleanupTailscaleExposure.mockResolvedValue(undefined);
@@ -76,6 +181,7 @@ describe("createVoiceCallRuntime lifecycle", () => {
       createVoiceCallRuntime({
         config: createBaseConfig(),
         coreConfig: {},
+        agentRuntime: {} as never,
       }),
     ).rejects.toThrow("init failed");
 
@@ -95,6 +201,7 @@ describe("createVoiceCallRuntime lifecycle", () => {
     const runtime = await createVoiceCallRuntime({
       config: createBaseConfig(),
       coreConfig: {} as CoreConfig,
+      agentRuntime: {} as never,
     });
 
     await runtime.stop();
@@ -104,4 +211,326 @@ describe("createVoiceCallRuntime lifecycle", () => {
     expect(mocks.cleanupTailscaleExposure).toHaveBeenCalledTimes(1);
     expect(mocks.webhookStop).toHaveBeenCalledTimes(1);
   });
+
+  it("passes fullConfig to the webhook server for streaming provider resolution", async () => {
+    const coreConfig = { messages: { tts: { provider: "openai" } } } as CoreConfig;
+    const fullConfig = {
+      plugins: {
+        entries: {
+          openai: { enabled: true },
+        },
+      },
+    } as OpenClawConfig;
+
+    await createVoiceCallRuntime({
+      config: createBaseConfig(),
+      coreConfig,
+      fullConfig,
+      agentRuntime: {} as never,
+    });
+
+    expect(mocks.webhookCtorArgs[0]?.[3]).toBe(coreConfig);
+    expect(mocks.webhookCtorArgs[0]?.[4]).toBe(fullConfig);
+  });
+
+  it.each(["twilio", "telnyx", "plivo"] as const)(
+    "fails closed when %s falls back to a local-only webhook",
+    async (provider) => {
+      await expect(
+        createVoiceCallRuntime({
+          config: createExternalProviderConfig({ provider }),
+          coreConfig: {} as CoreConfig,
+          agentRuntime: {} as never,
+        }),
+      ).rejects.toThrow(`${provider} requires a publicly reachable webhook URL`);
+      expect(mocks.webhookStop).toHaveBeenCalledTimes(1);
+    },
+  );
+
+  it.each([
+    "http://127.0.0.1:3334/voice/webhook",
+    "http://[::1]:3334/voice/webhook",
+    "http://[fd00::1]/voice/webhook",
+  ])("fails closed when Twilio publicUrl %s points at a local-only webhook", async (publicUrl) => {
+    await expect(
+      createVoiceCallRuntime({
+        config: createExternalProviderConfig({
+          provider: "twilio",
+          publicUrl,
+        }),
+        coreConfig: {} as CoreConfig,
+        agentRuntime: {} as never,
+      }),
+    ).rejects.toThrow("twilio requires a publicly reachable webhook URL");
+    expect(mocks.webhookStop).toHaveBeenCalledTimes(1);
+  });
+
+  it("accepts an explicit public URL for external voice providers", async () => {
+    const runtime = await createVoiceCallRuntime({
+      config: createExternalProviderConfig({
+        provider: "twilio",
+        publicUrl: "https://voice.example.com/voice/webhook",
+      }),
+      coreConfig: {} as CoreConfig,
+      agentRuntime: {} as never,
+    });
+
+    expect(runtime.webhookUrl).toBe("https://voice.example.com/voice/webhook");
+    expect(runtime.publicUrl).toBe("https://voice.example.com/voice/webhook");
+
+    await runtime.stop();
+  });
+
+  it("does not log duplicate webhook and public URLs when they match", async () => {
+    const logger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    };
+
+    const runtime = await createVoiceCallRuntime({
+      config: createExternalProviderConfig({
+        provider: "twilio",
+        publicUrl: "https://voice.example.com/voice/webhook",
+      }),
+      coreConfig: {} as CoreConfig,
+      agentRuntime: {} as never,
+      logger,
+    });
+
+    expect(logger.info).toHaveBeenCalledWith(
+      "[voice-call] Webhook URL: https://voice.example.com/voice/webhook",
+    );
+    expect(logger.info).not.toHaveBeenCalledWith(
+      "[voice-call] Public URL: https://voice.example.com/voice/webhook",
+    );
+
+    await runtime.stop();
+  });
+
+  it("wires the shared realtime agent consult tool and handler", async () => {
+    const config = createBaseConfig();
+    config.inboundPolicy = "allowlist";
+    config.realtime.enabled = true;
+    config.realtime.tools = [
+      {
+        type: "function",
+        name: "custom_tool",
+        description: "Custom tool",
+        parameters: { type: "object", properties: {} },
+      },
+    ];
+    const sessionStore: Record<string, unknown> = {};
+    const runEmbeddedPiAgent = vi.fn(async () => ({
+      payloads: [{ text: "Use the shipment status." }],
+      meta: {},
+    }));
+    const agentRuntime = {
+      defaults: { provider: "openai", model: "gpt-5.4" },
+      resolveAgentDir: vi.fn(() => "/tmp/agent"),
+      resolveAgentWorkspaceDir: vi.fn(() => "/tmp/workspace"),
+      resolveAgentIdentity: vi.fn(),
+      resolveThinkingDefault: vi.fn(() => "high"),
+      resolveAgentTimeoutMs: vi.fn(() => 30_000),
+      ensureAgentWorkspace: vi.fn(async () => {}),
+      session: {
+        resolveStorePath: vi.fn(() => "/tmp/sessions.json"),
+        loadSessionStore: vi.fn(() => sessionStore),
+        saveSessionStore: vi.fn(async () => {}),
+        updateSessionStore: vi.fn(async (_storePath, mutator) => mutator(sessionStore as never)),
+        resolveSessionFilePath: vi.fn(() => "/tmp/session.json"),
+      },
+      runEmbeddedPiAgent,
+    };
+    mocks.managerGetCall.mockReturnValue({
+      callId: "call-1",
+      direction: "outbound",
+      from: "+15550001234",
+      to: "+15550009999",
+      transcript: [{ speaker: "user", text: "Can you check shipment status?" }],
+    });
+
+    await createVoiceCallRuntime({
+      config,
+      coreConfig: {} as CoreConfig,
+      agentRuntime: agentRuntime as never,
+    });
+
+    expect(mocks.realtimeHandlerCtorArgs[0]?.[0]).toMatchObject({
+      tools: [
+        expect.objectContaining({ name: "openclaw_agent_consult" }),
+        expect.objectContaining({ name: "custom_tool" }),
+      ],
+    });
+    expect(mocks.realtimeHandlerRegisterToolHandler).toHaveBeenCalledWith(
+      "openclaw_agent_consult",
+      expect.any(Function),
+    );
+
+    const handler = mocks.realtimeHandlerRegisterToolHandler.mock.calls[0]?.[1] as
+      | ((
+          args: unknown,
+          callId: string,
+          context?: { partialUserTranscript?: string },
+        ) => Promise<unknown>)
+      | undefined;
+    await expect(
+      handler?.({ question: "What should I say?" }, "call-1", {
+        partialUserTranscript: "Also check the ETA.",
+      }),
+    ).resolves.toEqual({
+      text: "Use the shipment status.",
+    });
+    expect(runEmbeddedPiAgent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionKey: "voice:15550009999",
+        messageProvider: "voice",
+        lane: "voice",
+        provider: "openai",
+        model: "gpt-5.4",
+        toolsAllow: ["read", "web_search", "web_fetch", "x_search", "memory_search", "memory_get"],
+        extraSystemPrompt: expect.stringContaining("one or two bounded read-only queries"),
+        prompt: expect.stringContaining("Caller: Can you check shipment status?"),
+      }),
+    );
+    expect(runEmbeddedPiAgent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        prompt: expect.stringContaining("Caller: Also check the ETA."),
+      }),
+    );
+  });
+
+  it("uses persisted per-call session keys for realtime consults", async () => {
+    const config = createBaseConfig();
+    config.inboundPolicy = "allowlist";
+    config.realtime.enabled = true;
+    config.sessionScope = "per-call";
+    const runEmbeddedPiAgent = vi.fn(async () => ({
+      payloads: [{ text: "Per-call consult answer." }],
+      meta: {},
+    }));
+    const sessionStore: Record<string, unknown> = {};
+    const agentRuntime = {
+      defaults: { provider: "openai", model: "gpt-5.4" },
+      resolveAgentDir: vi.fn(() => "/tmp/agent"),
+      resolveAgentWorkspaceDir: vi.fn(() => "/tmp/workspace"),
+      resolveAgentIdentity: vi.fn(),
+      resolveThinkingDefault: vi.fn(() => "high"),
+      resolveAgentTimeoutMs: vi.fn(() => 30_000),
+      ensureAgentWorkspace: vi.fn(async () => {}),
+      session: {
+        resolveStorePath: vi.fn(() => "/tmp/sessions.json"),
+        loadSessionStore: vi.fn(() => sessionStore),
+        saveSessionStore: vi.fn(async () => {}),
+        updateSessionStore: vi.fn(async (_storePath, mutator) => mutator(sessionStore as never)),
+        resolveSessionFilePath: vi.fn(() => "/tmp/session.json"),
+      },
+      runEmbeddedPiAgent,
+    };
+    mocks.managerGetCall.mockReturnValue({
+      callId: "call-1",
+      sessionKey: "voice:call:call-1",
+      direction: "inbound",
+      from: "+15550001234",
+      to: "+15550009999",
+      transcript: [],
+    });
+
+    await createVoiceCallRuntime({
+      config,
+      coreConfig: {} as CoreConfig,
+      agentRuntime: agentRuntime as never,
+    });
+
+    const handler = mocks.realtimeHandlerRegisterToolHandler.mock.calls[0]?.[1] as
+      | ((
+          args: unknown,
+          callId: string,
+          context?: { partialUserTranscript?: string },
+        ) => Promise<unknown>)
+      | undefined;
+    await expect(handler?.({ question: "What should I say?" }, "call-1")).resolves.toEqual({
+      text: "Per-call consult answer.",
+    });
+    expect(runEmbeddedPiAgent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        sessionKey: "voice:call:call-1",
+      }),
+    );
+  });
+
+  it("answers realtime consults from fast memory context before starting the full agent", async () => {
+    const config = createBaseConfig();
+    config.realtime.enabled = true;
+    config.realtime.fastContext = {
+      enabled: true,
+      timeoutMs: 800,
+      maxResults: 2,
+      sources: ["memory"],
+      fallbackToConsult: false,
+    };
+    const runEmbeddedPiAgent = vi.fn(async () => ({
+      payloads: [{ text: "slow answer" }],
+      meta: {},
+    }));
+    const sessionStore: Record<string, unknown> = {};
+    const agentRuntime = {
+      resolveAgentDir: vi.fn(() => "/tmp/agent"),
+      resolveAgentWorkspaceDir: vi.fn(() => "/tmp/workspace"),
+      resolveAgentIdentity: vi.fn(),
+      resolveThinkingDefault: vi.fn(() => "high"),
+      resolveAgentTimeoutMs: vi.fn(() => 30_000),
+      ensureAgentWorkspace: vi.fn(async () => {}),
+      session: {
+        resolveStorePath: vi.fn(() => "/tmp/sessions.json"),
+        loadSessionStore: vi.fn(() => sessionStore),
+        saveSessionStore: vi.fn(async () => {}),
+        updateSessionStore: vi.fn(async (_storePath, mutator) => mutator(sessionStore as never)),
+        resolveSessionFilePath: vi.fn(() => "/tmp/session.json"),
+      },
+      runEmbeddedPiAgent,
+    };
+    mocks.managerGetCall.mockReturnValue({
+      callId: "call-1",
+      direction: "inbound",
+      from: "+15550001234",
+      to: "+15550009999",
+      transcript: [],
+    });
+    mocks.memorySearch.mockResolvedValue([
+      {
+        source: "memory",
+        path: "MEMORY.md",
+        startLine: 12,
+        endLine: 14,
+        score: 0.91,
+        snippet: "The caller's basement lights are on.",
+      },
+    ]);
+
+    await createVoiceCallRuntime({
+      config,
+      coreConfig: {} as CoreConfig,
+      agentRuntime: agentRuntime as never,
+    });
+
+    const handler = mocks.realtimeHandlerRegisterToolHandler.mock.calls[0]?.[1] as
+      | ((
+          args: unknown,
+          callId: string,
+          context?: { partialUserTranscript?: string },
+        ) => Promise<unknown>)
+      | undefined;
+    await expect(handler?.({ question: "Are the basement lights on?" }, "call-1")).resolves.toEqual(
+      {
+        text: expect.stringContaining("The caller's basement lights are on."),
+      },
+    );
+    expect(mocks.memorySearch).toHaveBeenCalledWith("Are the basement lights on?", {
+      maxResults: 2,
+      sessionKey: "voice:15550001234",
+      sources: ["memory"],
+    });
+    expect(runEmbeddedPiAgent).not.toHaveBeenCalled();
+  });
 });