@livekit/agents-plugin-openai 0.3.4 → 0.4.0

package/dist/realtime/realtime_model.js

@@ -1,53 +1,41 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _InputAudioBuffer_session, _ConversationItem_session, _Conversation_session, _Response_session, _RealtimeModel_defaultOpts, _RealtimeModel_sessions, _RealtimeSession_instances, _RealtimeSession_fncCtx, _RealtimeSession_opts, _RealtimeSession_pendingResponses, _RealtimeSession_sessionId, _RealtimeSession_ws, _RealtimeSession_expiresAt, _RealtimeSession_logger, _RealtimeSession_task, _RealtimeSession_closing, _RealtimeSession_sendQueue, _RealtimeSession_loggableEvent, _RealtimeSession_start, _RealtimeSession_getContent, _RealtimeSession_handleError, _RealtimeSession_handleSessionCreated, _RealtimeSession_handleSessionUpdated, _RealtimeSession_handleConversationCreated, _RealtimeSession_handleInputAudioBufferCommitted, _RealtimeSession_handleInputAudioBufferCleared, _RealtimeSession_handleInputAudioBufferSpeechStarted, _RealtimeSession_handleInputAudioBufferSpeechStopped, _RealtimeSession_handleConversationItemCreated, _RealtimeSession_handleConversationItemInputAudioTranscriptionCompleted, _RealtimeSession_handleConversationItemInputAudioTranscriptionFailed, _RealtimeSession_handleConversationItemTruncated, _RealtimeSession_handleConversationItemDeleted, _RealtimeSession_handleResponseCreated, _RealtimeSession_handleResponseDone, _RealtimeSession_handleResponseOutputItemAdded, _RealtimeSession_handleResponseOutputItemDone, _RealtimeSession_handleResponseContentPartAdded, _RealtimeSession_handleResponseContentPartDone, _RealtimeSession_handleResponseTextDelta, _RealtimeSession_handleResponseTextDone, _RealtimeSession_handleResponseAudioTranscriptDelta, _RealtimeSession_handleResponseAudioTranscriptDone, _RealtimeSession_handleResponseAudioDelta, _RealtimeSession_handleResponseAudioDone, _RealtimeSession_handleResponseFunctionCallArgumentsDelta, _RealtimeSession_handleResponseFunctionCallArgumentsDone, _RealtimeSession_handleRateLimitsUpdated;
 // SPDX-FileCopyrightText: 2024 LiveKit, Inc.
 //
 // SPDX-License-Identifier: Apache-2.0
-import { AsyncIterableQueue, Future, Queue, llm, log, multimodal } from '@livekit/agents';
+import { AsyncIterableQueue, Future, Queue, llm, log, mergeFrames, multimodal, } from '@livekit/agents';
 import { AudioFrame } from '@livekit/rtc-node';
-import { once } from 'events';
+import { once } from 'node:events';
 import { WebSocket } from 'ws';
 import * as api_proto from './api_proto.js';
 class InputAudioBuffer {
+    #session;
     constructor(session) {
-        _InputAudioBuffer_session.set(this, void 0);
-        __classPrivateFieldSet(this, _InputAudioBuffer_session, session, "f");
+        this.#session = session;
     }
     append(frame) {
-        __classPrivateFieldGet(this, _InputAudioBuffer_session, "f").queueMsg({
+        this.#session.queueMsg({
             type: 'input_audio_buffer.append',
             audio: Buffer.from(frame.data.buffer).toString('base64'),
         });
     }
     clear() {
-        __classPrivateFieldGet(this, _InputAudioBuffer_session, "f").queueMsg({
+        this.#session.queueMsg({
             type: 'input_audio_buffer.clear',
         });
     }
     commit() {
-        __classPrivateFieldGet(this, _InputAudioBuffer_session, "f").queueMsg({
+        this.#session.queueMsg({
             type: 'input_audio_buffer.commit',
         });
     }
 }
