@hazeljs/realtime 0.2.0-rc.3

package/dist/providers/openai/openai-realtime.client.js

@@ -0,0 +1,211 @@
+"use strict";
+/**
+ * OpenAI Realtime API WebSocket client
+ * Connects to wss://api.openai.com/v1/realtime and handles bidirectional event flow
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIRealtimeClient = void 0;
+const core_1 = __importDefault(require("@hazeljs/core"));
+const ws_1 = __importDefault(require("ws"));
+const OPENAI_REALTIME_URL = 'wss://api.openai.com/v1/realtime';
+/**
+ * Low-level OpenAI Realtime API WebSocket client
+ */
+class OpenAIRealtimeClient {
+    constructor(options) {
+        this.ws = null;
+        this.eventHandlers = new Map();
+        this.genericHandlers = new Set();
+        this._connected = false;
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? 'gpt-realtime';
+        this.sessionConfig = options.sessionConfig;
+    }
+    get connected() {
+        return this._connected && this.ws?.readyState === ws_1.default.OPEN;
+    }
+    /**
+     * Connect to OpenAI Realtime API
+     */
+    async connect() {
+        return new Promise((resolve, reject) => {
+            const url = `${OPENAI_REALTIME_URL}?model=${encodeURIComponent(this.model)}`;
+            this.ws = new ws_1.default(url, {
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            this.ws.on('open', () => {
+                this._connected = true;
+                this.sendSessionUpdate();
+                resolve();
+            });
+            this.ws.on('message', (data) => {
+                try {
+                    const event = JSON.parse(data.toString());
+                    this.handleServerEvent(event);
+                }
+                catch (err) {
+                    this.emit('error', { type: 'error', error: String(err) });
+                }
+            });
+            this.ws.on('close', (code, reason) => {
+                this._connected = false;
+                this.emit('session.ended', {
+                    type: 'session.ended',
+                    code,
+                    reason: reason.toString(),
+                });
+            });
+            this.ws.on('error', (err) => {
+                this._connected = false;
+                this.emit('error', { type: 'error', error: err.message });
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Send session.update with config
+     */
+    sendSessionUpdate() {
+        if (!this.sessionConfig)
+            return;
+        const session = {
+            type: 'realtime',
+            model: this.model,
+            output_modalities: this.sessionConfig.outputModalities ?? ['audio', 'text'],
+            instructions: this.sessionConfig.instructions ?? 'You are a helpful assistant.',
+        };
+        if (this.sessionConfig.voice) {
+            session.audio = {
+                ...session.audio,
+                output: {
+                    format: this.sessionConfig.outputFormat ?? { type: 'audio/pcm' },
+                    voice: this.sessionConfig.voice,
+                },
+            };
+        }
+        if (this.sessionConfig.inputFormat) {
+            session.audio = {
+                ...session.audio,
+                input: {
+                    format: this.sessionConfig.inputFormat,
+                    turn_detection: this.sessionConfig.turnDetection !== false ? { type: 'server_vad' } : undefined,
+                },
+            };
+        }
+        this.send({ type: 'session.update', session });
+    }
+    /**
+     * Send a client event to OpenAI
+     */
+    send(event) {
+        if (!this.ws || this.ws.readyState !== ws_1.default.OPEN) {
+            throw new Error('WebSocket not connected');
+        }
+        this.ws.send(JSON.stringify(event));
+    }
+    /**
+     * Append audio to input buffer (base64 PCM)
+     */
+    appendAudio(base64Audio) {
+        this.send({
+            type: 'input_audio_buffer.append',
+            audio: base64Audio,
+        });
+    }
+    /**
+     * Commit input buffer (when VAD disabled)
+     */
+    commitInputBuffer() {
+        this.send({ type: 'input_audio_buffer.commit' });
+    }
+    /**
+     * Clear input buffer
+     */
+    clearInputBuffer() {
+        this.send({ type: 'input_audio_buffer.clear' });
+    }
+    /**
+     * Create a response (trigger model to respond)
+     */
+    createResponse(options) {
+        this.send({
+            type: 'response.create',
+            response: options ?? {},
+        });
+    }
+    /**
+     * Add text to conversation
+     */
+    addConversationItem(text) {
+        this.send({
+            type: 'conversation.item.create',
+            item: {
+                type: 'message',
+                role: 'user',
+                content: [{ type: 'input_text', text }],
+            },
+        });
+    }
+    /**
+     * Subscribe to server events
+     */
+    on(eventType, handler) {
+        if (!this.eventHandlers.has(eventType)) {
+            this.eventHandlers.set(eventType, new Set());
+        }
+        this.eventHandlers.get(eventType).add(handler);
+        return () => {
+            this.eventHandlers.get(eventType)?.delete(handler);
+        };
+    }
+    /**
+     * Subscribe to all events
+     */
+    onAny(handler) {
+        this.genericHandlers.add(handler);
+        return () => this.genericHandlers.delete(handler);
+    }
+    handleServerEvent(event) {
+        const typeHandlers = this.eventHandlers.get(event.type);
+        if (typeHandlers) {
+            for (const h of typeHandlers) {
+                try {
+                    h(event);
+                }
+                catch (err) {
+                    core_1.default.error(`Realtime event handler error (${event.type}):`, err);
+                }
+            }
+        }
+        for (const h of this.genericHandlers) {
+            try {
+                h(event);
+            }
+            catch (err) {
+                core_1.default.error('Realtime generic handler error:', err);
+            }
+        }
+    }
+    emit(eventType, event) {
+        this.handleServerEvent(event);
+    }
+    /**
+     * Disconnect and cleanup
+     */
+    disconnect() {
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.close();
+            this.ws = null;
+        }
+        this._connected = false;
+        this.eventHandlers.clear();
+        this.genericHandlers.clear();
+    }
+}
+exports.OpenAIRealtimeClient = OpenAIRealtimeClient;

package/dist/providers/openai/openai-realtime.client.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=openai-realtime.client.test.d.ts.map

package/dist/providers/openai/openai-realtime.client.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-realtime.client.test.d.ts","sourceRoot":"","sources":["../../../src/providers/openai/openai-realtime.client.test.ts"],"names":[],"mappings":""}

package/dist/providers/openai/openai-realtime.client.test.js

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = __importDefault(require("@hazeljs/core"));
+const openai_realtime_client_1 = require("./openai-realtime.client");
+jest.mock('ws', () => {
+    const handlers = {};
+    const mockWs = {
+        send: jest.fn(),
+        close: jest.fn(),
+        removeAllListeners: jest.fn(),
+        on: jest.fn((event, cb) => {
+            handlers[event] = cb;
+            if (event === 'open') {
+                setImmediate(() => cb());
+            }
+            return mockWs;
+        }),
+        readyState: 1,
+    };
+    global.__mockWs =
+        Object.assign(mockWs, { _handlers: handlers });
+    const Ws = jest.fn(() => mockWs);
+    Ws.OPEN = 1;
+    return { __esModule: true, default: Ws };
+});
+const mockWs = global.__mockWs;
+describe('OpenAIRealtimeClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        if (mockWs)
+            mockWs.readyState = 1;
+    });
+    describe('constructor', () => {
+        it('should use default model gpt-realtime', () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            expect(client).toBeDefined();
+        });
+        it('should use provided model', () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({
+                apiKey: 'test',
+                model: 'gpt-4o',
+            });
+            expect(client).toBeDefined();
+        });
+    });
+    describe('connect', () => {
+        it('should connect and resolve', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test-key' });
+            await client.connect();
+            expect(client.connected).toBe(true);
+            expect(mockWs.on).toHaveBeenCalledWith('open', expect.any(Function));
+            expect(mockWs.on).toHaveBeenCalledWith('message', expect.any(Function));
+            expect(mockWs.on).toHaveBeenCalledWith('close', expect.any(Function));
+            expect(mockWs.on).toHaveBeenCalledWith('error', expect.any(Function));
+        });
+        it('should send session.update when sessionConfig provided', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({
+                apiKey: 'test-key',
+                sessionConfig: {
+                    instructions: 'Be helpful',
+                    voice: 'marin',
+                },
+            });
+            await client.connect();
+            expect(mockWs.send).toHaveBeenCalledWith(expect.stringContaining('session.update'));
+            expect(mockWs.send).toHaveBeenCalledWith(expect.stringContaining('Be helpful'));
+            expect(mockWs.send).toHaveBeenCalledWith(expect.stringContaining('marin'));
+        });
+        it('should send session.update with inputFormat when provided', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({
+                apiKey: 'test-key',
+                sessionConfig: {
+                    voice: 'alloy',
+                    inputFormat: { type: 'audio/pcm' },
+                },
+            });
+            await client.connect();
+            expect(mockWs.send).toHaveBeenCalledWith(expect.stringContaining('session.update'));
+            expect(mockWs.send).toHaveBeenCalledWith(expect.stringContaining('audio/pcm'));
+        });
+    });
+    describe('send', () => {
+        it('should throw when not connected', () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            expect(() => client.send({ type: 'test' })).toThrow('WebSocket not connected');
+        });
+        it('should send event when connected', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            client.send({ type: 'custom.event', data: 'test' });
+            expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify({ type: 'custom.event', data: 'test' }));
+        });
+    });
+    describe('appendAudio', () => {
+        it('should send input_audio_buffer.append', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            client.appendAudio('base64audio');
+            expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify({
+                type: 'input_audio_buffer.append',
+                audio: 'base64audio',
+            }));
+        });
+    });
+    describe('commitInputBuffer', () => {
+        it('should send input_audio_buffer.commit', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            client.commitInputBuffer();
+            expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify({ type: 'input_audio_buffer.commit' }));
+        });
+    });
+    describe('clearInputBuffer', () => {
+        it('should send input_audio_buffer.clear', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            client.clearInputBuffer();
+            expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify({ type: 'input_audio_buffer.clear' }));
+        });
+    });
+    describe('createResponse', () => {
+        it('should send response.create', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            client.createResponse({ outputModalities: ['text'] });
+            expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify({
+                type: 'response.create',
+                response: { outputModalities: ['text'] },
+            }));
+        });
+    });
+    describe('addConversationItem', () => {
+        it('should send conversation.item.create', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            client.addConversationItem('Hello');
+            expect(mockWs.send).toHaveBeenCalledWith(JSON.stringify({
+                type: 'conversation.item.create',
+                item: {
+                    type: 'message',
+                    role: 'user',
+                    content: [{ type: 'input_text', text: 'Hello' }],
+                },
+            }));
+        });
+    });
+    describe('on', () => {
+        it('should register handler and return unsubscribe', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const handler = jest.fn();
+            const unsubscribe = client.on('session.created', handler);
+            expect(typeof unsubscribe).toBe('function');
+            unsubscribe();
+        });
+        it('should invoke handler when server sends matching event', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const handler = jest.fn();
+            client.on('session.created', handler);
+            const msgHandler = mockWs
+                ._handlers?.['message'];
+            expect(msgHandler).toBeDefined();
+            msgHandler(Buffer.from(JSON.stringify({ type: 'session.created', session: { id: 'sess-1' } })));
+            expect(handler).toHaveBeenCalledWith(expect.objectContaining({ type: 'session.created', session: { id: 'sess-1' } }));
+        });
+        it('should catch type handler errors and continue', async () => {
+            const loggerSpy = jest.spyOn(core_1.default, 'error').mockImplementation();
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const handler = jest.fn().mockImplementation(() => {
+                throw new Error('handler error');
+            });
+            client.on('test.event', handler);
+            const msgHandler = mockWs
+                ._handlers?.['message'];
+            msgHandler(Buffer.from(JSON.stringify({ type: 'test.event' })));
+            expect(loggerSpy).toHaveBeenCalledWith('Realtime event handler error (test.event):', expect.any(Error));
+            loggerSpy.mockRestore();
+        });
+        it('should catch generic handler errors and continue', async () => {
+            const loggerSpy = jest.spyOn(core_1.default, 'error').mockImplementation();
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const handler = jest.fn().mockImplementation(() => {
+                throw new Error('generic handler error');
+            });
+            client.onAny(handler);
+            const msgHandler = mockWs
+                ._handlers?.['message'];
+            msgHandler(Buffer.from(JSON.stringify({ type: 'other.event' })));
+            expect(loggerSpy).toHaveBeenCalledWith('Realtime generic handler error:', expect.any(Error));
+            loggerSpy.mockRestore();
+        });
+    });
+    describe('onAny', () => {
+        it('should register handler and return unsubscribe', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const handler = jest.fn();
+            const unsubscribe = client.onAny(handler);
+            expect(typeof unsubscribe).toBe('function');
+            unsubscribe();
+        });
+        it('should invoke onAny when server sends any event', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const handler = jest.fn();
+            client.onAny(handler);
+            const msgHandler = mockWs
+                ._handlers?.['message'];
+            msgHandler(Buffer.from(JSON.stringify({ type: 'response.done' })));
+            expect(handler).toHaveBeenCalledWith(expect.objectContaining({ type: 'response.done' }));
+        });
+    });
+    describe('server message handling', () => {
+        it('should emit error on invalid JSON message', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const errorHandler = jest.fn();
+            client.on('error', errorHandler);
+            const msgHandler = mockWs
+                ._handlers?.['message'];
+            msgHandler(Buffer.from('not json'));
+            expect(errorHandler).toHaveBeenCalledWith(expect.objectContaining({ type: 'error', error: expect.any(String) }));
+        });
+        it('should emit session.ended on close', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const endedHandler = jest.fn();
+            client.on('session.ended', endedHandler);
+            const closeHandler = mockWs._handlers?.['close'];
+            closeHandler(1000, Buffer.from('normal'));
+            expect(endedHandler).toHaveBeenCalledWith(expect.objectContaining({ type: 'session.ended', code: 1000 }));
+            expect(client.connected).toBe(false);
+        });
+        it('should handle ws error event', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            const errorHandler = jest.fn();
+            client.on('error', errorHandler);
+            const wsErrorHandler = mockWs
+                ._handlers?.['error'];
+            wsErrorHandler(new Error('ws error'));
+            expect(client.connected).toBe(false);
+            expect(errorHandler).toHaveBeenCalledWith(expect.objectContaining({ type: 'error', error: 'ws error' }));
+        });
+    });
+    describe('disconnect', () => {
+        it('should close websocket and cleanup', async () => {
+            const client = new openai_realtime_client_1.OpenAIRealtimeClient({ apiKey: 'test' });
+            await client.connect();
+            client.disconnect();
+            expect(mockWs.removeAllListeners).toHaveBeenCalled();
+            expect(mockWs.close).toHaveBeenCalled();
+            expect(client.connected).toBe(false);
+        });
+    });
+});

