tools: unknown[];

service?: Parameters<OpenClawPluginApi["registerService"]>[0];

};

type MockCallSource = {

mock: {

calls: ArrayLike<ReadonlyArray<unknown>>;

};

};

type RespondCall = [

ok: boolean,

payload?: Record<string, unknown>,

error?: {

code?: unknown;

message?: unknown;

},

];

type RegisterVoiceCall = (api: Record<string, unknown>) => void;

type RegisterCliContext = {

program: Command;

return { source: "env" as const, provider: "default", id };

}

function mockCall(source: MockCallSource, callIndex = 0): ReadonlyArray<unknown> {

const call = source.mock.calls[callIndex];

if (!call) {

throw new Error(`expected mock call ${callIndex}`);

}

return call;

}

function firstRespondCall(source: MockCallSource): RespondCall {

return mockCall(source) as unknown as RespondCall;

}

function firstRuntimeConfig(): VoiceCallRuntime["config"] | undefined {

const options = mockCall(vi.mocked(createVoiceCallRuntime))[0] as

| { config?: VoiceCallRuntime["config"] }

| undefined;

return options?.config;

}

function expectWarningIncludes(text: string): void {

expect(noopLogger.warn.mock.calls.some(([message]) => String(message).includes(text))).toBe(true);

}

await service?.start(createServiceContext());

expect(createVoiceCallRuntime).toHaveBeenCalledTimes(1);

expect(

vi.mocked(createVoiceCallRuntime).mock.calls.at(0)?.[0]?.config.twilio?.authToken,

).toEqual(authToken);

expect(firstRuntimeConfig()?.twilio?.authToken).toEqual(authToken);

});

it("still reports missing provider setup when a command needs the runtime", async () => {

await handler?.({ params: { message: "Hi", to: "+15550001234" }, respond });

expect(createVoiceCallRuntime).not.toHaveBeenCalled();

const [ok, payload, error] = respond.mock.calls.at(0) ?? [];

const [ok, payload, error] = firstRespondCall(respond);

expect(ok).toBe(false);

expect(payload).toBeUndefined();

expect(String((error as { message?: unknown } | undefined)?.message)).toContain(

"TWILIO_ACCOUNT_SID",

);

expect(String(error?.message)).toContain("TWILIO_ACCOUNT_SID");

});

it("initiates a call via voicecall.initiate", async () => {

const respond = vi.fn();

await handler?.({ params: { message: "Hi" }, respond });

expect(runtimeStub.manager.initiateCall).toHaveBeenCalled();

const [ok, payload] = respond.mock.calls.at(0) ?? [];

const [ok, payload] = firstRespondCall(respond);

expect(ok).toBe(true);

expect(payload.callId).toBe("call-1");

expect(payload?.callId).toBe("call-1");

});

it("registers voice call gateway methods with least-privilege scopes", () => {

message: "Hi",

mode: "conversation",

});

expect(respond.mock.calls.at(0)?.[0]).toBe(true);

expect(firstRespondCall(respond)[0]).toBe(true);

});

it("preserves explicit session keys on voicecall.start", async () => {

requesterSessionKey: "agent:main:discord:channel:general",

},

);

expect(respond.mock.calls.at(0)?.[0]).toBe(true);

expect(firstRespondCall(respond)[0]).toBe(true);

});

it("returns call status", async () => {

| undefined;

const respond = vi.fn();

await handler?.({ params: { callId: "call-1" }, respond });

const [ok, payload] = respond.mock.calls.at(0) ?? [];

const [ok, payload] = firstRespondCall(respond);

expect(ok).toBe(true);

expect(payload.found).toBe(true);

expect(payload?.found).toBe(true);

});

it("sends DTMF via voicecall.dtmf", async () => {

await handler?.({ params: { callId: "call-1", digits: "ww123#" }, respond });

expect(runtimeStub.manager.sendDtmf).toHaveBeenCalledWith("call-1", "ww123#");

expect(respond.mock.calls.at(0)).toEqual([true, { success: true }]);

expect(firstRespondCall(respond)).toEqual([true, { success: true }]);

});