-_InputAudioBuffer_session = new WeakMap();
 class ConversationItem {
+    #session;
+    #logger = log();
     constructor(session) {
-        _ConversationItem_session.set(this, void 0);
-        __classPrivateFieldSet(this, _ConversationItem_session, session, "f");
+        this.#session = session;
     }
     truncate(itemId, contentIndex, audioEnd) {
-        __classPrivateFieldGet(this, _ConversationItem_session, "f").queueMsg({
+        this.#session.queueMsg({
             type: 'conversation.item.truncate',
             item_id: itemId,
             content_index: contentIndex,
@@ -55,48 +43,161 @@ class ConversationItem {
         });
     }
     delete(itemId) {
-        __classPrivateFieldGet(this, _ConversationItem_session, "f").queueMsg({
+        this.#session.queueMsg({
             type: 'conversation.item.delete',
             item_id: itemId,
         });
     }
-    create(item, previousItemId) {
-        __classPrivateFieldGet(this, _ConversationItem_session, "f").queueMsg({
-            type: 'conversation.item.create',
-            item,
-            previous_item_id: previousItemId,
-        });
+    create(message, previousItemId) {
+        if (!message.content) {
+            return;
+        }
+        let event;
+        if (message.toolCallId) {
+            if (typeof message.content !== 'string') {
+                throw new TypeError('message.content must be a string');
+            }
+            event = {
+                type: 'conversation.item.create',
+                previous_item_id: previousItemId,
+                item: {
+                    type: 'function_call_output',
+                    call_id: message.toolCallId,
+                    output: message.content,
+                },
+            };
+        }
+        else {
+            let content = message.content;
+            if (!Array.isArray(content)) {
+                content = [content];
+            }
+            if (message.role === llm.ChatRole.USER) {
+                const contents = [];
+                for (const c of content) {
+                    if (typeof c === 'string') {
+                        contents.push({
+                            type: 'input_text',
+                            text: c,
+                        });
+                    }
+                    else if (
+                    // typescript type guard for determining ChatAudio vs ChatImage
+                    ((c) => {
+                        return c.frame !== undefined;
+                    })(c)) {
+                        contents.push({
+                            type: 'input_audio',
+                            audio: Buffer.from(mergeFrames(c.frame).data.buffer).toString('base64'),
+                        });
+                    }
+                }
+                event = {
+                    type: 'conversation.item.create',
+                    previous_item_id: previousItemId,
+                    item: {
+                        type: 'message',
+                        role: 'user',
+                        content: contents,
+                    },
+                };
+            }
+            else if (message.role === llm.ChatRole.ASSISTANT) {
+                const contents = [];
+                for (const c of content) {
+                    if (typeof c === 'string') {
+                        contents.push({
+                            type: 'text',
+                            text: c,
+                        });
+                    }
+                    else if (
+                    // typescript type guard for determining ChatAudio vs ChatImage
+                    ((c) => {
+                        return c.frame !== undefined;
+                    })(c)) {
+                        this.#logger.warn('audio content in assistant message is not supported');
+                    }
+                }
+                event = {
+                    type: 'conversation.item.create',
+                    previous_item_id: previousItemId,
+                    item: {
+                        type: 'message',
+                        role: 'assistant',
+                        content: contents,
+                    },
+                };
+            }
+            else if (message.role === llm.ChatRole.SYSTEM) {
+                const contents = [];
+                for (const c of content) {
+                    if (typeof c === 'string') {
+                        contents.push({
+                            type: 'input_text',
+                            text: c,
+                        });
+                    }
+                    else if (
+                    // typescript type guard for determining ChatAudio vs ChatImage
+                    ((c) => {
+                        return c.frame !== undefined;
+                    })(c)) {
+                        this.#logger.warn('audio content in system message is not supported');
+                    }
+                }
+                event = {
+                    type: 'conversation.item.create',
+                    previous_item_id: previousItemId,
+                    item: {
+                        type: 'message',
+                        role: 'system',
+                        content: contents,
+                    },
+                };
+            }
+            else {
+                this.#logger
+                    .child({ message })
+                    .warn('chat message is not supported inside the realtime API');
+                return;
+            }
+        }
+        this.#session.queueMsg(event);
     }
 }
-_ConversationItem_session = new WeakMap();
 class Conversation {
+    #session;
     constructor(session) {
-        _Conversation_session.set(this, void 0);
-        __classPrivateFieldSet(this, _Conversation_session, session, "f");
+        this.#session = session;
     }
     get item() {
-        return new ConversationItem(__classPrivateFieldGet(this, _Conversation_session, "f"));
+        return new ConversationItem(this.#session);
     }
 }
-_Conversation_session = new WeakMap();
 class Response {
+    #session;
     constructor(session) {
-        _Response_session.set(this, void 0);
-        __classPrivateFieldSet(this, _Response_session, session, "f");
+        this.#session = session;
     }
     create() {
-        __classPrivateFieldGet(this, _Response_session, "f").queueMsg({
+        this.#session.queueMsg({
             type: 'response.create',
         });
     }
     cancel() {
-        __classPrivateFieldGet(this, _Response_session, "f").queueMsg({
+        this.#session.queueMsg({
             type: 'response.cancel',
         });
     }
 }
-_Response_session = new WeakMap();
 export class RealtimeModel extends multimodal.RealtimeModel {
+    sampleRate = api_proto.SAMPLE_RATE;
+    numChannels = api_proto.NUM_CHANNELS;
+    inFrameSize = api_proto.IN_FRAME_SIZE;
+    outFrameSize = api_proto.OUT_FRAME_SIZE;
+    #defaultOpts;
+    #sessions = [];
     static withAzure({ baseURL, azureDeployment, apiVersion = '2024-10-01-preview', apiKey = undefined, entraToken = undefined, instructions = '', modalities = ['text', 'audio'], voice = 'alloy', inputAudioFormat = 'pcm16', outputAudioFormat = 'pcm16', inputAudioTranscription = { model: 'whisper-1' }, turnDetection = { type: 'server_vad' }, temperature = 0.8, maxResponseOutputTokens = Infinity, }) {
         return new RealtimeModel({
             isAzure: true,
@@ -120,16 +221,10 @@ export class RealtimeModel extends multimodal.RealtimeModel {
     // used for microsoft
     isAzure = false, apiVersion = undefined, entraToken = undefined, }) {
         super();
-        this.sampleRate = api_proto.SAMPLE_RATE;
-        this.numChannels = api_proto.NUM_CHANNELS;
-        this.inFrameSize = api_proto.IN_FRAME_SIZE;
-        this.outFrameSize = api_proto.OUT_FRAME_SIZE;
-        _RealtimeModel_defaultOpts.set(this, void 0);
-        _RealtimeModel_sessions.set(this, []);
         if (apiKey === '') {
             throw new Error('OpenAI API key is required, either using the argument or by setting the OPENAI_API_KEY environmental variable');
         }
-        __classPrivateFieldSet(this, _RealtimeModel_defaultOpts, {
+        this.#defaultOpts = {
             modalities,
             instructions,
             voice,
@@ -145,12 +240,12 @@ export class RealtimeModel extends multimodal.RealtimeModel {
             isAzure,
             apiVersion,
             entraToken,
-        }, "f");
+        };
     }
     get sessions() {
-        return __classPrivateFieldGet(this, _RealtimeModel_sessions, "f");
+        return this.#sessions;
     }
-    session({ fncCtx, modalities = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").modalities, instructions = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").instructions, voice = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").voice, inputAudioFormat = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").inputAudioFormat, outputAudioFormat = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").outputAudioFormat, inputAudioTranscription = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").inputAudioTranscription, turnDetection = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").turnDetection, temperature = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").temperature, maxResponseOutputTokens = __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").maxResponseOutputTokens, }) {
+    session({ fncCtx, chatCtx, modalities = this.#defaultOpts.modalities, instructions = this.#defaultOpts.instructions, voice = this.#defaultOpts.voice, inputAudioFormat = this.#defaultOpts.inputAudioFormat, outputAudioFormat = this.#defaultOpts.outputAudioFormat, inputAudioTranscription = this.#defaultOpts.inputAudioTranscription, turnDetection = this.#defaultOpts.turnDetection, temperature = this.#defaultOpts.temperature, maxResponseOutputTokens = this.#defaultOpts.maxResponseOutputTokens, }) {
         const opts = {
             modalities,
             instructions,
@@ -161,57 +256,63 @@ export class RealtimeModel extends multimodal.RealtimeModel {
             turnDetection,
             temperature,
             maxResponseOutputTokens,
-            model: __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").model,
-            apiKey: __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").apiKey,
-            baseURL: __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").baseURL,
-            isAzure: __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").isAzure,
-            apiVersion: __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").apiVersion,
-            entraToken: __classPrivateFieldGet(this, _RealtimeModel_defaultOpts, "f").entraToken,
+            model: this.#defaultOpts.model,
+            apiKey: this.#defaultOpts.apiKey,
+            baseURL: this.#defaultOpts.baseURL,
+            isAzure: this.#defaultOpts.isAzure,
+            apiVersion: this.#defaultOpts.apiVersion,
+            entraToken: this.#defaultOpts.entraToken,
         };
-        const newSession = new RealtimeSession(opts, fncCtx);
-        __classPrivateFieldGet(this, _RealtimeModel_sessions, "f").push(newSession);
+        const newSession = new RealtimeSession(opts, {
+            chatCtx: chatCtx || new llm.ChatContext(),
+            fncCtx,
+        });
+        this.#sessions.push(newSession);
         return newSession;
     }
     async close() {
-        await Promise.allSettled(__classPrivateFieldGet(this, _RealtimeModel_sessions, "f").map((session) => session.close()));
+        await Promise.allSettled(this.#sessions.map((session) => session.close()));
     }
 }
-_RealtimeModel_defaultOpts = new WeakMap(), _RealtimeModel_sessions = new WeakMap();
 export class RealtimeSession extends multimodal.RealtimeSession {
-    constructor(opts, fncCtx) {
+    #chatCtx = undefined;
+    #fncCtx = undefined;
+    #opts;
+    #pendingResponses = {};
+    #sessionId = 'not-connected';
+    #ws = null;
+    #expiresAt = null;
+    #logger = log();
+    #task;
+    #closing = true;
+    #sendQueue = new Queue();
+    constructor(opts, { fncCtx, chatCtx }) {
         super();
-        _RealtimeSession_instances.add(this);
-        _RealtimeSession_fncCtx.set(this, undefined);
-        _RealtimeSession_opts.set(this, void 0);
-        _RealtimeSession_pendingResponses.set(this, {});
-        _RealtimeSession_sessionId.set(this, 'not-connected');
-        _RealtimeSession_ws.set(this, null);
-        _RealtimeSession_expiresAt.set(this, null);
-        _RealtimeSession_logger.set(this, log());
-        _RealtimeSession_task.set(this, void 0);
-        _RealtimeSession_closing.set(this, true);
-        _RealtimeSession_sendQueue.set(this, new Queue());
-        __classPrivateFieldSet(this, _RealtimeSession_opts, opts, "f");
-        __classPrivateFieldSet(this, _RealtimeSession_fncCtx, fncCtx, "f");
-        __classPrivateFieldSet(this, _RealtimeSession_task, __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_start).call(this), "f");
+        this.#opts = opts;
+        this.#chatCtx = chatCtx;
+        this.#fncCtx = fncCtx;
+        this.#task = this.#start();
         this.sessionUpdate({
-            modalities: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").modalities,
-            instructions: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").instructions,
-            voice: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").voice,
-            inputAudioFormat: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").inputAudioFormat,
-            outputAudioFormat: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").outputAudioFormat,
-            inputAudioTranscription: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").inputAudioTranscription,
-            turnDetection: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").turnDetection,
-            temperature: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").temperature,
-            maxResponseOutputTokens: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").maxResponseOutputTokens,
+            modalities: this.#opts.modalities,
+            instructions: this.#opts.instructions,
+            voice: this.#opts.voice,
+            inputAudioFormat: this.#opts.inputAudioFormat,
+            outputAudioFormat: this.#opts.outputAudioFormat,
+            inputAudioTranscription: this.#opts.inputAudioTranscription,
+            turnDetection: this.#opts.turnDetection,
+            temperature: this.#opts.temperature,
+            maxResponseOutputTokens: this.#opts.maxResponseOutputTokens,
             toolChoice: 'auto',
         });
     }
+    get chatCtx() {
+        return this.#chatCtx;
+    }
     get fncCtx() {
-        return __classPrivateFieldGet(this, _RealtimeSession_fncCtx, "f");
+        return this.#fncCtx;
     }
     set fncCtx(ctx) {
-        __classPrivateFieldSet(this, _RealtimeSession_fncCtx, ctx, "f");
+        this.#fncCtx = ctx;
     }
     get conversation() {
         return new Conversation(this);
@@ -223,16 +324,37 @@ export class RealtimeSession extends multimodal.RealtimeSession {
         return new Response(this);
     }
     get expiration() {
-        if (!__classPrivateFieldGet(this, _RealtimeSession_expiresAt, "f")) {
+        if (!this.#expiresAt) {
             throw new Error('session not started');
         }
-        return __classPrivateFieldGet(this, _RealtimeSession_expiresAt, "f") * 1000;
+        return this.#expiresAt * 1000;
     }
     queueMsg(command) {
-        __classPrivateFieldGet(this, _RealtimeSession_sendQueue, "f").put(command);
+        this.#sendQueue.put(command);
+    }
+    /// Truncates the data field of the event to the specified maxLength to avoid overwhelming logs
+    /// with large amounts of base64 audio data.
+    #loggableEvent(event, maxLength = 30) {
+        const untypedEvent = {};
+        for (const [key, value] of Object.entries(event)) {
+            if (value !== undefined) {
+                untypedEvent[key] = value;
+            }
+        }
+        if (untypedEvent.audio && typeof untypedEvent.audio === 'string') {
+            const truncatedData = untypedEvent.audio.slice(0, maxLength) + (untypedEvent.audio.length > maxLength ? '…' : '');
+            return { ...untypedEvent, audio: truncatedData };
+        }
+        if (untypedEvent.delta &&
+            typeof untypedEvent.delta === 'string' &&
+            event.type === 'response.audio.delta') {
+            const truncatedDelta = untypedEvent.delta.slice(0, maxLength) + (untypedEvent.delta.length > maxLength ? '…' : '');
+            return { ...untypedEvent, delta: truncatedDelta };
+        }
+        return untypedEvent;
     }
-    sessionUpdate({ modalities = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").modalities, instructions = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").instructions, voice = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").voice, inputAudioFormat = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").inputAudioFormat, outputAudioFormat = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").outputAudioFormat, inputAudioTranscription = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").inputAudioTranscription, turnDetection = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").turnDetection, temperature = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").temperature, maxResponseOutputTokens = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").maxResponseOutputTokens, toolChoice = 'auto', }) {
-        __classPrivateFieldSet(this, _RealtimeSession_opts, {
+    sessionUpdate({ modalities = this.#opts.modalities, instructions = this.#opts.instructions, voice = this.#opts.voice, inputAudioFormat = this.#opts.inputAudioFormat, outputAudioFormat = this.#opts.outputAudioFormat, inputAudioTranscription = this.#opts.inputAudioTranscription, turnDetection = this.#opts.turnDetection, temperature = this.#opts.temperature, maxResponseOutputTokens = this.#opts.maxResponseOutputTokens, toolChoice = 'auto', }) {
+        this.#opts = {
             modalities,
             instructions,
             voice,
@@ -242,15 +364,15 @@ export class RealtimeSession extends multimodal.RealtimeSession {
             turnDetection,
             temperature,
             maxResponseOutputTokens,
-            model: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").model,
-            apiKey: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").apiKey,
-            baseURL: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").baseURL,
-            isAzure: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").isAzure,
-            apiVersion: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").apiVersion,
-            entraToken: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").entraToken,
-        }, "f");
-        const tools = __classPrivateFieldGet(this, _RealtimeSession_fncCtx, "f")
-            ? Object.entries(__classPrivateFieldGet(this, _RealtimeSession_fncCtx, "f")).map(([name, func]) => ({
+            model: this.#opts.model,
+            apiKey: this.#opts.apiKey,
+            baseURL: this.#opts.baseURL,
+            isAzure: this.#opts.isAzure,
+            apiVersion: this.#opts.apiVersion,
+            entraToken: this.#opts.entraToken,
+        };
+        const tools = this.#fncCtx
+            ? Object.entries(this.#fncCtx).map(([name, func]) => ({
                 type: 'function',
                 name,
                 description: func.description,
@@ -260,386 +382,408 @@ export class RealtimeSession extends multimodal.RealtimeSession {
         const sessionUpdateEvent = {
             type: 'session.update',
             session: {
-                modalities: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").modalities,
-                instructions: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").instructions,
-                voice: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").voice,
-                input_audio_format: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").inputAudioFormat,
-                output_audio_format: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").outputAudioFormat,
-                input_audio_transcription: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").inputAudioTranscription,
-                turn_detection: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").turnDetection,
-                temperature: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").temperature,
-                max_response_output_tokens: __classPrivateFieldGet(this, _RealtimeSession_opts, "f").maxResponseOutputTokens === Infinity
+                modalities: this.#opts.modalities,
+                instructions: this.#opts.instructions,
+                voice: this.#opts.voice,
+                input_audio_format: this.#opts.inputAudioFormat,
+                output_audio_format: this.#opts.outputAudioFormat,
+                input_audio_transcription: this.#opts.inputAudioTranscription,
+                turn_detection: this.#opts.turnDetection,
+                temperature: this.#opts.temperature,
+                max_response_output_tokens: this.#opts.maxResponseOutputTokens === Infinity
                     ? 'inf'
-                    : __classPrivateFieldGet(this, _RealtimeSession_opts, "f").maxResponseOutputTokens,
+                    : this.#opts.maxResponseOutputTokens,
                 tools,
                 tool_choice: toolChoice,
             },
         };
-        if (__classPrivateFieldGet(this, _RealtimeSession_opts, "f").isAzure && __classPrivateFieldGet(this, _RealtimeSession_opts, "f").maxResponseOutputTokens === Infinity) {
+        if (this.#opts.isAzure && this.#opts.maxResponseOutputTokens === Infinity) {
             // microsoft doesn't support inf for max_response_output_tokens, but accepts no args
             sessionUpdateEvent.session.max_response_output_tokens = undefined;
         }
         this.queueMsg(sessionUpdateEvent);
     }
+    #start() {
+        return new Promise(async (resolve, reject) => {
+            const headers = {
+                'User-Agent': 'LiveKit-Agents-JS',
+            };
+            if (this.#opts.isAzure) {
+                // Microsoft API has two ways of authentication
+                // 1. Entra token set as `Bearer` token
+                // 2. API key set as `api_key` header (also accepts query string)
+                if (this.#opts.entraToken) {
+                    headers.Authorization = `Bearer ${this.#opts.entraToken}`;
+                }
+                else if (this.#opts.apiKey) {
+                    headers['api-key'] = this.#opts.apiKey;
+                }
+                else {
+                    reject(new Error('Microsoft API key or entraToken is required'));
+                    return;
+                }
+            }
+            else {
+                headers.Authorization = `Bearer ${this.#opts.apiKey}`;
+                headers['OpenAI-Beta'] = 'realtime=v1';
+            }
+            const url = new URL([this.#opts.baseURL, 'realtime'].join('/'));
+            if (url.protocol === 'https:') {
+                url.protocol = 'wss:';
+            }
+            // Construct query parameters
+            const queryParams = {};
+            if (this.#opts.isAzure) {
+                queryParams['api-version'] = '2024-10-01-preview';
+                queryParams['deployment'] = this.#opts.model;
+            }
+            else {
+                queryParams['model'] = this.#opts.model;
+            }
+            for (const [key, value] of Object.entries(queryParams)) {
+                url.searchParams.set(key, value);
+            }
+            console.debug('Connecting to OpenAI Realtime API at ', url.toString());
+            this.#ws = new WebSocket(url.toString(), {
+                headers: headers,
+            });
+            this.#ws.onerror = (error) => {
+                reject(new Error('OpenAI Realtime WebSocket error: ' + error.message));
+            };
+            await once(this.#ws, 'open');
+            this.#closing = false;
+            this.#ws.onmessage = (message) => {
+                const event = JSON.parse(message.data);
+                this.#logger.debug(`<- ${JSON.stringify(this.#loggableEvent(event))}`);
+                switch (event.type) {
+                    case 'error':
+                        this.#handleError(event);
+                        break;
+                    case 'session.created':
+                        this.#handleSessionCreated(event);
+                        break;
+                    case 'session.updated':
+                        this.#handleSessionUpdated(event);
+                        break;
+                    case 'conversation.created':
+                        this.#handleConversationCreated(event);
+                        break;
+                    case 'input_audio_buffer.committed':
+                        this.#handleInputAudioBufferCommitted(event);
+                        break;
+                    case 'input_audio_buffer.cleared':
+                        this.#handleInputAudioBufferCleared(event);
+                        break;
+                    case 'input_audio_buffer.speech_started':
+                        this.#handleInputAudioBufferSpeechStarted(event);
+                        break;
+                    case 'input_audio_buffer.speech_stopped':
+                        this.#handleInputAudioBufferSpeechStopped(event);
+                        break;
+                    case 'conversation.item.created':
+                        this.#handleConversationItemCreated(event);
+                        break;
+                    case 'conversation.item.input_audio_transcription.completed':
+                        this.#handleConversationItemInputAudioTranscriptionCompleted(event);
+                        break;
+                    case 'conversation.item.input_audio_transcription.failed':
+                        this.#handleConversationItemInputAudioTranscriptionFailed(event);
+                        break;
+                    case 'conversation.item.truncated':
+                        this.#handleConversationItemTruncated(event);
+                        break;
+                    case 'conversation.item.deleted':
+                        this.#handleConversationItemDeleted(event);
+                        break;
+                    case 'response.created':
+                        this.#handleResponseCreated(event);
+                        break;
+                    case 'response.done':
+                        this.#handleResponseDone(event);
+                        break;
+                    case 'response.output_item.added':
+                        this.#handleResponseOutputItemAdded(event);
+                        break;
+                    case 'response.output_item.done':
+                        this.#handleResponseOutputItemDone(event);
+                        break;
+                    case 'response.content_part.added':
+                        this.#handleResponseContentPartAdded(event);
+                        break;
+                    case 'response.content_part.done':
+                        this.#handleResponseContentPartDone(event);
+                        break;
+                    case 'response.text.delta':
+                        this.#handleResponseTextDelta(event);
+                        break;
+                    case 'response.text.done':
+                        this.#handleResponseTextDone(event);
+                        break;
+                    case 'response.audio_transcript.delta':
+                        this.#handleResponseAudioTranscriptDelta(event);
+                        break;
+                    case 'response.audio_transcript.done':
+                        this.#handleResponseAudioTranscriptDone(event);
+                        break;
+                    case 'response.audio.delta':
+                        this.#handleResponseAudioDelta(event);
+                        break;
+                    case 'response.audio.done':
+                        this.#handleResponseAudioDone(event);
+                        break;
+                    case 'response.function_call_arguments.delta':
+                        this.#handleResponseFunctionCallArgumentsDelta(event);
+                        break;
+                    case 'response.function_call_arguments.done':
+                        this.#handleResponseFunctionCallArgumentsDone(event);
+                        break;
+                    case 'rate_limits.updated':
+                        this.#handleRateLimitsUpdated(event);
+                        break;
+                }
+            };
+            const sendTask = async () => {
+                while (this.#ws && !this.#closing && this.#ws.readyState === WebSocket.OPEN) {
+                    try {
+                        const event = await this.#sendQueue.get();
+                        if (event.type !== 'input_audio_buffer.append') {
+                            this.#logger.debug(`-> ${JSON.stringify(this.#loggableEvent(event))}`);
+                        }
+                        this.#ws.send(JSON.stringify(event));
+                    }
+                    catch (error) {
+                        this.#logger.error('Error sending event:', error);
+                    }
+                }
+            };
+            sendTask();
+            this.#ws.onclose = () => {
+                if (this.#expiresAt && Date.now() >= this.#expiresAt * 1000) {
+                    this.#closing = true;
+                }
+                if (!this.#closing) {
+                    reject(new Error('OpenAI Realtime connection closed unexpectedly'));
+                }
+                this.#ws = null;
+                resolve();
+            };
+        });
+    }
     async close() {
-        if (!__classPrivateFieldGet(this, _RealtimeSession_ws, "f"))
+        if (!this.#ws)
             return;
-        __classPrivateFieldSet(this, _RealtimeSession_closing, true, "f");
-        __classPrivateFieldGet(this, _RealtimeSession_ws, "f").close();
-        await __classPrivateFieldGet(this, _RealtimeSession_task, "f");
+        this.#closing = true;
+        this.#ws.close();
+        await this.#task;
+    }
+    #getContent(ptr) {
+        const response = this.#pendingResponses[ptr.response_id];
+        const output = response.output[ptr.output_index];
+        const content = output.content[ptr.content_index];
+        return content;
+    }
+    #handleError(event) {
+        this.#logger.error(`OpenAI Realtime error ${JSON.stringify(event.error)}`);
+    }
+    #handleSessionCreated(event) {
+        this.#sessionId = event.session.id;
+        this.#expiresAt = event.session.expires_at;
+        this.#logger = this.#logger.child({ sessionId: this.#sessionId });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleSessionUpdated(event) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleConversationCreated(event) { }
+    #handleInputAudioBufferCommitted(event) {
+        this.emit('input_speech_committed', {
+            itemId: event.item_id,
+        });
     }
-}
-_RealtimeSession_fncCtx = new WeakMap(), _RealtimeSession_opts = new WeakMap(), _RealtimeSession_pendingResponses = new WeakMap(), _RealtimeSession_sessionId = new WeakMap(), _RealtimeSession_ws = new WeakMap(), _RealtimeSession_expiresAt = new WeakMap(), _RealtimeSession_logger = new WeakMap(), _RealtimeSession_task = new WeakMap(), _RealtimeSession_closing = new WeakMap(), _RealtimeSession_sendQueue = new WeakMap(), _RealtimeSession_instances = new WeakSet(), _RealtimeSession_loggableEvent = function _RealtimeSession_loggableEvent(event, maxLength = 30) {
-    const untypedEvent = {};
-    for (const [key, value] of Object.entries(event)) {
-        if (value !== undefined) {
-            untypedEvent[key] = value;
-        }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleInputAudioBufferCleared(event) { }
+    #handleInputAudioBufferSpeechStarted(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    event) {
+        this.emit('input_speech_started', {
+            itemId: event.item_id,
+        });
     }
-    if (untypedEvent.audio && typeof untypedEvent.audio === 'string') {
-        const truncatedData = untypedEvent.audio.slice(0, maxLength) + (untypedEvent.audio.length > maxLength ? '…' : '');
-        return Object.assign(Object.assign({}, untypedEvent), { audio: truncatedData });
-    }
-    if (untypedEvent.delta &&
-        typeof untypedEvent.delta === 'string' &&
-        event.type === 'response.audio.delta') {
-        const truncatedDelta = untypedEvent.delta.slice(0, maxLength) + (untypedEvent.delta.length > maxLength ? '…' : '');
-        return Object.assign(Object.assign({}, untypedEvent), { delta: truncatedDelta });
-    }
-    return untypedEvent;
-}, _RealtimeSession_start = function _RealtimeSession_start() {
-    return new Promise(async (resolve, reject) => {
-        const headers = {
-            'User-Agent': 'LiveKit-Agents-JS',
+    #handleInputAudioBufferSpeechStopped(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    event) {
+        this.emit('input_speech_stopped');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleConversationItemCreated(event) { }
+    #handleConversationItemInputAudioTranscriptionCompleted(event) {
+        const transcript = event.transcript;
+        this.emit('input_speech_transcription_completed', {
+            itemId: event.item_id,
+            transcript: transcript,
+        });
+    }
+    #handleConversationItemInputAudioTranscriptionFailed(event) {
+        const error = event.error;
+        this.#logger.error(`OpenAI Realtime failed to transcribe input audio: ${error.message}`);
+        this.emit('input_speech_transcription_failed', {
+            itemId: event.item_id,
+            message: error.message,
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleConversationItemTruncated(event) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleConversationItemDeleted(event) { }
+    #handleResponseCreated(responseCreated) {
+        const response = responseCreated.response;
+        const doneFut = new Future();
+        const newResponse = {
+            id: response.id,
+            status: response.status,
+            statusDetails: response.status_details,
+            usage: null,
+            output: [],
+            doneFut: doneFut,
         };
-        if (__classPrivateFieldGet(this, _RealtimeSession_opts, "f").isAzure) {
-            // Microsoft API has two ways of authentication
-            // 1. Entra token set as `Bearer` token
-            // 2. API key set as `api_key` header (also accepts query string)
-            if (__classPrivateFieldGet(this, _RealtimeSession_opts, "f").entraToken) {
-                headers.Authorization = `Bearer ${__classPrivateFieldGet(this, _RealtimeSession_opts, "f").entraToken}`;
-            }
-            else if (__classPrivateFieldGet(this, _RealtimeSession_opts, "f").apiKey) {
-                headers['api-key'] = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").apiKey;
-            }
-            else {
-                reject(new Error('Microsoft API key or entraToken is required'));
-                return;
-            }
-        }
-        else {
-            headers.Authorization = `Bearer ${__classPrivateFieldGet(this, _RealtimeSession_opts, "f").apiKey}`;
-            headers['OpenAI-Beta'] = 'realtime=v1';
+        this.#pendingResponses[newResponse.id] = newResponse;
+        this.emit('response_created', newResponse);
+    }
+    #handleResponseDone(event) {
+        const responseData = event.response;
+        const responseId = responseData.id;
+        const response = this.#pendingResponses[responseId];
+        response.status = responseData.status;
+        response.statusDetails = responseData.status_details;
+        response.usage = responseData.usage;
+        this.#pendingResponses[responseId] = response;
+        response.doneFut.resolve();
+        this.emit('response_done', response);
+    }
+    #handleResponseOutputItemAdded(event) {
+        const responseId = event.response_id;
+        const response = this.#pendingResponses[responseId];
+        const itemData = event.item;
+        if (itemData.type !== 'message' && itemData.type !== 'function_call') {
+            throw new Error(`Unexpected item type: ${itemData.type}`);
         }
-        const url = new URL([__classPrivateFieldGet(this, _RealtimeSession_opts, "f").baseURL, 'realtime'].join('/'));
-        if (url.protocol === 'https:') {
-            url.protocol = 'wss:';
-        }
-        // Construct query parameters
-        const queryParams = {};
-        if (__classPrivateFieldGet(this, _RealtimeSession_opts, "f").isAzure) {
-            queryParams['api-version'] = '2024-10-01-preview';
-            queryParams['deployment'] = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").model;
+        let role;
+        if (itemData.type === 'function_call') {
+            role = 'assistant'; // function_call doesn't have a role field, defaulting it to assistant
         }
         else {
-            queryParams['model'] = __classPrivateFieldGet(this, _RealtimeSession_opts, "f").model;
-        }
-        for (const [key, value] of Object.entries(queryParams)) {
-            url.searchParams.set(key, value);
+            role = itemData.role;
         }
-        console.debug('Connecting to OpenAI Realtime API at ', url.toString());
-        __classPrivateFieldSet(this, _RealtimeSession_ws, new WebSocket(url.toString(), {
-            headers: headers,
-        }), "f");
-        __classPrivateFieldGet(this, _RealtimeSession_ws, "f").onerror = (error) => {
-            reject(new Error('OpenAI Realtime WebSocket error: ' + error.message));
-        };
-        await once(__classPrivateFieldGet(this, _RealtimeSession_ws, "f"), 'open');
-        __classPrivateFieldSet(this, _RealtimeSession_closing, false, "f");
-        __classPrivateFieldGet(this, _RealtimeSession_ws, "f").onmessage = (message) => {
-            const event = JSON.parse(message.data);
-            __classPrivateFieldGet(this, _RealtimeSession_logger, "f").debug(`<- ${JSON.stringify(__classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_loggableEvent).call(this, event))}`);
-            switch (event.type) {
-                case 'error':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleError).call(this, event);
-                    break;
-                case 'session.created':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleSessionCreated).call(this, event);
-                    break;
-                case 'session.updated':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleSessionUpdated).call(this, event);
-                    break;
-                case 'conversation.created':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleConversationCreated).call(this, event);
-                    break;
-                case 'input_audio_buffer.committed':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleInputAudioBufferCommitted).call(this, event);
-                    break;
-                case 'input_audio_buffer.cleared':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleInputAudioBufferCleared).call(this, event);
-                    break;
-                case 'input_audio_buffer.speech_started':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleInputAudioBufferSpeechStarted).call(this, event);
-                    break;
-                case 'input_audio_buffer.speech_stopped':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleInputAudioBufferSpeechStopped).call(this, event);
-                    break;
-                case 'conversation.item.created':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleConversationItemCreated).call(this, event);
-                    break;
-                case 'conversation.item.input_audio_transcription.completed':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleConversationItemInputAudioTranscriptionCompleted).call(this, event);
-                    break;
-                case 'conversation.item.input_audio_transcription.failed':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleConversationItemInputAudioTranscriptionFailed).call(this, event);
-                    break;
-                case 'conversation.item.truncated':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleConversationItemTruncated).call(this, event);
-                    break;
-                case 'conversation.item.deleted':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleConversationItemDeleted).call(this, event);
-                    break;
-                case 'response.created':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseCreated).call(this, event);
-                    break;
-                case 'response.done':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseDone).call(this, event);
-                    break;
-                case 'response.output_item.added':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseOutputItemAdded).call(this, event);
-                    break;
-                case 'response.output_item.done':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseOutputItemDone).call(this, event);
-                    break;
-                case 'response.content_part.added':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseContentPartAdded).call(this, event);
-                    break;
-                case 'response.content_part.done':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseContentPartDone).call(this, event);
-                    break;
-                case 'response.text.delta':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseTextDelta).call(this, event);
-                    break;
-                case 'response.text.done':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseTextDone).call(this, event);
-                    break;
-                case 'response.audio_transcript.delta':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseAudioTranscriptDelta).call(this, event);
-                    break;
-                case 'response.audio_transcript.done':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseAudioTranscriptDone).call(this, event);
-                    break;
-                case 'response.audio.delta':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseAudioDelta).call(this, event);
-                    break;
-                case 'response.audio.done':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseAudioDone).call(this, event);
-                    break;
-                case 'response.function_call_arguments.delta':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseFunctionCallArgumentsDelta).call(this, event);
-                    break;
-                case 'response.function_call_arguments.done':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleResponseFunctionCallArgumentsDone).call(this, event);
-                    break;
-                case 'rate_limits.updated':
-                    __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_handleRateLimitsUpdated).call(this, event);
-                    break;
-            }
+        const newOutput = {
+            responseId: responseId,
+            itemId: itemData.id,
+            outputIndex: event.output_index,
+            type: itemData.type,
+            role: role,
+            content: [],
+            doneFut: new Future(),
         };
