});

};

async function waitForRealtimeTest(

callback: () => void | Promise<void>,

options: { timeout?: number; interval?: number } = {},

) {

await vi.waitFor(callback, { interval: 1, ...options });

}

describe("RealtimeCallHandler path routing", () => {

it("uses the request host and stream path in TwiML", () => {

const handler = makeHandler();

start: { streamSid: "MZ-outbound", callSid: "CA-outbound" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

callbacks?.onReady?.();

start: { streamSid: "MZ-silent", callSid: "CA-silent" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

start: { streamSid: "MZ-speak", callSid: "CA-speak" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

start: { streamSid: "MZ-complete", callSid: "CA-complete" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

ws.send(JSON.stringify({ event: "stop" }));

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

const events = processEvent.mock.calls.map(([event]) => event as NormalizedEvent);

const ended = events.find((event) => event.type === "call.ended");

expect(ended).toBeDefined();

start: { streamSid: "MZ-talk-events", callSid: "CA-talk-events" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

media: { payload: Buffer.from([0xff, 0xff]).toString("base64") },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(sendAudio).toHaveBeenCalledWith(Buffer.from([0xff, 0xff]));

});

callbacks?.onTranscript?.("user", "hello", true);

start: { streamSid: "MZ-barge-in", callSid: "CA-barge-in" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

ws.send(JSON.stringify({ event: "media", media: { payload: speechPayload } }));

ws.send(JSON.stringify({ event: "media", media: { payload: speechPayload } }));

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(sendAudio).toHaveBeenCalledTimes(2);

});

start: { streamSid: "MZ-tool", callSid: "CA-tool" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

args: { question: "Are the basement lights on?" },

});

await vi.advanceTimersByTimeAsync(350);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(receivedPartialTranscript).toBe("Are the basement");

});

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

const workingCall = submitToolResult.mock.calls.find(

([callId]) => callId === "consult-call",

);

resolveConsult?.({ text: "The basement lights are on." });

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(submitToolResult).toHaveBeenLastCalledWith(

"consult-call",

{

args: {},

});

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(submitToolResult).toHaveBeenCalledWith("custom-call", { ok: true }, undefined);

});

expect(submitToolResult).not.toHaveBeenCalledWith("custom-call", expect.anything(), {

start: { streamSid: "MZ-force", callSid: "CA-force" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

vi.useFakeTimers();

callbacks?.onTranscript?.("user", "Create a smoke test file for me.", true);

await vi.advanceTimersByTimeAsync(200);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(consult).toHaveBeenCalledTimes(1);

});

const [args, callId, context] = consult.mock.calls[0] ?? [];

});

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

expect(context).toEqual({});

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(sendUserMessage).toHaveBeenCalledWith(

expect.stringContaining("I created the smoke test file."),

);

start: { streamSid: "MZ-direct-turns", callSid: "CA-direct-turns" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

start: { streamSid: "MZ-settle", callSid: "CA-settle" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

callbacks?.onTranscript?.("user", "message.", false);

await vi.advanceTimersByTimeAsync(350);

await vi.waitFor(

await waitForRealtimeTest(

() => {

expect(consult).toHaveBeenCalledTimes(1);

},

);

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

expect(context).toEqual({ partialUserTranscript: "Send a Discord message." });

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(submitToolResult).toHaveBeenLastCalledWith(

"consult-call",

{ text: "I sent it." },

start: { streamSid: "MZ-native", callSid: "CA-native" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

args: { question: "Send me a Discord message." },

});

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(submitToolResult).toHaveBeenLastCalledWith(

"consult-call",

{ text: "Native consult result." },

start: { streamSid: "MZ-fast", callSid: "CA-fast" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(createBridge).toHaveBeenCalled();

});

args: { question: "What do you remember?" },

});

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

expect(submitToolResult).toHaveBeenCalledWith(

"consult-call",

{ text: "Fast context." },

start: { streamSid: "MZ-backpressure", callSid: "CA-backpressure" },

}),

);

await vi.waitFor(() => {

await waitForRealtimeTest(() => {

if (!sendProviderAudio) {

throw new Error("expected realtime provider audio sender");

}