type Registered = {

methods: Map<string, unknown>;

methodScopes: Map<string, string | undefined>;

tools: unknown[];

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

};

function setup(config: Record<string, unknown>): Registered {

const methods = new Map<string, unknown>();

const methodScopes = new Map<string, string | undefined>();

const tools: unknown[] = [];

let service: Registered["service"];

const api = createTestPluginApi({

pluginConfig: config,

runtime: { tts: { textToSpeechTelephony: vi.fn() } } as unknown as OpenClawPluginApi["runtime"],

logger: noopLogger,

registerGatewayMethod: (method: string, handler: unknown) => methods.set(method, handler),

registerGatewayMethod: (method: string, handler: unknown, opts?: { scope?: string }) => {

methods.set(method, handler);

methodScopes.set(method, opts?.scope);

},

registerTool: (tool: unknown) => tools.push(tool),

registerCli: () => {},

registerService: (registeredService) => {

resolvePath: (p: string) => p,

});

plugin.register(api);

return { methods, tools, service };

return { methods, methodScopes, tools, service };

}

function envRef(id: string) {

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

});

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

const { methodScopes } = setup({ provider: "mock" });

for (const method of [

"voicecall.initiate",

"voicecall.start",

"voicecall.continue",

"voicecall.continue.start",

"voicecall.speak",

"voicecall.dtmf",

"voicecall.end",

]) {

expect(methodScopes.get(method)).toBe("operator.write");

}

expect(methodScopes.get("voicecall.continue.result")).toBe("operator.read");

expect(methodScopes.get("voicecall.status")).toBe("operator.read");

});

it("preserves mode on legacy voicecall.start", async () => {

const { methods } = setup({ provider: "mock" });

const handler = methods.get("voicecall.start") as