await tool.execute("id", { action: "leave", sessionId: joined.details.session.id });

const [endParams] = voiceCallMocks.endMeetVoiceCallGatewayCall.mock.calls[0] as unknown as [

const [endParams] = voiceCallMocks.endMeetVoiceCallGatewayCall.mock.calls.at(0) as unknown as [

Record<string, unknown>,

];

expect(requireRecord(endParams.config, "voice-call end config").defaultTransport).toBe(

});

expect(requireRecord(spoken.details, "spoken details").spoken).toBe(true);

const [speakParams] = voiceCallMocks.speakMeetViaVoiceCallGateway.mock.calls[0] as unknown as [

Record<string, unknown>,

];

const [speakParams] = voiceCallMocks.speakMeetViaVoiceCallGateway.mock.calls.at(

0,

) as unknown as [Record<string, unknown>];

expect(requireRecord(speakParams.config, "voice-call speak config").defaultTransport).toBe(

"twilio",

);

respond,

});

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

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

expect(runCommandWithTimeout).not.toHaveBeenCalled();

const openCall = callGatewayFromCli.mock.calls.find(

([, , request]) => requireRecord(request, "browser request").path === "/tabs/open",

([, , request]) => (request as { path?: string }).path === "/permissions/grant",

),

).toBe(false);

const payload = requireRecord(respond.mock.calls[0]?.[1], "join response payload");

const payload = requireRecord(respond.mock.calls.at(0)?.[1], "join response payload");

const session = requireRecord(payload.session, "join session");

const chrome = requireRecord(session.chrome, "join chrome session");

const health = requireRecord(chrome.health, "join chrome health");

respond,

});

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

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

const grantCall = callGatewayFromCli.mock.calls.find(

([, , request]) => requireRecord(request, "browser request").path === "/permissions/grant",

);

respond,

});

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

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

expect(events.indexOf("browser:/act")).toBeGreaterThan(-1);

expect(events.indexOf("command:bridge start")).toBeGreaterThan(

events.indexOf("browser:/act"),

respond,

});

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

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

expect(events).toContain("browser:/act");

expect(events).not.toContain("command:bridge start");

} finally {

respond,

});

const payload = requireRecord(respond.mock.calls[0]?.[1], "join response payload");

const payload = requireRecord(respond.mock.calls.at(0)?.[1], "join response payload");

expect(payload.spoken).toBe(false);

const session = requireRecord(payload.session, "join session");

const chrome = requireRecord(session.chrome, "join chrome session");

await vi.advanceTimersByTimeAsync(2_000);

await run;

const payload = requireRecord(respond.mock.calls[0]?.[1], "join response payload");

const payload = requireRecord(respond.mock.calls.at(0)?.[1], "join response payload");

expect(payload.spoken).toBe(false);

const session = requireRecord(payload.session, "join session");

const chrome = requireRecord(session.chrome, "join chrome session");

respond,

});

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

expect(nodesList.mock.calls[0]).toStrictEqual([]);

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

expect(nodesList.mock.calls.at(0)).toStrictEqual([]);

const stopCall = nodesInvoke.mock.calls.find(([rawCall]) => {

const call = requireRecord(rawCall, "node invoke");

const params = requireRecord(call.params, "node invoke params");

expect(startParams.mode).toBe("transcribe");

expect(startParams.launch).toBe(false);

expect(startParams.joinTimeoutMs).toBe(30000);

const payload = requireRecord(respond.mock.calls[0]?.[1], "join response payload");

const payload = requireRecord(respond.mock.calls.at(0)?.[1], "join response payload");

const session = requireRecord(payload.session, "join session");

expect(session.transport).toBe("chrome-node");

const chrome = requireRecord(session.chrome, "join chrome session");

expect(

nodesInvoke.mock.calls.filter(([call]) => call.command === "googlemeet.chrome"),

).toHaveLength(2);

const payload = requireRecord(second.mock.calls[0]?.[1], "second join response payload");

const payload = requireRecord(second.mock.calls.at(0)?.[1], "second join response payload");

const session = requireRecord(payload.session, "second join session");

const chrome = requireRecord(session.chrome, "second join chrome session");

const health = requireRecord(chrome.health, "second join chrome health");

expect(

nodesInvoke.mock.calls.filter(([call]) => call.command === "googlemeet.chrome"),

).toHaveLength(2);

const payload = requireRecord(second.mock.calls[0]?.[1], "second join response payload");

const payload = requireRecord(second.mock.calls.at(0)?.[1], "second join response payload");

const session = requireRecord(payload.session, "second join session");

expect(session.notes).toContain("Reused existing active Meet session.");

});