-        const sendTask = async () => {
-            while (__classPrivateFieldGet(this, _RealtimeSession_ws, "f") && !__classPrivateFieldGet(this, _RealtimeSession_closing, "f") && __classPrivateFieldGet(this, _RealtimeSession_ws, "f").readyState === WebSocket.OPEN) {
-                try {
-                    const event = await __classPrivateFieldGet(this, _RealtimeSession_sendQueue, "f").get();
-                    if (event.type !== 'input_audio_buffer.append') {
-                        __classPrivateFieldGet(this, _RealtimeSession_logger, "f").debug(`-> ${JSON.stringify(__classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_loggableEvent).call(this, event))}`);
-                    }
-                    __classPrivateFieldGet(this, _RealtimeSession_ws, "f").send(JSON.stringify(event));
-                }
-                catch (error) {
-                    __classPrivateFieldGet(this, _RealtimeSession_logger, "f").error('Error sending event:', error);
-                }
-            }
-        };
-        sendTask();
-        __classPrivateFieldGet(this, _RealtimeSession_ws, "f").onclose = () => {
-            if (__classPrivateFieldGet(this, _RealtimeSession_expiresAt, "f") && Date.now() >= __classPrivateFieldGet(this, _RealtimeSession_expiresAt, "f") * 1000) {
-                __classPrivateFieldSet(this, _RealtimeSession_closing, true, "f");
+        response.output.push(newOutput);
+        this.emit('response_output_added', newOutput);
+    }
+    #handleResponseOutputItemDone(event) {
+        const responseId = event.response_id;
+        const response = this.#pendingResponses[responseId];
+        const outputIndex = event.output_index;
+        const output = response.output[outputIndex];
+        if (output.type === 'function_call') {
+            if (!this.#fncCtx) {
+                this.#logger.error('function call received but no fncCtx is available');
+                return;
             }
-            if (!__classPrivateFieldGet(this, _RealtimeSession_closing, "f")) {
-                reject(new Error('OpenAI Realtime connection closed unexpectedly'));
+            // parse the arguments and call the function inside the fnc_ctx
+            const item = event.item;
+            if (item.type !== 'function_call') {
+                throw new Error('Expected function_call item');
             }
-            __classPrivateFieldSet(this, _RealtimeSession_ws, null, "f");
-            resolve();
-        };
-    });
-}, _RealtimeSession_getContent = function _RealtimeSession_getContent(ptr) {
-    const response = __classPrivateFieldGet(this, _RealtimeSession_pendingResponses, "f")[ptr.response_id];
-    const output = response.output[ptr.output_index];
-    const content = output.content[ptr.content_index];
-    return content;
-}, _RealtimeSession_handleError = function _RealtimeSession_handleError(event) {
-    __classPrivateFieldGet(this, _RealtimeSession_logger, "f").error(`OpenAI Realtime error ${JSON.stringify(event.error)}`);
-}, _RealtimeSession_handleSessionCreated = function _RealtimeSession_handleSessionCreated(event) {
-    __classPrivateFieldSet(this, _RealtimeSession_sessionId, event.session.id, "f");
-    __classPrivateFieldSet(this, _RealtimeSession_expiresAt, event.session.expires_at, "f");
-    __classPrivateFieldSet(this, _RealtimeSession_logger, __classPrivateFieldGet(this, _RealtimeSession_logger, "f").child({ sessionId: __classPrivateFieldGet(this, _RealtimeSession_sessionId, "f") }), "f");
-}, _RealtimeSession_handleSessionUpdated = function _RealtimeSession_handleSessionUpdated(event) { }, _RealtimeSession_handleConversationCreated = function _RealtimeSession_handleConversationCreated(event) { }, _RealtimeSession_handleInputAudioBufferCommitted = function _RealtimeSession_handleInputAudioBufferCommitted(event) {
-    this.emit('input_speech_committed', {
-        itemId: event.item_id,
-    });
-}, _RealtimeSession_handleInputAudioBufferCleared = function _RealtimeSession_handleInputAudioBufferCleared(event) { }, _RealtimeSession_handleInputAudioBufferSpeechStarted = function _RealtimeSession_handleInputAudioBufferSpeechStarted(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-event) {
-    this.emit('input_speech_started', {
-        itemId: event.item_id,
-    });
-}, _RealtimeSession_handleInputAudioBufferSpeechStopped = function _RealtimeSession_handleInputAudioBufferSpeechStopped(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-event) {
-    this.emit('input_speech_stopped');
-}, _RealtimeSession_handleConversationItemCreated = function _RealtimeSession_handleConversationItemCreated(event) { }, _RealtimeSession_handleConversationItemInputAudioTranscriptionCompleted = function _RealtimeSession_handleConversationItemInputAudioTranscriptionCompleted(event) {
-    const transcript = event.transcript;
-    this.emit('input_speech_transcription_completed', {
-        itemId: event.item_id,
-        transcript: transcript,
-    });
-}, _RealtimeSession_handleConversationItemInputAudioTranscriptionFailed = function _RealtimeSession_handleConversationItemInputAudioTranscriptionFailed(event) {
-    const error = event.error;
-    __classPrivateFieldGet(this, _RealtimeSession_logger, "f").error(`OpenAI Realtime failed to transcribe input audio: ${error.message}`);
-    this.emit('input_speech_transcription_failed', {
-        itemId: event.item_id,
-        message: error.message,
-    });
-}, _RealtimeSession_handleConversationItemTruncated = function _RealtimeSession_handleConversationItemTruncated(event) { }, _RealtimeSession_handleConversationItemDeleted = function _RealtimeSession_handleConversationItemDeleted(event) { }, _RealtimeSession_handleResponseCreated = function _RealtimeSession_handleResponseCreated(responseCreated) {
-    const response = responseCreated.response;
-    const doneFut = new Future();
-    const newResponse = {
-        id: response.id,
-        status: response.status,
-        statusDetails: response.status_details,
-        output: [],
-        doneFut: doneFut,
-    };
-    __classPrivateFieldGet(this, _RealtimeSession_pendingResponses, "f")[newResponse.id] = newResponse;
-    this.emit('response_created', newResponse);
-}, _RealtimeSession_handleResponseDone = function _RealtimeSession_handleResponseDone(event) {
-    const responseData = event.response;
-    const responseId = responseData.id;
-    const response = __classPrivateFieldGet(this, _RealtimeSession_pendingResponses, "f")[responseId];
-    response.status = responseData.status;
-    response.statusDetails = responseData.status_details;
-    __classPrivateFieldGet(this, _RealtimeSession_pendingResponses, "f")[responseId] = response;
-    response.doneFut.resolve();
-    this.emit('response_done', response);
-}, _RealtimeSession_handleResponseOutputItemAdded = function _RealtimeSession_handleResponseOutputItemAdded(event) {
-    const responseId = event.response_id;
-    const response = __classPrivateFieldGet(this, _RealtimeSession_pendingResponses, "f")[responseId];
-    const itemData = event.item;
-    if (itemData.type !== 'message' && itemData.type !== 'function_call') {
-        throw new Error(`Unexpected item type: ${itemData.type}`);
-    }
-    let role;
-    if (itemData.type === 'function_call') {
-        role = 'assistant'; // function_call doesn't have a role field, defaulting it to assistant
-    }
-    else {
-        role = itemData.role;
-    }
-    const newOutput = {
-        responseId: responseId,
-        itemId: itemData.id,
-        outputIndex: event.output_index,
-        type: itemData.type,
-        role: role,
-        content: [],
-        doneFut: new Future(),
-    };
-    response.output.push(newOutput);
-    this.emit('response_output_added', newOutput);
-}, _RealtimeSession_handleResponseOutputItemDone = function _RealtimeSession_handleResponseOutputItemDone(event) {
-    const responseId = event.response_id;
-    const response = __classPrivateFieldGet(this, _RealtimeSession_pendingResponses, "f")[responseId];
-    const outputIndex = event.output_index;
-    const output = response.output[outputIndex];
-    if (output.type === 'function_call') {
-        if (!__classPrivateFieldGet(this, _RealtimeSession_fncCtx, "f")) {
-            __classPrivateFieldGet(this, _RealtimeSession_logger, "f").error('function call received but no fncCtx is available');
-            return;
-        }
-        // parse the arguments and call the function inside the fnc_ctx
-        const item = event.item;
-        if (item.type !== 'function_call') {
-            throw new Error('Expected function_call item');
-        }
-        this.emit('function_call_started', {
-            callId: item.call_id,
-        });
-        const parsedArgs = JSON.parse(item.arguments);
-        __classPrivateFieldGet(this, _RealtimeSession_logger, "f").debug(`[Function Call ${item.call_id}] Executing ${item.name} with arguments ${parsedArgs}`);
-        __classPrivateFieldGet(this, _RealtimeSession_fncCtx, "f")[item.name].execute(parsedArgs).then((content) => {
-            __classPrivateFieldGet(this, _RealtimeSession_logger, "f").debug(`[Function Call ${item.call_id}] ${item.name} returned ${content}`);
-            this.emit('function_call_completed', {
+            this.emit('function_call_started', {
                 callId: item.call_id,
             });
-            this.conversation.item.create({
-                type: 'function_call_output',
-                call_id: item.call_id,
-                output: content,
-            }, output.itemId);
-            this.response.create();
-        }, (error) => {
-            __classPrivateFieldGet(this, _RealtimeSession_logger, "f").error(`[Function Call ${item.call_id}] ${item.name} failed with ${error}`);
-            // TODO: send it back up as failed?
-            this.emit('function_call_failed', {
-                callId: item.call_id,
+            const parsedArgs = JSON.parse(item.arguments);
+            this.#logger.debug(`[Function Call ${item.call_id}] Executing ${item.name} with arguments ${parsedArgs}`);
+            this.#fncCtx[item.name].execute(parsedArgs).then((content) => {
+                this.#logger.debug(`[Function Call ${item.call_id}] ${item.name} returned ${content}`);
+                this.emit('function_call_completed', {
+                    callId: item.call_id,
+                });
+                this.conversation.item.create(llm.ChatMessage.createToolFromFunctionResult({
+                    name: item.name,
+                    toolCallId: item.call_id,
+                    result: content,
+                }), output.itemId);
+                this.response.create();
+            }, (error) => {
+                this.#logger.error(`[Function Call ${item.call_id}] ${item.name} failed with ${error}`);
+                // TODO: send it back up as failed?
+                this.emit('function_call_failed', {
+                    callId: item.call_id,
+                });
             });
-        });
-    }
-    output.doneFut.resolve();
-    this.emit('response_output_done', output);
-}, _RealtimeSession_handleResponseContentPartAdded = function _RealtimeSession_handleResponseContentPartAdded(event) {
-    const responseId = event.response_id;
-    const response = __classPrivateFieldGet(this, _RealtimeSession_pendingResponses, "f")[responseId];
-    const outputIndex = event.output_index;
-    const output = response.output[outputIndex];
-    const textStream = new AsyncIterableQueue();
-    const audioStream = new AsyncIterableQueue();
-    const newContent = {
-        responseId: responseId,
-        itemId: event.item_id,
-        outputIndex: outputIndex,
-        contentIndex: event.content_index,
-        text: '',
-        audio: [],
-        textStream: textStream,
-        audioStream: audioStream,
-        toolCalls: [],
-    };
-    output.content.push(newContent);
-    this.emit('response_content_added', newContent);
-}, _RealtimeSession_handleResponseContentPartDone = function _RealtimeSession_handleResponseContentPartDone(event) {
-    const content = __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_getContent).call(this, event);
-    this.emit('response_content_done', content);
-}, _RealtimeSession_handleResponseTextDelta = function _RealtimeSession_handleResponseTextDelta(event) { }, _RealtimeSession_handleResponseTextDone = function _RealtimeSession_handleResponseTextDone(event) { }, _RealtimeSession_handleResponseAudioTranscriptDelta = function _RealtimeSession_handleResponseAudioTranscriptDelta(event) {
-    const content = __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_getContent).call(this, event);
-    const transcript = event.delta;
-    content.text += transcript;
-    content.textStream.put(transcript);
-}, _RealtimeSession_handleResponseAudioTranscriptDone = function _RealtimeSession_handleResponseAudioTranscriptDone(event) {
-    const content = __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_getContent).call(this, event);
-    content.textStream.close();
-}, _RealtimeSession_handleResponseAudioDelta = function _RealtimeSession_handleResponseAudioDelta(event) {
-    const content = __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_getContent).call(this, event);
-    const data = Buffer.from(event.delta, 'base64');
-    const audio = new AudioFrame(new Int16Array(data.buffer), api_proto.SAMPLE_RATE, api_proto.NUM_CHANNELS, data.length / 2);
-    content.audio.push(audio);
-    content.audioStream.put(audio);
-}, _RealtimeSession_handleResponseAudioDone = function _RealtimeSession_handleResponseAudioDone(event) {
-    const content = __classPrivateFieldGet(this, _RealtimeSession_instances, "m", _RealtimeSession_getContent).call(this, event);
-    content.audioStream.close();
-}, _RealtimeSession_handleResponseFunctionCallArgumentsDelta = function _RealtimeSession_handleResponseFunctionCallArgumentsDelta(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-event) { }, _RealtimeSession_handleResponseFunctionCallArgumentsDone = function _RealtimeSession_handleResponseFunctionCallArgumentsDone(
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-event) { }, _RealtimeSession_handleRateLimitsUpdated = function _RealtimeSession_handleRateLimitsUpdated(event) { };
+        }
+        output.doneFut.resolve();
+        this.emit('response_output_done', output);
+    }
+    #handleResponseContentPartAdded(event) {
+        const responseId = event.response_id;
+        const response = this.#pendingResponses[responseId];
+        const outputIndex = event.output_index;
+        const output = response.output[outputIndex];
+        const textStream = new AsyncIterableQueue();
+        const audioStream = new AsyncIterableQueue();
+        const newContent = {
+            responseId: responseId,
+            itemId: event.item_id,
+            outputIndex: outputIndex,
+            contentIndex: event.content_index,
+            text: '',
+            audio: [],
+            textStream: textStream,
+            audioStream: audioStream,
+            toolCalls: [],
+        };
+        output.content.push(newContent);
+        this.emit('response_content_added', newContent);
+    }
+    #handleResponseContentPartDone(event) {
+        const content = this.#getContent(event);
+        this.emit('response_content_done', content);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleResponseTextDelta(event) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleResponseTextDone(event) { }
+    #handleResponseAudioTranscriptDelta(event) {
+        const content = this.#getContent(event);
+        const transcript = event.delta;
+        content.text += transcript;
+        content.textStream.put(transcript);
+    }
+    #handleResponseAudioTranscriptDone(event) {
+        const content = this.#getContent(event);
+        content.textStream.close();
+    }
+    #handleResponseAudioDelta(event) {
+        const content = this.#getContent(event);
+        const data = Buffer.from(event.delta, 'base64');
+        const audio = new AudioFrame(new Int16Array(data.buffer), api_proto.SAMPLE_RATE, api_proto.NUM_CHANNELS, data.length / 2);
+        content.audio.push(audio);
+        content.audioStream.put(audio);
+    }
+    #handleResponseAudioDone(event) {
+        const content = this.#getContent(event);
+        content.audioStream.close();
+    }
+    #handleResponseFunctionCallArgumentsDelta(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    event) { }
+    #handleResponseFunctionCallArgumentsDone(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    event) { }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    #handleRateLimitsUpdated(event) { }
+}
 //# sourceMappingURL=realtime_model.js.map