realtime-voice-agents 2.0.0

package/dist/OpenAICompatibleProvider-Bdtl-UXH.mjs

@@ -0,0 +1,402 @@
+import { a as noopLogger, t as BaseRealtimeProvider } from "./BaseRealtimeProvider-BQigr5mB.mjs";
+import { t as buildSessionUpdate } from "./session-config-BVLl7-ha.mjs";
+import WebSocket$1 from "ws";
+//#region src/providers/openai-compatible/OpenAICompatibleProvider.ts
+/**
+* Provider for the OpenAI Realtime API (GA protocol) and API-compatible
+* services (xAI Grok Voice Agent). Speaks `audio/pcmu` in both directions, so
+* Twilio payloads pass through verbatim — zero transcoding on this path.
+*
+* Connect handshake: open WS → receive `session.created` → send
+* `session.update` (audio/pcmu, VAD, tools, instructions) → resolve on
+* `session.updated`. A handshake that hangs rejects after `connectTimeoutMs`
+* so a dead upstream can't leak half-open calls.
+*/
+const DEFAULT_BASE_URL = "wss://api.openai.com/v1/realtime";
+/** WS close codes where retrying cannot help (protocol/auth/policy failures). */
+const NON_RETRIABLE_CLOSE_CODES = /* @__PURE__ */ new Set([
+	1002,
+	1003,
+	1007,
+	1008
+]);
+var OpenAICompatibleProvider = class extends BaseRealtimeProvider {
+	name;
+	capabilities;
+	config;
+	logger;
+	ws = null;
+	sessionInit = null;
+	ready = false;
+	intentionalClose = false;
+	currentResponseId = null;
+	/**
+	* response.create serialization. The GA API rejects a `response.create`
+	* issued while another response is in flight
+	* (`conversation_already_has_active_response`), so creates requested
+	* mid-response wait in a single pending slot and fire on `response.done`.
+	* Later requests coalesce into that slot — one response reads the whole
+	* conversation state, so only the instructions payload is worth keeping.
+	*/
+	responseActive = false;
+	pendingCreate = null;
+	lastCreateSent = null;
+	constructor(config, logger = noopLogger) {
+		super();
+		this.config = config;
+		this.logger = logger;
+		this.name = config.providerName ?? "openai";
+		this.capabilities = {
+			truncate: true,
+			sessionUpdate: true,
+			voiceChangeMidSession: false,
+			transcodeRequired: false,
+			resumption: false,
+			agentTranscriptDeltas: true,
+			vadInterruptControl: true,
+			...config.capabilityOverrides
+		};
+	}
+	get isConnected() {
+		return this.ready && this.ws?.readyState === WebSocket$1.OPEN;
+	}
+	async connect(init) {
+		if (this.ws) await this.close();
+		let vad = init.vad !== void 0 ? init.vad : this.config.defaultVad;
+		if (init.bridgeOwnsInterruptions && this.capabilities.vadInterruptControl && vad !== null) vad = {
+			interruptResponse: false,
+			...vad ?? { type: "server" }
+		};
+		this.sessionInit = {
+			...init,
+			vad,
+			transcription: init.transcription !== void 0 ? init.transcription : this.config.defaultTranscription
+		};
+		this.intentionalClose = false;
+		this.ready = false;
+		this.responseActive = false;
+		this.pendingCreate = null;
+		this.lastCreateSent = null;
+		this.currentResponseId = null;
+		const url = `${this.config.baseUrl ?? DEFAULT_BASE_URL}?model=${encodeURIComponent(this.config.model)}`;
+		const ws = new WebSocket$1(url, {
+			headers: {
+				Authorization: `Bearer ${this.config.apiKey}`,
+				...this.config.headers
+			},
+			perMessageDeflate: false
+		});
+		this.ws = ws;
+		await new Promise((resolve, reject) => {
+			const timeoutMs = this.config.connectTimeoutMs ?? 1e4;
+			const timer = setTimeout(() => {
+				fail(/* @__PURE__ */ new Error(`${this.name} session not ready within ${timeoutMs}ms`));
+			}, timeoutMs);
+			timer.unref?.();
+			let settled = false;
+			const fail = (error) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				try {
+					ws.close();
+				} catch {}
+				reject(error);
+			};
+			ws.on("unexpected-response", (_request, response) => {
+				let body = "";
+				response.setEncoding("utf8");
+				response.on("data", (chunk) => {
+					if (body.length < 512) body += chunk;
+				});
+				response.on("end", () => {
+					const detail = body.trim().slice(0, 500);
+					this.logger.error("provider rejected the WebSocket upgrade", {
+						status: response.statusCode,
+						body: detail
+					});
+					fail(/* @__PURE__ */ new Error(`${this.name} rejected the WebSocket upgrade: HTTP ${response.statusCode}${detail ? ` — ${detail}` : ""}`));
+				});
+			});
+			ws.on("open", () => this.emit("open"));
+			ws.on("message", (raw) => {
+				const event = this.parseEvent(raw);
+				if (!event) return;
+				if (!settled) {
+					if (event.type === "session.created") {
+						this.send(this.buildSessionPayload());
+						return;
+					}
+					if (event.type === "session.updated") {
+						settled = true;
+						clearTimeout(timer);
+						this.ready = true;
+						resolve();
+						return;
+					}
+					if (event.type === "error") {
+						fail(/* @__PURE__ */ new Error(`${this.name} session setup error: ${JSON.stringify(event.error ?? event)}`));
+						return;
+					}
+				}
+				this.handleEvent(event);
+			});
+			ws.on("error", (error) => {
+				if (!settled) fail(error instanceof Error ? error : new Error(String(error)));
+				else this.emit("error", error instanceof Error ? error : new Error(String(error)));
+			});
+			ws.on("close", (code, reasonBuf) => {
+				const reason = reasonBuf?.toString();
+				this.ready = false;
+				if (!settled) {
+					fail(/* @__PURE__ */ new Error(`${this.name} socket closed during setup (${code} ${reason ?? ""})`));
+					return;
+				}
+				this.emit("close", {
+					code,
+					reason,
+					retriable: !this.intentionalClose && !NON_RETRIABLE_CLOSE_CODES.has(code)
+				});
+			});
+		});
+	}
+	async close() {
+		this.intentionalClose = true;
+		this.ready = false;
+		const ws = this.ws;
+		this.ws = null;
+		if (!ws) return;
+		if (ws.readyState === WebSocket$1.CLOSED) return;
+		await new Promise((resolve) => {
+			const timer = setTimeout(() => {
+				ws.terminate();
+				resolve();
+			}, 1e3);
+			timer.unref?.();
+			ws.once("close", () => {
+				clearTimeout(timer);
+				resolve();
+			});
+			try {
+				ws.close(1e3);
+			} catch {
+				clearTimeout(timer);
+				ws.terminate();
+				resolve();
+			}
+		});
+	}
+	sendAudio(base64Mulaw) {
+		if (!this.isConnected) return;
+		this.send({
+			type: "input_audio_buffer.append",
+			audio: base64Mulaw
+		});
+	}
+	sendText(text, options = {}) {
+		const role = options.role ?? "user";
+		this.send({
+			type: "conversation.item.create",
+			item: {
+				type: "message",
+				role,
+				content: [{
+					type: role === "assistant" ? "output_text" : "input_text",
+					text
+				}]
+			}
+		});
+		if (options.triggerResponse !== false) this.createResponse();
+	}
+	sendToolResult(callId, output, options = {}) {
+		this.send({
+			type: "conversation.item.create",
+			item: {
+				type: "function_call_output",
+				call_id: callId,
+				output: typeof output === "string" ? output : JSON.stringify(output ?? null)
+			}
+		});
+		if (options.triggerResponse !== false) this.createResponse();
+	}
+	createResponse(options = {}) {
+		if (this.responseActive) {
+			this.pendingCreate = {
+				instructions: options.instructions ?? this.pendingCreate?.instructions,
+				attempts: 0
+			};
+			return;
+		}
+		this.sendCreate({
+			instructions: options.instructions,
+			attempts: 0
+		});
+	}
+	sendCreate(create) {
+		this.lastCreateSent = create;
+		this.send({
+			type: "response.create",
+			...create.instructions ? { response: { instructions: create.instructions } } : {}
+		});
+	}
+	async updateSession(patch) {
+		if (!this.sessionInit) throw new Error("updateSession before connect");
+		this.sessionInit = {
+			...this.sessionInit,
+			...patch
+		};
+		this.send(this.buildSessionPayload());
+	}
+	buildSessionPayload() {
+		return (this.config.buildSession ?? buildSessionUpdate)(this.sessionInit, {
+			defaultVoice: this.config.voice,
+			extraSessionOptions: this.config.extraSessionOptions
+		});
+	}
+	cancelResponse() {
+		if (this.pendingCreate && !this.pendingCreate.instructions) this.pendingCreate = null;
+		this.send({ type: "response.cancel" });
+	}
+	truncatePlayback(itemId, audioEndMs) {
+		this.send({
+			type: "conversation.item.truncate",
+			item_id: itemId,
+			content_index: 0,
+			audio_end_ms: Math.max(0, Math.round(audioEndMs))
+		});
+	}
+	handleEvent(event) {
+		switch (event.type) {
+			case "response.created": {
+				const responseId = event.response?.id ?? `resp_${Date.now()}`;
+				this.currentResponseId = responseId;
+				this.responseActive = true;
+				this.emit("responseStarted", { responseId });
+				break;
+			}
+			case "response.output_item.added": {
+				const itemId = event.item?.id;
+				if (itemId) this.emit("outputItemAdded", {
+					itemId,
+					responseId: event.response_id ?? this.currentResponseId ?? ""
+				});
+				break;
+			}
+			case "response.output_audio.delta":
+				if (typeof event.delta === "string" && event.delta.length > 0) this.emit("audio", {
+					base64Mulaw: event.delta,
+					responseId: event.response_id ?? this.currentResponseId ?? "",
+					itemId: event.item_id
+				});
+				break;
+			case "response.output_audio_transcript.delta":
+				if (typeof event.delta === "string") this.emit("agentTranscriptDelta", {
+					responseId: event.response_id ?? this.currentResponseId ?? "",
+					delta: event.delta
+				});
+				break;
+			case "response.output_audio_transcript.done":
+				if (typeof event.transcript === "string") this.emit("agentTranscript", {
+					responseId: event.response_id ?? this.currentResponseId ?? "",
+					text: event.transcript
+				});
+				break;
+			case "conversation.item.input_audio_transcription.completed":
+				if (typeof event.transcript === "string" && event.transcript.trim().length > 0) this.emit("userTranscript", { text: event.transcript.trim() });
+				break;
+			case "input_audio_buffer.speech_started":
+				if (this.pendingCreate && !this.pendingCreate.instructions) this.pendingCreate = null;
+				this.emit("userSpeechStarted");
+				break;
+			case "input_audio_buffer.speech_stopped":
+				this.emit("userSpeechStopped");
+				break;
+			case "response.done": {
+				const responseId = event.response?.id ?? this.currentResponseId ?? "";
+				const usage = normalizeUsage(event.response?.usage);
+				this.responseActive = false;
+				const pending = this.pendingCreate;
+				if (pending) {
+					this.pendingCreate = null;
+					this.sendCreate(pending);
+				}
+				if (usage) this.emit("usage", usage);
+				this.emit("responseDone", {
+					responseId,
+					usage: usage ?? void 0
+				});
+				break;
+			}
+			case "response.function_call_arguments.done":
+				this.emit("toolCall", {
+					id: event.call_id ?? event.item_id ?? `call_${Date.now()}`,
+					name: event.name,
+					argumentsJson: typeof event.arguments === "string" ? event.arguments : "{}",
+					responseId: event.response_id ?? this.currentResponseId ?? void 0,
+					itemId: event.item_id
+				});
+				break;
+			case "error": {
+				const code = event.error?.code;
+				if (code === "conversation_already_has_active_response") {
+					this.responseActive = true;
+					const last = this.lastCreateSent;
+					if (last && last.attempts < 2 && !this.pendingCreate) this.pendingCreate = {
+						...last,
+						attempts: last.attempts + 1
+					};
+					this.logger.warn("response.create raced an active response; deferred until it completes", { error: event.error });
+					break;
+				}
+				{
+					const message = typeof event.error?.message === "string" ? event.error.message : "";
+					if (code === "response_cancel_not_active" || /cancellation failed: no active response/i.test(message)) {
+						this.logger.warn("response.cancel raced completion (ignored)", { error: event.error });
+						break;
+					}
+				}
+				this.logger.warn("provider error event", { error: event.error });
+				this.emit("error", /* @__PURE__ */ new Error(`${this.name} error: ${JSON.stringify(event.error ?? event)}`));
+				break;
+			}
+		}
+	}
+	parseEvent(raw) {
+		try {
+			return JSON.parse(raw.toString());
+		} catch {
+			this.logger.warn("unparseable provider frame");
+			return null;
+		}
+	}
+	send(payload) {
+		if (this.ws?.readyState !== WebSocket$1.OPEN) return;
+		try {
+			this.ws.send(JSON.stringify(payload));
+		} catch (error) {
+			this.emit("error", error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+};
+function normalizeUsage(raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const inputDetails = raw.input_token_details ?? raw.input_tokens_details;
+	const outputDetails = raw.output_token_details ?? raw.output_tokens_details;
+	return {
+		inputTokens: raw.input_tokens ?? 0,
+		outputTokens: raw.output_tokens ?? 0,
+		totalTokens: raw.total_tokens ?? (raw.input_tokens ?? 0) + (raw.output_tokens ?? 0),
+		...inputDetails ? { inputTokenDetails: {
+			textTokens: inputDetails.text_tokens,
+			audioTokens: inputDetails.audio_tokens,
+			cachedTokens: inputDetails.cached_tokens
+		} } : {},
+		...outputDetails ? { outputTokenDetails: {
+			textTokens: outputDetails.text_tokens,
+			audioTokens: outputDetails.audio_tokens
+		} } : {},
+		raw
+	};
+}
+//#endregion
+export { OpenAICompatibleProvider as t };