"Conversation already has an active response in progress:";

const OPENAI_REALTIME_NO_ACTIVE_RESPONSE_CANCEL_ERROR =

"Cancellation failed: no active response found";

const OPENAI_REALTIME_MAX_SESSION_DURATION_FRAGMENT = "maximum duration";

const OPENAI_REALTIME_DEFAULT_MIN_BARGE_IN_AUDIO_END_MS = 250;

const OPENAI_REALTIME_VOICES = [

"alloy",

return (model ?? OPENAI_REALTIME_DEFAULT_MODEL).trim().toLowerCase().startsWith("gpt-");

}

function isOpenAIRealtimeMaxSessionDurationError(detail: string): boolean {

const normalized = detail.toLowerCase();

return (

normalized.includes("session") &&

normalized.includes(OPENAI_REALTIME_MAX_SESSION_DURATION_FRAGMENT)

);

}

async function resolveOpenAIRealtimeDefaultAuth(params: {

configuredApiKey: string | undefined;

cfg: RealtimeVoiceBrowserSessionCreateRequest["cfg"] | undefined;

private deliveredToolCallKeys = new Set<string>();

private readonly flowId = randomUUID();

private sessionReadyFired = false;

private reconnectReason: string | undefined;

private activeConnectionReason: string | undefined;

private readonly audioFormat: RealtimeVoiceAudioFormat;

constructor(private readonly config: OpenAIRealtimeVoiceBridgeConfig) {

settleReject(new Error("OpenAI realtime connection closed before ready"));

return;

}

void this.attemptReconnect();

const reason = this.reconnectReason ?? "websocket-close";

this.reconnectReason = undefined;

void this.attemptReconnect(reason);

});

};

};

}

private async attemptReconnect(): Promise<void> {

private async attemptReconnect(reason: string): Promise<void> {

if (this.intentionallyClosed) {

return;

}

if (this.reconnectAttempts >= OpenAIRealtimeVoiceBridge.MAX_RECONNECT_ATTEMPTS) {

this.config.onEvent?.({

direction: "client",

type: "session.reconnect.exhausted",

detail: `reason=${reason} attempts=${this.reconnectAttempts}`,

});

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

return;

}

this.reconnectAttempts += 1;

const delay =

OpenAIRealtimeVoiceBridge.BASE_RECONNECT_DELAY_MS * 2 ** (this.reconnectAttempts - 1);

const attempt = this.reconnectAttempts;

const delay = OpenAIRealtimeVoiceBridge.BASE_RECONNECT_DELAY_MS * 2 ** (attempt - 1);

this.config.onEvent?.({

direction: "client",

type: "session.reconnect.scheduled",

detail: `reason=${reason} attempt=${attempt} delayMs=${delay}`,

});

await new Promise((resolve) => setTimeout(resolve, delay));

if (this.intentionallyClosed) {

return;

}

try {

await this.doConnect();

this.config.onEvent?.({

direction: "client",

type: "session.reconnect.ready",

detail: `reason=${reason} attempt=${attempt}`,

});

} catch (error) {

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

await this.attemptReconnect();

await this.attemptReconnect(reason);

}

}

}

private handleEvent(event: RealtimeEvent): void {

this.config.onEvent?.({

direction: "server",

type: event.type,

detail: this.describeServerEvent(event),

});

const emitServerEvent = () =>

this.config.onEvent?.({

direction: "server",

type: event.type,

detail: this.describeServerEvent(event),

});

if (

event.type === "error" &&

isOpenAIRealtimeMaxSessionDurationError(readRealtimeErrorDetail(event.error))

) {

this.reconnectReason = "max-duration";

this.activeConnectionReason = "max-duration";

this.config.onEvent?.({

direction: "server",

type: "session.rotation",

detail: "reason=max-duration",

});

this.ws?.close(1000, "max-duration rotation");

return;

}

emitServerEvent();

switch (event.type) {

case "session.created":

return;

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

this.sendAudio(chunk);

}

if (this.activeConnectionReason) {

this.config.onEvent?.({

direction: "server",

type: "session.rotation.ready",

detail: `reason=${this.activeConnectionReason}`,

});

this.activeConnectionReason = undefined;

}

if (!this.sessionReadyFired) {

this.sessionReadyFired = true;

this.config.onReady?.();