@crewhaus/voice-runtime 0.1.3 → 0.1.5
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +163 -0
- package/dist/index.js +450 -0
- package/package.json +9 -6
- package/src/index.coverage.test.ts +0 -590
- package/src/index.test.ts +0 -296
- package/src/index.ts +0 -577
|
@@ -1,590 +0,0 @@
|
|
|
1
|
-
/**
|
|
2
|
-
* Coverage-hardening suite for `voice-runtime`. Drives every adapter
|
|
3
|
-
* branch deterministically with a scripted WebSocket stub — no real
|
|
4
|
-
* sockets, no real timers, no leaked handles. Complements the contract
|
|
5
|
-
* tests in `index.test.ts`; this file targets the lines those tests do
|
|
6
|
-
* not reach (default WS factory, error/close handlers, sendText /
|
|
7
|
-
* commitInput / interrupt, the Vapi adapter passthrough, and the
|
|
8
|
-
* subscriber-isolation paths).
|
|
9
|
-
*/
|
|
10
|
-
import { afterEach, beforeEach, describe, expect, test } from "bun:test";
|
|
11
|
-
import {
|
|
12
|
-
type RealtimeConnectOptions,
|
|
13
|
-
type RealtimeEvent,
|
|
14
|
-
type WebSocketFactory,
|
|
15
|
-
type WebSocketLike,
|
|
16
|
-
createOpenAIRealtimeAdapter,
|
|
17
|
-
createVapiRealtimeAdapter,
|
|
18
|
-
} from "./index.js";
|
|
19
|
-
|
|
20
|
-
/**
|
|
21
|
-
* Fully synchronous WebSocket stub. Listeners fire only when the test
|
|
22
|
-
* calls `triggerOpen` / `triggerError` / `triggerClose` / `emit`, so
|
|
23
|
-
* there is no clock and no ordering ambiguity. `readyState` starts at 0
|
|
24
|
-
* (CONNECTING) and flips to 1 (OPEN) on `triggerOpen`.
|
|
25
|
-
*/
|
|
26
|
-
class StubWs implements WebSocketLike {
|
|
27
|
-
readyState = 0;
|
|
28
|
-
readonly sent: Record<string, unknown>[] = [];
|
|
29
|
-
closed: { code?: number; reason?: string } | undefined;
|
|
30
|
-
closeThrows = false;
|
|
31
|
-
private readonly listeners = new Map<string, Array<(ev: unknown) => void>>();
|
|
32
|
-
|
|
33
|
-
send(data: string | ArrayBuffer): void {
|
|
34
|
-
if (typeof data === "string") this.sent.push(JSON.parse(data));
|
|
35
|
-
}
|
|
36
|
-
|
|
37
|
-
close(code?: number, reason?: string): void {
|
|
38
|
-
if (this.closeThrows) throw new Error("close boom");
|
|
39
|
-
this.readyState = 3;
|
|
40
|
-
this.closed = { code, reason };
|
|
41
|
-
}
|
|
42
|
-
|
|
43
|
-
addEventListener(type: string, handler: (ev: unknown) => void): void {
|
|
44
|
-
const arr = this.listeners.get(type) ?? [];
|
|
45
|
-
arr.push(handler);
|
|
46
|
-
this.listeners.set(type, arr);
|
|
47
|
-
}
|
|
48
|
-
|
|
49
|
-
private fire(type: string, ev: unknown): void {
|
|
50
|
-
for (const h of this.listeners.get(type) ?? []) h(ev);
|
|
51
|
-
}
|
|
52
|
-
|
|
53
|
-
triggerOpen(): void {
|
|
54
|
-
this.readyState = 1;
|
|
55
|
-
this.fire("open", {});
|
|
56
|
-
}
|
|
57
|
-
|
|
58
|
-
triggerError(ev: unknown): void {
|
|
59
|
-
this.fire("error", ev);
|
|
60
|
-
}
|
|
61
|
-
|
|
62
|
-
triggerClose(code?: number, reason?: string): void {
|
|
63
|
-
this.readyState = 3;
|
|
64
|
-
this.fire("close", { code, reason });
|
|
65
|
-
}
|
|
66
|
-
|
|
67
|
-
emit(event: Record<string, unknown>): void {
|
|
68
|
-
this.fire("message", { data: JSON.stringify(event) });
|
|
69
|
-
}
|
|
70
|
-
|
|
71
|
-
emitRaw(data: unknown): void {
|
|
72
|
-
this.fire("message", { data });
|
|
73
|
-
}
|
|
74
|
-
}
|
|
75
|
-
|
|
76
|
-
/** Connect an OpenAI adapter against a fresh StubWs, opening synchronously. */
|
|
77
|
-
async function connectedOpenAI(
|
|
78
|
-
connectOpts: RealtimeConnectOptions = { model: "m" },
|
|
79
|
-
): Promise<{ adapter: ReturnType<typeof createOpenAIRealtimeAdapter>; socket: StubWs }> {
|
|
80
|
-
const socket = new StubWs();
|
|
81
|
-
const ctor: WebSocketFactory = () => socket;
|
|
82
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: ctor });
|
|
83
|
-
const cp = adapter.connect(connectOpts);
|
|
84
|
-
socket.triggerOpen();
|
|
85
|
-
await cp;
|
|
86
|
-
socket.sent.length = 0; // discard the session.update so assertions start clean
|
|
87
|
-
return { adapter, socket };
|
|
88
|
-
}
|
|
89
|
-
|
|
90
|
-
// ===========================================================================
|
|
91
|
-
// OpenAI adapter — uncovered branches
|
|
92
|
-
// ===========================================================================
|
|
93
|
-
|
|
94
|
-
describe("createOpenAIRealtimeAdapter — default WebSocket factory (251-256)", () => {
|
|
95
|
-
const realWs = globalThis.WebSocket;
|
|
96
|
-
let constructed: { url: string; init: unknown } | undefined;
|
|
97
|
-
let lastSocket: StubWs | undefined;
|
|
98
|
-
|
|
99
|
-
beforeEach(() => {
|
|
100
|
-
constructed = undefined;
|
|
101
|
-
lastSocket = undefined;
|
|
102
|
-
// Swap the global constructor for a stub the default factory will `new`.
|
|
103
|
-
// Extending StubWs means `new` yields a real StubWs instance (no constructor
|
|
104
|
-
// return needed); `this` captures the recorded url/init.
|
|
105
|
-
(globalThis as { WebSocket: unknown }).WebSocket = class extends StubWs {
|
|
106
|
-
constructor(url: string, init?: unknown) {
|
|
107
|
-
super();
|
|
108
|
-
constructed = { url, init };
|
|
109
|
-
lastSocket = this;
|
|
110
|
-
}
|
|
111
|
-
} as unknown as typeof WebSocket;
|
|
112
|
-
});
|
|
113
|
-
|
|
114
|
-
afterEach(() => {
|
|
115
|
-
(globalThis as { WebSocket: typeof WebSocket }).WebSocket = realWs;
|
|
116
|
-
});
|
|
117
|
-
|
|
118
|
-
test("uses globalThis.WebSocket when no _ws is injected", async () => {
|
|
119
|
-
// No `_ws` → exercises the default factory arrow that calls `new`.
|
|
120
|
-
const adapter = createOpenAIRealtimeAdapter({
|
|
121
|
-
apiKey: "sk-test",
|
|
122
|
-
url: "wss://example.test/rt",
|
|
123
|
-
});
|
|
124
|
-
const cp = adapter.connect({ model: "gpt-4o-realtime-preview" });
|
|
125
|
-
expect(lastSocket).toBeDefined();
|
|
126
|
-
lastSocket?.triggerOpen();
|
|
127
|
-
await cp;
|
|
128
|
-
expect(adapter.connected).toBe(true);
|
|
129
|
-
expect(constructed?.url).toContain("wss://example.test/rt");
|
|
130
|
-
expect(constructed?.url).toContain("model=gpt-4o-realtime-preview");
|
|
131
|
-
// Auth + beta headers are threaded through `init`.
|
|
132
|
-
const init = constructed?.init as { headers?: Record<string, string> };
|
|
133
|
-
expect(init.headers?.["Authorization"]).toBe("Bearer sk-test");
|
|
134
|
-
expect(init.headers?.["OpenAI-Beta"]).toBe("realtime=v1");
|
|
135
|
-
await adapter.disconnect();
|
|
136
|
-
});
|
|
137
|
-
|
|
138
|
-
test("falls back to the default model when an empty model string is passed", async () => {
|
|
139
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test" });
|
|
140
|
-
const cp = adapter.connect({ model: "" });
|
|
141
|
-
lastSocket?.triggerOpen();
|
|
142
|
-
await cp;
|
|
143
|
-
expect(constructed?.url).toContain("model=gpt-4o-realtime-preview");
|
|
144
|
-
await adapter.disconnect();
|
|
145
|
-
});
|
|
146
|
-
});
|
|
147
|
-
|
|
148
|
-
describe("createOpenAIRealtimeAdapter — error handler (271-278)", () => {
|
|
149
|
-
test("error before open rejects connect AND emits an error event", async () => {
|
|
150
|
-
const socket = new StubWs();
|
|
151
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: () => socket });
|
|
152
|
-
const events: RealtimeEvent[] = [];
|
|
153
|
-
adapter.on((e) => events.push(e));
|
|
154
|
-
const cp = adapter.connect({ model: "m" });
|
|
155
|
-
socket.triggerError({ message: "handshake failed" });
|
|
156
|
-
await expect(cp).rejects.toThrow(/handshake failed/);
|
|
157
|
-
// The handler also emits an error event regardless of connect state.
|
|
158
|
-
expect(events.some((e) => e.kind === "error" && e.message === "handshake failed")).toBe(true);
|
|
159
|
-
});
|
|
160
|
-
|
|
161
|
-
test("error with no message uses the 'websocket error' fallback", async () => {
|
|
162
|
-
const socket = new StubWs();
|
|
163
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: () => socket });
|
|
164
|
-
const cp = adapter.connect({ model: "m" });
|
|
165
|
-
socket.triggerError({}); // object without `message`
|
|
166
|
-
await expect(cp).rejects.toThrow(/websocket error/);
|
|
167
|
-
});
|
|
168
|
-
|
|
169
|
-
test("error AFTER connect does not reject — only emits (connected branch false)", async () => {
|
|
170
|
-
const { adapter, socket } = await connectedOpenAI();
|
|
171
|
-
const events: RealtimeEvent[] = [];
|
|
172
|
-
adapter.on((e) => events.push(e));
|
|
173
|
-
// Already connected: `if (!connected) reject(...)` is skipped, emit still runs.
|
|
174
|
-
socket.triggerError({ message: "late blip" });
|
|
175
|
-
expect(adapter.connected).toBe(true);
|
|
176
|
-
expect(events).toEqual([{ kind: "error", message: "late blip" }]);
|
|
177
|
-
await adapter.disconnect();
|
|
178
|
-
});
|
|
179
|
-
});
|
|
180
|
-
|
|
181
|
-
describe("createOpenAIRealtimeAdapter — tools in session.update (317-321)", () => {
|
|
182
|
-
test("maps Anthropic-style tool schemas into OpenAI function tools", async () => {
|
|
183
|
-
const socket = new StubWs();
|
|
184
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: () => socket });
|
|
185
|
-
const cp = adapter.connect({
|
|
186
|
-
model: "m",
|
|
187
|
-
vad: "none",
|
|
188
|
-
tools: [
|
|
189
|
-
{
|
|
190
|
-
name: "get_weather",
|
|
191
|
-
description: "Look up weather",
|
|
192
|
-
inputSchema: { type: "object", properties: { city: { type: "string" } } },
|
|
193
|
-
},
|
|
194
|
-
],
|
|
195
|
-
});
|
|
196
|
-
socket.triggerOpen();
|
|
197
|
-
await cp;
|
|
198
|
-
const session = socket.sent[0]?.["session"] as Record<string, unknown>;
|
|
199
|
-
expect(session["turn_detection"]).toBeNull(); // vad: "none"
|
|
200
|
-
const tools = session["tools"] as Array<Record<string, unknown>>;
|
|
201
|
-
expect(tools).toHaveLength(1);
|
|
202
|
-
expect(tools[0]).toEqual({
|
|
203
|
-
type: "function",
|
|
204
|
-
name: "get_weather",
|
|
205
|
-
description: "Look up weather",
|
|
206
|
-
parameters: { type: "object", properties: { city: { type: "string" } } },
|
|
207
|
-
});
|
|
208
|
-
await adapter.disconnect();
|
|
209
|
-
});
|
|
210
|
-
|
|
211
|
-
test("empty tools array is omitted from the session payload", async () => {
|
|
212
|
-
const socket = new StubWs();
|
|
213
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: () => socket });
|
|
214
|
-
const cp = adapter.connect({ model: "m", tools: [] });
|
|
215
|
-
socket.triggerOpen();
|
|
216
|
-
await cp;
|
|
217
|
-
const session = socket.sent[0]?.["session"] as Record<string, unknown>;
|
|
218
|
-
expect(session["tools"]).toBeUndefined();
|
|
219
|
-
await adapter.disconnect();
|
|
220
|
-
});
|
|
221
|
-
});
|
|
222
|
-
|
|
223
|
-
describe("createOpenAIRealtimeAdapter — commitInput (334-340)", () => {
|
|
224
|
-
test("sends input_audio_buffer.commit then response.create", async () => {
|
|
225
|
-
const { adapter, socket } = await connectedOpenAI();
|
|
226
|
-
adapter.commitInput();
|
|
227
|
-
expect(socket.sent.map((m) => m["type"])).toEqual([
|
|
228
|
-
"input_audio_buffer.commit",
|
|
229
|
-
"response.create",
|
|
230
|
-
]);
|
|
231
|
-
await adapter.disconnect();
|
|
232
|
-
});
|
|
233
|
-
|
|
234
|
-
test("commitInput on a never-connected adapter swallows the throw", () => {
|
|
235
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: () => new StubWs() });
|
|
236
|
-
// No connect() → send() throws → caught by the try/catch.
|
|
237
|
-
expect(() => adapter.commitInput()).not.toThrow();
|
|
238
|
-
});
|
|
239
|
-
});
|
|
240
|
-
|
|
241
|
-
describe("createOpenAIRealtimeAdapter — sendText (343-352)", () => {
|
|
242
|
-
test("creates a user message item then requests a response", async () => {
|
|
243
|
-
const { adapter, socket } = await connectedOpenAI();
|
|
244
|
-
adapter.sendText("hello there");
|
|
245
|
-
expect(socket.sent).toHaveLength(2);
|
|
246
|
-
expect(socket.sent[0]).toEqual({
|
|
247
|
-
type: "conversation.item.create",
|
|
248
|
-
item: {
|
|
249
|
-
type: "message",
|
|
250
|
-
role: "user",
|
|
251
|
-
content: [{ type: "input_text", text: "hello there" }],
|
|
252
|
-
},
|
|
253
|
-
});
|
|
254
|
-
expect(socket.sent[1]?.["type"]).toBe("response.create");
|
|
255
|
-
await adapter.disconnect();
|
|
256
|
-
});
|
|
257
|
-
|
|
258
|
-
test("sendText before connect throws (not swallowed, unlike commitInput)", () => {
|
|
259
|
-
const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: () => new StubWs() });
|
|
260
|
-
expect(() => adapter.sendText("nope")).toThrow(/not connected/);
|
|
261
|
-
});
|
|
262
|
-
});
|
|
263
|
-
|
|
264
|
-
describe("createOpenAIRealtimeAdapter — on()/disconnect (366-379)", () => {
|
|
265
|
-
test("unsubscribe stops delivery to that handler", async () => {
|
|
266
|
-
const { adapter, socket } = await connectedOpenAI();
|
|
267
|
-
const seen: RealtimeEvent[] = [];
|
|
268
|
-
const off = adapter.on((e) => seen.push(e));
|
|
269
|
-
socket.emit({ type: "response.audio_transcript.delta", delta: "a" });
|
|
270
|
-
expect(seen).toHaveLength(1);
|
|
271
|
-
off(); // remove the handler
|
|
272
|
-
socket.emit({ type: "response.audio_transcript.delta", delta: "b" });
|
|
273
|
-
expect(seen).toHaveLength(1); // no new delivery
|
|
274
|
-
await adapter.disconnect();
|
|
275
|
-
});
|
|
276
|
-
|
|
277
|
-
test("disconnect closes the socket with 1000 and flips connected=false", async () => {
|
|
278
|
-
const { adapter, socket } = await connectedOpenAI();
|
|
279
|
-
expect(adapter.connected).toBe(true);
|
|
280
|
-
await adapter.disconnect();
|
|
281
|
-
expect(socket.closed).toEqual({ code: 1000, reason: "client closed" });
|
|
282
|
-
expect(adapter.connected).toBe(false);
|
|
283
|
-
});
|
|
284
|
-
|
|
285
|
-
test("disconnect is idempotent (second call returns early)", async () => {
|
|
286
|
-
const { adapter, socket } = await connectedOpenAI();
|
|
287
|
-
await adapter.disconnect();
|
|
288
|
-
socket.closed = undefined; // detect a second close() call
|
|
289
|
-
await adapter.disconnect();
|
|
290
|
-
expect(socket.closed).toBeUndefined(); // early return — close() not called again
|
|
291
|
-
});
|
|
292
|
-
|
|
293
|
-
test("disconnect tolerates a throwing close()", async () => {
|
|
294
|
-
const { adapter, socket } = await connectedOpenAI();
|
|
295
|
-
socket.closeThrows = true;
|
|
296
|
-
await expect(adapter.disconnect()).resolves.toBeUndefined();
|
|
297
|
-
expect(adapter.connected).toBe(false);
|
|
298
|
-
});
|
|
299
|
-
});
|
|
300
|
-
|
|
301
|
-
// ===========================================================================
|
|
302
|
-
// Vapi adapter — uncovered branches (420-534)
|
|
303
|
-
// ===========================================================================
|
|
304
|
-
|
|
305
|
-
/** Connect a Vapi adapter against a fresh StubWs (readyState OPEN, sync open). */
|
|
306
|
-
async function connectedVapi(opts: {
|
|
307
|
-
assistantId?: string;
|
|
308
|
-
now?: () => Date;
|
|
309
|
-
connect?: RealtimeConnectOptions;
|
|
310
|
-
}): Promise<{ adapter: ReturnType<typeof createVapiRealtimeAdapter>; socket: StubWs }> {
|
|
311
|
-
const socket = new StubWs();
|
|
312
|
-
socket.readyState = 1; // Vapi sends inside the open handler, needs OPEN already
|
|
313
|
-
const adapter = createVapiRealtimeAdapter({
|
|
314
|
-
apiKey: "vapi_test",
|
|
315
|
-
_ws: () => socket,
|
|
316
|
-
...(opts.assistantId !== undefined ? { assistantId: opts.assistantId } : {}),
|
|
317
|
-
...(opts.now !== undefined ? { _now: opts.now } : {}),
|
|
318
|
-
});
|
|
319
|
-
const cp = adapter.connect(
|
|
320
|
-
opts.connect ?? { model: "m", instructions: "be brief", voice: "alloy" },
|
|
321
|
-
);
|
|
322
|
-
socket.triggerOpen();
|
|
323
|
-
await cp;
|
|
324
|
-
socket.sent.length = 0;
|
|
325
|
-
return { adapter, socket };
|
|
326
|
-
}
|
|
327
|
-
|
|
328
|
-
describe("createVapiRealtimeAdapter — default WebSocket factory (450-453)", () => {
|
|
329
|
-
const realWs = globalThis.WebSocket;
|
|
330
|
-
let lastSocket: StubWs | undefined;
|
|
331
|
-
let lastUrl: string | undefined;
|
|
332
|
-
|
|
333
|
-
beforeEach(() => {
|
|
334
|
-
lastSocket = undefined;
|
|
335
|
-
lastUrl = undefined;
|
|
336
|
-
(globalThis as { WebSocket: unknown }).WebSocket = class extends StubWs {
|
|
337
|
-
constructor(url: string) {
|
|
338
|
-
super();
|
|
339
|
-
this.readyState = 1;
|
|
340
|
-
lastSocket = this;
|
|
341
|
-
lastUrl = url;
|
|
342
|
-
}
|
|
343
|
-
} as unknown as typeof WebSocket;
|
|
344
|
-
});
|
|
345
|
-
|
|
346
|
-
afterEach(() => {
|
|
347
|
-
(globalThis as { WebSocket: typeof WebSocket }).WebSocket = realWs;
|
|
348
|
-
});
|
|
349
|
-
|
|
350
|
-
test("constructs globalThis.WebSocket at the default Vapi URL", async () => {
|
|
351
|
-
const adapter = createVapiRealtimeAdapter({ apiKey: "vapi_test" });
|
|
352
|
-
const cp = adapter.connect({ model: "m" });
|
|
353
|
-
lastSocket?.triggerOpen();
|
|
354
|
-
await cp;
|
|
355
|
-
expect(adapter.connected).toBe(true);
|
|
356
|
-
expect(lastUrl).toBe("wss://api.vapi.ai/v1/realtime");
|
|
357
|
-
await adapter.disconnect();
|
|
358
|
-
});
|
|
359
|
-
|
|
360
|
-
test("honors a custom url override", async () => {
|
|
361
|
-
const adapter = createVapiRealtimeAdapter({ apiKey: "vapi_test", url: "wss://custom.vapi/rt" });
|
|
362
|
-
const cp = adapter.connect({ model: "m" });
|
|
363
|
-
lastSocket?.triggerOpen();
|
|
364
|
-
await cp;
|
|
365
|
-
expect(lastUrl).toBe("wss://custom.vapi/rt");
|
|
366
|
-
await adapter.disconnect();
|
|
367
|
-
});
|
|
368
|
-
});
|
|
369
|
-
|
|
370
|
-
describe("createVapiRealtimeAdapter — connect rejections", () => {
|
|
371
|
-
test("rejects when already disconnected", async () => {
|
|
372
|
-
const socket = new StubWs();
|
|
373
|
-
socket.readyState = 1;
|
|
374
|
-
const adapter = createVapiRealtimeAdapter({ apiKey: "k", _ws: () => socket });
|
|
375
|
-
await adapter.disconnect(); // sets disconnected=true without ever connecting
|
|
376
|
-
await expect(adapter.connect({ model: "m" })).rejects.toThrow(/has been disconnected/);
|
|
377
|
-
});
|
|
378
|
-
|
|
379
|
-
test("rejects when the factory returns undefined", async () => {
|
|
380
|
-
const adapter = createVapiRealtimeAdapter({
|
|
381
|
-
apiKey: "k",
|
|
382
|
-
_ws: () => undefined as unknown as WebSocketLike,
|
|
383
|
-
});
|
|
384
|
-
await expect(adapter.connect({ model: "m" })).rejects.toThrow(/ws factory returned undefined/);
|
|
385
|
-
});
|
|
386
|
-
|
|
387
|
-
test("rejects on a ws error during the handshake (473-477)", async () => {
|
|
388
|
-
const socket = new StubWs();
|
|
389
|
-
socket.readyState = 1;
|
|
390
|
-
const adapter = createVapiRealtimeAdapter({ apiKey: "k", _ws: () => socket });
|
|
391
|
-
const cp = adapter.connect({ model: "m" });
|
|
392
|
-
socket.triggerError({ message: "vapi down" });
|
|
393
|
-
await expect(cp).rejects.toThrow(/vapi ws error: vapi down/);
|
|
394
|
-
});
|
|
395
|
-
|
|
396
|
-
test("ws error with no message stringifies the raw event (473-477)", async () => {
|
|
397
|
-
const socket = new StubWs();
|
|
398
|
-
socket.readyState = 1;
|
|
399
|
-
const adapter = createVapiRealtimeAdapter({ apiKey: "k", _ws: () => socket });
|
|
400
|
-
const cp = adapter.connect({ model: "m" });
|
|
401
|
-
socket.triggerError("plain-string-error");
|
|
402
|
-
await expect(cp).rejects.toThrow(/vapi ws error: plain-string-error/);
|
|
403
|
-
});
|
|
404
|
-
});
|
|
405
|
-
|
|
406
|
-
describe("createVapiRealtimeAdapter — session.update handshake (463-471)", () => {
|
|
407
|
-
test("includes assistant_id only when provided", async () => {
|
|
408
|
-
const { adapter, socket } = await connectedVapi({ assistantId: "asst_9" });
|
|
409
|
-
// sent[] was cleared post-connect; re-run a fresh connect to inspect the update.
|
|
410
|
-
await adapter.disconnect();
|
|
411
|
-
const s2 = new StubWs();
|
|
412
|
-
s2.readyState = 1;
|
|
413
|
-
const a2 = createVapiRealtimeAdapter({ apiKey: "k", _ws: () => s2 });
|
|
414
|
-
const cp = a2.connect({ model: "m", instructions: "hi", voice: "nova" });
|
|
415
|
-
s2.triggerOpen();
|
|
416
|
-
await cp;
|
|
417
|
-
const session = s2.sent[0]?.["session"] as Record<string, unknown>;
|
|
418
|
-
expect(session["voice"]).toBe("nova");
|
|
419
|
-
expect(session["instructions"]).toBe("hi");
|
|
420
|
-
expect(session["assistant_id"]).toBeUndefined(); // no assistantId on a2
|
|
421
|
-
await a2.disconnect();
|
|
422
|
-
expect(socket.closed).toBeDefined();
|
|
423
|
-
});
|
|
424
|
-
});
|
|
425
|
-
|
|
426
|
-
describe("createVapiRealtimeAdapter — close handler (480-482)", () => {
|
|
427
|
-
test("a server close flips connected back to false", async () => {
|
|
428
|
-
const { adapter, socket } = await connectedVapi({});
|
|
429
|
-
expect(adapter.connected).toBe(true);
|
|
430
|
-
socket.triggerClose(1001, "going away");
|
|
431
|
-
expect(adapter.connected).toBe(false);
|
|
432
|
-
await adapter.disconnect();
|
|
433
|
-
});
|
|
434
|
-
});
|
|
435
|
-
|
|
436
|
-
describe("createVapiRealtimeAdapter — message handler (483-494)", () => {
|
|
437
|
-
test("emits a raw passthrough event with a fixed timestamp via _now", async () => {
|
|
438
|
-
const fixed = new Date("2026-06-04T12:00:00.000Z");
|
|
439
|
-
const { adapter, socket } = await connectedVapi({ now: () => fixed });
|
|
440
|
-
const events: RealtimeEvent[] = [];
|
|
441
|
-
adapter.on((e) => events.push(e));
|
|
442
|
-
socket.emit({ type: "speech-update", status: "started" });
|
|
443
|
-
expect(events).toHaveLength(1);
|
|
444
|
-
const ev = events[0];
|
|
445
|
-
expect(ev?.kind).toBe("raw");
|
|
446
|
-
if (ev?.kind === "raw") {
|
|
447
|
-
expect(ev.provider).toBe("vapi");
|
|
448
|
-
expect(ev.ts).toBe("2026-06-04T12:00:00.000Z");
|
|
449
|
-
expect(ev.payload).toEqual({ type: "speech-update", status: "started" });
|
|
450
|
-
}
|
|
451
|
-
await adapter.disconnect();
|
|
452
|
-
});
|
|
453
|
-
|
|
454
|
-
test("default _now produces a real ISO timestamp when not injected", async () => {
|
|
455
|
-
const { adapter, socket } = await connectedVapi({});
|
|
456
|
-
const events: RealtimeEvent[] = [];
|
|
457
|
-
adapter.on((e) => events.push(e));
|
|
458
|
-
socket.emit({ type: "transcript", text: "hi" });
|
|
459
|
-
const ev = events[0];
|
|
460
|
-
expect(ev?.kind).toBe("raw");
|
|
461
|
-
if (ev?.kind === "raw") {
|
|
462
|
-
// ISO-8601 shape; value is real-clock but format is deterministic.
|
|
463
|
-
expect(ev.ts).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/);
|
|
464
|
-
}
|
|
465
|
-
await adapter.disconnect();
|
|
466
|
-
});
|
|
467
|
-
|
|
468
|
-
test("frames without a string type are ignored", async () => {
|
|
469
|
-
const { adapter, socket } = await connectedVapi({});
|
|
470
|
-
const events: RealtimeEvent[] = [];
|
|
471
|
-
adapter.on((e) => events.push(e));
|
|
472
|
-
socket.emit({ noType: true }); // valid JSON, but type is not a string
|
|
473
|
-
expect(events).toHaveLength(0);
|
|
474
|
-
await adapter.disconnect();
|
|
475
|
-
});
|
|
476
|
-
|
|
477
|
-
test("malformed (non-JSON) frames are swallowed", async () => {
|
|
478
|
-
const { adapter, socket } = await connectedVapi({});
|
|
479
|
-
const events: RealtimeEvent[] = [];
|
|
480
|
-
adapter.on((e) => events.push(e));
|
|
481
|
-
expect(() => socket.emitRaw("{not json")).not.toThrow();
|
|
482
|
-
expect(events).toHaveLength(0);
|
|
483
|
-
// Missing data → defaults to "" → JSON.parse throws → swallowed.
|
|
484
|
-
expect(() => socket.emitRaw(undefined)).not.toThrow();
|
|
485
|
-
expect(events).toHaveLength(0);
|
|
486
|
-
await adapter.disconnect();
|
|
487
|
-
});
|
|
488
|
-
});
|
|
489
|
-
|
|
490
|
-
describe("createVapiRealtimeAdapter — emit isolates throwing subscribers (420-426)", () => {
|
|
491
|
-
test("a handler that throws does not break sibling handlers", async () => {
|
|
492
|
-
const { adapter, socket } = await connectedVapi({});
|
|
493
|
-
const good: RealtimeEvent[] = [];
|
|
494
|
-
adapter.on(() => {
|
|
495
|
-
throw new Error("subscriber blew up");
|
|
496
|
-
});
|
|
497
|
-
adapter.on((e) => good.push(e));
|
|
498
|
-
expect(() => socket.emit({ type: "any" })).not.toThrow();
|
|
499
|
-
expect(good).toHaveLength(1); // the well-behaved subscriber still received it
|
|
500
|
-
await adapter.disconnect();
|
|
501
|
-
});
|
|
502
|
-
});
|
|
503
|
-
|
|
504
|
-
describe("createVapiRealtimeAdapter — send path methods (501-518)", () => {
|
|
505
|
-
test("sendAudio base64-encodes the PCM frame", async () => {
|
|
506
|
-
const { adapter, socket } = await connectedVapi({});
|
|
507
|
-
const pcm = new Int16Array([1, 2, 3, 4]);
|
|
508
|
-
adapter.sendAudio(pcm);
|
|
509
|
-
expect(socket.sent[0]?.["type"]).toBe("input_audio_buffer.append");
|
|
510
|
-
const audio = socket.sent[0]?.["audio"] as string;
|
|
511
|
-
// Decode and confirm the bytes round-trip (little-endian int16).
|
|
512
|
-
const back = new Int16Array(Buffer.from(audio, "base64").buffer.slice(0));
|
|
513
|
-
expect(Array.from(back)).toEqual([1, 2, 3, 4]);
|
|
514
|
-
await adapter.disconnect();
|
|
515
|
-
});
|
|
516
|
-
|
|
517
|
-
test("sendAudio respects a non-zero byteOffset view", async () => {
|
|
518
|
-
const { adapter, socket } = await connectedVapi({});
|
|
519
|
-
const backing = new Int16Array([9, 8, 7, 6]);
|
|
520
|
-
const view = backing.subarray(1, 3); // [8, 7], offset != 0
|
|
521
|
-
adapter.sendAudio(view);
|
|
522
|
-
const audio = socket.sent[0]?.["audio"] as string;
|
|
523
|
-
const bytes = Buffer.from(audio, "base64");
|
|
524
|
-
expect(bytes.byteLength).toBe(4); // 2 samples * 2 bytes
|
|
525
|
-
const back = new Int16Array(bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + 4));
|
|
526
|
-
expect(Array.from(back)).toEqual([8, 7]);
|
|
527
|
-
await adapter.disconnect();
|
|
528
|
-
});
|
|
529
|
-
|
|
530
|
-
test("commitInput sends a single input_audio_buffer.commit", async () => {
|
|
531
|
-
const { adapter, socket } = await connectedVapi({});
|
|
532
|
-
adapter.commitInput();
|
|
533
|
-
expect(socket.sent).toEqual([{ type: "input_audio_buffer.commit" }]);
|
|
534
|
-
await adapter.disconnect();
|
|
535
|
-
});
|
|
536
|
-
|
|
537
|
-
test("sendText sends response.create with the text input", async () => {
|
|
538
|
-
const { adapter, socket } = await connectedVapi({});
|
|
539
|
-
adapter.sendText("say hi");
|
|
540
|
-
expect(socket.sent[0]).toEqual({
|
|
541
|
-
type: "response.create",
|
|
542
|
-
response: { modalities: ["text", "audio"], input: "say hi" },
|
|
543
|
-
});
|
|
544
|
-
await adapter.disconnect();
|
|
545
|
-
});
|
|
546
|
-
|
|
547
|
-
test("interrupt sends response.cancel when connected", async () => {
|
|
548
|
-
const { adapter, socket } = await connectedVapi({});
|
|
549
|
-
adapter.interrupt("barge-in");
|
|
550
|
-
expect(socket.sent[0]?.["type"]).toBe("response.cancel");
|
|
551
|
-
await adapter.disconnect();
|
|
552
|
-
});
|
|
553
|
-
|
|
554
|
-
test("interrupt swallows the throw when the socket is closed", async () => {
|
|
555
|
-
const { adapter, socket } = await connectedVapi({});
|
|
556
|
-
socket.readyState = 3; // not OPEN → send() throws
|
|
557
|
-
expect(() => adapter.interrupt("barge-in")).not.toThrow();
|
|
558
|
-
await adapter.disconnect();
|
|
559
|
-
});
|
|
560
|
-
});
|
|
561
|
-
|
|
562
|
-
describe("createVapiRealtimeAdapter — on()/disconnect (519-536)", () => {
|
|
563
|
-
test("unsubscribe removes the handler", async () => {
|
|
564
|
-
const { adapter, socket } = await connectedVapi({});
|
|
565
|
-
const seen: RealtimeEvent[] = [];
|
|
566
|
-
const off = adapter.on((e) => seen.push(e));
|
|
567
|
-
socket.emit({ type: "a" });
|
|
568
|
-
expect(seen).toHaveLength(1);
|
|
569
|
-
off();
|
|
570
|
-
socket.emit({ type: "b" });
|
|
571
|
-
expect(seen).toHaveLength(1);
|
|
572
|
-
await adapter.disconnect();
|
|
573
|
-
});
|
|
574
|
-
|
|
575
|
-
test("disconnect closes the socket and clears state", async () => {
|
|
576
|
-
const { adapter, socket } = await connectedVapi({});
|
|
577
|
-
await adapter.disconnect();
|
|
578
|
-
expect(socket.closed).toEqual({ code: undefined, reason: undefined });
|
|
579
|
-
expect(adapter.connected).toBe(false);
|
|
580
|
-
});
|
|
581
|
-
|
|
582
|
-
test("disconnect tolerates a throwing close() and still clears state", async () => {
|
|
583
|
-
const { adapter, socket } = await connectedVapi({});
|
|
584
|
-
socket.closeThrows = true;
|
|
585
|
-
await expect(adapter.disconnect()).resolves.toBeUndefined();
|
|
586
|
-
expect(adapter.connected).toBe(false);
|
|
587
|
-
// A second disconnect with no ws is a no-op (ws === undefined branch).
|
|
588
|
-
await expect(adapter.disconnect()).resolves.toBeUndefined();
|
|
589
|
-
});
|
|
590
|
-
});
|