package/dist/providers/openai/openai-realtime.session.d.ts

@@ -0,0 +1,63 @@
+/**
+ * OpenAI Realtime Session - manages a single voice session with proxying to client
+ */
+/**
+ * Minimal client interface for realtime session (avoids @hazeljs/websocket peer dep)
+ */
+export interface RealtimeClientAdapter {
+    id: string;
+    send(event: string, data: unknown): void;
+}
+import type { RealtimeSessionConfig } from '../../realtime.types';
+export interface OpenAIRealtimeSessionOptions {
+    apiKey: string;
+    model?: string;
+    sessionConfig?: RealtimeSessionConfig;
+}
+/**
+ * A realtime session that proxies between a WebSocket client and OpenAI Realtime API
+ */
+export declare class OpenAIRealtimeSession {
+    private readonly client;
+    private readonly hazelClient;
+    private stats;
+    constructor(hazelClient: RealtimeClientAdapter, options: OpenAIRealtimeSessionOptions);
+    /**
+     * Connect to OpenAI and start session
+     */
+    connect(): Promise<void>;
+    /**
+     * Forward OpenAI server event to HazelJS client
+     */
+    private forwardToClient;
+    /**
+     * Handle message from HazelJS client - forward to OpenAI
+     */
+    handleClientMessage(payload: unknown): void;
+    /**
+     * Append audio from client
+     */
+    appendAudio(base64Audio: string): void;
+    /**
+     * Send text message
+     */
+    sendText(text: string): void;
+    /**
+     * Get session stats
+     */
+    getStats(): {
+        sessionId: string;
+        provider: 'openai';
+        connectedAt: number;
+        audioChunksReceived: number;
+        audioChunksSent: number;
+        eventsReceived: number;
+        eventsSent: number;
+    };
+    /**
+     * Disconnect and cleanup
+     */
+    disconnect(): void;
+    get isConnected(): boolean;
+}
+//# sourceMappingURL=openai-realtime.session.d.ts.map

