openclaw/dist/realtime-quicksilver-events-CbzMdwSI.js

Multi-channel AI gateway with extensible messaging integrations

import { i as asOptionalObjectRecord } from "./record-coerce-DItp3I4t.js";
import { Et as array, Rn as string, Tn as object, dn as literal, wn as number, yt as _enum } from "./schemas-zxit8y5H.js";
import "./string-coerce-runtime-GQa0ehRA.js";
//#region extensions/openai/realtime-quicksilver-events.ts
const eventEnvelopeSchema = object({ type: string() }).passthrough();
const sessionStartedSchema = object({
	type: literal("session.started"),
	session: object({ expires_at: number().optional() }).passthrough()
}).passthrough();
const transcriptAddedSchema = object({ item: object({ text: string() }).passthrough() }).passthrough();
const outputAudioDeltaSchema = object({
	type: literal("output_audio.delta"),
	audio: string()
}).passthrough();
const turnDoneSchema = object({ turn: object({
	role: _enum(["user", "assistant"]),
	transcript: string()
}).passthrough() }).passthrough();
const delegationSchema = object({
	type: literal("delegation.created"),
	item: object({
		type: string(),
		target: string(),
		id: string().optional(),
		content: array(object({
			type: string(),
			text: string().optional()
		}).passthrough()).optional()
	}).passthrough()
}).passthrough();
function readQuicksilverErrorMessage(value) {
	if (typeof value === "string" && value.trim()) return value.trim();
	const record = asOptionalObjectRecord(value);
	if (record) {
		if (typeof record.message === "string" && record.message.trim()) return record.message.trim();
		const error = record.error;
		if (error && typeof error === "object") {
			const nestedMessage = asOptionalObjectRecord(error)?.message;
			if (typeof nestedMessage === "string" && nestedMessage.trim()) return nestedMessage.trim();
		}
		if (typeof error === "string" && error.trim()) return error.trim();
		try {
			const serialized = JSON.stringify(error ?? value);
			if (serialized && serialized !== "{}") return serialized;
		} catch {}
	}
	return "GPT-Live sideband error";
}
function isFatalQuicksilverAuthError(value) {
	const record = asOptionalObjectRecord(value);
	if (!record) return false;
	const error = asOptionalObjectRecord(record.error);
	const status = record.status ?? error?.status;
	if (status === 401 || status === "401") return true;
	const code = typeof (record.code ?? error?.code) === "string" ? String(record.code ?? error?.code).toLowerCase() : "";
	return [
		"authentication_error",
		"invalid_api_key",
		"invalid_token",
		"token_expired"
	].includes(code);
}
function parseOpenAIQuicksilverEvent(payload) {
	let decoded;
	try {
		decoded = JSON.parse(payload);
	} catch {
		return null;
	}
	const envelope = eventEnvelopeSchema.safeParse(decoded);
	if (!envelope.success) return null;
	const eventType = envelope.data.type;
	if (eventType === "session.started") {
		const started = sessionStartedSchema.safeParse(decoded);
		if (!started.success) return {
			kind: "ignored",
			eventType
		};
		const expiresAt = started.data.session.expires_at;
		return {
			kind: "session-started",
			...expiresAt !== void 0 ? { expiresAt } : {}
		};
	}
	if (eventType === "input_transcript.added" || eventType === "output_transcript.added") {
		const transcript = transcriptAddedSchema.safeParse(decoded);
		return transcript.success ? {
			kind: "transcript-delta",
			role: eventType === "input_transcript.added" ? "user" : "assistant",
			text: transcript.data.item.text
		} : {
			kind: "ignored",
			eventType
		};
	}
	if (eventType === "turn.done") {
		const turn = turnDoneSchema.safeParse(decoded);
		return turn.success ? {
			kind: "transcript-done",
			role: turn.data.turn.role,
			text: turn.data.turn.transcript
		} : {
			kind: "ignored",
			eventType
		};
	}
	if (eventType === "output_audio.delta") {
		const audio = outputAudioDeltaSchema.safeParse(decoded);
		return audio.success ? {
			kind: "audio",
			data: audio.data.audio
		} : {
			kind: "ignored",
			eventType
		};
	}
	if (eventType === "session.updated") return {
		kind: "ignored",
		eventType
	};
	if (eventType === "delegation.created") {
		const delegation = delegationSchema.safeParse(decoded);
		if (!delegation.success) return {
			kind: "ignored",
			eventType
		};
		const { item } = delegation.data;
		if (item.type !== "delegation" || item.target !== "client" || !item.id) return {
			kind: "ignored",
			eventType
		};
		return {
			kind: "delegation",
			id: item.id,
			prompt: (item.content ?? []).filter((part) => part.type === "input_text").map((part) => part.text ?? "").join("")
		};
	}
	if (eventType === "error") return {
		kind: "error",
		message: readQuicksilverErrorMessage(decoded),
		fatalAuth: isFatalQuicksilverAuthError(decoded)
	};
	return {
		kind: "unknown",
		eventType
	};
}
//#endregion
export { parseOpenAIQuicksilverEvent as t };