it("normalizes provider call ids before speaking", async () => {

await handler?.({ params: { callId: "CA123", message: "hello" }, respond });

expect(runtimeStub.manager.speak).toHaveBeenCalledWith("call-1", "hello");

expect(respond.mock.calls.at(0)).toEqual([true, { success: true }]);

expect(firstRespondCall(respond)).toEqual([true, { success: true }]);

});

it("does not fall back to one-shot TwiML speak when realtime-only speech is requested", async () => {

expect(runtimeStub.webhookServer.speakRealtime).toHaveBeenCalledWith("call-1", "hello");

expect(runtimeStub.manager.speak).not.toHaveBeenCalled();

expect(respond.mock.calls.at(0)).toEqual([

expect(firstRespondCall(respond)).toEqual([

true,

{ success: false, error: "No active realtime bridge for call" },

]);

await handler?.({ params: { callId: "CA123", message: "hello" }, respond });

const [ok, , error] = respond.mock.calls.at(0) ?? [];

const [ok, , error] = firstRespondCall(respond);

expect(ok).toBe(false);

expect(error.message).toContain("call is not active");

expect(error.message).toContain("last state=completed");

expect(error.message).toContain("endReason=completed");

expect(error?.message).toContain("call is not active");

expect(error?.message).toContain("last state=completed");

expect(error?.message).toContain("endReason=completed");

expect(runtimeStub.manager.speak).not.toHaveBeenCalled();

});

await handler?.({ params: { callId: "call-1" }, respond });

expect(vi.mocked(createVoiceCallRuntime)).toHaveBeenCalledTimes(1);

const runtimeConfig = vi.mocked(createVoiceCallRuntime).mock.calls.at(0)?.[0]?.config;

const runtimeConfig = firstRuntimeConfig();

expect(runtimeConfig?.enabled).toBe(true);

expect(runtimeConfig?.provider).toBe("mock");

expect(runtimeConfig?.fromNumber).toBe("+15550001234");

await handler?.({ params: {}, respond });

const [ok, payload, error] = respond.mock.calls.at(0) ?? [];

const [ok, payload, error] = firstRespondCall(respond);

expect(ok).toBe(false);

expect(payload).toBeUndefined();

expect((error as { code?: unknown } | undefined)?.code).toBe("INVALID_REQUEST");

expect((error as { message?: unknown } | undefined)?.message).toBe("to required");

expect(error?.code).toBe("INVALID_REQUEST");

expect(error?.message).toBe("to required");

});

it("starts and polls delegated gateway continue operations", async () => {

params: { callId: "call-1", message: "Hello" },

respond: startRespond,

});

const startPayload = startRespond.mock.calls.at(0)?.[1] as

const startPayload = firstRespondCall(startRespond)[1] as

| { operationId?: string; pollTimeoutMs?: number; status?: string }

| undefined;

expect(startPayload?.operationId).toMatch(

params: { operationId: startPayload?.operationId },

respond: pendingRespond,

});

expect(pendingRespond.mock.calls.at(0)?.[0]).toBe(true);

expect((pendingRespond.mock.calls.at(0)?.[1] as { status?: unknown } | undefined)?.status).toBe(

"pending",

);

const pendingCall = firstRespondCall(pendingRespond);

expect(pendingCall[0]).toBe(true);

expect((pendingCall[1] as { status?: unknown } | undefined)?.status).toBe("pending");

finishContinue?.({ success: true, transcript: "gateway hello" });

await continuePromise;

params: { operationId: startPayload?.operationId },

respond: completedRespond,

});

const completedPayload = completedRespond.mock.calls.at(0)?.[1] as

| { status?: unknown; result?: unknown }

| undefined;

expect(completedRespond.mock.calls.at(0)?.[0]).toBe(true);

const completedCall = firstRespondCall(completedRespond);

const completedPayload = completedCall[1] as { status?: unknown; result?: unknown } | undefined;

expect(completedCall[0]).toBe(true);

expect(completedPayload?.status).toBe("completed");

expect(completedPayload?.result).toEqual({ success: true, transcript: "gateway hello" });

});