package/dist/providers/openai/openai-realtime.session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-realtime.session.d.ts","sourceRoot":"","sources":["../../../src/providers/openai/openai-realtime.session.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,CAAC;CAC1C;AAED,OAAO,KAAK,EAAE,qBAAqB,EAAuB,MAAM,sBAAsB,CAAC;AAEvF,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,qBAAqB,CAAC;CACvC;AAED;;GAEG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAwB;IACpD,OAAO,CAAC,KAAK,CAKX;gBAEU,WAAW,EAAE,qBAAqB,EAAE,OAAO,EAAE,4BAA4B;IAerF;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9B;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB;;OAEG;IACH,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI;IAiB3C;;OAEG;IACH,WAAW,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAKtC;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAK5B;;OAEG;IACH,QAAQ,IAAI;QACV,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,QAAQ,CAAC;QACnB,WAAW,EAAE,MAAM,CAAC;QACpB,mBAAmB,EAAE,MAAM,CAAC;QAC5B,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;QACvB,UAAU,EAAE,MAAM,CAAC;KACpB;IASD;;OAEG;IACH,UAAU,IAAI,IAAI;IAIlB,IAAI,WAAW,IAAI,OAAO,CAEzB;CACF"}

package/dist/providers/openai/openai-realtime.session.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * OpenAI Realtime Session - manages a single voice session with proxying to client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIRealtimeSession = void 0;
+const openai_realtime_client_1 = require("./openai-realtime.client");
+/**
+ * A realtime session that proxies between a WebSocket client and OpenAI Realtime API
+ */
+class OpenAIRealtimeSession {
+    constructor(hazelClient, options) {
+        this.stats = {
+            audioChunksReceived: 0,
+            audioChunksSent: 0,
+            eventsReceived: 0,
+            eventsSent: 0,
+        };
+        this.hazelClient = hazelClient;
+        this.client = new openai_realtime_client_1.OpenAIRealtimeClient({
+            apiKey: options.apiKey,
+            model: options.model,
+            sessionConfig: options.sessionConfig,
+        });
+        // Forward all OpenAI server events to HazelJS client
+        this.client.onAny((event) => {
+            this.stats.eventsReceived++;
+            this.forwardToClient(event);
+        });
+    }
+    /**
+     * Connect to OpenAI and start session
+     */
+    async connect() {
+        await this.client.connect();
+    }
+    /**
+     * Forward OpenAI server event to HazelJS client
+     */
+    forwardToClient(event) {
+        this.hazelClient.send('realtime', event);
+    }
+    /**
+     * Handle message from HazelJS client - forward to OpenAI
+     */
+    handleClientMessage(payload) {
+        if (typeof payload !== 'object' || payload === null)
+            return;
+        const obj = payload;
+        // Client can send raw OpenAI client events
+        if (obj.type && typeof obj.type === 'string') {
+            this.client.send(obj);
+            this.stats.eventsSent++;
+            // Special handling for base64 audio
+            if (obj.type === 'input_audio_buffer.append' && typeof obj.audio === 'string') {
+                this.stats.audioChunksSent++;
+            }
+        }
+    }
+    /**
+     * Append audio from client
+     */
+    appendAudio(base64Audio) {
+        this.client.appendAudio(base64Audio);
+        this.stats.audioChunksSent++;
+    }
+    /**
+     * Send text message
+     */
+    sendText(text) {
+        this.client.addConversationItem(text);
+        this.client.createResponse({ outputModalities: ['audio', 'text'] });
+    }
+    /**
+     * Get session stats
+     */
+    getStats() {
+        return {
+            sessionId: this.hazelClient.id,
+            provider: 'openai',
+            connectedAt: Date.now(),
+            ...this.stats,
+        };
+    }
+    /**
+     * Disconnect and cleanup
+     */
+    disconnect() {
+        this.client.disconnect();
+    }
+    get isConnected() {
+        return this.client.connected;
+    }
+}
+exports.OpenAIRealtimeSession = OpenAIRealtimeSession;

package/dist/providers/openai/openai-realtime.session.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=openai-realtime.session.test.d.ts.map

package/dist/providers/openai/openai-realtime.session.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai-realtime.session.test.d.ts","sourceRoot":"","sources":["../../../src/providers/openai/openai-realtime.session.test.ts"],"names":[],"mappings":""}