params: { url: "https://meet.google.com/abc-defg-hij" },

respond: joinRespond,

});

const joinPayload = requireRecord(joinRespond.mock.calls[0]?.[1], "join response payload");

const joinPayload = requireRecord(joinRespond.mock.calls.at(0)?.[1], "join response payload");

const joinSession = requireRecord(joinPayload.session, "join session");

const joinChrome = requireRecord(joinSession.chrome, "join chrome session");

expect(requireRecord(joinChrome.health, "join chrome health").inCall).toBe(false);

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

const statusPayload = requireRecord(

statusRespond.mock.calls[0]?.[1],

statusRespond.mock.calls.at(0)?.[1],

"status response payload",

);

const sessions = statusPayload.sessions as unknown[];

});

expect(join).toHaveBeenCalledTimes(1);

const joinArgs = requireRecord(join.mock.calls[0]?.[0], "test speech join args");

const joinArgs = requireRecord(join.mock.calls.at(0)?.[0], "test speech join args");

expect(joinArgs.message).toBe("Say exactly: hello.");

expect(joinArgs.mode).toBe("agent");

expect(speak).not.toHaveBeenCalled();

});

expect(join).toHaveBeenCalledTimes(1);

const joinArgs = requireRecord(join.mock.calls[0]?.[0], "test speech join args");

const joinArgs = requireRecord(join.mock.calls.at(0)?.[0], "test speech join args");

expect(joinArgs.message).toBe("Say exactly: hello.");

expect(joinArgs.mode).toBe("bidi");

});

respond,

});

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

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

expect(runCommandWithTimeout).toHaveBeenNthCalledWith(2, ["bridge", "status"], {

timeoutMs: 30000,

});

await vi.advanceTimersByTimeAsync(GOOGLE_MEET_AGENT_TRANSCRIPT_DEBOUNCE_MS);

expect(sendAudio).toHaveBeenCalledTimes(1);

const audioChunk = sendAudio.mock.calls[0]?.[0];

const audioChunk = sendAudio.mock.calls.at(0)?.[0];

expect(Buffer.isBuffer(audioChunk)).toBe(true);

expect(audioChunk.byteLength).toBeGreaterThan(0);

expect(runtime.agent.runEmbeddedPiAgent).toHaveBeenCalled();

args: { question: "What should I say about launch timing?" },

});

expect(bridge.submitToolResult).toHaveBeenCalled();

const firstToolResultCall = bridge.submitToolResult.mock.calls[0];

const firstToolResultCall = bridge.submitToolResult.mock.calls.at(0);

expect(firstToolResultCall?.[0]).toBe("tool-call-1");

expect(firstToolResultCall?.[2]).toStrictEqual({ willContinue: true });

const progressPayload = requireRecord(firstToolResultCall?.[1], "tool progress payload");

}

expect(runtime.agent.runEmbeddedPiAgent).toHaveBeenCalledTimes(1);

const agentRequest = requireRecord(

runtime.agent.runEmbeddedPiAgent.mock.calls[0]?.[0],

runtime.agent.runEmbeddedPiAgent.mock.calls.at(0)?.[0],

"embedded agent request",

);

expect(agentRequest.messageProvider).toBe("google-meet");

"Are we still on track?\\nPlease include launch blockers.",

);

expect(sendUserMessage).toHaveBeenCalledTimes(1);

const sentUserMessage = sendUserMessage.mock.calls[0]?.[0];

const sentUserMessage = sendUserMessage.mock.calls.at(0)?.[0];

expect(typeof sentUserMessage).toBe("string");

expect(sentUserMessage).toContain(JSON.stringify("The launch is still on track."));

expect(sessionStore).toHaveProperty("agent:jay:subagent:google-meet:meet-1");

args: { question: "What should I say?" },

});

expect(bridge.submitToolResult).toHaveBeenCalled();

const firstToolResultCall = bridge.submitToolResult.mock.calls[0];

const firstToolResultCall = bridge.submitToolResult.mock.calls.at(0);

expect(firstToolResultCall?.[0]).toBe("tool-call-1");

expect(firstToolResultCall?.[2]).toStrictEqual({ willContinue: true });

const progressPayload = requireRecord(firstToolResultCall?.[1], "node tool progress payload");