private ws: WebSocket | null = null;

private connected = false;

private sessionConfigured = false;

private intentionallyClosed = false;

private reconnectAttempts = 0;

private pendingAudio: Buffer[] = [];

private lastAssistantItemId: string | null = null;

private toolCallBuffers = new Map<string, { name: string; callId: string; args: string }>();

private readonly flowId = randomUUID();

private sessionReadyFired = false;

constructor(private readonly config: OpenAIRealtimeVoiceBridgeConfig) {}

}

sendAudio(audio: Buffer): void {

if (!this.connected || this.ws?.readyState !== WebSocket.OPEN) {

if (!this.connected || !this.sessionConfigured || this.ws?.readyState !== WebSocket.OPEN) {

if (this.pendingAudio.length < 320) {

this.pendingAudio.push(audio);

}

}

triggerGreeting(instructions?: string): void {

if (!this.connected || !this.ws) {

if (!this.isConnected() || !this.ws) {

return;

}

this.sendEvent({

close(): void {

this.intentionallyClosed = true;

this.connected = false;

this.sessionConfigured = false;

if (this.ws) {

this.ws.close(1000, "Bridge closed");

this.ws = null;

}

}

isConnected(): boolean {

return this.connected;

return this.connected && this.sessionConfigured;

}

private async doConnect(): Promise<void> {

await new Promise<void>((resolve, reject) => {

let connectTimeout: ReturnType<typeof setTimeout>;

let settled = false;

const settleResolve = () => {

if (settled) {

return;

}

settled = true;

clearTimeout(connectTimeout);

resolve();

};

const settleReject = (error: Error) => {

if (settled) {

return;

}

settled = true;

clearTimeout(connectTimeout);

reject(error);

};

const { url, headers } = this.resolveConnectionParams();

const debugProxy = resolveDebugProxySettings();

const proxyAgent = createDebugProxyWebSocketAgent(debugProxy);

...(proxyAgent ? { agent: proxyAgent } : {}),

});

const connectTimeout = setTimeout(() => {

reject(new Error("OpenAI realtime connection timeout"));

connectTimeout = setTimeout(() => {

if (!this.connected && !this.intentionallyClosed) {

this.ws?.terminate();

settleReject(new Error("OpenAI realtime connection timeout"));

}

}, OpenAIRealtimeVoiceBridge.CONNECT_TIMEOUT_MS);

this.ws.on("open", () => {

clearTimeout(connectTimeout);

this.connected = true;

this.sessionConfigured = false;

this.reconnectAttempts = 0;

captureWsEvent({

url,

},

});

this.sendSessionUpdate();

for (const chunk of this.pendingAudio.splice(0)) {

this.sendAudio(chunk);

}

this.config.onReady?.();

resolve();

settleResolve();

});

this.ws.on("message", (data: Buffer) => {

},

});

if (!this.connected) {

clearTimeout(connectTimeout);

reject(error);

settleReject(error instanceof Error ? error : new Error(String(error)));

}

this.config.onError?.(error instanceof Error ? error : new Error(String(error)));

});

reasonBuffer,

});

this.connected = false;

this.sessionConfigured = false;

if (this.intentionallyClosed) {

settleResolve();

this.config.onClose?.("completed");

return;

}

private handleEvent(event: RealtimeEvent): void {

switch (event.type) {

case "session.created":

return;

case "session.updated":

this.sessionConfigured = true;

for (const chunk of this.pendingAudio.splice(0)) {

this.sendAudio(chunk);

}

if (!this.sessionReadyFired) {

this.sessionReadyFired = true;

this.config.onReady?.();

}

return;

case "response.audio.delta": {

if (!event.delta) {

return;