@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/src/index.test.ts DELETED
@@ -1,296 +0,0 @@
1
- import { describe, expect, test } from "bun:test";
2
- import {
3
- type RealtimeEvent,
4
- type WebSocketFactory,
5
- type WebSocketLike,
6
- createOpenAIRealtimeAdapter,
7
- createRealtimeAdapter,
8
- createVapiRealtimeAdapter,
9
- decodePcm16Base64,
10
- encodePcm16Base64,
11
- } from "./index.js";
12
-
13
- /**
14
- * Scripted WebSocket stub. Exposes `mockServerEmit({type, ...})` for
15
- * tests to drive incoming events, and `lastSent` to assert outbound
16
- * messages.
17
- */
18
- function makeStubWs(): {
19
- ctor: WebSocketFactory;
20
- socket: WebSocketLike & {
21
- mockServerEmit(event: Record<string, unknown>): void;
22
- lastSent: Record<string, unknown>[];
23
- triggerOpen(): void;
24
- triggerClose(code?: number, reason?: string): void;
25
- };
26
- } {
27
- const lastSent: Record<string, unknown>[] = [];
28
- const listeners = new Map<string, Array<(ev: unknown) => void>>();
29
- const socket = {
30
- readyState: 0,
31
- send(data: string | ArrayBuffer): void {
32
- if (typeof data === "string") {
33
- lastSent.push(JSON.parse(data));
34
- }
35
- },
36
- close(code?: number, reason?: string): void {
37
- this.readyState = 3;
38
- const handlers = listeners.get("close") ?? [];
39
- for (const h of handlers) h({ code, reason });
40
- },
41
- addEventListener(type: string, handler: (ev: unknown) => void): void {
42
- const arr = listeners.get(type) ?? [];
43
- arr.push(handler);
44
- listeners.set(type, arr);
45
- },
46
- mockServerEmit(event: Record<string, unknown>): void {
47
- const handlers = listeners.get("message") ?? [];
48
- for (const h of handlers) h({ data: JSON.stringify(event) });
49
- },
50
- lastSent,
51
- triggerOpen(): void {
52
- this.readyState = 1;
53
- const handlers = listeners.get("open") ?? [];
54
- for (const h of handlers) h({});
55
- },
56
- triggerClose(code?: number, reason?: string): void {
57
- this.readyState = 3;
58
- const handlers = listeners.get("close") ?? [];
59
- for (const h of handlers) h({ code, reason });
60
- },
61
- };
62
- const ctor: WebSocketFactory = () => socket;
63
- return { ctor, socket };
64
- }
65
-
66
- describe("createOpenAIRealtimeAdapter — connect + protocol contract (T2)", () => {
67
- test("connect() sends a session.update after the WebSocket opens", async () => {
68
- const { ctor, socket } = makeStubWs();
69
- const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: ctor });
70
- const connectPromise = adapter.connect({
71
- model: "gpt-4o-realtime-preview",
72
- instructions: "be brief",
73
- voice: "alloy",
74
- vad: "server",
75
- });
76
- socket.triggerOpen();
77
- await connectPromise;
78
- expect(adapter.connected).toBe(true);
79
- expect(socket.lastSent[0]).toBeDefined();
80
- const sessionUpdate = socket.lastSent[0];
81
- if (sessionUpdate === undefined) throw new Error("missing session.update");
82
- expect(sessionUpdate["type"]).toBe("session.update");
83
- const session = sessionUpdate["session"] as Record<string, unknown>;
84
- expect(session["instructions"]).toBe("be brief");
85
- expect(session["voice"]).toBe("alloy");
86
- expect(session["input_audio_format"]).toBe("pcm16");
87
- expect(session["output_audio_format"]).toBe("pcm16");
88
- expect((session["turn_detection"] as { type?: string })["type"]).toBe("server_vad");
89
- });
90
-
91
- test("sendAudio packs Int16Array as base64 and emits input_audio_buffer.append", async () => {
92
- const { ctor, socket } = makeStubWs();
93
- const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: ctor });
94
- const cp = adapter.connect({ model: "m" });
95
- socket.triggerOpen();
96
- await cp;
97
- socket.lastSent.length = 0;
98
-
99
- const pcm = new Int16Array([0, 1024, -1024]);
100
- adapter.sendAudio(pcm);
101
- expect(socket.lastSent[0]?.["type"]).toBe("input_audio_buffer.append");
102
- const audio = socket.lastSent[0]?.["audio"] as string;
103
- expect(typeof audio).toBe("string");
104
- const decoded = decodePcm16Base64(audio);
105
- expect(decoded[0]).toBe(0);
106
- expect(decoded[1]).toBe(1024);
107
- expect(decoded[2]).toBe(-1024);
108
- });
109
-
110
- test("server response.audio_transcript.delta → transcript_partial event", async () => {
111
- const { ctor, socket } = makeStubWs();
112
- const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: ctor });
113
- const events: RealtimeEvent[] = [];
114
- adapter.on((e) => events.push(e));
115
- const cp = adapter.connect({ model: "m" });
116
- socket.triggerOpen();
117
- await cp;
118
-
119
- socket.mockServerEmit({
120
- type: "response.audio_transcript.delta",
121
- delta: "Hello",
122
- item_id: "item_1",
123
- });
124
- socket.mockServerEmit({
125
- type: "response.audio_transcript.delta",
126
- delta: " world",
127
- item_id: "item_1",
128
- });
129
- socket.mockServerEmit({
130
- type: "response.audio_transcript.done",
131
- transcript: "Hello world",
132
- item_id: "item_1",
133
- });
134
-
135
- const partials = events.filter((e) => e.kind === "transcript_partial");
136
- expect(partials.map((e) => (e.kind === "transcript_partial" ? e.text : ""))).toEqual([
137
- "Hello",
138
- " world",
139
- ]);
140
- const final = events.find((e) => e.kind === "transcript_final");
141
- expect(final).toBeDefined();
142
- if (final?.kind === "transcript_final") {
143
- expect(final.text).toBe("Hello world");
144
- }
145
- });
146
-
147
- test("server response.audio.delta → audio_chunk event with PCM Int16Array", async () => {
148
- const { ctor, socket } = makeStubWs();
149
- const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: ctor });
150
- const events: RealtimeEvent[] = [];
151
- adapter.on((e) => events.push(e));
152
- const cp = adapter.connect({ model: "m" });
153
- socket.triggerOpen();
154
- await cp;
155
-
156
- const pcm = new Int16Array([100, 200, 300]);
157
- socket.mockServerEmit({
158
- type: "response.audio.delta",
159
- delta: encodePcm16Base64(pcm),
160
- });
161
-
162
- const audio = events.find((e) => e.kind === "audio_chunk");
163
- expect(audio).toBeDefined();
164
- if (audio?.kind === "audio_chunk") {
165
- expect(audio.sampleRate).toBe(24_000);
166
- expect(audio.pcm[0]).toBe(100);
167
- expect(audio.pcm[1]).toBe(200);
168
- expect(audio.pcm[2]).toBe(300);
169
- }
170
- });
171
-
172
- test("interrupt() sends response.cancel and emits interrupt event", async () => {
173
- const { ctor, socket } = makeStubWs();
174
- const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: ctor });
175
- const events: RealtimeEvent[] = [];
176
- adapter.on((e) => events.push(e));
177
- const cp = adapter.connect({ model: "m" });
178
- socket.triggerOpen();
179
- await cp;
180
- socket.lastSent.length = 0;
181
-
182
- adapter.interrupt("user spoke");
183
- expect(socket.lastSent[0]?.["type"]).toBe("response.cancel");
184
- expect(events.some((e) => e.kind === "interrupt")).toBe(true);
185
- });
186
-
187
- test("close from server → disconnect event", async () => {
188
- const { ctor, socket } = makeStubWs();
189
- const adapter = createOpenAIRealtimeAdapter({ apiKey: "sk-test", _ws: ctor });
190
- const events: RealtimeEvent[] = [];
191
- adapter.on((e) => events.push(e));
192
- const cp = adapter.connect({ model: "m" });
193
- socket.triggerOpen();
194
- await cp;
195
-
196
- socket.triggerClose(1000, "ok");
197
- expect(events.some((e) => e.kind === "disconnect")).toBe(true);
198
- });
199
-
200
- test("missing API key throws on connect", async () => {
201
- const { ctor } = makeStubWs();
202
- const saved = process.env["OPENAI_API_KEY"];
203
- (process.env as Record<string, string | undefined>)["OPENAI_API_KEY"] = undefined;
204
- try {
205
- const adapter = createOpenAIRealtimeAdapter({ _ws: ctor });
206
- await expect(adapter.connect({ model: "m" })).rejects.toThrow(/OPENAI_API_KEY/);
207
- } finally {
208
- if (saved !== undefined) {
209
- (process.env as Record<string, string | undefined>)["OPENAI_API_KEY"] = saved;
210
- }
211
- }
212
- });
213
- });
214
-
215
- describe("createRealtimeAdapter dispatch", () => {
216
- test("openai → openai adapter", () => {
217
- const a = createRealtimeAdapter("openai", { apiKey: "sk-test" });
218
- expect(a.providerId).toBe("openai");
219
- });
220
-
221
- test("vapi → vapi stub adapter", () => {
222
- const a = createRealtimeAdapter("vapi", { apiKey: "test" });
223
- expect(a.providerId).toBe("vapi");
224
- });
225
-
226
- test("unknown provider throws", () => {
227
- expect(() => createRealtimeAdapter("unknown" as unknown as "openai", { apiKey: "x" })).toThrow(
228
- /unknown realtime provider/,
229
- );
230
- });
231
- });
232
-
233
- describe("createVapiRealtimeAdapter (Section 30)", () => {
234
- test("missing VAPI_API_KEY throws on connect", async () => {
235
- const oldKey = process.env["VAPI_API_KEY"];
236
- process.env["VAPI_API_KEY"] = undefined;
237
- const adapter = createVapiRealtimeAdapter({});
238
- await expect(adapter.connect({ model: "m" })).rejects.toThrow(/VAPI_API_KEY/);
239
- if (oldKey !== undefined) process.env["VAPI_API_KEY"] = oldKey;
240
- });
241
-
242
- test("connect handshake sends session.update and reaches connected=true", async () => {
243
- const sentMessages: string[] = [];
244
- const stubFactory: WebSocketFactory = (_url, _init) => {
245
- const listeners = new Map<string, (ev: unknown) => void>();
246
- const ws: WebSocketLike = {
247
- readyState: 1,
248
- send(data: string | ArrayBuffer): void {
249
- if (typeof data === "string") sentMessages.push(data);
250
- },
251
- close(): void {},
252
- addEventListener(type, handler): void {
253
- listeners.set(type, handler);
254
- },
255
- };
256
- // Simulate open after one tick.
257
- queueMicrotask(() => listeners.get("open")?.({}));
258
- return ws;
259
- };
260
- const adapter = createVapiRealtimeAdapter({
261
- apiKey: "vapi_test",
262
- assistantId: "asst_123",
263
- _ws: stubFactory,
264
- });
265
- await adapter.connect({ model: "m", instructions: "be brief", voice: "alloy" });
266
- expect(adapter.connected).toBe(true);
267
- const sessionUpdate = sentMessages.find((m) => m.includes("session.update"));
268
- expect(sessionUpdate).toBeDefined();
269
- expect(sessionUpdate).toContain("assistant_id");
270
- expect(sessionUpdate).toContain("asst_123");
271
- });
272
-
273
- test("interrupt is idempotent when not connected", () => {
274
- const adapter = createVapiRealtimeAdapter({ apiKey: "k" });
275
- adapter.interrupt("user spoke");
276
- adapter.interrupt("user spoke again");
277
- });
278
- });
279
-
280
- describe("encodePcm16Base64 / decodePcm16Base64", () => {
281
- test("round-trips an Int16Array of mixed values", () => {
282
- const samples = new Int16Array([-32768, -1, 0, 1, 32767, 1234, -5678]);
283
- const b64 = encodePcm16Base64(samples);
284
- const decoded = decodePcm16Base64(b64);
285
- expect(Array.from(decoded)).toEqual(Array.from(samples));
286
- });
287
-
288
- test("handles a 30ms-frame-sized buffer (720 samples at 24kHz)", () => {
289
- const samples = new Int16Array(720);
290
- for (let i = 0; i < samples.length; i++) samples[i] = (i * 37) & 0xffff;
291
- const decoded = decodePcm16Base64(encodePcm16Base64(samples));
292
- expect(decoded.length).toBe(720);
293
- expect(decoded[0]).toBe(samples[0]);
294
- expect(decoded[719]).toBe(samples[719]);
295
- });
296
- });