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

}

function expectWarningIncludes(text: string): void {

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

}

async function registerVoiceCallCli(

program: Command,

pluginConfig: Record<string, unknown> = { provider: "mock" },

String(message).includes("Failed to start runtime"),

),

).toBe(false);

expect(noopLogger.warn).toHaveBeenCalledWith(

expect.stringContaining("Runtime not started; setup incomplete"),

);

expect(noopLogger.warn).toHaveBeenCalledWith(expect.stringContaining("TWILIO_ACCOUNT_SID"));

expectWarningIncludes("Runtime not started; setup incomplete");

expectWarningIncludes("TWILIO_ACCOUNT_SID");

});

it("registers Twilio configs with SecretRef auth tokens", async () => {

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

expect(createVoiceCallRuntime).not.toHaveBeenCalled();

expect(respond).toHaveBeenCalledWith(

false,

undefined,

expect.objectContaining({

message: expect.stringContaining("TWILIO_ACCOUNT_SID"),

}),

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

expect(ok).toBe(false);

expect(payload).toBeUndefined();

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

"TWILIO_ACCOUNT_SID",

);

});

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

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

expect(vi.mocked(createVoiceCallRuntime).mock.calls[0]?.[0]?.config).toMatchObject({

enabled: true,

provider: "mock",

fromNumber: "+15550001234",

streaming: {

enabled: true,

provider: "openai",

providers: {

openai: {

apiKey: "sk-test",

},

},

},

});

expect(noopLogger.warn).toHaveBeenCalledWith(

expect.stringContaining('Run "openclaw doctor --fix"'),

);

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

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

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

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

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

expect(runtimeConfig?.streaming?.provider).toBe("openai");

expect(runtimeConfig?.streaming?.providers?.openai?.apiKey).toBe("sk-test");

expectWarningIncludes('Run "openclaw doctor --fix"');

});

it("tool get_status returns json payload", async () => {

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

expect(respond).toHaveBeenCalledWith(

false,

undefined,

expect.objectContaining({

code: "INVALID_REQUEST",

message: "to required",

}),

);

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

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");

});

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

respond: startRespond,

});

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

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

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

| undefined;

expect(startPayload).toEqual(

expect.objectContaining({

operationId: expect.stringMatching(

/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu,

),

status: "pending",

pollTimeoutMs: 180000,

}),

expect(startPayload?.operationId).toMatch(

/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/iu,

);

expect(startPayload?.status).toBe("pending");

expect(startPayload?.pollTimeoutMs).toBe(180000);

expect(runtimeStub.manager.continueCall).toHaveBeenCalledWith("call-1", "Hello");

const pendingRespond = vi.fn();

await result?.({

params: { operationId: startPayload?.operationId },

respond: pendingRespond,

});

expect(pendingRespond).toHaveBeenCalledWith(

true,

expect.objectContaining({ status: "pending" }),

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

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

"pending",

);

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

params: { operationId: startPayload?.operationId },

respond: completedRespond,

});

expect(completedRespond).toHaveBeenCalledWith(

true,

expect.objectContaining({

status: "completed",

result: { success: true, transcript: "gateway hello" },

}),

);

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

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

| undefined;

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

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

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

});

it("CLI setup prints human-readable checks by default", async () => {

checks?: Array<{ id: string; ok: boolean }>;

};

expect(parsed.ok).toBe(false);

expect(parsed.checks).toContainEqual(

expect.objectContaining({ id: "webhook-exposure", ok: false }),

);

const webhookExposure = parsed.checks?.find((check) => check.id === "webhook-exposure");

expect(webhookExposure?.ok).toBe(false);

} finally {

stdout.restore();

}

checks?: Array<{ id: string; ok: boolean; message: string }>;

};

expect(parsed.ok).toBe(false);

expect(parsed.checks).toContainEqual(

expect.objectContaining({

id: "webhook-exposure",

ok: false,

message: expect.stringContaining("local/private"),

}),

);

const webhookExposure = parsed.checks?.find((check) => check.id === "webhook-exposure");

expect(webhookExposure?.ok).toBe(false);

expect(webhookExposure?.message).toContain("local/private");

} finally {

stdout.restore();

}

const parsed = JSON.parse(stdout.output()) as {

calls?: Array<{ callId?: string }>;

};

expect(parsed.calls).toEqual([expect.objectContaining({ callId: "call-1" })]);

expect(parsed.calls).toHaveLength(1);

expect(parsed.calls?.[0]?.callId).toBe("call-1");

} finally {

stdout.restore();

}

{ progress: false },

);

expect(createVoiceCallRuntime).not.toHaveBeenCalled();

expect(parsed.calls).toEqual([expect.objectContaining({ callId: "gateway-call" })]);

expect(parsed.calls).toHaveLength(1);

expect(parsed.calls?.[0]?.callId).toBe("gateway-call");

} finally {

stdout.restore();

}